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..9de1f8952 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
@@ -244,3 +339,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/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 58e6a4ac7..36b30e703 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:
@@ -247,6 +259,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
@@ -267,5 +281,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/CHANGELOG.md b/CHANGELOG.md
index 32b027a47..e3b4b15a8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,16 +11,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
- **Breaking** — Admin Basic-auth coverage now includes `GET /_ts/admin/ec`, `GET /_ts/admin/ec/{id}`, and `GET /_ts/admin/eids`. Existing configurations whose `[[handlers]]` patterns protect only the key-management endpoints now fail startup; broaden coverage before deploying, preferably with a namespace-boundary pattern such as `^/_ts/admin(?:/|$)`. Coverage of the dynamic `/_ts/admin/ec/{id}` route is no longer inferred from ID-shaped samples: the router accepts any segment after `/_ts/admin/ec/` and Basic Auth runs on the raw path before routing, so patterns anchored to the EC ID grammar (for example `^/_ts/admin/ec/[a-f0-9]{64}[.][A-Za-z0-9]{6}$`) are rejected in favor of a prefix-level matcher. Placeholder and well-known weak handler passwords (`changeme`, `password`, `admin`, `replace-with-…`) now fail startup on every handler rather than only on handlers inferred to cover an admin endpoint, because first-match-wins handler selection lets a narrow handler shadow the admin namespace.
- Publisher HTML uses the browser-only `Cache-Control: private, max-age=60` policy for successful GET document responses and their `304 Not Modified` revalidations when server-side ad templates are structurally inactive, while preserving origin `private`/`no-store` policies and request-scoped bot, prefetch, or consent-denied responses. The `private` directive prevents shared caches that use `Cache-Control` from storing the document. Cookie-bearing responses using the generated inactive policy are finalized as `private, max-age=0`; CDN-specific cache headers remain unchanged and continue to control supporting CDNs independently. Set `[creative_opportunities].enabled = false` to disable publisher HTML and SPA template delivery without disabling direct `POST /auction` callers; an absent configuration, an unmatched slot, or a disabled auction also make the stack structurally inactive. An explicit `enabled = false` is not compatible with older binaries: restore the default, re-push and finalize the config before rolling back.
-- **Breaking** — Replaced the legacy APS contextual integration with APS OpenRTB at `/e/pb/bid`. APS configuration now uses canonical `account_id` (`pub_id` remains a compatibility alias), no longer requires APS-specific slot IDs, and defaults script creative eligibility off. Operators must update the endpoint, disable native APS demand for Trusted Server cohorts, and prepare GAM/Universal Creative targeting for `hb_bidder=aps` before rollout. `aps` entries in Prebid bidder lists are logged and stripped. APS renderer winners now preserve the upstream bid `id`, omit `crid` when APS omits it, and carry `ext.trusted_server.renderer` instead of `adm`; external `/auction` consumers must support this response shape.
-- **Breaking** — All auction paths now forward only a validated publisher-owned page URL as `site.page`, removing query and fragment data. APS OpenRTB omits `site.ref`; the existing Prebid Server path continues to forward the browser `Referer` as `site.ref`. Query-driven sites may lose contextual targeting and per-page reporting signals that previously came from query parameters.
-- Publisher HTML now uses `Cache-Control: max-age=60` when server-side ad templates are inactive, while preserving origin `private`/`no-store` policies and CDN-specific cache headers. Set `[creative_opportunities].enabled = false` to disable publisher HTML and SPA template delivery without disabling direct `POST /auction` callers.
+- **Breaking** — Replaced the legacy APS contextual integration with APS OpenRTB at `/e/pb/bid`. APS configuration accepts only canonical `account_id`, no longer requires APS-specific slot IDs, and defaults script creative eligibility off. Operators must update the endpoint, remove `pub_id`, disable native APS demand for Trusted Server cohorts, and prepare GAM/Universal Creative targeting for `hb_bidder=aps` before rollout. `aps` entries in Prebid bidder lists are logged and stripped. APS renderer winners now preserve the upstream bid `id`, omit `crid` when APS omits it, and carry a typed render source instead of executable markup on the public browser wire.
+- **Breaking** — All auction paths forward only a validated publisher-owned page URL as `site.page`, removing query and fragment data. APS OpenRTB omits `site.ref`; the Prebid Server path continues to forward the browser `Referer` as `site.ref`. Query-driven sites may lose contextual targeting and per-page reporting signals that previously came from query parameters.
- **Breaking** — `bid_param_zone_overrides` inner values must now be JSON objects; previously non-object or empty values (`"header" = "x"`, `"header" = {}`) were accepted and silently produced a dead rule at runtime. They now fail at startup with a configuration error. Operators upgrading should audit their `bid_param_zone_overrides` config for non-object zone entries.
- **Breaking** — Integration configuration strings are no longer globally reinterpreted as JSON scalars. Operators upgrading should audit `[integrations.*]` settings and use native TOML/typed-config booleans and numbers (for example, `enabled = true`, not `enabled = "true"`); quoted numeric and boolean scalars now fail validation instead of silently converting.
- **Breaking** — Sourcepoint browser module inclusion now requires explicit `[integrations.sourcepoint].enabled = true`; operators relying on the previous unconditional Sourcepoint module should enable the integration before upgrading.
-- **Breaking** — Auction creative sanitization is now opt-in: the new `[auction].sanitize_creatives` defaults to `false` because unconditional sanitization blanked script-based creatives (the majority of programmatic display) while recording normal impressions. `[auction].rewrite_creatives` keeps its `true` default. The per-creative cap is now enforced on rewritten output as well as raw input and in every processing mode (1 MiB for auction `adm`; proxied HTML documents keep the proxy's own 10 MiB bound), rewriting fails closed on parser errors instead of emitting partial output and never turns a rejected creative into a runtime-only `adm`, and `hb_cache_host`/`hb_cache_path` are emitted only for bids that supplied no creative — any bid carrying its own `adm` ships without them, so a processed or rejected creative can never be re-fetched raw from PBS Cache. Creative markup with no `` token now receives the click-guard runtime, and bidder `` elements are stripped whenever rewriting is enabled. The creative iframe sandbox no longer grants `allow-same-origin`, restoring origin isolation; rewritten-click recovery from the resulting opaque-origin iframe uses the GET `/first-party/proxy-rebuild` navigation fallback, now registered in every adapter and documented alongside the POST JSON form. Inside those iframes, dynamic resource signing and CORS-mode subresources (ES modules, `crossorigin` fonts) are unavailable pending the constrained asset capability in [#982](https://github.com/IABTechLab/trusted-server/issues/982); ordinary image, script, and stylesheet loads are unaffected. Upgrading: binaries that predate `sanitize_creatives` reject a blob carrying it, so upgrade the binary first, then push the config. Rollback: non-default values (`sanitize_creatives = true`, `rewrite_creatives = false`) are serialized into the config blob and older binaries reject unknown fields — before rolling back to a binary that predates a field, restore its default, push the default-compatible blob, then roll back.
-- The SPA re-auction endpoint moved from `/__ts/page-bids` to `/_ts/page-bids`, joining every other internal route in the `/_ts/` namespace. The old path stays registered as a deprecated alias so already-loaded bundles keep serving ads, and responses on it carry a `Link: …; rel="deprecation"` header so remaining traffic is measurable from edge logs; removal is tracked in [#970](https://github.com/IABTechLab/trusted-server/issues/970). Two deployment notes: audit `[[handlers]]` for patterns broad enough to cover `/_ts` (for example `^/_ts`), which would put this browser-facing endpoint behind Basic Auth and return `401` to every visitor — scope them to `^/_ts/admin`; and prefer rolling forward over rolling back, since a server reverted past this release does not register the canonical path. In both cases the shipped client falls back to the deprecated alias, so the exposure is bounded until that alias is removed.
+- **Breaking** — Auction creative sanitization is now opt-in: `[auction].sanitize_creatives` defaults to `false` because unconditional sanitization blanked script-based creatives while recording normal impressions; `[auction].rewrite_creatives` stays default-on. The auction `adm` cap is 1 MiB while full proxied HTML keeps the proxy's 10 MiB bound. Rewriting now fails closed on parser or output-limit errors, never resurrects rejected markup as a runtime-only `adm`, removes bidder `` elements, and injects the click guard into body-less fragments. Creative frames omit `allow-same-origin`; mutated clicks recover through GET or form-POST `/first-party/proxy-rebuild` navigation. The generic proxy strips upstream CORS grants, so opaque frames cannot read proxied bodies; CORS-mode subresources and dynamic resource signing remain unavailable pending [#982](https://github.com/IABTechLab/trusted-server/issues/982), while ordinary image, script, stylesheet, and media loads are unaffected.
+- **Breaking** — The SPA re-auction endpoint is `/_ts/page-bids`. The removed `/__ts/page-bids` spelling is an unknown route; update handler rules and callers at cutover.
- Added optional APS `inventory_domain` and `inventory_page_origin` overrides for deployments whose edge hostname differs from the APS-authorized inventory identity.
-- Preserved APS renderer capabilities through the client-side `trustedServer` Prebid adapter, allowing its generated `hb_adid` to render through GAM and Prebid Universal Creative instead of producing an empty creative.
+- APS/ADM Prebid delivery now crosses Prebid normalization using only standard `adId` plus per-bid `meta` identity; executable renderer sources remain in the bounded server-owned reservation and cannot be stripped with an unknown top-level bid field.
### Security
@@ -30,10 +29,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Fixed
- Protocol-relative creative URLs now honor `rewrite.exclude_domains`, so excluded creative assets stay direct and excluded absolute or protocol-relative URLs submitted to `/first-party/sign` are rejected.
-- Server-side ad template bids now always carry `hb_adid` in `window.tsjs.bids`. Bidders that return neither a Prebid Cache UUID nor an `adid` previously produced no `hb_adid` at all, so no `hb_adid` GPT targeting key was set and the Universal Creative render bridge had nothing to match — the winning creative never rendered. The OpenRTB bid `id`, which is mandatory per spec, is now the last-resort source; `cache_id` and `adid` still take priority where present. Blank `cacheId`/`adid` values no longer win that precedence and emit an unusable empty `hb_adid`, and `hb_cache_host`/`hb_cache_path` are now emitted only alongside a real Prebid Cache UUID — without one they pointed the Universal Creative at a guaranteed cache miss instead of letting it fall through to the inline creative.
+- The canonical browser auction projection now rejects blank upstream bid IDs per winner, uses a server-minted renderer reservation as the sole GAM render identity, and emits cache coordinates only as part of a validated cache render source. This replaces the legacy `window.tsjs.bids` `hb_adid` fallback chain.
### Added
+- Added opt-in APS HTTP debug metadata for controlled test sites, exposing the direct request and response under `/auction` provider metadata using the Prebid Server `debug.httpcalls` shape.
+- Added typed APS renderer transport for direct auctions and GAM/Prebid Universal Creative, using a minimized one-bid envelope, a fragment-bound nonce, and an opaque sandboxed renderer endpoint.
- Added the `[auction].rewrite_creatives` (default `true`) and `[auction].sanitize_creatives` (default `false`) options. `rewrite_creatives` rewrites winning-bid adm to first-party endpoints across `POST /auction` and publisher SSAT/page-bids delivery (proxy/click URL conversion, bidder `` removal; creative TSJS injection on `POST /auction` only). Enabling `sanitize_creatives` strips executable markup from winning-bid adm before delivery.
- `creative_opportunities.slot.gam_unit_path` is now a template supporting `{network_id}`, `{slot_id}`, and `{section}`, so a publisher whose ad unit varies by site section expresses it in one slot rule instead of one per (slot × section). `{section}` derives from the request path: `[creative_opportunities].section_segment` selects which path segment names the section (0-based, default `0`; set `1` for locale-prefixed URLs), and `section_root` supplies the value for paths with no such segment. `section_root` is required when a template uses `{section}`. Existing static and absent `gam_unit_path` configs are unchanged. Startup rejects a blank `gam_network_id` only when an absent/default path or `{network_id}` template consumes it. Trusted Server conservatively caps whole rendered dynamic paths at 100 UTF-8 bytes, informed by Google's 100-character per-ad-unit-code limit; an over-limit request-specific path omits that slot without failing the response. During typed/startup finalization, every placeholder-bearing template that omits `section_segment` materializes `section_segment = 0`, so an older binary rejects the blob loudly. Static and absent paths remain legacy-schema compatible only when both `section_root` and `section_segment` are omitted. Before rolling back below this feature, replace or remove dynamic paths, remove both keys, re-push and finalize the config, then roll back the binary.
- Added opt-in APS HTTP debug metadata for controlled test sites, exposing the direct request and response under `/auction` provider metadata using the Prebid Server `debug.httpcalls` shape.
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 65b1d9507..d028a4876 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 4b71d07ce..855d27541 100644
--- a/crates/trusted-server-adapter-axum/src/app.rs
+++ b/crates/trusted-server-adapter-axum/src/app.rs
@@ -24,8 +24,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,
@@ -34,6 +34,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;
@@ -84,6 +85,91 @@ fn build_state_with_settings(
}))
}
+async fn dispatch_reserved_for_state(state: &Arc, req: Request) -> Option {
+ 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,
+}
+
+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> {
+ // 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> {
+ 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 {
+ 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, Report> {
+ 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, Report> {
+ Ok(ReservedApsDispatcher::from_startup_settings()?
+ .dispatch(req)
+ .await)
+}
+
// ---------------------------------------------------------------------------
// Error helper
// ---------------------------------------------------------------------------
@@ -191,7 +277,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);
}
@@ -274,6 +360,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,
@@ -298,7 +385,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",
@@ -359,6 +446,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],
@@ -371,13 +463,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",
@@ -450,6 +541,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| {
+ 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 a511daab2..a44ceb147 100644
--- a/crates/trusted-server-adapter-axum/src/platform.rs
+++ b/crates/trusted-server-adapter-axum/src/platform.rs
@@ -11,7 +11,8 @@ use error_stack::{Report, ResultExt as _};
use trusted_server_core::platform::{
ClientInfo, GeoInfo, PlatformBackend, PlatformBackendSpec, PlatformConfigStore, PlatformError,
PlatformGeo, PlatformHttpClient, PlatformHttpRequest, PlatformPendingRequest, PlatformResponse,
- PlatformSecretStore, PlatformSelectResult, RuntimeServices, StoreId, StoreName,
+ PlatformSecretStore, PlatformSelectResult, ProxyHeaderEvidenceV1, ProxyResponseEvidenceV1,
+ RawProxyPolicyV1, RawProxyResponseV1, RuntimeServices, StoreId, StoreName,
};
// ---------------------------------------------------------------------------
@@ -285,6 +286,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.
///
@@ -307,6 +311,38 @@ impl AxumPlatformHttpClient {
}
}
+ #[cfg(feature = "aps-runner-proxy-integration-test")]
+ fn aps_runner_proxy_test_transport_uri(
+ logical_uri: &str,
+ ) -> Result, Report> {
+ 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`.
///
/// For `Body::Stream` this awaits every chunk in the current async context
@@ -380,6 +416,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 {
+ 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> {
+ 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 {
@@ -397,6 +554,14 @@ impl PlatformHttpClient for AxumPlatformHttpClient {
self.execute(request).await
}
+ async fn send_raw_proxy_v1(
+ &self,
+ request: PlatformHttpRequest,
+ policy: RawProxyPolicyV1,
+ ) -> Result> {
+ self.execute_raw_proxy_v1(request, policy).await
+ }
+
async fn send_async(
&self,
request: PlatformHttpRequest,
@@ -756,6 +921,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 ed199e6bf..013a40ca8 100644
--- a/crates/trusted-server-adapter-axum/tests/routes.rs
+++ b/crates/trusted-server-adapter-axum/tests/routes.rs
@@ -18,14 +18,19 @@ const LEGACY_ADMIN_DENY_METHODS: &[&str] =
/// The settings baked into the binary contain placeholder secrets that
/// `get_settings()` rejects by design, which would turn every route into a
/// startup error page (and its route table into the fallback-only set).
-fn test_router() -> edgezero_core::router::RouterService {
- let settings = trusted_server_core::settings::Settings::from_toml(
+fn test_settings() -> trusted_server_core::settings::Settings {
+ trusted_server_core::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"
@@ -34,14 +39,33 @@ fn test_router() -> edgezero_core::router::RouterService {
[ec]
passphrase = "test-secret-key-32-bytes-minimum"
+
+ [integrations.aps]
+ enabled = true
+ 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() -> edgezero_core::router::RouterService {
+ TrustedServerApp::routes_with_settings(test_settings())
.expect("should build router from test settings")
}
+async fn route_reserved(request: Request) -> axum::http::Response {
+ 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())
}
@@ -80,16 +104,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"),
@@ -101,6 +118,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
@@ -212,39 +232,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 86ac86987..cae088aa5 100644
--- a/crates/trusted-server-adapter-cloudflare/src/app.rs
+++ b/crates/trusted-server-adapter-cloudflare/src/app.rs
@@ -27,14 +27,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};
use crate::platform::build_runtime_services;
@@ -123,6 +123,47 @@ fn build_state_with_settings(
}))
}
+async fn dispatch_reserved_for_state(state: &Arc, req: Request) -> Option {
+ 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, Report> {
+ 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, Report> {
+ let state = build_state()?;
+ Ok(dispatch_reserved_for_state(&state, req).await)
+}
+
// ---------------------------------------------------------------------------
// Per-request RuntimeServices
// ---------------------------------------------------------------------------
@@ -371,7 +412,7 @@ fn build_router(state: &Arc) -> 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,
ctx: RequestContext,
@@ -389,10 +430,7 @@ fn build_router(state: &Arc) -> 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,
@@ -492,19 +530,12 @@ fn build_router(state: &Arc) -> RouterService {
.post("/_ts/admin/keys/deactivate", |_ctx: RequestContext| async {
Ok::(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::(admin_ec_lookup_not_supported())
})
.get("/_ts/admin/ec/{id}", |_ctx: RequestContext| async {
Ok::(admin_ec_lookup_not_supported())
})
- // Admin EIDs echo: pure request inspection (no KV), so this
- // adapter serves the real handler.
.get(
"/_ts/admin/eids",
make_handler(Arc::clone(&state), |s, _services, req| async move {
@@ -512,6 +543,15 @@ fn build_router(state: &Arc) -> RouterService {
handle_admin_eids_lookup(&partner_registry, &req)
}),
)
+ // Render-trace toggle: arms/disarms the ts-trace cookie and
+ // redirects to `/`. Gated by [debug] trace_route_enabled (404 when
+ // off).
+ .get(
+ "/_ts/trace",
+ make_handler(Arc::clone(&state), |s, _services, req| async move {
+ handle_trace_mode(&s.settings, req.uri().query())
+ }),
+ )
.post(
"/auction",
make_handler(Arc::clone(&state), |s, services, req| async move {
@@ -572,15 +612,8 @@ fn build_router(state: &Arc) -> 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 {
@@ -594,10 +627,8 @@ fn build_router(state: &Arc) -> 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 {
@@ -611,6 +642,9 @@ fn build_router(state: &Arc) -> 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());
diff --git a/crates/trusted-server-adapter-cloudflare/src/lib.rs b/crates/trusted-server-adapter-cloudflare/src/lib.rs
index 2ce435b17..3ab7d3434 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::from_bytes(value.as_bytes()).ok()
+}
+
#[cfg(target_arch = "wasm32")]
#[event(fetch)]
/// Dispatches an incoming Cloudflare Worker fetch event.
@@ -28,6 +33,31 @@ pub async fn main(req: Request, env: Env, ctx: Context) -> Result {
app::set_cloudflare_config_json(config.to_string());
}
+ 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::(req, env, ctx).await {
Ok(resp) => Ok(resp),
Err(e) => {
@@ -36,3 +66,16 @@ pub async fn main(req: Request, env: Env, ctx: Context) -> Result {
}
}
}
+
+#[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 fff0bfed1..4984b5999 100644
--- a/crates/trusted-server-adapter-cloudflare/src/platform.rs
+++ b/crates/trusted-server-adapter-cloudflare/src/platform.rs
@@ -20,6 +20,7 @@ use error_stack::ResultExt as _;
#[cfg(target_arch = "wasm32")]
use trusted_server_core::platform::{
PlatformHttpRequest, PlatformPendingRequest, PlatformResponse, PlatformSelectResult,
+ ProxyHeaderEvidenceV1, ProxyResponseEvidenceV1, RawProxyPolicyV1, RawProxyResponseV1,
};
// ---------------------------------------------------------------------------
@@ -204,7 +205,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,
+}
+
+#[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.
///
@@ -286,6 +293,27 @@ fn outbound_cache_mode(bypass_cache: bool) -> OutboundCacheMode {
#[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,
@@ -444,6 +472,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 {
+ 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> {
+ 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::>(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")]
@@ -456,6 +697,14 @@ impl PlatformHttpClient for CloudflareHttpClient {
self.execute(request).await
}
+ async fn send_raw_proxy_v1(
+ &self,
+ request: PlatformHttpRequest,
+ policy: RawProxyPolicyV1,
+ ) -> Result> {
+ 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
@@ -602,7 +851,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 = Arc::new(CloudflareHttpClient);
+ let http_client: Arc = Arc::new(CloudflareHttpClient::new(ctx));
#[cfg(not(target_arch = "wasm32"))]
let http_client: Arc = 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..77a4b908b 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,18 @@ fn test_router() -> RouterService {
[ec]
passphrase = "test-secret-key-32-bytes-minimum"
+
+ [integrations.aps]
+ enabled = true
+ 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 +70,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 +120,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 +294,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 +338,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 +352,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..90ec710b0
--- /dev/null
+++ b/crates/trusted-server-adapter-cloudflare/wrangler.aps-runner-proxy.toml
@@ -0,0 +1,16 @@
+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 = "{}"
diff --git a/crates/trusted-server-adapter-fastly/Cargo.toml b/crates/trusted-server-adapter-fastly/Cargo.toml
index 47cc609b2..97b651661 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 }
@@ -31,6 +35,7 @@ sha2 = { 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 5e78a87ed..2dfcd87b1 100644
--- a/crates/trusted-server-adapter-fastly/src/app.rs
+++ b/crates/trusted-server-adapter-fastly/src/app.rs
@@ -29,6 +29,7 @@
//! | GET | `/_ts/api/v1/identify` | [`handle_identify`] |
//! | GET | `/_ts/set-tester` | [`handle_set_tester`] |
//! | GET | `/_ts/clear-tester` | [`handle_clear_tester`] |
+//! | GET | `/_ts/trace` | [`handle_trace_mode`] |
//! | OPTIONS | `/_ts/api/v1/identify` | [`cors_preflight_identify`] |
//! | POST | `/auction` | [`handle_auction`] |
//! | GET | `/first-party/proxy` | [`handle_first_party_proxy`] |
@@ -125,9 +126,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,
@@ -138,6 +138,7 @@ use trusted_server_core::settings_data::{
default_config_key, default_config_store_name, 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::{
@@ -171,6 +172,25 @@ pub(crate) fn build_state() -> Result, Report>
build_state_from_settings(load_settings_from_config_store()?)
}
+pub(crate) async fn dispatch_reserved_for_state(
+ state: &Arc,
+ req: Request,
+) -> Option {
+ 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() -> Result> {
let store_name = default_config_store_name();
let config_key = default_config_key();
@@ -290,8 +310,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=")
}
// ---------------------------------------------------------------------------
@@ -635,6 +655,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
@@ -1054,6 +1075,7 @@ enum NamedRouteHandler {
Identify,
SetTester,
ClearTester,
+ TraceMode,
Auction,
PageBids,
FirstPartyProxy,
@@ -1154,6 +1176,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],
@@ -1166,15 +1193,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",
@@ -1302,18 +1326,17 @@ impl Hooks for TrustedServerApp {
mod tests {
use std::sync::Arc;
+ #[cfg(feature = "aps-runner-proxy-integration-test")]
+ use super::dispatch_reserved_for_state;
use super::{
- AppState, NAMED_ROUTES, NamedRouteHandler, PAGE_BIDS_LEGACY_PATH, PAGE_BIDS_PATH,
- TrustedServerApp, build_per_request_services, build_state_from_settings,
- startup_error_router,
+ AppState, NAMED_ROUTES, NamedRouteHandler, PAGE_BIDS_PATH, TrustedServerApp,
+ build_state_from_settings, startup_error_router,
};
use base64::Engine as _;
use bytes::Bytes;
use edgezero_core::body::Body;
- use edgezero_core::context::RequestContext;
use edgezero_core::http::{Method, Response, StatusCode, header, request_builder};
use edgezero_core::key_value_store::NoopKvStore;
- use edgezero_core::params::PathParams;
use edgezero_core::router::RouterService;
use std::net::{IpAddr, Ipv4Addr};
use std::sync::Mutex;
@@ -1412,6 +1435,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"
@@ -1434,6 +1462,11 @@ mod tests {
server_url = "https://test-prebid.com/openrtb2/auction"
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
providers = ["prebid"]
@@ -1448,34 +1481,101 @@ mod tests {
TrustedServerApp::routes_for_state(&state)
}
- #[test]
- fn per_request_services_register_the_fastly_template_assembler() {
+ #[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");
- let context = RequestContext::new(
- empty_request(Method::GET, "/article"),
- PathParams::default(),
- );
+ block_on(dispatch_reserved_for_state(&state, request))
+ .expect("APS family should be reserved")
+ }
- let services = build_per_request_services(&state, &context);
- let template = format!(
- "article{}",
- trusted_server_core::publisher::AD_ASSEMBLY_SEAM
+ #[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"
);
- let fragment = b"";
- let assembled = services
- .template_assembler()
- .assemble(template.as_bytes(), fragment)
- .expect("Fastly services should provide ESI assembly");
-
assert_eq!(
- assembled,
- template
- .replace(
- trusted_server_core::publisher::AD_ASSEMBLY_SEAM,
- std::str::from_utf8(fragment).expect("fragment should be UTF-8")
- )
- .into_bytes()
+ 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
@@ -1611,18 +1711,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"
);
}
@@ -1751,83 +1851,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]
@@ -2039,6 +2085,55 @@ mod tests {
);
}
+ #[test]
+ fn dispatch_trace_route_is_disabled_by_default() {
+ let router = test_router();
+ let response = route(&router, empty_request(Method::GET, "/_ts/trace"));
+
+ assert_eq!(
+ response.status(),
+ StatusCode::NOT_FOUND,
+ "disabled trace route should return 404"
+ );
+ assert!(
+ response.headers().get(header::SET_COOKIE).is_none(),
+ "disabled trace route should not set a cookie"
+ );
+ }
+
+ #[test]
+ fn dispatch_trace_route_arms_cookie_and_redirects() {
+ let mut settings = test_settings();
+ settings.debug.trace_route_enabled = true;
+ let state = app_state_for_settings(settings);
+ let router = TrustedServerApp::routes_for_state(&state);
+ let response = route(&router, empty_request(Method::GET, "/_ts/trace"));
+
+ assert_eq!(
+ response.status(),
+ StatusCode::FOUND,
+ "enabled trace route should redirect to root"
+ );
+ assert_eq!(
+ response
+ .headers()
+ .get(header::LOCATION)
+ .and_then(|v| v.to_str().ok()),
+ Some("/"),
+ "trace route should redirect to /"
+ );
+ 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;"),
+ "trace route should arm the ts-trace cookie"
+ );
+ }
+
#[test]
fn dispatch_set_tester_sets_cookie_on_configured_domain() {
let mut settings = test_settings();
diff --git a/crates/trusted-server-adapter-fastly/src/backend.rs b/crates/trusted-server-adapter-fastly/src/backend.rs
index f2ff5d9e5..db55aa07b 100644
--- a/crates/trusted-server-adapter-fastly/src/backend.rs
+++ b/crates/trusted-server-adapter-fastly/src/backend.rs
@@ -328,10 +328,11 @@ impl<'a> BackendConfig<'a> {
/// Ensure a dynamic backend exists for this configuration and return its name.
///
- /// The name is a collision-resistant function of the complete backend spec
- /// (see `Self::compute_name`), so different specs — for example, different
- /// timeout values — always produce different backend registrations and a
- /// tight deadline cannot be silently widened by an earlier registration.
+ /// The backend name is derived from the scheme, host, port, certificate
+ /// setting, `first_byte_timeout`, and `between_bytes_timeout` to avoid
+ /// collisions. Different timeout values produce different backend
+ /// registrations so that a tight deadline cannot be silently widened by an
+ /// earlier registration.
///
/// # Errors
///
diff --git a/crates/trusted-server-adapter-fastly/src/main.rs b/crates/trusted-server-adapter-fastly/src/main.rs
index e9184ea71..ea3b41af9 100644
--- a/crates/trusted-server-adapter-fastly/src/main.rs
+++ b/crates/trusted-server-adapter-fastly/src/main.rs
@@ -174,7 +174,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),
}
@@ -193,7 +206,12 @@ fn edgezero_main(mut req: FastlyRequest) {
let asset_cache_policy = response.extensions_mut().remove::();
let request_filter_effects = response.extensions_mut().remove::();
- if !take_finalize_sentinel(&mut response) {
+ let should_finalize = response
+ .extensions()
+ .get::()
+ .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 {
@@ -335,8 +353,7 @@ fn send_edgezero_response(
mut response: HttpResponse,
request_filter_effects: Option<&RequestFilterEffects>,
) {
- apply_terminal_response_effects(&mut response, request_filter_effects);
- crate::middleware::enforce_uncacheable_cache_privacy(&mut response);
+ apply_send_response_effects(&mut response, request_filter_effects);
let (parts, body) = response.into_parts();
@@ -365,6 +382,21 @@ fn send_edgezero_response(
}
}
+fn apply_send_response_effects(
+ response: &mut HttpResponse,
+ request_filter_effects: Option<&RequestFilterEffects>,
+) {
+ if response
+ .extensions()
+ .get::()
+ .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,
@@ -583,6 +615,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 638aed82b..21f0537c2 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::{
ClientInfo, GeoInfo, PlatformBackend, PlatformBackendSpec, PlatformConfigStore, PlatformError,
PlatformGeo, PlatformHttpClient, PlatformHttpRequest, PlatformImageOptimizerCrop,
PlatformImageOptimizerCropMode, PlatformImageOptimizerOptions, PlatformImageOptimizerParams,
PlatformImageOptimizerRegion, PlatformKvStore, PlatformPendingRequest, PlatformResponse,
- PlatformSecretStore, PlatformSelectResult, StoreId, StoreName,
+ PlatformSecretStore, PlatformSelectResult, ProxyHeaderEvidenceV1, ProxyResponseEvidenceV1,
+ RawProxyPolicyV1, RawProxyResponseV1, StoreId, StoreName,
};
use trusted_server_core::settings::TrustedClientIpConfig;
@@ -532,6 +537,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 {
+ 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
@@ -546,6 +576,51 @@ fn apply_fastly_cache_bypass(request: &mut fastly::Request, bypass_cache: bool)
/// `fastly::http::request::select()`.
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> {
+ 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::().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 {
@@ -572,6 +647,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> {
+ 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,
@@ -985,6 +1142,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 06bb1a15a..67bc9b52f 100644
--- a/crates/trusted-server-adapter-spin/src/app.rs
+++ b/crates/trusted-server-adapter-spin/src/app.rs
@@ -11,6 +11,8 @@ use error_stack::Report;
use trusted_server_core::auction::endpoints::handle_auction;
use trusted_server_core::auction::{AuctionOrchestrator, build_orchestrator};
use trusted_server_core::cache_policy::EdgeCacheHeader;
+#[cfg(all(feature = "aps-runner-proxy-integration-test", target_arch = "wasm32"))]
+use trusted_server_core::config_payload::settings_from_config_blob;
use trusted_server_core::ec::EcContext;
use trusted_server_core::ec::admin::{
admin_ec_lookup_not_supported as core_admin_ec_lookup_not_supported,
@@ -26,14 +28,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, NormalizeMiddleware};
use crate::platform::build_runtime_services;
@@ -55,11 +57,26 @@ 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, Report> {
let settings = Settings::from_toml(include_str!("../../../trusted-server.example.toml"))?;
build_state_with_settings(settings)
}
+#[cfg(all(feature = "aps-runner-proxy-integration-test", target_arch = "wasm32"))]
+fn build_state() -> Result, Report> {
+ 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 settings = settings_from_config_blob(&envelope)?;
+ build_state_with_settings(settings)
+}
+
/// Build the application state from explicit settings.
///
/// # Errors
@@ -79,6 +96,49 @@ fn build_state_with_settings(
}))
}
+async fn dispatch_reserved_for_state(state: &Arc, req: Request) -> Option {
+ 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, Report> {
+ 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, Report> {
+ let state = build_state()?;
+ Ok(dispatch_reserved_for_state(&state, req).await)
+}
+
// ---------------------------------------------------------------------------
// Publisher response helper
// ---------------------------------------------------------------------------
@@ -148,7 +208,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]),
@@ -159,9 +219,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]),
@@ -581,6 +642,21 @@ fn build_router(state: &Arc) -> RouterService {
}
};
+ // GET /_ts/trace — render-trace toggle: arms/disarms the ts-trace
+ // cookie and redirects to `/`. Gated by [debug] trace_route_enabled
+ // (404 when off).
+ 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::(
+ handle_trace_mode(&s.settings, req.uri().query())
+ .unwrap_or_else(|e| http_error(&e)),
+ )
+ }
+ };
+
// GET /_ts/page-bids — SPA re-auction endpoint.
let s = Arc::clone(&state);
let page_bids_handler = move |ctx: RequestContext| {
@@ -695,9 +771,7 @@ fn build_router(state: &Arc) -> 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();
@@ -792,27 +866,13 @@ fn build_router(state: &Arc) -> 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)
@@ -823,6 +883,7 @@ fn build_router(state: &Arc) -> 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
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 {
+ 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::(req).await
}
diff --git a/crates/trusted-server-adapter-spin/src/platform.rs b/crates/trusted-server-adapter-spin/src/platform.rs
index 492f1a518..e5b5f2daf 100644
--- a/crates/trusted-server-adapter-spin/src/platform.rs
+++ b/crates/trusted-server-adapter-spin/src/platform.rs
@@ -25,7 +25,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
@@ -472,8 +473,56 @@ struct SpinPendingResponse {
#[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, Report> {
+ 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, Report> {
+ 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,
@@ -559,6 +608,173 @@ 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 {
+ 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> {
+ 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 timeout_nanos = policy.total_timeout.as_nanos().try_into().map_err(|_| {
+ Report::new(PlatformError::HttpClient)
+ .attach("raw proxy timeout exceeds WASI HTTP duration range")
+ })?;
+ let options = RequestOptions::new();
+ options
+ .set_connect_timeout(Some(timeout_nanos))
+ .map_err(|_| {
+ Report::new(PlatformError::Unsupported)
+ .attach("Spin raw proxy connect timeout is unavailable")
+ })?;
+ options
+ .set_first_byte_timeout(Some(timeout_nanos))
+ .map_err(|_| {
+ Report::new(PlatformError::Unsupported)
+ .attach("Spin raw proxy first-byte timeout is unavailable")
+ })?;
+ options
+ .set_between_bytes_timeout(Some(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"))]
@@ -578,6 +794,14 @@ impl PlatformHttpClient for SpinPlatformHttpClient {
self.execute(request).await
}
+ async fn send_raw_proxy_v1(
+ &self,
+ request: PlatformHttpRequest,
+ policy: RawProxyPolicyV1,
+ ) -> Result> {
+ self.execute_raw_proxy_v1(request, policy).await
+ }
+
async fn send_async(
&self,
request: PlatformHttpRequest,
@@ -801,6 +1025,22 @@ mod tests {
use flate2::write::GzEncoder;
use std::io::Write as _;
+ #[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..1f0693987 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,18 @@ fn test_router() -> RouterService {
[ec]
passphrase = "test-secret-key-32-bytes-minimum"
+
+ [integrations.aps]
+ enabled = true
+ 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 +60,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 +74,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 +456,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 +605,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..9cf6aca02 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::>()
.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\
@@ -258,7 +261,8 @@ mod tests {
// 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\
+ 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 cb11a0a0c..ac99f101d 100644
--- a/crates/trusted-server-cli/src/commands/audit/ad_templates.rs
+++ b/crates/trusted-server-cli/src/commands/audit/ad_templates.rs
@@ -625,7 +625,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 0485214fa..105c02156 100644
--- a/crates/trusted-server-cli/src/commands/audit/generate/mod.rs
+++ b/crates/trusted-server-cli/src/commands/audit/generate/mod.rs
@@ -1677,7 +1677,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",
@@ -1757,7 +1757,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",
@@ -1775,7 +1775,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",
@@ -2096,7 +2096,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.
@@ -2366,7 +2366,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();
@@ -2473,7 +2473,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());
@@ -2510,7 +2510,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 1c401cb3d..433a34b4d 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
@@ -526,6 +526,11 @@ 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 {
+ // The hard-cutover schema requires an explicit switch. A generated
+ // section is active by definition because the operator requested it.
+ creative["enabled"] = toml_edit::value(true);
+ }
if let Some(network_id) = keys.network_id {
creative["gam_network_id"] = toml_edit::value(network_id);
}
@@ -555,7 +560,13 @@ fn ensure_only_managed_fields_changed(before: &str, after: &str) -> CliResult<()
.get_mut("creative_opportunities")
.and_then(toml::Value::as_table_mut)
{
- for key in ["slot", "gam_network_id", "section_root", "section_segment"] {
+ for key in [
+ "slot",
+ "enabled",
+ "gam_network_id",
+ "section_root",
+ "section_segment",
+ ] {
creative.remove(key);
}
creative.is_empty()
@@ -808,13 +819,14 @@ slot_id = "sidebar"
}
fn existing_config(toml_str: &str) -> CreativeOpportunitiesConfig {
- toml::from_str::(toml_str).expect("valid creative config")
+ toml::from_str::(&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\
@@ -827,6 +839,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\""),
@@ -947,7 +963,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");
@@ -975,7 +991,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(
@@ -999,7 +1015,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(
@@ -1025,7 +1041,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");
@@ -1087,6 +1103,11 @@ slot_id = "sidebar"
value["creative_opportunities"]["gam_network_id"].as_str(),
Some("222")
);
+ assert_eq!(
+ value["creative_opportunities"]["enabled"].as_bool(),
+ Some(true),
+ "a newly generated hard-cutover section must be loadable"
+ );
}
#[test]
@@ -1094,6 +1115,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\
@@ -1109,6 +1131,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", ""),
@@ -1150,7 +1173,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())
@@ -1340,7 +1363,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())
@@ -1372,8 +1395,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");
@@ -1398,6 +1420,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";
@@ -1421,6 +1444,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";
@@ -1721,7 +1745,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(
@@ -1758,7 +1782,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 11138ccd8..e4ea2b628 100644
--- a/crates/trusted-server-cli/src/commands/audit/mod.rs
+++ b/crates/trusted-server-cli/src/commands/audit/mod.rs
@@ -466,7 +466,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)
.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 5caab273b..e0d6a8c34 100644
--- a/crates/trusted-server-cli/tests/config_env_overlay.rs
+++ b/crates/trusted-server-cli/tests/config_env_overlay.rs
@@ -50,6 +50,7 @@ fn migrated_legacy_project() -> MigratedProject {
// 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");
fs::write(&config_path, document.to_string()).expect("should write migrated config");
@@ -156,7 +157,7 @@ fn migrated_legacy_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..20993125e 100644
--- a/crates/trusted-server-core/benches/html_processor_bench.rs
+++ b/crates/trusted-server-core/benches/html_processor_bench.rs
@@ -16,11 +16,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 fdf387e93..c47586a67 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,
+ delivered_winner_slots: HashSet,
+ dropped_winner_count: usize,
+}
+
+fn exact_auction_response_v1(
+ result: &OrchestrationResult,
+ settings: &Settings,
+ auction_request: &AuctionRequest,
+ request_origin: &str,
+ ec_allowed: bool,
+) -> Result> {
+ 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 = 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.
@@ -221,15 +298,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
@@ -326,10 +409,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,
@@ -357,7 +441,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),
},
)
})
@@ -366,8 +450,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
);
@@ -572,11 +656,10 @@ 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::test_support::tests::{crate_test_settings_str, create_test_settings};
+ use crate::platform::{ClientInfo, PlatformResponse};
+ use crate::test_support::tests::create_test_settings;
use base64::Engine as _;
use base64::engine::general_purpose::STANDARD as BASE64;
use serde_json::json;
@@ -661,41 +744,25 @@ mod tests {
}
}
- /// Provider used to prove that direct `/auction` remains available when
- /// publisher server-side ad templates are disabled.
- struct TemplateSwitchProbeProvider {
- calls: Arc>,
+ struct CallRecordingProvider {
+ called: Arc>,
}
#[async_trait::async_trait(?Send)]
- impl AuctionProvider for TemplateSwitchProbeProvider {
+ impl AuctionProvider for CallRecordingProvider {
fn provider_name(&self) -> &'static str {
- "template_switch_probe"
+ "call_recording_provider"
}
async fn request_bids(
&self,
_request: &AuctionRequest,
- context: &AuctionContext<'_>,
+ _context: &AuctionContext<'_>,
) -> Result> {
- *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(
@@ -703,11 +770,7 @@ mod tests {
_response: PlatformResponse,
_response_time_ms: u64,
) -> Result> {
- 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 {
@@ -715,35 +778,30 @@ mod tests {
}
fn backend_name(&self, _services: &RuntimeServices, _timeout_ms: u32) -> Option {
- Some("template-switch-probe-backend".to_string())
+ Some("call-recording-backend".to_string())
}
}
#[tokio::test]
- async fn direct_auction_remains_available_when_templates_are_disabled() {
- let settings_toml = format!(
- "{}\n[auction]\nenabled = true\nproviders = [\"template_switch_probe\"]\n\n[creative_opportunities]\nenabled = false\ngam_network_id = \"12345\"\n",
- crate_test_settings_str()
+ async fn disabled_creative_opportunities_do_not_disable_direct_auction() {
+ let mut settings = create_test_settings();
+ settings.creative_opportunities = Some(
+ toml::from_str("enabled = false\ngam_network_id = \"12345\"\n")
+ .expect("should build disabled creative opportunity config"),
);
- let settings = Settings::from_toml(&settings_toml)
- .expect("should parse settings with disabled templates");
- let calls = Arc::new(Mutex::new(0));
- let mut orchestrator = AuctionOrchestrator::new(settings.auction.clone());
- orchestrator.register_provider(Arc::new(TemplateSwitchProbeProvider {
- calls: Arc::clone(&calls),
+ let config = AuctionConfig {
+ enabled: true,
+ providers: vec!["call_recording_provider".to_string()],
+ timeout_ms: 2_000,
+ mediator: None,
+ ..Default::default()
+ };
+ let called = Arc::new(Mutex::new(false));
+ let mut orchestrator = AuctionOrchestrator::new(config);
+ 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)
- .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": [{
@@ -759,7 +817,7 @@ mod tests {
))
.expect("should build auction request");
- let response = handle_auction(
+ let _ = handle_auction(
&settings,
&orchestrator,
None,
@@ -768,15 +826,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]
@@ -844,6 +899,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 e09912aab..cccd9c24f 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,
+ auction_request: &AuctionRequest,
+ ec_allowed: bool,
+) -> Result<(), Report> {
+ 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,
+ /// Whether the exact aggregate overflow rule replaced every winner.
+ pub reduced_for_size: bool,
+ }
+
+ fn projection_contract_error(message: impl Into) -> Report {
+ 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) -> 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> {
+ 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> {
+ 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> {
+ ensure!(
+ json.len() <= MAX_BROWSER_AUCTION_PROJECTION_BYTES,
+ projection_contract_error("Browser auction projection exceeds 8 MiB")
+ );
+ let projection =
+ serde_json::from_str::(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>,
+ }
+
+ #[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>,
+ 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, Report> {
+ 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,
-}
-
-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,
@@ -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, Report> {
- 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> {
+ 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, Report> {
+ 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, AuctionDeliveryReport), Report> {
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,36 +1043,17 @@ 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)]
mod tests {
use super::*;
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;
@@ -609,6 +1109,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(),
}
@@ -617,6 +1122,9 @@ mod tests {
fn make_bid(slot_id: &str, bidder: &str, price: Option) -> 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("Ad
".to_string()),
@@ -657,6 +1165,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(),
}
@@ -1159,7 +1672,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)));
@@ -1199,18 +1713,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("Ad
"),
- "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!("Ad
"));
assert_eq!(bid["crid"], json!("appnexus-creative"));
assert_eq!(bid["w"], json!(300));
assert_eq!(bid["h"], json!(250));
@@ -1275,7 +1778,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}"
);
}
@@ -1288,7 +1791,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());
@@ -1298,7 +1800,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!(
@@ -1341,7 +1843,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,
@@ -1355,8 +1857,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;
@@ -1400,7 +1900,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}"
);
}
@@ -1432,6 +1932,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(),
};
@@ -1448,26 +1953,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("".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("".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(),
@@ -1484,37 +1982,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")
@@ -1523,30 +2005,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("Ad
")),
- "should preserve ordinary creative markup: {}",
- ordinary["adm"]
- );
+ assert_eq!(ordinary["adm"], "Ad
");
let renderer = bids
.iter()
.find(|bid| bid["impid"] == "renderer")
@@ -1561,11 +2029,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("".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(),
@@ -1579,20 +2074,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("Ad
"),
- "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"
);
}
@@ -1605,7 +2096,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(),
@@ -1672,6 +2163,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(),
};
@@ -1694,7 +2190,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));
@@ -1712,6 +2209,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(),
};
@@ -1746,12 +2248,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("Ad
")),
- "should preserve top creative: {}",
- top_bid["adm"]
+ assert_eq!(
+ top_bid["adm"],
+ json!("Ad
"),
+ "should preserve top creative"
);
let sidebar_seatbid = seatbids
@@ -1779,12 +2279,10 @@ mod tests {
json!(1.25),
"should preserve sidebar price"
);
- assert!(
- sidebar_bid["adm"]
- .as_str()
- .is_some_and(|adm| adm.contains("Sidebar
")),
- "should preserve sidebar creative: {}",
- sidebar_bid["adm"]
+ assert_eq!(
+ sidebar_bid["adm"],
+ json!("Sidebar
"),
+ "should preserve sidebar creative"
);
assert_eq!(
json["ext"]["orchestrator"]["total_bids"],
@@ -1823,9 +2321,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]
@@ -1850,10 +2354,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")
@@ -2026,4 +2536,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::(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/orchestrator.rs b/crates/trusted-server-core/src/auction/orchestrator.rs
index 728cc1efe..3494b7361 100644
--- a/crates/trusted-server-core/src/auction/orchestrator.rs
+++ b/crates/trusted-server-core/src/auction/orchestrator.rs
@@ -12,9 +12,25 @@ use crate::error::TrustedServerError;
use crate::platform::{PlatformPendingRequest, RuntimeServices};
use super::config::AuctionConfig;
-use super::provider::{AuctionProvider, ProviderParseState, ProviderRequestOutcome};
+use super::provider::{
+ AuctionProvider, ProviderParseState, ProviderRequestOutcome, ProviderSlotDisposition,
+ ProviderSlotOutcome,
+};
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,
+};
+
+const CANDIDATE_ID_BYTES: usize = 9;
+const CANDIDATE_ID_COLLISION_RETRIES: usize = 8;
+const MAX_UPSTREAM_BID_ID_BYTES: usize = 64;
+
+struct NormalizedProviderResponses {
+ outcomes: Vec,
+ candidates: HashMap,
+}
/// In-flight auction requests dispatched to SSP backends.
///
@@ -43,23 +59,6 @@ struct ProviderLaunchState {
parse_state: Option,
}
-/// Outcome of attempting to dispatch split-phase auction provider requests.
-pub enum DispatchAuctionOutcome {
- /// No provider request was started and no provider failure was observed.
- NotStarted,
- /// No provider request could be launched, but launch failures were observed.
- DispatchFailed {
- /// Original auction request.
- request: AuctionRequest,
- /// Provider launch-failure responses.
- provider_responses: Vec,
- /// Elapsed dispatch time.
- elapsed_ms: u64,
- },
- /// One or more providers produced an immediate response or started a request.
- Dispatched(DispatchedAuction),
-}
-
impl DispatchedAuction {
/// Consume the dispatch token without collecting provider responses.
#[must_use]
@@ -182,6 +181,23 @@ fn provider_timeout_response(provider_name: &str, response_time_ms: u64) -> Auct
.with_metadata("message", serde_json::json!("Provider request timed out"))
}
+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,
@@ -205,6 +221,7 @@ fn snapshot_context_request(request: &Request) -> Request {
pub struct AuctionOrchestrator {
config: AuctionConfig,
providers: HashMap>,
+ identity_generator: Arc,
}
impl AuctionOrchestrator {
@@ -214,6 +231,19 @@ impl AuctionOrchestrator {
Self {
config,
providers: HashMap::new(),
+ identity_generator: Arc::new(SystemAuctionIdentityGenerator),
+ }
+ }
+
+ #[cfg(test)]
+ fn with_identity_generator(
+ config: AuctionConfig,
+ identity_generator: Arc,
+ ) -> Self {
+ Self {
+ config,
+ providers: HashMap::new(),
+ identity_generator,
}
}
@@ -277,6 +307,366 @@ impl AuctionOrchestrator {
Ok(())
}
+ 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))
+ })
+ }
+
+ fn eligible_slot_ids(&self, provider_name: &str, request: &AuctionRequest) -> HashSet {
+ 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) -> Option {
+ 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 {
+ 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
+ }
+
+ fn normalize_provider_responses(
+ &self,
+ request: &AuctionRequest,
+ responses: &mut [AuctionResponse],
+ ) -> 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 = self.eligible_slot_ids(&response.provider, request);
+ let response_failure = Self::response_failure_reason(response);
+ let mut upstream_counts = HashMap::::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::>()
+ })
+ .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
+ && self
+ .providers
+ .get(&response.provider)
+ .is_some_and(|provider| {
+ provider.supports_media_type(&format.media_type)
+ })
+ })
+ });
+ 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 = 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,
+ 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 = self
+ .config
+ .provider_names()
+ .iter()
+ .filter(|provider| self.provider_is_eligible_for_slot(provider, slot))
+ .count();
+ if eligible_provider_count == 0 {
+ return SlotAuctionDecisionV1::Failed {
+ slot: slot.id.clone(),
+ reason: AuctionSlotFailureReason::SlotNotEligible,
+ };
+ }
+
+ let mut failures: Vec = 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,
+ ) -> Result {
+ 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:
@@ -294,6 +684,20 @@ impl AuctionOrchestrator {
) -> Result> {
let start_time = Instant::now();
+ if !self.config.enabled {
+ return Ok(OrchestrationResult {
+ provider_responses: Vec::new(),
+ mediator_response: None,
+ winning_bids: HashMap::new(),
+ decision_set: AuctionDecisionSetV1::failed(
+ request,
+ AuctionSlotFailureReason::AuctionDisabled,
+ ),
+ total_time_ms: 0,
+ metadata: HashMap::new(),
+ });
+ }
+
// Auto-detect strategy based on mediator configuration
let (strategy_name, result) = if self.config.has_mediator() {
(
@@ -330,119 +734,125 @@ impl AuctionOrchestrator {
context: &AuctionContext<'_>,
) -> Result> {
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,
- provider_responses: Some(&provider_responses),
- services: context.services,
- };
-
- 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",
+ let mut mediation_failed = false;
+ let mut mediator_response = None;
+ let mut winning_bids = None;
+
+ 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);
+ if remaining_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: context
+ .services
+ .backend()
+ .canonicalize_transport_timeout_ms(remaining_ms, mediator.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
+ {
+ Ok(ProviderRequestOutcome::Immediate(response)) => Some(response),
+ Ok(ProviderRequestOutcome::Pending {
+ request: pending,
+ parse_state,
+ }) => match mediator_context.services.http_client().wait(pending).await {
+ Ok(platform_response) => mediator
+ .parse_response_with_context_and_state(
+ platform_response,
+ start_time.elapsed().as_millis() as u64,
+ request,
+ &mediator_context,
+ parse_state.as_deref(),
+ )
+ .await
+ .inspect_err(|error| {
+ log::warn!(
+ "Mediator '{}' parse failed: {error:?}",
+ mediator.provider_name()
+ );
+ })
+ .ok(),
+ Err(error) => {
+ log::warn!(
+ "Mediator '{}' request failed: {error:?}",
+ mediator.provider_name()
+ );
+ None
+ }
+ },
+ Err(error) => {
+ log::warn!(
+ "Mediator '{}' failed to launch: {error:?}",
mediator.provider_name()
- ),
- })?;
-
- mediator
- .parse_response_with_context_and_state(
- platform_resp,
- start_time.elapsed().as_millis() as u64,
- request,
- &mediator_context,
- parse_state.as_deref(),
- )
- .await
- .change_context(TrustedServerError::Auction {
- message: format!("Mediator {} parse failed", 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(),
})
@@ -454,14 +864,18 @@ impl AuctionOrchestrator {
request: &AuctionRequest,
context: &AuctionContext<'_>,
) -> Result> {
- 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(),
})
@@ -479,9 +893,7 @@ impl AuctionOrchestrator {
let provider_names = self.config.provider_names();
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
@@ -490,14 +902,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!(
@@ -513,8 +925,6 @@ impl AuctionOrchestrator {
let mut backend_to_provider: HashMap = HashMap::new();
let mut pending_requests: Vec = 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,
@@ -545,20 +955,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;
@@ -585,14 +998,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!(
@@ -605,6 +1017,21 @@ 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 '{}' pending request has no backend name; response cannot be correlated",
+ provider.provider_name()
+ );
+ responses.push(provider_launch_failed_response(
+ provider.provider_name(),
+ start_time.elapsed().as_millis() as u64,
+ ));
+ continue;
+ };
if backend_to_provider.contains_key(&request_backend_name) {
log::warn!(
"Provider '{}' resolved backend name '{}' already belongs to another provider; skipping launch",
@@ -634,12 +1061,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;
@@ -657,18 +1086,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 = Duration::from_millis(u64::from(context.timeout_ms));
@@ -685,7 +1103,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;
@@ -742,7 +1160,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]
@@ -850,9 +1271,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(¤t_winner.bidder),
+ current_winner.bid_id.as_deref().unwrap_or_default(),
+ ))
+ }),
None => true,
};
@@ -919,23 +1351,6 @@ impl AuctionOrchestrator {
.collect()
}
- /// Get a provider by name.
- fn get_provider(
- &self,
- name: &str,
- ) -> Result<&Arc, Report> {
- self.providers.get(name).ok_or_else(|| {
- log::warn!(
- "Provider '{}' configured but not registered. Available providers: {:?}",
- name,
- self.providers.keys().collect::>()
- );
- Report::new(TrustedServerError::Auction {
- message: format!("Provider '{}' not registered", name),
- })
- })
- }
-
/// Dispatch SSP bid requests without blocking WASM.
///
/// Calls each enabled provider's [`AuctionProvider::request_bids`] (which
@@ -943,28 +1358,31 @@ 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,
request: &AuctionRequest,
context: &AuctionContext<'_>,
- ) -> DispatchAuctionOutcome {
+ ) -> DispatchedAuction {
let provider_names = self.config.provider_names();
- if provider_names.is_empty() {
- return DispatchAuctionOutcome::NotStarted;
- }
+ let auction_start = Instant::now();
+ let mut backend_to_provider: HashMap = HashMap::new();
+ let mut pending_requests: Vec = Vec::new();
+ let mut completed_responses: Vec = Vec::new();
+ let mut immediate_response_count = 0usize;
// Mirror run_providers_parallel: reject multi-provider fan-out before
// any request launches when the platform executes `send_async` eagerly
// (e.g. Cloudflare Workers, Spin). Sequential execution would accrue
// the sum of provider latencies before the origin fetch and then fail
// collection with empty bids.
- if provider_names.len() > 1 && !context.services.http_client().supports_concurrent_fanout()
- {
+ let fanout_supported = provider_names.len() <= 1
+ || context.services.http_client().supports_concurrent_fanout();
+ if !fanout_supported {
log::warn!(
"{} auction providers configured, but this platform's HTTP client \
executes requests sequentially — skipping initial-page auction \
@@ -972,16 +1390,14 @@ impl AuctionOrchestrator {
concurrent fan-out support",
provider_names.len(),
);
- return DispatchAuctionOutcome::NotStarted;
+ completed_responses.extend(
+ provider_names
+ .iter()
+ .map(|provider| provider_launch_failed_response(provider, 0)),
+ );
}
- let auction_start = Instant::now();
- let mut backend_to_provider: HashMap = HashMap::new();
- let mut pending_requests: Vec = Vec::new();
- let mut completed_responses: Vec = Vec::new();
- let mut immediate_response_count = 0usize;
-
- for provider_name in provider_names {
+ for provider_name in provider_names.iter().filter(|_| fanout_supported) {
let provider = match self.providers.get(provider_name) {
Some(p) => p,
None => {
@@ -1014,20 +1430,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));
@@ -1048,16 +1468,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",
@@ -1069,9 +1483,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,
);
@@ -1101,7 +1520,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;
@@ -1118,18 +1540,6 @@ impl AuctionOrchestrator {
}
}
- if pending_requests.is_empty() && immediate_response_count == 0 {
- return if completed_responses.is_empty() {
- DispatchAuctionOutcome::NotStarted
- } else {
- DispatchAuctionOutcome::DispatchFailed {
- request: request.clone(),
- provider_responses: completed_responses,
- elapsed_ms: auction_start.elapsed().as_millis() as u64,
- }
- };
- }
-
log::info!(
"Dispatched {} SSP request(s) with {} immediate response(s) (timeout: {}ms)",
pending_requests.len(),
@@ -1137,7 +1547,7 @@ impl AuctionOrchestrator {
context.timeout_ms
);
- DispatchAuctionOutcome::Dispatched(DispatchedAuction {
+ DispatchedAuction {
pending_requests,
backend_to_provider,
completed_responses,
@@ -1146,7 +1556,7 @@ impl AuctionOrchestrator {
floor_prices: self.floor_prices_by_slot(request),
provider_request_context: Box::new(snapshot_context_request(context.request)),
request: request.clone(),
- })
+ }
}
/// Collect bid responses from a previously-dispatched auction.
@@ -1239,7 +1649,10 @@ impl AuctionOrchestrator {
auction_response.bids.len(),
auction_response.response_time_ms
);
- responses.push(auction_response);
+ responses.push(canonical_provider_response(
+ &state.provider_name,
+ auction_response,
+ ));
}
Err(e) => {
log::warn!(
@@ -1315,50 +1728,25 @@ impl AuctionOrchestrator {
));
}
backend_to_provider.clear();
-
- let (mediator_response, winning_bids) = if let Some(mediator_name) = &self.config.mediator {
- match self.providers.get(mediator_name.as_str()) {
- Some(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 normalized = self.normalize_provider_responses(&request, &mut responses);
+ let mut mediation_failed = false;
+ let mut mediator_response = None;
+ let mut mediated_winners = None;
+
+ if let Some(mediator_name) = &self.config.mediator {
+ if let Some(mediator) = self.providers.get(mediator_name.as_str()) {
+ let remaining = remaining_budget_ms(auction_start, timeout_ms);
+ if remaining == 0 {
+ log::warn!(
+ "A_deadline exhausted before mediator '{}' — using direct fallback",
+ mediator.provider_name(),
+ );
+ mediation_failed = true;
+ } else {
let mediator_timeout = services
.backend()
.canonicalize_transport_timeout_ms(remaining, mediator.timeout_ms());
- if mediator_timeout == 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: HashMap::new(),
- };
- }
let mediator_start = Instant::now();
- log::info!(
- "Running mediator '{}' with {}ms budget (A_deadline remaining: {}ms, configured: {}ms)",
- mediator.provider_name(),
- mediator_timeout,
- 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())
@@ -1370,93 +1758,84 @@ impl AuctionOrchestrator {
provider_responses: Some(&responses),
services: context.services,
};
- let mediator_response =
+ let raw_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) => match mediator
+ }) => match services.http_client().wait(pending).await {
+ Ok(platform_response) => mediator
.parse_response_with_context_and_state(
- platform_resp,
+ platform_response,
mediator_start.elapsed().as_millis() as u64,
&request,
&mediator_context,
parse_state.as_deref(),
)
.await
- {
- Ok(response) => Some(response),
- Err(error) => {
+ .inspect_err(|error| {
log::warn!(
- "Mediator '{}' parse failed: {:?}",
- mediator.provider_name(),
- error
+ "Mediator '{}' parse failed: {error:?}",
+ mediator.provider_name()
);
- None
- }
- },
+ })
+ .ok(),
Err(error) => {
- log::warn!("Mediator request failed: {:?}", error);
+ log::warn!("Mediator request failed: {error:?}");
None
}
},
Err(error) => {
log::warn!(
- "Mediator '{}' failed to dispatch: {:?}",
- mediator.provider_name(),
- error
+ "Mediator '{}' failed to dispatch: {error:?}",
+ mediator.provider_name()
);
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)
+ 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(()) => mediation_failed = true,
+ }
} else {
- (None, self.select_winning_bids(&responses, &floor_prices))
+ mediation_failed = true;
}
}
- None => {
- // lgtm[rust/cleartext-logging]
- // The mediator name is a static config identifier, not a secret.
- log::warn!("Mediator '{}' not registered", mediator_name);
- (None, self.select_winning_bids(&responses, &floor_prices))
- }
+ } else {
+ log::warn!("Mediator '{}' not registered", mediator_name);
+ 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: HashMap::new(),
}
@@ -1478,6 +1857,8 @@ pub struct OrchestrationResult {
pub mediator_response: Option,
/// Winning bids per slot
pub winning_bids: HashMap,
+ /// 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
@@ -1514,12 +1895,14 @@ mod tests {
use web_time::Instant;
use crate::auction::config::AuctionConfig;
- use crate::auction::orchestrator::DispatchAuctionOutcome;
- use crate::auction::provider::{AuctionProvider, ProviderRequestOutcome};
+ use crate::auction::provider::{
+ AuctionProvider, ProviderRequestOutcome, ProviderSlotDisposition,
+ };
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::platform::test_support::{
@@ -1533,9 +1916,10 @@ mod tests {
use crate::test_support::tests::crate_test_settings_str;
use error_stack::{Report, ResultExt};
use std::collections::{HashMap, HashSet};
+ use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
- use super::AuctionOrchestrator;
+ use super::{AuctionIdentityGenerator, AuctionOrchestrator};
// ---------------------------------------------------------------------------
// Minimal test double for AuctionProvider
@@ -1544,6 +1928,46 @@ mod tests {
struct StubAuctionProvider {
name: &'static str,
backend: &'static str,
+ configured_timeout_ms: u32,
+ predicted_timeouts: Option>>>,
+ request_timeouts: Option>>>,
+ }
+
+ 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>>,
+ request_timeouts: Arc>>,
+ ) -> Self {
+ Self {
+ name,
+ backend,
+ configured_timeout_ms,
+ predicted_timeouts: Some(predicted_timeouts),
+ request_timeouts: Some(request_timeouts),
+ }
+ }
+
+ fn record(slot: &Option>>>, timeout_ms: u32) {
+ if let Some(observed) = slot {
+ observed
+ .lock()
+ .expect("should lock observed timeouts")
+ .push(timeout_ms);
+ }
+ }
}
#[async_trait::async_trait(?Send)]
@@ -1557,6 +1981,7 @@ mod tests {
_request: &AuctionRequest,
context: &AuctionContext<'_>,
) -> Result> {
+ Self::record(&self.request_timeouts, context.timeout_ms);
let req = PlatformHttpRequest::new(
http::Request::builder()
.method("POST")
@@ -1607,82 +2032,18 @@ mod tests {
.with_metadata("context_timeout_ms", serde_json::json!(context.timeout_ms)))
}
- fn timeout_ms(&self) -> u32 {
- 125
- }
-
- fn backend_name(&self, _services: &RuntimeServices, _timeout_ms: u32) -> Option {
- Some(self.backend.to_string())
- }
- }
-
- struct RecordingTimeoutProvider {
- name: &'static str,
- backend: &'static str,
- configured_timeout_ms: u32,
- predicted: Arc>>,
- requested: Arc>>,
- }
-
- #[async_trait::async_trait(?Send)]
- impl AuctionProvider for RecordingTimeoutProvider {
- fn provider_name(&self) -> &'static str {
- self.name
- }
-
- async fn request_bids(
- &self,
- _request: &AuctionRequest,
- context: &AuctionContext<'_>,
- ) -> Result> {
- self.requested
- .lock()
- .expect("should lock requested timeouts")
- .push(context.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> {
- 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 {
- self.predicted
- .lock()
- .expect("should lock predicted timeouts")
- .push(timeout_ms);
+ Self::record(&self.predicted_timeouts, timeout_ms);
Some(self.backend.to_string())
}
}
+ /// Provider whose `backend_name` prediction deliberately differs from the
+ /// backend name its `request_bids` puts on the wire.
struct DivergentBackendProvider {
name: &'static str,
predicted: &'static str,
@@ -1700,7 +2061,7 @@ mod tests {
_request: &AuctionRequest,
context: &AuctionContext<'_>,
) -> Result> {
- let request = PlatformHttpRequest::new(
+ let req = PlatformHttpRequest::new(
http::Request::builder()
.method("POST")
.uri("https://example.com/bid")
@@ -1711,7 +2072,7 @@ mod tests {
context
.services
.http_client()
- .send_async(request)
+ .send_async(req)
.await
.change_context(TrustedServerError::Auction {
message: "divergent launch failed".to_string(),
@@ -1772,14 +2133,14 @@ mod tests {
configured_timeout_ms: u32,
predicted: &Arc>>,
requested: &Arc>>,
- ) -> 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
@@ -1789,7 +2150,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(),
@@ -1803,6 +2164,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
@@ -1823,28 +2187,131 @@ mod tests {
cache_path: None,
metadata: HashMap::new(),
}
- }
+ }
+
+ 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(())
+ }
+ }
+
+ fn mediated_bid(nurl: Option) -> 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("ad
".to_string()),
+ adomain: None,
+ bidder: "mediator".to_string(),
+ width: 728,
+ height: 90,
+ nurl: nurl.clone(),
+ burl: nurl,
+ bid_id: None,
+ ad_id: Some("creative-123".to_string()),
+ creative_id: None,
+ renderer: None,
+ cache_id: Some("cache-abc".to_string()),
+ cache_host: None,
+ cache_path: None,
+ metadata: HashMap::new(),
+ }
+ }
+
+ 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> {
+ 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> {
+ 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 mediated_bid(nurl: Option) -> Bid {
- Bid {
- slot_id: "header-banner".to_string(),
- price: Some(2.5),
- currency: "USD".to_string(),
- creative: Some("ad
".to_string()),
- adomain: None,
- bidder: "mediator".to_string(),
- width: 728,
- height: 90,
- nurl: nurl.clone(),
- burl: nurl,
- bid_id: None,
- ad_id: Some("creative-123".to_string()),
- creative_id: None,
- renderer: None,
- cache_id: Some("cache-abc".to_string()),
- cache_host: None,
- cache_path: None,
- metadata: HashMap::new(),
+ fn backend_name(&self, _services: &RuntimeServices, _timeout_ms: u32) -> Option {
+ Some("bidder-backend".to_string())
}
}
@@ -1896,12 +2363,18 @@ mod tests {
_response: PlatformResponse,
response_time_ms: u64,
_request: &AuctionRequest,
- _context: &AuctionContext<'_>,
+ context: &AuctionContext<'_>,
) -> Result> {
- // 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,
))
}
@@ -1926,13 +2399,18 @@ mod tests {
async fn request_bids(
&self,
_request: &AuctionRequest,
- _context: &AuctionContext<'_>,
+ context: &AuctionContext<'_>,
) -> Result> {
+ 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,
)))
}
@@ -1971,9 +2449,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));
@@ -2027,9 +2504,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();
@@ -2044,11 +2520,7 @@ mod tests {
};
let result = if split {
- let DispatchAuctionOutcome::Dispatched(dispatched) =
- orchestrator.dispatch_auction(&request, &context).await
- else {
- panic!("bidder request should dispatch");
- };
+ let dispatched = orchestrator.dispatch_auction(&request, &context).await;
orchestrator
.collect_dispatched_auction(dispatched, &services, &context)
.await
@@ -2118,6 +2590,374 @@ mod tests {
}
}
+ 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: providers
+ .iter()
+ .map(|provider| (*provider).to_string())
+ .collect(),
+ ..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")
@@ -2229,6 +3069,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]
@@ -2246,12 +3097,9 @@ 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
+ let dispatched = orchestrator
.dispatch_auction(&create_test_auction_request(), &context)
- .await
- else {
- panic!("enabled immediate provider should dispatch");
- };
+ .await;
let result = orchestrator
.collect_dispatched_auction(dispatched, &services, &context)
.await;
@@ -2259,6 +3107,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]
@@ -2272,10 +3131,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);
@@ -2285,11 +3144,7 @@ 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 = orchestrator.dispatch_auction(&request, &context).await;
orchestrator
.collect_dispatched_auction(dispatched, &services, &context)
.await
@@ -2419,6 +3274,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("Ad
".to_string()),
@@ -2442,6 +3300,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("Ad
".to_string()),
@@ -2512,14 +3373,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,
@@ -2539,16 +3411,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,
+ },
+ ]
);
});
}
@@ -2592,14 +3468,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);
@@ -2609,11 +3485,7 @@ 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 = orchestrator.dispatch_auction(&request, &context).await;
orchestrator
.collect_dispatched_auction(dispatched, &services, &context)
.await
@@ -2734,13 +3606,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()));
@@ -2760,14 +3636,80 @@ 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)
+ .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: vec!["bidder".to_string()],
+ 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 dispatched = orchestrator.dispatch_auction(&request, &context).await;
+ let result = orchestrator
+ .collect_dispatched_auction(dispatched, &services, &context)
.await;
- 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,
+ },
+ ]
+ );
});
}
@@ -2794,10 +3736,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",
@@ -2863,11 +3805,7 @@ 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 = orchestrator.dispatch_auction(&request, &context).await;
orchestrator
.collect_dispatched_auction(dispatched, &services, &context)
.await;
@@ -2915,18 +3853,21 @@ 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 = 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"
+ );
});
}
@@ -2958,21 +3899,23 @@ 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 = 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);
});
}
@@ -3000,14 +3943,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();
@@ -3075,10 +4018,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()
@@ -3093,13 +4035,9 @@ mod tests {
provider_responses: None,
services: &services,
};
- let dispatched = match orchestrator
+ let dispatched = orchestrator
.dispatch_auction(&request, &dispatch_context)
- .await
- {
- DispatchAuctionOutcome::Dispatched(dispatched) => dispatched,
- _ => panic!("should dispatch provider request"),
- };
+ .await;
let placeholder = http::Request::builder()
.uri("https://placeholder.invalid/")
.body(edgezero_core::body::Body::empty())
@@ -3153,14 +4091,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();
@@ -3180,11 +4118,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(),
@@ -3218,14 +4166,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();
@@ -3245,15 +4193,27 @@ mod tests {
// Act
let dispatched = orchestrator.dispatch_auction(&request, &context).await;
- // 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 result = orchestrator
+ .collect_dispatched_auction(dispatched, services, &context)
+ .await;
+ 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,
+ ..
+ }
+ )));
});
}
@@ -3303,6 +4263,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("Ad
".to_string()),
@@ -3347,6 +4310,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("APS Ad
".to_string()),
@@ -3386,6 +4352,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("APS Ad
".to_string()),
diff --git a/crates/trusted-server-core/src/auction/provider.rs b/crates/trusted-server-core/src/auction/provider.rs
index 766bd7a08..a3c6f012f 100644
--- a/crates/trusted-server-core/src/auction/provider.rs
+++ b/crates/trusted-server-core/src/auction/provider.rs
@@ -8,7 +8,31 @@ use error_stack::Report;
use crate::error::TrustedServerError;
use crate::platform::{PlatformPendingRequest, PlatformResponse, RuntimeServices};
-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),
+ /// Provider completed successfully without a candidate for this slot.
+ NoBid,
+ /// Provider failed for this slot.
+ Failed(AuctionSlotFailureReason),
+}
/// Provider-local state carried from request dispatch to response parsing.
pub type ProviderParseState = Box;
diff --git a/crates/trusted-server-core/src/auction/telemetry.rs b/crates/trusted-server-core/src/auction/telemetry.rs
index b3e049eaf..1ba73a655 100644
--- a/crates/trusted-server-core/src/auction/telemetry.rs
+++ b/crates/trusted-server-core/src/auction/telemetry.rs
@@ -933,7 +933,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::*;
@@ -969,6 +969,9 @@ mod tests {
fn bid(slot_id: &str, bidder: &str, ad_id: Option<&str>, price: Option) -> 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,
@@ -1049,6 +1052,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(),
};
@@ -1112,6 +1120,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(),
};
@@ -1153,6 +1166,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(),
};
@@ -1191,6 +1209,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(),
};
@@ -1231,6 +1254,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 f61334787..0c3335af3 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,
+ prefix: &str,
+ random_byte_count: usize,
+ collision_retries: usize,
+) -> Option {
+ 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 {
@@ -154,6 +196,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 {
+ Some(self.cmp(other))
+ }
+}
+
+/// Typed counts projected into the existing `drop_reasons` debug object.
+pub type AuctionDropReasons = BTreeMap;
+
+/// 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(&self, serializer: S) -> Result
+ 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,
+}
+
+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,
+ /// Server-minted renderer capability identity for APS/ADM only.
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub renderer_reservation_id: Option,
+ /// 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,
+}
+
+/// 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,
+ /// Winner bids in matching decision order.
+ pub bids: Vec,
+}
+
/// 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
@@ -187,7 +576,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,
@@ -210,22 +599,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::(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.
@@ -233,13 +908,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,
+ /// Provider integration name paired with the upstream bid ID for provenance.
+ #[serde(skip)]
+ pub candidate_provider: Option,
+ /// Server-minted renderer capability identifier (populated during projection).
+ #[serde(skip)]
+ pub renderer_reservation_id: Option,
/// Bid price in CPM.
pub price: Option,
/// 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,
/// Advertiser domain
pub adomain: Option>,
@@ -267,11 +951,11 @@ pub struct Bid {
pub creative_id: Option,
/// Typed browser renderer capability.
#[serde(skip_serializing_if = "Option::is_none")]
- pub renderer: Option,
+ pub renderer: Option,
/// 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,
/// Prebid Cache host (e.g., `"openads.adsrvr.org"`).
@@ -288,6 +972,28 @@ pub struct Bid {
pub metadata: HashMap,
}
+/// 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 {
+ self.creative.as_deref().map(adm_trace_hash)
+ }
+}
+
/// Per-provider summary included in the auction response.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProviderSummary {
@@ -338,7 +1044,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,
+ pub dropped_winner_reasons: AuctionDropReasons,
}
/// Status of bid response.
@@ -394,6 +1100,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)]
@@ -401,9 +1131,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,
@@ -536,6 +1316,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,
@@ -575,7 +1358,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(),
@@ -609,7 +1392,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(),
@@ -638,10 +1421,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 6c92d042d..26a1da1b8 100644
--- a/crates/trusted-server-core/src/auth.rs
+++ b/crates/trusted-server-core/src/auth.rs
@@ -300,9 +300,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 66a0232df..678f3273c 100644
--- a/crates/trusted-server-core/src/config.rs
+++ b/crates/trusted-server-core/src/config.rs
@@ -226,6 +226,7 @@ mod tests {
#[serde(deny_unknown_fields)]
#[allow(dead_code)]
struct LegacyCreativeOpportunitiesConfig {
+ enabled: bool,
gam_network_id: String,
#[serde(default)]
auction_timeout_ms: Option,
@@ -241,6 +242,7 @@ mod tests {
r#"
[creative_opportunities]
+enabled = true
gam_network_id = "99999"
[[creative_opportunities.slot]]
@@ -325,37 +327,10 @@ formats = [{ width = 300, height = 250 }]
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::(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::(creative_opportunities)
- .expect_err("legacy binaries should reject an explicit disabled switch");
- }
-
#[test]
fn deploy_validation_rejects_placeholders() {
let settings = Settings::from_toml(
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 `![]()
` pixels → `/first-party/proxy?tsurl=<base-url><params>&tstoken=<sig>`
/// - Non-pixel absolute images → `/first-party/proxy?tsurl=<base-url><params>&tstoken=<sig>`
/// - `';
- const source = document.querySelector('#div-header > iframe')!.contentWindow;
-
- const accepted = dispatchApsRendering({
- slotId: 'div-header-container',
- renderer: descriptor(),
- source,
- trustedServer: () => true,
- });
- const frame = Array.from(
- document.querySelectorAll('#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 =
- '' +
- '';
- const source = document.querySelector(
- '#div-header-second > iframe'
- )!.contentWindow;
-
- const accepted = dispatchApsRendering({
- slotId: 'div-header-',
- renderer: descriptor(),
- source,
- trustedServer: () => true,
- });
- const frame = Array.from(
- document.querySelectorAll('#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;
- 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 = 'existing
';
- });
-
- afterEach(() => {
- vi.restoreAllMocks();
- document.body.innerHTML = '';
- });
-
- 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, helper: unknown, target: Window) => Promise;
- };
- 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('input[name="tsclick"]')?.value).toBe(longClick);
+ expect(form?.querySelector('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((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 {
- 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> = {}
+): Promise {
+ 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 48133fb72..cef3195b5 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';
@@ -42,7 +44,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';
@@ -52,4 +54,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 44105571d..80a93eed7 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';
@@ -42,7 +44,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';
@@ -52,4 +54,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((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 = {}): Readonly {
+ 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;
-
- 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 b7186518b..000000000
--- a/crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts
+++ /dev/null
@@ -1,5038 +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 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('script');
- const frameWindow = frame!.contentWindow as unknown as {
- _aps: Map> }>;
- };
- 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 & {
- googletag?: unknown;
- apstag?: { setDisplayBids?: () => void };
- tsjs?: Partial;
-};
-
-async function runGptBootstrapWithGoogleTag(googletag: object): Promise {
- 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 {
- 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,
- formats: Array<[number, number]> = [[300, 250]]
- ) {
- 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,
- targeting: {},
- },
- ],
- bids: bid ? { atf_sidebar_ad: bid } : {},
- gptDiagnosticsRecorder: {
- recordTrustedServerOpportunity,
- } as unknown as TsjsApi['gptDiagnosticsRecorder'],
- };
-
- return { mockPubads, mockSlot };
- }
-
- it.each([
- [
- 'inline markup',
- { hb_pb: '1.00', hb_adid: 'abc-uuid', adm: 'Creative
' },
- '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: 'Creative
' },
- 'unrenderable_candidate',
- ],
- [
- 'no non-empty Trusted Server bid targeting',
- { hb_pb: '', hb_bidder: '', hb_adid: '', adm: 'Creative
' },
- '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: 'Existing
',
- },
- new_slot_ad: {
- hb_pb: '2.00',
- hb_adid: 'new-id',
- adm: 'New
',
- },
- },
- 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();
- 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();
- 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();
- 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();
- 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();
- 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!();
-
- expect(nativeRefresh).toHaveBeenCalledWith([mockSlot]);
-
- 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).toHaveBeenCalledWith([mockSlot]);
-
- // 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: 'Inline creative
',
- },
- },
- };
-
- 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 {
- 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: '',
- ...(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];
- 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: 'cached
', w: 300, h: 250, price: 1.23 })
- );
- expect(bid).toEqual({ adm: 'cached
', width: 300, height: 250, price: 1.23 });
- });
-
- it('accepts width/height as an alternate dimension spelling', async () => {
- const bid = await parseCachedBid(
- JSON.stringify({ adm: 'cached
', 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: 'cached
', 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('raw
');
- expect(bid).toEqual({ adm: 'raw
' });
- });
-
- 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;
-
- 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!;
- }
-
- 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 = 'Creative
';
- 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('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 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 = 'Creative
';
-
- 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(() => {
- throw new Error('port closed');
- }),
- },
- ],
- 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(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 source = createTrustedSlotIframe();
- 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;
- 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);
-
- // 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, helper: unknown, target: Window) => Promise;
- };
- window.eval(String(response.renderer));
- try {
- const rendered = dynamicWindow.render!(response, undefined, window);
- const outerFrame = document.querySelector(
- '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 source = createTrustedSlotIframe();
- 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(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 resolve a registered APS dynamic 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();
- const firstSource = 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(
- Array.from(document.querySelectorAll('#div-native-first iframe')).some(
- (frame) => frame.contentWindow === firstSource
- )
- ).toBe(true);
- } 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 = 'Test Creative
';
- // 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((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((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: 'Creative
' })),
- } 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((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((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