From b56a0a1fe3693766b693170a4a5e2c7acc0ba3e8 Mon Sep 17 00:00:00 2001
From: prk-Jr <prakashsagwara@gmail.com>
Date: Mon, 13 Jul 2026 22:03:16 +0530
Subject: [PATCH 01/10] Add design spec for SSAT inline creative rendering

---
 ...7-13-ssat-render-inline-creative-design.md | 141 ++++++++++++++++++
 1 file changed, 141 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md

diff --git a/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md b/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
new file mode 100644
index 00000000..0a263c71
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
@@ -0,0 +1,141 @@
+# SSAT: render the winning creative inline (no PBS Cache round trip)
+
+**Date:** 2026-07-13
+**Status:** Design approved, pending spec review
+**Branch:** `feat/ssat-render-inline-creative`
+
+## Problem
+
+On the server-side auction (SSAT / streaming path), when GAM picks the
+trusted-server header-bid line item, the winning creative is fetched at render
+time from PBS Cache:
+
+```
+https://<hb_cache_host><hb_cache_path>?uuid=<hb_adid>
+```
+
+This is an extra network round trip *after* the GAM call, even though
+trusted-server already holds the winning creative markup (`bid.creative`) from
+the server-side auction it just ran. The client-side `/auction` flow never does
+this — Prebid.js renders the winner from the copy it already has in the browser.
+
+## Goal
+
+Make SSAT render the winning creative **from the copy it already holds**, the
+same way the client does — eliminating the render-time PBS Cache round trip —
+while keeping GAM in the loop (the header bid still competes against GAM's own
+demand via `hb_pb`).
+
+Non-goal: bypassing GAM. SSAT winners must still compete in GAM; we only remove
+the round trip that happens *after* GAM has already picked the TS line item.
+
+## Current flow (verified in code)
+
+1. `build_bid_map` ([publisher.rs:1933]) writes `window.tsjs.bids[slot]` with
+   `hb_pb`, `hb_bidder`, `hb_adid`, `hb_cache_host`, `hb_cache_path`. The raw
+   `adm` (creative) is included **only** when `include_adm` is set — today wired
+   to `settings.debug.inject_adm_for_testing`.
+2. `build_bids_script` ([publisher.rs:2018]) serializes the bid map and runs it
+   through `html_escape_for_script` (escapes `<`/`>`/`&` and `U+2028/2029`),
+   embedding it as `JSON.parse("…")`.
+3. GAM's Prebid line item (matched by `hb_pb`) serves the Prebid Universal
+   Creative, which `postMessage`s `"Prebid Request"`.
+4. `installTsRenderBridge` ([gpt/index.ts:839]) intercepts and either:
+   - serves `matchedBid.adm` **directly** when present (no round trip), or
+   - **fetches from PBS Cache** using `hb_cache_host`/`hb_cache_path` (the round
+     trip we want to remove).
+
+A separate consumer, `injectAdmIntoSlot` ([gpt/index.ts:599]), fires on
+`if (bid.adm)` and **replaces the GAM creative directly** — a GAM *bypass*. Its
+"testing only" status is a comment, not an actual gate.
+
+## Design
+
+### 1. Always include the render `adm` for SSAT winners
+
+Split the single `include_adm` parameter, which currently bundles two unrelated
+things, into two independent signals:
+
+- `render_adm` (production, **always on** for SSAT winners) — inserts the `adm`
+  field so the render bridge can serve it locally.
+- `debug_bid` (testing only, gated on `inject_adm_for_testing`) — the verbose
+  `debug_bid` blob at [publisher.rs:1987] stays behind the testing flag and is
+  **not** shipped in production.
+
+`hb_cache_host`/`hb_cache_path` remain inserted unconditionally, so the cache
+fetch stays available as a fallback.
+
+### 2. Bridge renders local `adm`; cache is the fallback
+
+No change to `installTsRenderBridge` logic is required: it already prefers
+`matchedBid.adm` and falls back to PBS Cache. Once `adm` is present in
+production, the local render becomes the default and the round trip disappears.
+If `adm` is ever absent or unrenderable, the existing cache path still runs —
+zero-risk regression.
+
+### 3. Decouple the GAM-bypass path
+
+`injectAdmIntoSlot` must **not** fire in production just because `adm` is now
+present. Gate it behind an explicit injected config flag (e.g.
+`injectAdmForTesting`) read by the JS, so:
+
+- production inline-`adm` feeds **only** the render bridge → GAM stays in the
+  loop, and
+- the direct GAM-replace path remains available for testing behind the flag.
+
+The flag is surfaced to the JS the same way other tsjs config is injected.
+
+### 4. Security
+
+No new escaping code. The `adm` string is part of the bid-map JSON that already
+passes through `html_escape_for_script` + `JSON.parse("…")`, which neutralizes
+`</script>` breakout and `U+2028/2029`. Requirement: a regression test proving a
+hostile `adm` containing `</script>` (and `U+2028/2029`) cannot break out of the
+injected `<script>` context. The render itself stays sandboxed in an iframe
+(`srcdoc`/`src`) inside `injectAdmIntoSlot`/the bridge renderer.
+
+## Components changed
+
+| Unit | Change |
+| --- | --- |
+| `build_bid_map` (Rust) | Split `include_adm` → `render_adm` (always) + `debug_bid` (testing). Always insert `adm` for winners. |
+| `build_bid_map` callers | Pass `render_adm = true`; `debug_bid = inject_adm_for_testing`. |
+| tsjs config injection (Rust→JS) | Surface `injectAdmForTesting` flag. |
+| `gpt/index.ts` `injectAdmIntoSlot` call site | Gate on the injected `injectAdmForTesting` flag, not bare `bid.adm`. |
+
+## Data flow (after)
+
+```
+SSAT auction → winner (bid.creative held) → build_bid_map inserts adm
+  → build_bids_script (html_escape_for_script) → window.tsjs.bids
+  → hb_pb targeting → GAM competes
+      ├ GAM picks TS line item → PUC "Prebid Request"
+      │     → bridge replies with local adm  → RENDER (no round trip)
+      │     → (adm absent) → PBS Cache fetch  → RENDER (fallback)
+      └ GAM has higher demand → GAM serves its own creative
+```
+
+## Testing
+
+- **Rust**: `build_bid_map` includes `adm` for winners on the production path;
+  `debug_bid` present only under the testing flag; a hostile `</script>` /
+  `U+2028/2029` `adm` is escaped so `build_bids_script` output stays inside the
+  `<script>`.
+- **JS (vitest)**: bridge serves local `adm` without a cache fetch when present;
+  falls back to cache when `adm` absent; `injectAdmIntoSlot` does **not** fire
+  without the `injectAdmForTesting` flag.
+
+## Risks / accepted costs
+
+- **Page weight**: every SSAT navigation response now carries winners' creatives
+  inline (~3–8 KB each), making that response larger and per-auction
+  (uncacheable). Accepted as the cost of client-parity rendering. A future
+  size-cap (inline small, cache large) is out of scope here.
+- **Renderability**: some creatives may assume a PBS Cache/PUC context. The cache
+  fallback covers any that don't render inline.
+
+## Out of scope
+
+- Size-capping / conditional inline vs cache.
+- Bypassing GAM for SSAT winners.
+- Changing the client-side `/auction` render path.

From 6e8c48fbd2605b02c8c74f12961d91ec146a0940 Mon Sep 17 00:00:00 2001
From: prk-Jr <prakashsagwara@gmail.com>
Date: Mon, 13 Jul 2026 22:07:53 +0530
Subject: [PATCH 02/10] Add implementation plan for SSAT inline creative
 rendering

---
 .../2026-07-13-ssat-render-inline-creative.md | 215 ++++++++++++++++++
 1 file changed, 215 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md

diff --git a/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md b/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
new file mode 100644
index 00000000..4ae03837
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
@@ -0,0 +1,215 @@
+# SSAT Inline Creative Rendering — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Render SSAT-winning creatives from the copy trusted-server already holds (no render-time PBS Cache round trip), while keeping GAM in the loop.
+
+**Architecture:** Always include the winning `adm` in `window.tsjs.bids` so the existing `installTsRenderBridge` serves it locally when GAM's Prebid Universal Creative fires. Keep `hb_cache_*` as a fallback. Split the render `adm` from the debug-only `debug_bid` blob, and gate the GAM-bypass path (`injectAdmIntoSlot`) behind an explicit `window.tsjs.injectAdmForTesting` flag so production keeps GAM.
+
+**Tech Stack:** Rust (`trusted-server-core`, wasm32-wasip1 via Viceroy), TypeScript (`trusted-server-js`, vitest).
+
+**Spec:** `docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md`
+
+---
+
+## File Structure
+
+| File | Responsibility | Change |
+| --- | --- | --- |
+| `crates/trusted-server-core/src/publisher.rs` | Build `window.tsjs.bids` + injection | Split `include_adm`→`render_adm`+`debug_bid`; always insert `adm`; emit `injectAdmForTesting` flag |
+| `crates/trusted-server-js/lib/src/integrations/gpt/index.ts` | Client render paths | Gate `injectAdmIntoSlot` on the flag |
+| `crates/trusted-server-js/lib/test/integrations/gpt/*.test.ts` | JS tests | Bypass-off-without-flag; bridge-serves-local-adm |
+
+---
+
+## Task 1: Split `build_bid_map` flags and always include render `adm`
+
+**Files:**
+- Modify: `crates/trusted-server-core/src/publisher.rs` (`build_bid_map` ~1933)
+- Test: same file, `#[cfg(test)] mod tests`
+
+- [ ] **Step 1: Write failing test** — production path includes `adm`, excludes `debug_bid`.
+
+```rust
+#[test]
+fn build_bid_map_includes_adm_for_render_without_debug_bid() {
+    let mut winning = std::collections::HashMap::new();
+    let mut bid = /* build a Bid with creative Some("<div>x</div>"), price Some(1.0) */;
+    winning.insert("ad-header-0".to_string(), bid);
+    // render_adm = true (production), debug_bid = false
+    let map = build_bid_map(&winning, PriceGranularity::Dense, true, false);
+    let slot = map["ad-header-0"].as_object().expect("slot obj");
+    assert_eq!(slot["adm"], serde_json::json!("<div>x</div>"), "render adm present");
+    assert!(!slot.contains_key("debug_bid"), "debug_bid absent in production");
+}
+```
+
+- [ ] **Step 2: Run — expect FAIL** (signature mismatch: `build_bid_map` takes 3 args).
+
+Run: `cargo test-fastly build_bid_map_includes_adm_for_render_without_debug_bid`
+
+- [ ] **Step 3: Implement** — change signature and body:
+
+```rust
+pub(crate) fn build_bid_map(
+    winning_bids: &std::collections::HashMap<String, Bid>,
+    granularity: crate::price_bucket::PriceGranularity,
+    render_adm: bool,
+    debug_bid: bool,
+) -> serde_json::Map<String, serde_json::Value> {
+    // ... unchanged hb_* / cache / nurl / burl inserts ...
+    // Replace the single `if include_adm { adm + debug_bid }` block with:
+    if render_adm {
+        if let Some(ref adm) = bid.creative {
+            obj.insert("adm".to_string(), serde_json::Value::String(adm.clone()));
+        }
+    }
+    if debug_bid {
+        obj.insert("debug_bid".to_string(), serde_json::json!({ /* unchanged blob */ }));
+    }
+    // ...
+}
+```
+
+- [ ] **Step 4: Run — expect PASS.**
+
+- [ ] **Step 5: Update the 3 call sites** so the crate compiles:
+  - `publisher.rs:~853`, `~1241`, `~2390`: pass `render_adm = true, debug_bid = settings.debug.inject_adm_for_testing`.
+  - The pure-test caller at `~4043`: `build_bid_map(&winning_bids, PriceGranularity::Dense, false, false)`.
+
+- [ ] **Step 6: Run** `cargo check-fastly` — expect clean.
+
+- [ ] **Step 7: Commit** — `git commit -m "Split build_bid_map render adm from debug_bid blob"`
+
+---
+
+## Task 2: Emit the `injectAdmForTesting` flag with the bids script
+
+**Files:**
+- Modify: `crates/trusted-server-core/src/publisher.rs` (`build_bids_script` ~2018 + its caller ~853)
+
+- [ ] **Step 1: Write failing test** — script sets the flag.
+
+```rust
+#[test]
+fn bids_script_emits_inject_adm_for_testing_flag() {
+    let script = build_bids_script(&serde_json::Map::new(), true);
+    assert!(script.contains("injectAdmForTesting=true"), "flag emitted: {script}");
+    let off = build_bids_script(&serde_json::Map::new(), false);
+    assert!(off.contains("injectAdmForTesting=false"), "flag false: {off}");
+}
+```
+
+- [ ] **Step 2: Run — expect FAIL** (arity).
+
+- [ ] **Step 3: Implement** — add a bool param and emit the flag on `window.tsjs`:
+
+```rust
+pub(crate) fn build_bids_script(
+    bid_map: &serde_json::Map<String, serde_json::Value>,
+    inject_adm_for_testing: bool,
+) -> String {
+    let json = serde_json::to_string(bid_map).expect("serialize bid map");
+    let escaped = html_escape_for_script(&json);
+    format!(
+        "<script>(window.tsjs=window.tsjs||{{}}).injectAdmForTesting={inject_adm_for_testing};\
+         (window.tsjs=window.tsjs||{{}}).bids=JSON.parse(\"{escaped}\");\
+         (function(){{var f=window.tsjs.adInit;if(typeof f===\"function\")f();}})();</script>"
+    )
+}
+```
+
+- [ ] **Step 4: Update the caller** at `~853/854` to pass `settings.debug.inject_adm_for_testing`; update the empty-bids helper at `~2033` and any test expectations that pin the old script string.
+
+- [ ] **Step 5: Run — expect PASS.** `cargo test-fastly bids_script_emits_inject_adm_for_testing_flag`
+
+- [ ] **Step 6: Commit** — `git commit -m "Emit injectAdmForTesting flag on window.tsjs with bids"`
+
+---
+
+## Task 3: Escaping regression — hostile `adm` cannot break out of `<script>`
+
+**Files:**
+- Modify: `crates/trusted-server-core/src/publisher.rs` tests
+
+- [ ] **Step 1: Write test** — a `</script>` + `U+2028` adm is neutralized in the emitted script.
+
+```rust
+#[test]
+fn build_bids_script_escapes_hostile_adm() {
+    let mut winning = std::collections::HashMap::new();
+    let mut bid = /* Bid, price Some(1.0), creative Some("</script><script>alert(1)</script>\u{2028}") */;
+    winning.insert("s".to_string(), bid);
+    let map = build_bid_map(&winning, PriceGranularity::Dense, true, false);
+    let script = build_bids_script(&map, false);
+    // Raw </script> must not survive; U+2028 must be unicode-escaped.
+    assert!(!script.contains("</script><script>"), "no raw breakout: {script}");
+    assert!(!script.contains('\u{2028}'), "U+2028 escaped");
+}
+```
+
+- [ ] **Step 2: Run — expect PASS** (existing `html_escape_for_script` already handles it — this pins the guarantee).
+
+- [ ] **Step 3: Commit** — `git commit -m "Pin escaping guarantee for inline adm"`
+
+---
+
+## Task 4: Gate the GAM-bypass (`injectAdmIntoSlot`) behind the flag
+
+**Files:**
+- Modify: `crates/trusted-server-js/lib/src/integrations/gpt/index.ts:~599`
+- Test: `crates/trusted-server-js/lib/test/integrations/gpt/` (add/extend a test file)
+
+- [ ] **Step 1: Write failing vitest** — bypass does NOT fire when the flag is off, even with `bid.adm`.
+
+```ts
+// window.tsjs = { bids: { 'ad-header-0': { adm: '<div>x</div>' } }, injectAdmForTesting: false }
+// simulate slotRenderEnded for ad-header-0
+// assert injectAdmIntoSlot was NOT called (spy) — the bridge handles render instead
+```
+
+- [ ] **Step 2: Run — expect FAIL.** `cd crates/trusted-server-js/lib && npx vitest run <file>`
+
+- [ ] **Step 3: Implement** — change the guard:
+
+```ts
+if (bid.adm && window.tsjs?.injectAdmForTesting) {
+  injectAdmIntoSlot(divId, bid.adm);
+}
+```
+
+- [ ] **Step 4: Add the companion test** — with `injectAdmForTesting: true`, `injectAdmIntoSlot` IS called.
+
+- [ ] **Step 5: Run — expect PASS.**
+
+- [ ] **Step 6: Commit** — `git commit -m "Gate GAM-bypass adm injection behind injectAdmForTesting flag"`
+
+---
+
+## Task 5: Bridge serves local `adm` (no cache fetch) — confirm/extend
+
+**Files:**
+- Test: `crates/trusted-server-js/lib/test/integrations/gpt/` (bridge tests)
+
+- [ ] **Step 1:** Check for an existing `installTsRenderBridge` test. If a "serves local adm without cache fetch" case is missing, add: given a bid with `adm` and `hb_cache_*`, a `"Prebid Request"` for its `hb_adid` is answered from `adm` and **no `fetch`** occurs.
+- [ ] **Step 2:** Add the fallback case: bid with `hb_cache_*` but no `adm` → bridge fetches from cache.
+- [ ] **Step 3: Run — expect PASS.**
+- [ ] **Step 4: Commit** — `git commit -m "Cover bridge local-adm render and cache fallback"`
+
+---
+
+## Task 6: Full verification
+
+- [ ] **Step 1:** `cargo fmt --all -- --check`
+- [ ] **Step 2:** `cargo test-fastly && cargo test-axum && cargo test-cloudflare && cargo test-spin`
+- [ ] **Step 3:** `cargo clippy-fastly` (and axum/cloudflare/spin per CI gate)
+- [ ] **Step 4:** `cd crates/trusted-server-js/lib && npx vitest run && npm run format && node build-all.mjs`
+- [ ] **Step 5:** Manual: with `[debug].auction_html_comment` off and inline adm on, load a nav page; confirm the winning creative renders **without** a request to `hb_cache_host` (Network tab) and GAM still received `hb_pb`.
+- [ ] **Step 6: Commit** any format fixes.
+
+---
+
+## Notes
+- Do NOT remove `hb_cache_host`/`hb_cache_path` — they are the fallback.
+- Do NOT ship the `debug_bid` blob in production (Task 1 keeps it behind the flag).
+- Page-weight cost (inline creatives, uncacheable response) is accepted per spec; size-capping is out of scope.

From 16e9d958c0b932be384bcf27525b52d622912a47 Mon Sep 17 00:00:00 2001
From: prk-Jr <prakashsagwara@gmail.com>
Date: Mon, 13 Jul 2026 22:17:25 +0530
Subject: [PATCH 03/10] Correct plan call graph, add TsjsApi type + beacon
 steps, note precondition

---
 .../2026-07-13-ssat-render-inline-creative.md | 43 +++++++++++++------
 ...7-13-ssat-render-inline-creative-design.md |  8 ++++
 2 files changed, 38 insertions(+), 13 deletions(-)

diff --git a/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md b/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
index 4ae03837..a7ef84b6 100644
--- a/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
+++ b/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
@@ -73,9 +73,12 @@ pub(crate) fn build_bid_map(
 
 - [ ] **Step 4: Run — expect PASS.**
 
-- [ ] **Step 5: Update the 3 call sites** so the crate compiles:
-  - `publisher.rs:~853`, `~1241`, `~2390`: pass `render_adm = true, debug_bid = settings.debug.inject_adm_for_testing`.
-  - The pure-test caller at `~4043`: `build_bid_map(&winning_bids, PriceGranularity::Dense, false, false)`.
+- [ ] **Step 5: Thread the flag through `write_bids_to_state` and update the other call sites** so the crate compiles.
+  Note the real call graph: `write_bids_to_state` (`~846`) owns an `inject_adm: bool` param and calls both `build_bid_map` (`~853`) and `build_bids_script` (`~854`). Its callers at `~695`/`~1241` pass `settings.debug.inject_adm_for_testing`. `handle_page_bids` (`~2390`) calls `build_bid_map` directly.
+  - In `write_bids_to_state`: rename the param `inject_adm_for_testing`; call `build_bid_map(winning_bids, price_granularity, /* render_adm */ true, /* debug_bid */ inject_adm_for_testing)`; pass the same flag to `build_bids_script` (Task 2).
+  - Callers `~695` and `~1241`: **no change** (already pass the flag to `write_bids_to_state`).
+  - `handle_page_bids` (`~2390`): `build_bid_map(&winning_bids, co_config.price_granularity, /* render_adm */ true, /* debug_bid */ settings.debug.inject_adm_for_testing)`.
+  - Pure-test caller (`~4043`): `build_bid_map(&winning_bids, PriceGranularity::Dense, false, false)`.
 
 - [ ] **Step 6: Run** `cargo check-fastly` — expect clean.
 
@@ -119,11 +122,16 @@ pub(crate) fn build_bids_script(
 }
 ```
 
-- [ ] **Step 4: Update the caller** at `~853/854` to pass `settings.debug.inject_adm_for_testing`; update the empty-bids helper at `~2033` and any test expectations that pin the old script string.
+- [ ] **Step 4: Update `build_bids_script` callers:**
+  - `write_bids_to_state` (`~854`): pass the `inject_adm_for_testing` param threaded in Task 1.
+  - `build_empty_bids_script` (`~2032`) has **no settings access** — pass `false` (no bids ⇒ no `adm` ⇒ flag inert). Documented tradeoff: an empty *initial* nav on a testing build emits `injectAdmForTesting=false`, so a later SPA-loaded `adm` won't fire the test bypass; acceptable (production is always `false`).
+  - Fix any test that pins the old `bids` `<script>` string.
 
-- [ ] **Step 5: Run — expect PASS.** `cargo test-fastly bids_script_emits_inject_adm_for_testing_flag`
+- [ ] **Step 5: SPA path needs no flag.** Confirm `handle_page_bids` (`~2390`) returns JSON (not a `<script>`) — the flag is set once on the initial nav load and persists on `window.tsjs` across SPA navigations. No flag emission there.
 
-- [ ] **Step 6: Commit** — `git commit -m "Emit injectAdmForTesting flag on window.tsjs with bids"`
+- [ ] **Step 6: Run — expect PASS.** `cargo test-fastly bids_script_emits_inject_adm_for_testing_flag`
+
+- [ ] **Step 7: Commit** — `git commit -m "Emit injectAdmForTesting flag on window.tsjs with bids"`
 
 ---
 
@@ -170,19 +178,26 @@ fn build_bids_script_escapes_hostile_adm() {
 
 - [ ] **Step 2: Run — expect FAIL.** `cd crates/trusted-server-js/lib && npx vitest run <file>`
 
-- [ ] **Step 3: Implement** — change the guard:
+- [ ] **Step 3: Add the field to the `TsjsApi` type** (`crates/trusted-server-js/lib/src/core/types.ts`, or `core/global.d.ts` — grep `interface TsjsApi`):
+
+```ts
+injectAdmForTesting?: boolean;
+```
+Without it, `tsc`/vitest fail to typecheck `window.tsjs.injectAdmForTesting`.
+
+- [ ] **Step 4: Implement** — change the guard (`gpt/index.ts:~599`; `ts` is the local `window.tsjs`):
 
 ```ts
-if (bid.adm && window.tsjs?.injectAdmForTesting) {
+if (bid.adm && ts.injectAdmForTesting) {
   injectAdmIntoSlot(divId, bid.adm);
 }
 ```
 
-- [ ] **Step 4: Add the companion test** — with `injectAdmForTesting: true`, `injectAdmIntoSlot` IS called.
+- [ ] **Step 5: Add the companion test** — with `injectAdmForTesting: true`, `injectAdmIntoSlot` IS called.
 
-- [ ] **Step 5: Run — expect PASS.**
+- [ ] **Step 6: Run — expect PASS.**
 
-- [ ] **Step 6: Commit** — `git commit -m "Gate GAM-bypass adm injection behind injectAdmForTesting flag"`
+- [ ] **Step 7: Commit** — `git commit -m "Gate GAM-bypass adm injection behind injectAdmForTesting flag"`
 
 ---
 
@@ -193,8 +208,9 @@ if (bid.adm && window.tsjs?.injectAdmForTesting) {
 
 - [ ] **Step 1:** Check for an existing `installTsRenderBridge` test. If a "serves local adm without cache fetch" case is missing, add: given a bid with `adm` and `hb_cache_*`, a `"Prebid Request"` for its `hb_adid` is answered from `adm` and **no `fetch`** occurs.
 - [ ] **Step 2:** Add the fallback case: bid with `hb_cache_*` but no `adm` → bridge fetches from cache.
-- [ ] **Step 3: Run — expect PASS.**
-- [ ] **Step 4: Commit** — `git commit -m "Cover bridge local-adm render and cache fallback"`
+- [ ] **Step 3:** Assert win/billing beacons still fire on the local-`adm` path — `fireWinBillingBeacons` runs in the `adm` branch (`gpt/index.ts:~904`), so removing the cache fetch must not drop `nurl`/`burl` beacons.
+- [ ] **Step 4: Run — expect PASS.**
+- [ ] **Step 5: Commit** — `git commit -m "Cover bridge local-adm render, cache fallback, and win beacons"`
 
 ---
 
@@ -213,3 +229,4 @@ if (bid.adm && window.tsjs?.injectAdmForTesting) {
 - Do NOT remove `hb_cache_host`/`hb_cache_path` — they are the fallback.
 - Do NOT ship the `debug_bid` blob in production (Task 1 keeps it behind the flag).
 - Page-weight cost (inline creatives, uncacheable response) is accepted per spec; size-capping is out of scope.
+- **Precondition (sets expectations):** this only changes the render bridge's *data source* (local `adm` vs cache fetch) **when GAM's Prebid line item already serves the Prebid Universal Creative**. It does not change GAM competition, nor whether the PUC fires. A publisher without Prebid line items in GAM sees no change — same as today's cache path.
diff --git a/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md b/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
index 0a263c71..4322b7a4 100644
--- a/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
+++ b/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
@@ -125,6 +125,14 @@ SSAT auction → winner (bid.creative held) → build_bid_map inserts adm
   falls back to cache when `adm` absent; `injectAdmIntoSlot` does **not** fire
   without the `injectAdmForTesting` flag.
 
+## Precondition
+
+This changes only the render bridge's *data source* — local `adm` vs a PBS Cache
+fetch — **when GAM's Prebid line item already serves the Prebid Universal
+Creative**. It does not change GAM competition, nor whether the PUC fires. A
+publisher without Prebid line items in GAM sees no behavioral change (same as
+the current cache path).
+
 ## Risks / accepted costs
 
 - **Page weight**: every SSAT navigation response now carries winners' creatives

From 34018e4bb1817ea68194c8e88d7317cdb99f3d8a Mon Sep 17 00:00:00 2001
From: prk-Jr <prakashsagwara@gmail.com>
Date: Mon, 13 Jul 2026 22:39:39 +0530
Subject: [PATCH 04/10] Revise SSAT inline-creative plan/spec per review

- Drop render_adm param: always include adm when creative present
- Gate GAM-bypass on per-bid debug_bid instead of a global window.tsjs flag
  (removes SPA-staleness edge case, TsjsApi change, and whole flag-emit task)
- Correct fallback scope: cache fallback only when adm absent; render failure
  after adm is supplied is not detectable
- Qualify sandbox claim: TS guarantees script-context escaping; bridge frame
  isolation depends on the Prebid Universal Creative
- Reconcile with existing ad_init.test.ts coverage (rename, no duplicates)
- Fix test assertion messages to expect("should ..."); list exact clippy gates
---
 .../2026-07-13-ssat-render-inline-creative.md | 219 ++++++++----------
 ...7-13-ssat-render-inline-creative-design.md | 134 ++++++-----
 2 files changed, 171 insertions(+), 182 deletions(-)

diff --git a/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md b/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
index a7ef84b6..fc71045d 100644
--- a/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
+++ b/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
@@ -4,7 +4,7 @@
 
 **Goal:** Render SSAT-winning creatives from the copy trusted-server already holds (no render-time PBS Cache round trip), while keeping GAM in the loop.
 
-**Architecture:** Always include the winning `adm` in `window.tsjs.bids` so the existing `installTsRenderBridge` serves it locally when GAM's Prebid Universal Creative fires. Keep `hb_cache_*` as a fallback. Split the render `adm` from the debug-only `debug_bid` blob, and gate the GAM-bypass path (`injectAdmIntoSlot`) behind an explicit `window.tsjs.injectAdmForTesting` flag so production keeps GAM.
+**Architecture:** Always include the winning `adm` in `window.tsjs.bids` so the existing `installTsRenderBridge` serves it locally when GAM's Prebid Universal Creative fires. Keep `hb_cache_*` as the fallback for an *absent* `adm`. Keep the verbose `debug_bid` blob behind the testing flag, and gate the GAM-bypass path (`injectAdmIntoSlot`) on the per-bid `debug_bid` field — no global flag, no `TsjsApi` change.
 
 **Tech Stack:** Rust (`trusted-server-core`, wasm32-wasip1 via Viceroy), TypeScript (`trusted-server-js`, vitest).
 
@@ -16,55 +16,61 @@
 
 | File | Responsibility | Change |
 | --- | --- | --- |
-| `crates/trusted-server-core/src/publisher.rs` | Build `window.tsjs.bids` + injection | Split `include_adm`→`render_adm`+`debug_bid`; always insert `adm`; emit `injectAdmForTesting` flag |
-| `crates/trusted-server-js/lib/src/integrations/gpt/index.ts` | Client render paths | Gate `injectAdmIntoSlot` on the flag |
-| `crates/trusted-server-js/lib/test/integrations/gpt/*.test.ts` | JS tests | Bypass-off-without-flag; bridge-serves-local-adm |
+| `crates/trusted-server-core/src/publisher.rs` | Build `window.tsjs.bids` | Always insert `adm`; rename `include_adm`→`include_debug_bid` (gates only the blob) |
+| `crates/trusted-server-js/lib/src/integrations/gpt/index.ts` | Client render paths | Gate `injectAdmIntoSlot` on `bid.adm && bid.debug_bid` |
+| `crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts` | JS tests | Rename "debug adm"→"inline/local adm"; add bypass-gate test |
 
 ---
 
-## Task 1: Split `build_bid_map` flags and always include render `adm`
+## Task 1: `build_bid_map` — always include `adm`, gate only `debug_bid`
 
 **Files:**
-- Modify: `crates/trusted-server-core/src/publisher.rs` (`build_bid_map` ~1933)
+- Modify: `crates/trusted-server-core/src/publisher.rs` (`build_bid_map` ~1933; `write_bids_to_state` ~846; callers)
 - Test: same file, `#[cfg(test)] mod tests`
 
-- [ ] **Step 1: Write failing test** — production path includes `adm`, excludes `debug_bid`.
+- [ ] **Step 1: Write failing test** — `adm` present for a winner regardless of the debug flag; `debug_bid` only when the flag is set.
 
 ```rust
 #[test]
-fn build_bid_map_includes_adm_for_render_without_debug_bid() {
+fn build_bid_map_always_includes_adm_and_gates_debug_bid() {
     let mut winning = std::collections::HashMap::new();
-    let mut bid = /* build a Bid with creative Some("<div>x</div>"), price Some(1.0) */;
-    winning.insert("ad-header-0".to_string(), bid);
-    // render_adm = true (production), debug_bid = false
-    let map = build_bid_map(&winning, PriceGranularity::Dense, true, false);
-    let slot = map["ad-header-0"].as_object().expect("slot obj");
-    assert_eq!(slot["adm"], serde_json::json!("<div>x</div>"), "render adm present");
-    assert!(!slot.contains_key("debug_bid"), "debug_bid absent in production");
+    winning.insert("ad-header-0".to_string(), make_test_bid_with_creative("<div>x</div>"));
+    // include_debug_bid = false (production)
+    let map = build_bid_map(&winning, PriceGranularity::Dense, false);
+    let slot = map["ad-header-0"]
+        .as_object()
+        .expect("should contain an object for the winning slot");
+    assert_eq!(
+        slot["adm"],
+        serde_json::json!("<div>x</div>"),
+        "should include creative markup for local rendering"
+    );
+    assert!(
+        !slot.contains_key("debug_bid"),
+        "should omit the debug_bid blob when the testing flag is off"
+    );
 }
 ```
 
-- [ ] **Step 2: Run — expect FAIL** (signature mismatch: `build_bid_map` takes 3 args).
+- [ ] **Step 2: Run — expect FAIL** (signature is 3-arg with `include_adm` semantics; adm currently gated off).
 
-Run: `cargo test-fastly build_bid_map_includes_adm_for_render_without_debug_bid`
+Run: `cargo test-fastly build_bid_map_always_includes_adm_and_gates_debug_bid`
 
-- [ ] **Step 3: Implement** — change signature and body:
+- [ ] **Step 3: Implement** — rename the param and split the gating:
 
 ```rust
 pub(crate) fn build_bid_map(
     winning_bids: &std::collections::HashMap<String, Bid>,
     granularity: crate::price_bucket::PriceGranularity,
-    render_adm: bool,
-    debug_bid: bool,
+    include_debug_bid: bool,
 ) -> serde_json::Map<String, serde_json::Value> {
     // ... unchanged hb_* / cache / nurl / burl inserts ...
-    // Replace the single `if include_adm { adm + debug_bid }` block with:
-    if render_adm {
-        if let Some(ref adm) = bid.creative {
-            obj.insert("adm".to_string(), serde_json::Value::String(adm.clone()));
-        }
+    // Always include the creative for local rendering.
+    if let Some(ref adm) = bid.creative {
+        obj.insert("adm".to_string(), serde_json::Value::String(adm.clone()));
     }
-    if debug_bid {
+    // Verbose debug blob only under the testing flag.
+    if include_debug_bid {
         obj.insert("debug_bid".to_string(), serde_json::json!({ /* unchanged blob */ }));
     }
     // ...
@@ -73,69 +79,21 @@ pub(crate) fn build_bid_map(
 
 - [ ] **Step 4: Run — expect PASS.**
 
-- [ ] **Step 5: Thread the flag through `write_bids_to_state` and update the other call sites** so the crate compiles.
-  Note the real call graph: `write_bids_to_state` (`~846`) owns an `inject_adm: bool` param and calls both `build_bid_map` (`~853`) and `build_bids_script` (`~854`). Its callers at `~695`/`~1241` pass `settings.debug.inject_adm_for_testing`. `handle_page_bids` (`~2390`) calls `build_bid_map` directly.
-  - In `write_bids_to_state`: rename the param `inject_adm_for_testing`; call `build_bid_map(winning_bids, price_granularity, /* render_adm */ true, /* debug_bid */ inject_adm_for_testing)`; pass the same flag to `build_bids_script` (Task 2).
-  - Callers `~695` and `~1241`: **no change** (already pass the flag to `write_bids_to_state`).
-  - `handle_page_bids` (`~2390`): `build_bid_map(&winning_bids, co_config.price_granularity, /* render_adm */ true, /* debug_bid */ settings.debug.inject_adm_for_testing)`.
-  - Pure-test caller (`~4043`): `build_bid_map(&winning_bids, PriceGranularity::Dense, false, false)`.
+- [ ] **Step 5: Update call sites** so the crate compiles (real call graph):
+  - `write_bids_to_state` (`~846`): rename its `inject_adm: bool` param to `include_debug_bid`; call `build_bid_map(winning_bids, price_granularity, include_debug_bid)` (`~853`). `build_bids_script` is **unchanged**.
+  - Callers `~695` / `~1241`: no change (already pass `settings.debug.inject_adm_for_testing`).
+  - `handle_page_bids` (`~2390`): `build_bid_map(&winning_bids, co_config.price_granularity, settings.debug.inject_adm_for_testing)`.
+  - Pure-test caller (`~4043`): `build_bid_map(&winning_bids, PriceGranularity::Dense, false)`.
 
-- [ ] **Step 6: Run** `cargo check-fastly` — expect clean.
+- [ ] **Step 6: Update any test that asserted "no adm" on the production path** — production now always carries `adm`; adjust expectations to the new behavior.
 
-- [ ] **Step 7: Commit** — `git commit -m "Split build_bid_map render adm from debug_bid blob"`
+- [ ] **Step 7: Run** `cargo check-fastly` — expect clean.
 
----
-
-## Task 2: Emit the `injectAdmForTesting` flag with the bids script
-
-**Files:**
-- Modify: `crates/trusted-server-core/src/publisher.rs` (`build_bids_script` ~2018 + its caller ~853)
-
-- [ ] **Step 1: Write failing test** — script sets the flag.
-
-```rust
-#[test]
-fn bids_script_emits_inject_adm_for_testing_flag() {
-    let script = build_bids_script(&serde_json::Map::new(), true);
-    assert!(script.contains("injectAdmForTesting=true"), "flag emitted: {script}");
-    let off = build_bids_script(&serde_json::Map::new(), false);
-    assert!(off.contains("injectAdmForTesting=false"), "flag false: {off}");
-}
-```
-
-- [ ] **Step 2: Run — expect FAIL** (arity).
-
-- [ ] **Step 3: Implement** — add a bool param and emit the flag on `window.tsjs`:
-
-```rust
-pub(crate) fn build_bids_script(
-    bid_map: &serde_json::Map<String, serde_json::Value>,
-    inject_adm_for_testing: bool,
-) -> String {
-    let json = serde_json::to_string(bid_map).expect("serialize bid map");
-    let escaped = html_escape_for_script(&json);
-    format!(
-        "<script>(window.tsjs=window.tsjs||{{}}).injectAdmForTesting={inject_adm_for_testing};\
-         (window.tsjs=window.tsjs||{{}}).bids=JSON.parse(\"{escaped}\");\
-         (function(){{var f=window.tsjs.adInit;if(typeof f===\"function\")f();}})();</script>"
-    )
-}
-```
-
-- [ ] **Step 4: Update `build_bids_script` callers:**
-  - `write_bids_to_state` (`~854`): pass the `inject_adm_for_testing` param threaded in Task 1.
-  - `build_empty_bids_script` (`~2032`) has **no settings access** — pass `false` (no bids ⇒ no `adm` ⇒ flag inert). Documented tradeoff: an empty *initial* nav on a testing build emits `injectAdmForTesting=false`, so a later SPA-loaded `adm` won't fire the test bypass; acceptable (production is always `false`).
-  - Fix any test that pins the old `bids` `<script>` string.
-
-- [ ] **Step 5: SPA path needs no flag.** Confirm `handle_page_bids` (`~2390`) returns JSON (not a `<script>`) — the flag is set once on the initial nav load and persists on `window.tsjs` across SPA navigations. No flag emission there.
-
-- [ ] **Step 6: Run — expect PASS.** `cargo test-fastly bids_script_emits_inject_adm_for_testing_flag`
-
-- [ ] **Step 7: Commit** — `git commit -m "Emit injectAdmForTesting flag on window.tsjs with bids"`
+- [ ] **Step 8: Commit** — `git commit -m "Always include adm in bid map; gate only debug_bid blob"`
 
 ---
 
-## Task 3: Escaping regression — hostile `adm` cannot break out of `<script>`
+## Task 2: Escaping regression — hostile `adm` cannot break out of `<script>`
 
 **Files:**
 - Modify: `crates/trusted-server-core/src/publisher.rs` tests
@@ -146,87 +104,104 @@ pub(crate) fn build_bids_script(
 #[test]
 fn build_bids_script_escapes_hostile_adm() {
     let mut winning = std::collections::HashMap::new();
-    let mut bid = /* Bid, price Some(1.0), creative Some("</script><script>alert(1)</script>\u{2028}") */;
-    winning.insert("s".to_string(), bid);
-    let map = build_bid_map(&winning, PriceGranularity::Dense, true, false);
-    let script = build_bids_script(&map, false);
-    // Raw </script> must not survive; U+2028 must be unicode-escaped.
-    assert!(!script.contains("</script><script>"), "no raw breakout: {script}");
-    assert!(!script.contains('\u{2028}'), "U+2028 escaped");
+    winning.insert(
+        "s".to_string(),
+        make_test_bid_with_creative("</script><script>alert(1)</script>\u{2028}"),
+    );
+    let map = build_bid_map(&winning, PriceGranularity::Dense, false);
+    let script = build_bids_script(&map);
+    assert!(
+        !script.contains("</script><script>"),
+        "should not let a hostile adm break out of the script context"
+    );
+    assert!(
+        !script.contains('\u{2028}'),
+        "should unicode-escape U+2028 in the adm"
+    );
 }
 ```
 
 - [ ] **Step 2: Run — expect PASS** (existing `html_escape_for_script` already handles it — this pins the guarantee).
 
-- [ ] **Step 3: Commit** — `git commit -m "Pin escaping guarantee for inline adm"`
+Run: `cargo test-fastly build_bids_script_escapes_hostile_adm`
+
+- [ ] **Step 3: Commit** — `git commit -m "Pin script-context escaping guarantee for inline adm"`
 
 ---
 
-## Task 4: Gate the GAM-bypass (`injectAdmIntoSlot`) behind the flag
+## Task 3: Gate the GAM-bypass (`injectAdmIntoSlot`) on `bid.debug_bid`
 
 **Files:**
 - Modify: `crates/trusted-server-js/lib/src/integrations/gpt/index.ts:~599`
-- Test: `crates/trusted-server-js/lib/test/integrations/gpt/` (add/extend a test file)
+- Test: `crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts`
 
-- [ ] **Step 1: Write failing vitest** — bypass does NOT fire when the flag is off, even with `bid.adm`.
+- [ ] **Step 1: Write failing vitest** — bypass does NOT fire in production (no `debug_bid`), even with `bid.adm`.
 
 ```ts
-// window.tsjs = { bids: { 'ad-header-0': { adm: '<div>x</div>' } }, injectAdmForTesting: false }
+// window.tsjs.bids = { 'ad-header-0': { adm: '<div>x</div>' } }  // no debug_bid
 // simulate slotRenderEnded for ad-header-0
-// assert injectAdmIntoSlot was NOT called (spy) — the bridge handles render instead
+// spy on injectAdmIntoSlot → assert NOT called (the bridge handles render)
 ```
 
-- [ ] **Step 2: Run — expect FAIL.** `cd crates/trusted-server-js/lib && npx vitest run <file>`
+- [ ] **Step 2: Run — expect FAIL.** `cd crates/trusted-server-js/lib && npx vitest run ad_init`
 
-- [ ] **Step 3: Add the field to the `TsjsApi` type** (`crates/trusted-server-js/lib/src/core/types.ts`, or `core/global.d.ts` — grep `interface TsjsApi`):
+- [ ] **Step 3: Implement** — change the guard (`ts` is the local `window.tsjs`):
 
 ```ts
-injectAdmForTesting?: boolean;
-```
-Without it, `tsc`/vitest fail to typecheck `window.tsjs.injectAdmForTesting`.
-
-- [ ] **Step 4: Implement** — change the guard (`gpt/index.ts:~599`; `ts` is the local `window.tsjs`):
-
-```ts
-if (bid.adm && ts.injectAdmForTesting) {
+// Direct GAM replacement is a testing-only bypass. `debug_bid` is present only
+// when inject_adm_for_testing is on, so it doubles as the per-bid gate — no
+// global flag needed, and it is correct across SPA auction responses.
+if (bid.adm && bid.debug_bid) {
   injectAdmIntoSlot(divId, bid.adm);
 }
 ```
 
-- [ ] **Step 5: Add the companion test** — with `injectAdmForTesting: true`, `injectAdmIntoSlot` IS called.
+- [ ] **Step 4: Add companion test** — with `bid.debug_bid` present, `injectAdmIntoSlot` IS called.
 
-- [ ] **Step 6: Run — expect PASS.**
+- [ ] **Step 5: Run — expect PASS.**
 
-- [ ] **Step 7: Commit** — `git commit -m "Gate GAM-bypass adm injection behind injectAdmForTesting flag"`
+- [ ] **Step 6: Commit** — `git commit -m "Gate GAM-bypass adm injection on per-bid debug_bid"`
 
 ---
 
-## Task 5: Bridge serves local `adm` (no cache fetch) — confirm/extend
+## Task 4: Reconcile existing bridge tests (no duplicates)
 
 **Files:**
-- Test: `crates/trusted-server-js/lib/test/integrations/gpt/` (bridge tests)
+- Modify: `crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts`
 
-- [ ] **Step 1:** Check for an existing `installTsRenderBridge` test. If a "serves local adm without cache fetch" case is missing, add: given a bid with `adm` and `hb_cache_*`, a `"Prebid Request"` for its `hb_adid` is answered from `adm` and **no `fetch`** occurs.
-- [ ] **Step 2:** Add the fallback case: bid with `hb_cache_*` but no `adm` → bridge fetches from cache.
-- [ ] **Step 3:** Assert win/billing beacons still fire on the local-`adm` path — `fireWinBillingBeacons` runs in the `adm` branch (`gpt/index.ts:~904`), so removing the cache fetch must not drop `nurl`/`burl` beacons.
-- [ ] **Step 4: Run — expect PASS.**
-- [ ] **Step 5: Commit** — `git commit -m "Cover bridge local-adm render, cache fallback, and win beacons"`
+`ad_init.test.ts` already covers: PBS Cache fetch when `adm` absent; local `adm`
+response without a cache fetch; `nurl`/`burl` on the local path; cache-fetch
+concurrency + beacon dedup. Do **not** duplicate them.
+
+- [ ] **Step 1:** Rename "debug adm" terminology → "inline/local adm" in the existing bridge tests.
+- [ ] **Step 2:** Confirm the local-`adm` test fixtures carry **both** `hb_cache_*` coordinates **and** inline `adm`, proving the bridge prefers local `adm` even when cache coords are present (the production shape).
+- [ ] **Step 3: Run — expect PASS.** `cd crates/trusted-server-js/lib && npx vitest run ad_init`
+- [ ] **Step 4: Commit** — `git commit -m "Rename debug-adm test terminology to inline/local adm"`
 
 ---
 
-## Task 6: Full verification
+## Task 5: Full verification
 
 - [ ] **Step 1:** `cargo fmt --all -- --check`
 - [ ] **Step 2:** `cargo test-fastly && cargo test-axum && cargo test-cloudflare && cargo test-spin`
-- [ ] **Step 3:** `cargo clippy-fastly` (and axum/cloudflare/spin per CI gate)
+- [ ] **Step 3:** Clippy — exact CI-gate commands:
+  ```
+  cargo clippy-fastly
+  cargo clippy-axum
+  cargo clippy-cloudflare
+  cargo clippy-cloudflare-wasm
+  cargo clippy-spin-native
+  cargo clippy-spin-wasm
+  ```
 - [ ] **Step 4:** `cd crates/trusted-server-js/lib && npx vitest run && npm run format && node build-all.mjs`
-- [ ] **Step 5:** Manual: with `[debug].auction_html_comment` off and inline adm on, load a nav page; confirm the winning creative renders **without** a request to `hb_cache_host` (Network tab) and GAM still received `hb_pb`.
+- [ ] **Step 5:** Manual: with `[debug].auction_html_comment` off, load a nav page; confirm the winning creative renders **without** a request to `hb_cache_host` (Network tab) and GAM still received `hb_pb`.
 - [ ] **Step 6: Commit** any format fixes.
 
 ---
 
 ## Notes
-- Do NOT remove `hb_cache_host`/`hb_cache_path` — they are the fallback.
+- Do NOT remove `hb_cache_host`/`hb_cache_path` — they are the fallback for an **absent** `adm`. Render failure *after* `adm` is supplied is not detectable and does not fall back (spec Risks).
 - Do NOT ship the `debug_bid` blob in production (Task 1 keeps it behind the flag).
-- Page-weight cost (inline creatives, uncacheable response) is accepted per spec; size-capping is out of scope.
-- **Precondition (sets expectations):** this only changes the render bridge's *data source* (local `adm` vs cache fetch) **when GAM's Prebid line item already serves the Prebid Universal Creative**. It does not change GAM competition, nor whether the PUC fires. A publisher without Prebid line items in GAM sees no change — same as today's cache path.
+- No global `window.tsjs` flag, no `TsjsApi` change — the bypass gate is the per-bid `debug_bid`.
+- Page-weight cost (inline creatives, uncacheable response) accepted per spec; size-capping out of scope.
+- **Precondition:** only changes the bridge's data source when GAM's Prebid line item already serves the PUC — no change to GAM competition or whether the PUC fires.
diff --git a/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md b/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
index 4322b7a4..8c826d63 100644
--- a/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
+++ b/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
@@ -1,7 +1,7 @@
 # SSAT: render the winning creative inline (no PBS Cache round trip)
 
 **Date:** 2026-07-13
-**Status:** Design approved, pending spec review
+**Status:** Design revised after review, pending final approval
 **Branch:** `feat/ssat-render-inline-creative`
 
 ## Problem
@@ -33,75 +33,87 @@ the round trip that happens *after* GAM has already picked the TS line item.
 
 1. `build_bid_map` ([publisher.rs:1933]) writes `window.tsjs.bids[slot]` with
    `hb_pb`, `hb_bidder`, `hb_adid`, `hb_cache_host`, `hb_cache_path`. The raw
-   `adm` (creative) is included **only** when `include_adm` is set — today wired
-   to `settings.debug.inject_adm_for_testing`.
+   `adm` (creative) and a verbose `debug_bid` blob are included **only** when the
+   current `include_adm` param is set — today wired to
+   `settings.debug.inject_adm_for_testing`.
 2. `build_bids_script` ([publisher.rs:2018]) serializes the bid map and runs it
    through `html_escape_for_script` (escapes `<`/`>`/`&` and `U+2028/2029`),
    embedding it as `JSON.parse("…")`.
 3. GAM's Prebid line item (matched by `hb_pb`) serves the Prebid Universal
-   Creative, which `postMessage`s `"Prebid Request"`.
+   Creative (PUC), which `postMessage`s `"Prebid Request"`.
 4. `installTsRenderBridge` ([gpt/index.ts:839]) intercepts and either:
-   - serves `matchedBid.adm` **directly** when present (no round trip), or
+   - serves `matchedBid.adm` **directly** when present (no round trip), then
+     fires win/billing beacons, or
    - **fetches from PBS Cache** using `hb_cache_host`/`hb_cache_path` (the round
      trip we want to remove).
-
-A separate consumer, `injectAdmIntoSlot` ([gpt/index.ts:599]), fires on
-`if (bid.adm)` and **replaces the GAM creative directly** — a GAM *bypass*. Its
-"testing only" status is a comment, not an actual gate.
+5. A separate consumer, `injectAdmIntoSlot` ([gpt/index.ts:599]), fires on
+   `if (bid.adm)` and **replaces the GAM creative directly** — a GAM *bypass*.
+   Its "testing only" status is a comment, not an actual gate.
 
 ## Design
 
-### 1. Always include the render `adm` for SSAT winners
+### 1. Always include the render `adm`; keep `debug_bid` gated
 
-Split the single `include_adm` parameter, which currently bundles two unrelated
-things, into two independent signals:
+`build_bid_map`:
+- **Always** insert `adm` (from `bid.creative`) for a winner when present —
+  there is no runtime reason to withhold it, so it is not parameterized.
+- Insert the verbose `debug_bid` blob **only** when the testing flag is set. The
+  single `include_adm` param becomes `include_debug_bid`.
 
-- `render_adm` (production, **always on** for SSAT winners) — inserts the `adm`
-  field so the render bridge can serve it locally.
-- `debug_bid` (testing only, gated on `inject_adm_for_testing`) — the verbose
-  `debug_bid` blob at [publisher.rs:1987] stays behind the testing flag and is
-  **not** shipped in production.
+`hb_cache_host`/`hb_cache_path` remain inserted unconditionally.
 
-`hb_cache_host`/`hb_cache_path` remain inserted unconditionally, so the cache
-fetch stays available as a fallback.
+### 2. Bridge renders local `adm`; cache is the fallback for an *absent* `adm`
 
-### 2. Bridge renders local `adm`; cache is the fallback
+`installTsRenderBridge` already prefers `matchedBid.adm` and falls back to PBS
+Cache. Once `adm` is present in production, the local render becomes the default
+and the round trip disappears.
 
-No change to `installTsRenderBridge` logic is required: it already prefers
-`matchedBid.adm` and falls back to PBS Cache. Once `adm` is present in
-production, the local render becomes the default and the round trip disappears.
-If `adm` is ever absent or unrenderable, the existing cache path still runs —
-zero-risk regression.
+**Fallback scope (corrected):** the bridge posts the markup to the PUC and
+returns; it receives **no render-success signal**. So the PBS Cache fallback
+fires only when `adm` is **absent or empty** — *not* when `adm` is present but
+fails to render. Render failures after `adm` is supplied are not currently
+detectable and do not trigger fallback.
 
-### 3. Decouple the GAM-bypass path
+### 3. Gate the GAM-bypass on `bid.debug_bid` (no new global flag)
 
-`injectAdmIntoSlot` must **not** fire in production just because `adm` is now
-present. Gate it behind an explicit injected config flag (e.g.
-`injectAdmForTesting`) read by the JS, so:
+`injectAdmIntoSlot` must not fire in production merely because `adm` is now
+present. Rather than introduce a global `window.tsjs` flag (which goes stale
+across SPA navigations — an empty initial response would pin it `false`), gate
+the bypass on the per-bid `debug_bid` field, which is already present **iff**
+`inject_adm_for_testing` is on:
 
-- production inline-`adm` feeds **only** the render bridge → GAM stays in the
-  loop, and
-- the direct GAM-replace path remains available for testing behind the flag.
+```ts
+if (bid.adm && bid.debug_bid) {
+  injectAdmIntoSlot(divId, bid.adm);
+}
+```
 
-The flag is surfaced to the JS the same way other tsjs config is injected.
+This works for both initial and SPA auction responses, needs no `TsjsApi`
+change, and keeps production `adm` on the bridge-only (keep-GAM) path.
 
 ### 4. Security
 
 No new escaping code. The `adm` string is part of the bid-map JSON that already
 passes through `html_escape_for_script` + `JSON.parse("…")`, which neutralizes
-`</script>` breakout and `U+2028/2029`. Requirement: a regression test proving a
-hostile `adm` containing `</script>` (and `U+2028/2029`) cannot break out of the
-injected `<script>` context. The render itself stays sandboxed in an iframe
-(`srcdoc`/`src`) inside `injectAdmIntoSlot`/the bridge renderer.
+`</script>` breakout and `U+2028/2029`. **This is the guarantee trusted-server
+directly provides**, pinned by a hostile-`adm` regression test.
+
+Frame isolation of the rendered creative is **not** guaranteed by TS on the
+bridge path: `injectAdmIntoSlot` sets `sandbox=ADM_IFRAME_SANDBOX`, but the
+bridge renderer hands `adm` to the PUC-provided `mkFrame`, which TS neither sets
+nor verifies a sandbox on. Bridge isolation therefore depends on the Prebid
+Universal Creative implementation, not on TS.
 
 ## Components changed
 
 | Unit | Change |
 | --- | --- |
-| `build_bid_map` (Rust) | Split `include_adm` → `render_adm` (always) + `debug_bid` (testing). Always insert `adm` for winners. |
-| `build_bid_map` callers | Pass `render_adm = true`; `debug_bid = inject_adm_for_testing`. |
-| tsjs config injection (Rust→JS) | Surface `injectAdmForTesting` flag. |
-| `gpt/index.ts` `injectAdmIntoSlot` call site | Gate on the injected `injectAdmForTesting` flag, not bare `bid.adm`. |
+| `build_bid_map` (Rust) | Always insert `adm` when `bid.creative` is `Some`. Rename `include_adm` → `include_debug_bid`, gating only the `debug_bid` blob. |
+| `build_bid_map` callers | Pass `include_debug_bid = inject_adm_for_testing`. |
+| `gpt/index.ts` `injectAdmIntoSlot` call site | Gate on `bid.adm && bid.debug_bid`. |
+| bridge/`ad_init` tests (JS) | Rename "debug adm" → "inline/local adm"; confirm existing coverage. |
+
+No `build_bids_script` change, no `window.tsjs` flag, no `TsjsApi` change.
 
 ## Data flow (after)
 
@@ -110,40 +122,42 @@ SSAT auction → winner (bid.creative held) → build_bid_map inserts adm
   → build_bids_script (html_escape_for_script) → window.tsjs.bids
   → hb_pb targeting → GAM competes
       ├ GAM picks TS line item → PUC "Prebid Request"
-      │     → bridge replies with local adm  → RENDER (no round trip)
+      │     → bridge replies with local adm  → RENDER (no round trip) + beacons
       │     → (adm absent) → PBS Cache fetch  → RENDER (fallback)
       └ GAM has higher demand → GAM serves its own creative
 ```
 
-## Testing
-
-- **Rust**: `build_bid_map` includes `adm` for winners on the production path;
-  `debug_bid` present only under the testing flag; a hostile `</script>` /
-  `U+2028/2029` `adm` is escaped so `build_bids_script` output stays inside the
-  `<script>`.
-- **JS (vitest)**: bridge serves local `adm` without a cache fetch when present;
-  falls back to cache when `adm` absent; `injectAdmIntoSlot` does **not** fire
-  without the `injectAdmForTesting` flag.
-
 ## Precondition
 
 This changes only the render bridge's *data source* — local `adm` vs a PBS Cache
-fetch — **when GAM's Prebid line item already serves the Prebid Universal
-Creative**. It does not change GAM competition, nor whether the PUC fires. A
-publisher without Prebid line items in GAM sees no behavioral change (same as
-the current cache path).
+fetch — **when GAM's Prebid line item already serves the PUC**. It does not
+change GAM competition, nor whether the PUC fires. A publisher without Prebid
+line items in GAM sees no behavioral change.
+
+## Testing
+
+- **Rust**: `build_bid_map` includes `adm` for winners on every path; `debug_bid`
+  present only under the testing flag; a hostile `</script>` / `U+2028/2029`
+  `adm` is escaped so `build_bids_script` output stays inside the `<script>`.
+- **JS (vitest)**: `injectAdmIntoSlot` fires only when `bid.debug_bid` is present;
+  existing `ad_init.test.ts` bridge coverage (local-adm-without-cache-fetch,
+  cache-fetch-when-adm-absent, `nurl`/`burl` beacons, dedup) is retained with
+  terminology updated to "inline/local adm" — no duplicate tests.
 
 ## Risks / accepted costs
 
 - **Page weight**: every SSAT navigation response now carries winners' creatives
   inline (~3–8 KB each), making that response larger and per-auction
-  (uncacheable). Accepted as the cost of client-parity rendering. A future
-  size-cap (inline small, cache large) is out of scope here.
-- **Renderability**: some creatives may assume a PBS Cache/PUC context. The cache
-  fallback covers any that don't render inline.
+  (uncacheable). Accepted as the cost of client-parity rendering.
+- **Renderability**: some creatives may assume a PBS Cache/PUC context. Because
+  render failure after the bridge supplies `adm` is **not detectable**, such a
+  creative will fail to render rather than fall back to cache. Mitigation is
+  operational (validate creatives) — automatic fallback on render failure is out
+  of scope.
 
 ## Out of scope
 
 - Size-capping / conditional inline vs cache.
+- Detecting render failure to trigger cache fallback.
 - Bypassing GAM for SSAT winners.
 - Changing the client-side `/auction` render path.

From a1b844dccba61e61b68d55ea7b995d51c5b4747c Mon Sep 17 00:00:00 2001
From: prk-Jr <prakashsagwara@gmail.com>
Date: Mon, 13 Jul 2026 22:48:42 +0530
Subject: [PATCH 05/10] Refine plan test details per second review

- Task 3: assert observable DOM (GAM iframe src) instead of spying on the
  module-private injectAdmIntoSlot
- Use existing make_bid helper + set .creative (make_test_bid_with_creative
  does not exist on this branch)
- Hostile-adm regression test covers both U+2028 and U+2029
- Add 'cd docs && npm run format' to verification
---
 .../2026-07-13-ssat-render-inline-creative.md | 36 +++++++++++--------
 1 file changed, 22 insertions(+), 14 deletions(-)

diff --git a/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md b/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
index fc71045d..f191568b 100644
--- a/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
+++ b/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
@@ -34,7 +34,11 @@
 #[test]
 fn build_bid_map_always_includes_adm_and_gates_debug_bid() {
     let mut winning = std::collections::HashMap::new();
-    winning.insert("ad-header-0".to_string(), make_test_bid_with_creative("<div>x</div>"));
+    // Reuse the existing `make_bid(slot_id, price, bidder, ad_id, nurl, burl)`
+    // helper (~:3969); it sets `creative: None`, so set the creative here.
+    let mut bid = make_bid("ad-header-0", 1.50, "kargo", "abc123", "https://ssp/win", "https://ssp/bill");
+    bid.creative = Some("<div>x</div>".to_string());
+    winning.insert("ad-header-0".to_string(), bid);
     // include_debug_bid = false (production)
     let map = build_bid_map(&winning, PriceGranularity::Dense, false);
     let slot = map["ad-header-0"]
@@ -104,10 +108,10 @@ pub(crate) fn build_bid_map(
 #[test]
 fn build_bids_script_escapes_hostile_adm() {
     let mut winning = std::collections::HashMap::new();
-    winning.insert(
-        "s".to_string(),
-        make_test_bid_with_creative("</script><script>alert(1)</script>\u{2028}"),
-    );
+    let mut bid = make_bid("s", 1.50, "kargo", "abc123", "https://ssp/win", "https://ssp/bill");
+    // Both line/paragraph separators — the spec promises escaping for each.
+    bid.creative = Some("</script><script>alert(1)</script>\u{2028}\u{2029}".to_string());
+    winning.insert("s".to_string(), bid);
     let map = build_bid_map(&winning, PriceGranularity::Dense, false);
     let script = build_bids_script(&map);
     assert!(
@@ -115,8 +119,8 @@ fn build_bids_script_escapes_hostile_adm() {
         "should not let a hostile adm break out of the script context"
     );
     assert!(
-        !script.contains('\u{2028}'),
-        "should unicode-escape U+2028 in the adm"
+        !script.contains('\u{2028}') && !script.contains('\u{2029}'),
+        "should unicode-escape both U+2028 and U+2029 in the adm"
     );
 }
 ```
@@ -135,12 +139,15 @@ Run: `cargo test-fastly build_bids_script_escapes_hostile_adm`
 - Modify: `crates/trusted-server-js/lib/src/integrations/gpt/index.ts:~599`
 - Test: `crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts`
 
-- [ ] **Step 1: Write failing vitest** — bypass does NOT fire in production (no `debug_bid`), even with `bid.adm`.
+- [ ] **Step 1: Write failing vitest — observable behavior (not a spy).** `injectAdmIntoSlot` is module-private, so assert its *effect* on the DOM:
 
 ```ts
-// window.tsjs.bids = { 'ad-header-0': { adm: '<div>x</div>' } }  // no debug_bid
-// simulate slotRenderEnded for ad-header-0
-// spy on injectAdmIntoSlot → assert NOT called (the bridge handles render)
+// Setup:
+//   bids['ad-header-0'] = { adm: '<iframe src="https://cdn.example/creative.html"></iframe>' }  // NO debug_bid
+//   place an existing GAM iframe (src="about:blank") in the slot div
+//   capture the slotRenderEnded listener, fire it for 'ad-header-0'
+// Assert (production): the GAM iframe src stays 'about:blank'
+//   — the bypass did not fire; the render bridge handles it.
 ```
 
 - [ ] **Step 2: Run — expect FAIL.** `cd crates/trusted-server-js/lib && npx vitest run ad_init`
@@ -156,7 +163,7 @@ if (bid.adm && bid.debug_bid) {
 }
 ```
 
-- [ ] **Step 4: Add companion test** — with `bid.debug_bid` present, `injectAdmIntoSlot` IS called.
+- [ ] **Step 4: Add companion test (testing mode)** — same setup but with `bid.debug_bid` present. Fire `slotRenderEnded` → assert the slot iframe's `src` **changes to** the creative URL (`https://cdn.example/creative.html`), proving `injectAdmIntoSlot` ran.
 
 - [ ] **Step 5: Run — expect PASS.**
 
@@ -194,8 +201,9 @@ concurrency + beacon dedup. Do **not** duplicate them.
   cargo clippy-spin-wasm
   ```
 - [ ] **Step 4:** `cd crates/trusted-server-js/lib && npx vitest run && npm run format && node build-all.mjs`
-- [ ] **Step 5:** Manual: with `[debug].auction_html_comment` off, load a nav page; confirm the winning creative renders **without** a request to `hb_cache_host` (Network tab) and GAM still received `hb_pb`.
-- [ ] **Step 6: Commit** any format fixes.
+- [ ] **Step 5:** Docs format (these spec/plan docs changed): `cd docs && npm run format`
+- [ ] **Step 6:** Manual: with `[debug].auction_html_comment` off, load a nav page; confirm the winning creative renders **without** a request to `hb_cache_host` (Network tab) and GAM still received `hb_pb`.
+- [ ] **Step 7: Commit** any format fixes.
 
 ---
 

From 6649875643b5c70b2cf218fbf477a9fa9eaae47a Mon Sep 17 00:00:00 2001
From: prk-Jr <prakashsagwara@gmail.com>
Date: Mon, 13 Jul 2026 22:53:35 +0530
Subject: [PATCH 06/10] Always include adm in bid map; gate only debug_bid blob

build_bid_map now always inserts the winning creative as adm so the pbRender
bridge can render it locally (no PBS Cache round trip); the verbose debug_bid
blob and the GAM-bypass gate stay behind inject_adm_for_testing. Rename the
param include_adm -> include_debug_bid and thread it through write_bids_to_state.
Reconcile the by-default test to the new behavior, drop the now-redundant
debug-only-adm test, and pin script-context escaping for a hostile adm
(</script> + U+2028/U+2029).
---
 crates/trusted-server-core/src/publisher.rs | 66 ++++++++++++---------
 1 file changed, 37 insertions(+), 29 deletions(-)

diff --git a/crates/trusted-server-core/src/publisher.rs b/crates/trusted-server-core/src/publisher.rs
index 6b0ea3a5..f32d3289 100644
--- a/crates/trusted-server-core/src/publisher.rs
+++ b/crates/trusted-server-core/src/publisher.rs
@@ -843,14 +843,14 @@ pub(crate) fn write_bids_to_state(
     winning_bids: &std::collections::HashMap<String, Bid>,
     price_granularity: PriceGranularity,
     ad_bids_state: &Arc<Mutex<Option<String>>>,
-    inject_adm: bool,
+    include_debug_bid: bool,
 ) {
     log::debug!(
         "write_bids_to_state: {} winning bid(s): [{}]",
         winning_bids.len(),
         winning_bids.keys().cloned().collect::<Vec<_>>().join(", ")
     );
-    let bid_map = build_bid_map(winning_bids, price_granularity, inject_adm);
+    let bid_map = build_bid_map(winning_bids, price_granularity, include_debug_bid);
     let bids_script = build_bids_script(&bid_map);
     *ad_bids_state.lock().expect("should lock bid state") = Some(bids_script);
 }
@@ -1933,7 +1933,7 @@ fn html_escape_for_script(s: &str) -> String {
 pub(crate) fn build_bid_map(
     winning_bids: &std::collections::HashMap<String, Bid>,
     granularity: crate::price_bucket::PriceGranularity,
-    include_adm: bool,
+    include_debug_bid: bool,
 ) -> serde_json::Map<String, serde_json::Value> {
     winning_bids
         .iter()
@@ -1978,12 +1978,16 @@ pub(crate) fn build_bid_map(
                 if let Some(ref burl) = bid.burl {
                     obj.insert("burl".to_string(), serde_json::Value::String(burl.clone()));
                 }
-                // Include raw creative markup only for explicit debug injection.
-                // The pbRender bridge can use it while PBS Cache is unavailable.
-                if include_adm {
-                    if let Some(ref adm) = bid.creative {
-                        obj.insert("adm".to_string(), serde_json::Value::String(adm.clone()));
-                    }
+                // Always include the winning creative so the pbRender bridge can
+                // render it locally when GAM serves the Prebid Universal Creative
+                // — no PBS Cache round trip. The `hb_cache_*` coordinates above
+                // remain as the fallback for an absent `adm`.
+                if let Some(ref adm) = bid.creative {
+                    obj.insert("adm".to_string(), serde_json::Value::String(adm.clone()));
+                }
+                // Verbose per-bid debug blob only under the testing flag; also
+                // doubles as the client-side gate for the direct GAM-replace path.
+                if include_debug_bid {
                     obj.insert(
                         "debug_bid".to_string(),
                         serde_json::json!({
@@ -4071,7 +4075,7 @@ mod tests {
         }
 
         #[test]
-        fn client_bid_map_omits_adm_by_default() {
+        fn client_bid_map_includes_adm_and_omits_debug_bid_by_default() {
             let mut winning_bids = HashMap::new();
             let mut bid = make_bid(
                 "atf_sidebar_ad",
@@ -4084,6 +4088,9 @@ mod tests {
             bid.creative = Some("<div>Creative</div>".to_string());
             winning_bids.insert("atf_sidebar_ad".to_string(), bid);
 
+            // Production path (include_debug_bid = false): the creative is always
+            // included so the bridge can render it locally, but the verbose
+            // debug_bid blob is not.
             let map = build_bid_map(&winning_bids, PriceGranularity::Dense, false);
             let obj = map
                 .get("atf_sidebar_ad")
@@ -4091,41 +4098,42 @@ mod tests {
                 .as_object()
                 .expect("should be object");
 
-            assert!(
-                obj.get("adm").is_none(),
-                "should omit adm when debug injection is disabled"
+            assert_eq!(
+                obj.get("adm").and_then(|v| v.as_str()),
+                Some("<div>Creative</div>"),
+                "should include creative markup for local rendering by default"
             );
             assert!(
                 obj.get("debug_bid").is_none(),
-                "should omit debug bid when debug injection is disabled"
+                "should omit the debug_bid blob when debug injection is disabled"
             );
         }
 
         #[test]
-        fn client_bid_map_includes_adm_when_debug_injection_enabled() {
+        fn build_bids_script_escapes_hostile_adm() {
             let mut winning_bids = HashMap::new();
             let mut bid = make_bid(
-                "atf_sidebar_ad",
+                "s",
                 1.50,
                 "kargo",
                 "abc123",
                 "https://ssp/win",
                 "https://ssp/bill",
             );
-            bid.creative = Some("<div>Creative</div>".to_string());
-            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
-
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, true);
-            let obj = map
-                .get("atf_sidebar_ad")
-                .expect("should have bid entry")
-                .as_object()
-                .expect("should be object");
+            // A hostile creative that tries to break out of the <script> and
+            // includes both line/paragraph separators the spec promises to escape.
+            bid.creative = Some("</script><script>alert(1)</script>\u{2028}\u{2029}".to_string());
+            winning_bids.insert("s".to_string(), bid);
 
-            assert_eq!(
-                obj.get("adm").and_then(|v| v.as_str()),
-                Some("<div>Creative</div>"),
-                "should include adm when debug injection is enabled"
+            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, false);
+            let script = build_bids_script(&map);
+            assert!(
+                !script.contains("</script><script>"),
+                "should not let a hostile adm break out of the script context"
+            );
+            assert!(
+                !script.contains('\u{2028}') && !script.contains('\u{2029}'),
+                "should unicode-escape both U+2028 and U+2029 in the adm"
             );
         }
 

From e2b13bbdfbd5d92e9241dbe13cdefa1de1a61bd4 Mon Sep 17 00:00:00 2001
From: prk-Jr <prakashsagwara@gmail.com>
Date: Mon, 13 Jul 2026 22:59:23 +0530
Subject: [PATCH 07/10] Gate GAM-bypass adm injection on per-bid debug_bid

The direct GAM-replace path (injectAdmIntoSlot) now fires only when the bid
carries debug_bid, which is present only under inject_adm_for_testing. In
production the always-present adm is rendered by the pbRender bridge and GAM
stays in the loop. Add observable-DOM tests (GAM iframe src unchanged without
debug_bid, rewritten with it), strengthen the bridge test to prove inline adm
is preferred even when cache coords are present, and rename debug-adm
terminology to inline adm.
---
 .../lib/src/integrations/gpt/index.ts         | 13 +--
 .../lib/test/integrations/gpt/ad_init.test.ts | 90 +++++++++++++++++--
 2 files changed, 92 insertions(+), 11 deletions(-)

diff --git a/crates/trusted-server-js/lib/src/integrations/gpt/index.ts b/crates/trusted-server-js/lib/src/integrations/gpt/index.ts
index ca468968..c21e54ac 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt/index.ts
@@ -593,10 +593,13 @@ export function installTsAdInit(): void {
           // Read ts.bids live (not the snapshot above) so post-navigation bid data is used.
           const bid = (ts.bids ?? {})[slotId] ?? {};
 
-          // GAM interceptor (testing): when adm is present, replace the GAM creative.
-          // Adapted from PR #241 — uses window.tsjs.bids[slotId].adm instead of pbjs.
-          // Only active when inject_adm_for_testing injects adm into bids server-side.
-          if (bid.adm) {
+          // GAM interceptor (testing bypass): directly replace the GAM creative.
+          // `adm` is now always injected in production, so it can no longer gate
+          // this path. `debug_bid` is present only when inject_adm_for_testing is
+          // on, so it is the per-bid signal that the testing bypass is enabled.
+          // In production the render bridge serves the creative and GAM stays in
+          // the loop; this direct replace stays testing-only.
+          if (bid.adm && bid.debug_bid) {
             injectAdmIntoSlot(divId, bid.adm);
           }
         });
@@ -902,7 +905,7 @@ export function installTsRenderBridge(): void {
         })
       );
       fireWinBillingBeacons(slotId, matchedBid);
-      log.debug(`[tsjs-gpt] pbRender bridge served '${slotId}' from debug adm`);
+      log.debug(`[tsjs-gpt] pbRender bridge served '${slotId}' from inline adm`);
       return;
     }
 
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
index 4a636876..1df0138a 100644
--- 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
@@ -371,7 +371,7 @@ describe('installTsAdInit', () => {
     expect(mockPubads.refresh).not.toHaveBeenCalled();
   });
 
-  it('keeps the GAM path when debug adm is present', async () => {
+  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(),
@@ -408,7 +408,7 @@ describe('installTsAdInit', () => {
           hb_pb: '0.20',
           hb_bidder: 'mocktioneer',
           hb_adid: 'debug-uuid',
-          adm: '<div>Debug creative</div>',
+          adm: '<div>Inline creative</div>',
         },
       },
     };
@@ -426,6 +426,80 @@ describe('installTsAdInit', () => {
     expect(mockPubads.refresh).toHaveBeenCalledWith([mockSlot]);
   });
 
+  // Helper: full adInit setup for a single slot whose bid carries an iframe adm.
+  // `debugBid` toggles the per-bid `debug_bid` field that gates the testing bypass.
+  async function fireSlotRenderWithAdm(debugBid: boolean): Promise<HTMLIFrameElement> {
+    let capturedListener: ((e: SlotRenderEvent) => void) | undefined;
+    const mockSlot = {
+      addService: vi.fn().mockReturnThis(),
+      setTargeting: vi.fn().mockReturnThis(),
+      getSlotElementId: vi.fn().mockReturnValue('div-atf-sidebar'),
+      getTargeting: vi.fn().mockReturnValue(['abc']),
+    };
+    const mockPubads = {
+      enableSingleRequest: vi.fn(),
+      getSlots: vi.fn().mockReturnValue([mockSlot]),
+      refresh: vi.fn(),
+      addEventListener: vi.fn((event: string, fn: (e: SlotRenderEvent) => void) => {
+        if (event === 'slotRenderEnded') capturedListener = fn;
+      }),
+    };
+    (window as TestWindow).googletag = {
+      cmd: { push: vi.fn((fn: () => void) => fn()) },
+      defineSlot: vi.fn().mockReturnValue(mockSlot),
+      pubads: vi.fn().mockReturnValue(mockPubads),
+      enableServices: vi.fn(),
+    };
+    (window as TestWindow).tsjs = {
+      adSlots: [
+        {
+          id: 'atf_sidebar_ad',
+          gam_unit_path: '/123/atf',
+          div_id: 'div-atf-sidebar',
+          formats: [[300, 250]],
+          targeting: {},
+        },
+      ],
+      bids: {
+        atf_sidebar_ad: {
+          hb_pb: '1.00',
+          hb_bidder: 'kargo',
+          hb_adid: 'abc',
+          adm: '<iframe src="https://cdn.example/creative.html"></iframe>',
+          ...(debugBid ? { debug_bid: { slot_id: 'atf_sidebar_ad' } } : {}),
+        },
+      },
+    };
+
+    const { installTsAdInit } = await import('../../../src/integrations/gpt/index');
+    installTsAdInit();
+    (window as TestWindow).tsjs!.adInit!();
+
+    // A pre-existing GAM iframe; the bypass, if it runs, rewrites its src.
+    const slotEl = document.getElementById('div-atf-sidebar')!;
+    const gamIframe = document.createElement('iframe');
+    gamIframe.src = 'about:blank';
+    slotEl.appendChild(gamIframe);
+
+    expect(capturedListener).toBeDefined();
+    capturedListener!({ isEmpty: false, slot: mockSlot });
+    return gamIframe;
+  }
+
+  it('does not run the GAM-replace bypass without debug_bid (production)', async () => {
+    const gamIframe = await fireSlotRenderWithAdm(false);
+    // No debug_bid ⇒ testing bypass is off; the render bridge handles the creative
+    // and GAM stays in the loop, so the GAM iframe src is untouched.
+    expect(gamIframe.src).toBe('about:blank');
+  });
+
+  it('runs the GAM-replace bypass when debug_bid is present (testing)', async () => {
+    const gamIframe = await fireSlotRenderWithAdm(true);
+    // debug_bid present ⇒ inject_adm_for_testing on ⇒ direct GAM replace fires,
+    // rewriting the iframe to the creative URL from the adm.
+    expect(gamIframe.src).toBe('https://cdn.example/creative.html');
+  });
+
   it('does not fire win/billing beacons from slotRenderEnded targeting alone', async () => {
     const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
     let capturedListener: ((e: SlotRenderEvent) => void) | undefined;
@@ -1039,18 +1113,22 @@ describe('installTsRenderBridge', () => {
     beaconSpy.mockRestore();
   });
 
-  it('responds with adm without fetching PBS Cache when debug adm is available', async () => {
+  it('serves inline adm without fetching PBS Cache even when cache coords are present', async () => {
     const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
-    const debugAdm = '<div>Debug Creative</div>';
+    const inlineAdm = '<div>Inline Creative</div>';
     (window as TestWindow).tsjs = {
       bids: {
         homepage_header: {
           hb_adid: 'debug-adid',
           hb_bidder: 'mocktioneer',
           hb_pb: '0.20',
+          // Production shape: cache coordinates ARE present, but the bridge must
+          // prefer the local inline adm and skip the PBS Cache fetch.
+          hb_cache_host: 'cache.example.com',
+          hb_cache_path: '/pbc/v1/cache',
           nurl: 'https://debug.example/win',
           burl: 'https://debug.example/bill',
-          adm: debugAdm,
+          adm: inlineAdm,
         },
       },
       adSlots: [
@@ -1103,7 +1181,7 @@ describe('installTsRenderBridge', () => {
     const parsed = JSON.parse(portMessages[0]) as Record<string, any>;
     expect(parsed.message).toBe('Prebid Response');
     expect(parsed.adId).toBe('debug-adid');
-    expect(parsed.ad).toBe(debugAdm);
+    expect(parsed.ad).toBe(inlineAdm);
     expect(parsed.width).toBe(728);
     expect(parsed.height).toBe(90);
     expect(beaconSpy).toHaveBeenCalledWith('https://debug.example/win');

From cb60fd26b91c9576ff7c306888f2b822642be9ef Mon Sep 17 00:00:00 2001
From: prk-Jr <prakashsagwara@gmail.com>
Date: Mon, 13 Jul 2026 23:04:41 +0530
Subject: [PATCH 08/10] Apply prettier formatting to spec/plan docs

---
 .../2026-07-13-ssat-render-inline-creative.md | 23 +++++++++-------
 ...7-13-ssat-render-inline-creative-design.md | 27 ++++++++++---------
 2 files changed, 28 insertions(+), 22 deletions(-)

diff --git a/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md b/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
index f191568b..07df67f5 100644
--- a/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
+++ b/docs/superpowers/plans/2026-07-13-ssat-render-inline-creative.md
@@ -4,7 +4,7 @@
 
 **Goal:** Render SSAT-winning creatives from the copy trusted-server already holds (no render-time PBS Cache round trip), while keeping GAM in the loop.
 
-**Architecture:** Always include the winning `adm` in `window.tsjs.bids` so the existing `installTsRenderBridge` serves it locally when GAM's Prebid Universal Creative fires. Keep `hb_cache_*` as the fallback for an *absent* `adm`. Keep the verbose `debug_bid` blob behind the testing flag, and gate the GAM-bypass path (`injectAdmIntoSlot`) on the per-bid `debug_bid` field — no global flag, no `TsjsApi` change.
+**Architecture:** Always include the winning `adm` in `window.tsjs.bids` so the existing `installTsRenderBridge` serves it locally when GAM's Prebid Universal Creative fires. Keep `hb_cache_*` as the fallback for an _absent_ `adm`. Keep the verbose `debug_bid` blob behind the testing flag, and gate the GAM-bypass path (`injectAdmIntoSlot`) on the per-bid `debug_bid` field — no global flag, no `TsjsApi` change.
 
 **Tech Stack:** Rust (`trusted-server-core`, wasm32-wasip1 via Viceroy), TypeScript (`trusted-server-js`, vitest).
 
@@ -14,17 +14,18 @@
 
 ## File Structure
 
-| File | Responsibility | Change |
-| --- | --- | --- |
-| `crates/trusted-server-core/src/publisher.rs` | Build `window.tsjs.bids` | Always insert `adm`; rename `include_adm`→`include_debug_bid` (gates only the blob) |
-| `crates/trusted-server-js/lib/src/integrations/gpt/index.ts` | Client render paths | Gate `injectAdmIntoSlot` on `bid.adm && bid.debug_bid` |
-| `crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts` | JS tests | Rename "debug adm"→"inline/local adm"; add bypass-gate test |
+| File                                                                 | Responsibility           | Change                                                                              |
+| -------------------------------------------------------------------- | ------------------------ | ----------------------------------------------------------------------------------- |
+| `crates/trusted-server-core/src/publisher.rs`                        | Build `window.tsjs.bids` | Always insert `adm`; rename `include_adm`→`include_debug_bid` (gates only the blob) |
+| `crates/trusted-server-js/lib/src/integrations/gpt/index.ts`         | Client render paths      | Gate `injectAdmIntoSlot` on `bid.adm && bid.debug_bid`                              |
+| `crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts` | JS tests                 | Rename "debug adm"→"inline/local adm"; add bypass-gate test                         |
 
 ---
 
 ## Task 1: `build_bid_map` — always include `adm`, gate only `debug_bid`
 
 **Files:**
+
 - Modify: `crates/trusted-server-core/src/publisher.rs` (`build_bid_map` ~1933; `write_bids_to_state` ~846; callers)
 - Test: same file, `#[cfg(test)] mod tests`
 
@@ -100,6 +101,7 @@ pub(crate) fn build_bid_map(
 ## Task 2: Escaping regression — hostile `adm` cannot break out of `<script>`
 
 **Files:**
+
 - Modify: `crates/trusted-server-core/src/publisher.rs` tests
 
 - [ ] **Step 1: Write test** — a `</script>` + `U+2028` adm is neutralized in the emitted script.
@@ -136,10 +138,11 @@ Run: `cargo test-fastly build_bids_script_escapes_hostile_adm`
 ## Task 3: Gate the GAM-bypass (`injectAdmIntoSlot`) on `bid.debug_bid`
 
 **Files:**
+
 - Modify: `crates/trusted-server-js/lib/src/integrations/gpt/index.ts:~599`
 - Test: `crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts`
 
-- [ ] **Step 1: Write failing vitest — observable behavior (not a spy).** `injectAdmIntoSlot` is module-private, so assert its *effect* on the DOM:
+- [ ] **Step 1: Write failing vitest — observable behavior (not a spy).** `injectAdmIntoSlot` is module-private, so assert its _effect_ on the DOM:
 
 ```ts
 // Setup:
@@ -159,7 +162,7 @@ Run: `cargo test-fastly build_bids_script_escapes_hostile_adm`
 // when inject_adm_for_testing is on, so it doubles as the per-bid gate — no
 // global flag needed, and it is correct across SPA auction responses.
 if (bid.adm && bid.debug_bid) {
-  injectAdmIntoSlot(divId, bid.adm);
+  injectAdmIntoSlot(divId, bid.adm)
 }
 ```
 
@@ -174,6 +177,7 @@ if (bid.adm && bid.debug_bid) {
 ## Task 4: Reconcile existing bridge tests (no duplicates)
 
 **Files:**
+
 - Modify: `crates/trusted-server-js/lib/test/integrations/gpt/ad_init.test.ts`
 
 `ad_init.test.ts` already covers: PBS Cache fetch when `adm` absent; local `adm`
@@ -208,7 +212,8 @@ concurrency + beacon dedup. Do **not** duplicate them.
 ---
 
 ## Notes
-- Do NOT remove `hb_cache_host`/`hb_cache_path` — they are the fallback for an **absent** `adm`. Render failure *after* `adm` is supplied is not detectable and does not fall back (spec Risks).
+
+- Do NOT remove `hb_cache_host`/`hb_cache_path` — they are the fallback for an **absent** `adm`. Render failure _after_ `adm` is supplied is not detectable and does not fall back (spec Risks).
 - Do NOT ship the `debug_bid` blob in production (Task 1 keeps it behind the flag).
 - No global `window.tsjs` flag, no `TsjsApi` change — the bypass gate is the per-bid `debug_bid`.
 - Page-weight cost (inline creatives, uncacheable response) accepted per spec; size-capping out of scope.
diff --git a/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md b/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
index 8c826d63..8dee3f45 100644
--- a/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
+++ b/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
@@ -14,7 +14,7 @@ time from PBS Cache:
 https://<hb_cache_host><hb_cache_path>?uuid=<hb_adid>
 ```
 
-This is an extra network round trip *after* the GAM call, even though
+This is an extra network round trip _after_ the GAM call, even though
 trusted-server already holds the winning creative markup (`bid.creative`) from
 the server-side auction it just ran. The client-side `/auction` flow never does
 this — Prebid.js renders the winner from the copy it already has in the browser.
@@ -27,7 +27,7 @@ while keeping GAM in the loop (the header bid still competes against GAM's own
 demand via `hb_pb`).
 
 Non-goal: bypassing GAM. SSAT winners must still compete in GAM; we only remove
-the round trip that happens *after* GAM has already picked the TS line item.
+the round trip that happens _after_ GAM has already picked the TS line item.
 
 ## Current flow (verified in code)
 
@@ -47,7 +47,7 @@ the round trip that happens *after* GAM has already picked the TS line item.
    - **fetches from PBS Cache** using `hb_cache_host`/`hb_cache_path` (the round
      trip we want to remove).
 5. A separate consumer, `injectAdmIntoSlot` ([gpt/index.ts:599]), fires on
-   `if (bid.adm)` and **replaces the GAM creative directly** — a GAM *bypass*.
+   `if (bid.adm)` and **replaces the GAM creative directly** — a GAM _bypass_.
    Its "testing only" status is a comment, not an actual gate.
 
 ## Design
@@ -55,6 +55,7 @@ the round trip that happens *after* GAM has already picked the TS line item.
 ### 1. Always include the render `adm`; keep `debug_bid` gated
 
 `build_bid_map`:
+
 - **Always** insert `adm` (from `bid.creative`) for a winner when present —
   there is no runtime reason to withhold it, so it is not parameterized.
 - Insert the verbose `debug_bid` blob **only** when the testing flag is set. The
@@ -62,7 +63,7 @@ the round trip that happens *after* GAM has already picked the TS line item.
 
 `hb_cache_host`/`hb_cache_path` remain inserted unconditionally.
 
-### 2. Bridge renders local `adm`; cache is the fallback for an *absent* `adm`
+### 2. Bridge renders local `adm`; cache is the fallback for an _absent_ `adm`
 
 `installTsRenderBridge` already prefers `matchedBid.adm` and falls back to PBS
 Cache. Once `adm` is present in production, the local render becomes the default
@@ -70,7 +71,7 @@ and the round trip disappears.
 
 **Fallback scope (corrected):** the bridge posts the markup to the PUC and
 returns; it receives **no render-success signal**. So the PBS Cache fallback
-fires only when `adm` is **absent or empty** — *not* when `adm` is present but
+fires only when `adm` is **absent or empty** — _not_ when `adm` is present but
 fails to render. Render failures after `adm` is supplied are not currently
 detectable and do not trigger fallback.
 
@@ -84,7 +85,7 @@ the bypass on the per-bid `debug_bid` field, which is already present **iff**
 
 ```ts
 if (bid.adm && bid.debug_bid) {
-  injectAdmIntoSlot(divId, bid.adm);
+  injectAdmIntoSlot(divId, bid.adm)
 }
 ```
 
@@ -106,12 +107,12 @@ Universal Creative implementation, not on TS.
 
 ## Components changed
 
-| Unit | Change |
-| --- | --- |
-| `build_bid_map` (Rust) | Always insert `adm` when `bid.creative` is `Some`. Rename `include_adm` → `include_debug_bid`, gating only the `debug_bid` blob. |
-| `build_bid_map` callers | Pass `include_debug_bid = inject_adm_for_testing`. |
-| `gpt/index.ts` `injectAdmIntoSlot` call site | Gate on `bid.adm && bid.debug_bid`. |
-| bridge/`ad_init` tests (JS) | Rename "debug adm" → "inline/local adm"; confirm existing coverage. |
+| Unit                                         | Change                                                                                                                           |
+| -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `build_bid_map` (Rust)                       | Always insert `adm` when `bid.creative` is `Some`. Rename `include_adm` → `include_debug_bid`, gating only the `debug_bid` blob. |
+| `build_bid_map` callers                      | Pass `include_debug_bid = inject_adm_for_testing`.                                                                               |
+| `gpt/index.ts` `injectAdmIntoSlot` call site | Gate on `bid.adm && bid.debug_bid`.                                                                                              |
+| bridge/`ad_init` tests (JS)                  | Rename "debug adm" → "inline/local adm"; confirm existing coverage.                                                              |
 
 No `build_bids_script` change, no `window.tsjs` flag, no `TsjsApi` change.
 
@@ -129,7 +130,7 @@ SSAT auction → winner (bid.creative held) → build_bid_map inserts adm
 
 ## Precondition
 
-This changes only the render bridge's *data source* — local `adm` vs a PBS Cache
+This changes only the render bridge's _data source_ — local `adm` vs a PBS Cache
 fetch — **when GAM's Prebid line item already serves the PUC**. It does not
 change GAM competition, nor whether the PUC fires. A publisher without Prebid
 line items in GAM sees no behavioral change.

From 1c983027cc7d95b42dc77e409ac65042a4016a93 Mon Sep 17 00:00:00 2001
From: prk-Jr <prakashsagwara@gmail.com>
Date: Thu, 16 Jul 2026 11:27:50 +0530
Subject: [PATCH 09/10] Run SSAT inline creative through the sanitize/rewrite
 boundary and decode cached bids

The inline-adm path fed raw bid.creative into window.tsjs.bids, bypassing the
creative-processing boundary the /auction path applies (sanitize_creative_html
then rewrite_creative_html, which also enforces the 1 MiB creative cap). Run the
same boundary in build_bid_map before inserting adm; omit adm when the creative
is rejected so the bridge falls back to the PBS Cache coordinates. Thread
&Settings through build_bid_map and write_bids_to_state for rewrite_creative_html.

The pbRender bridge's PBS Cache fallback forwarded the raw GET body as the ad,
but PBS Cache returns a JSON bid object and the Prebid Universal Creative renders
bidObject.adm. Add extractCachedAdm to parse the cached bid and extract its adm,
keep raw-markup compatibility, and decline to render when no adm is present.

Add hostile and oversized creative coverage in Rust, and realistic
returnCreative=false, malformed, and raw-markup cache-response coverage in JS.
Update the inject_adm_for_testing, AuctionBidData, GPT bridge, and design-spec
docs to distinguish production inline adm from the testing-only debug_bid path.
---
 crates/trusted-server-core/src/publisher.rs   | 186 ++++++++++++++++--
 crates/trusted-server-core/src/settings.rs    |  15 +-
 .../trusted-server-js/lib/src/core/types.ts   |  16 +-
 .../lib/src/integrations/gpt/index.ts         |  53 ++++-
 .../lib/test/integrations/gpt/ad_init.test.ts |  73 ++++++-
 ...7-13-ssat-render-inline-creative-design.md |  84 +++++---
 6 files changed, 371 insertions(+), 56 deletions(-)

diff --git a/crates/trusted-server-core/src/publisher.rs b/crates/trusted-server-core/src/publisher.rs
index b3a2369a..894609e1 100644
--- a/crates/trusted-server-core/src/publisher.rs
+++ b/crates/trusted-server-core/src/publisher.rs
@@ -697,6 +697,7 @@ pub async fn stream_publisher_body_async<W: Write>(
             &result.winning_bids,
             params.price_granularity,
             &params.ad_bids_state,
+            settings,
             settings.debug.inject_adm_for_testing,
         );
         return stream_publisher_body(body, output, params, settings, integration_registry);
@@ -848,6 +849,7 @@ pub(crate) fn write_bids_to_state(
     winning_bids: &std::collections::HashMap<String, Bid>,
     price_granularity: PriceGranularity,
     ad_bids_state: &Arc<Mutex<Option<String>>>,
+    settings: &Settings,
     include_debug_bid: bool,
 ) {
     log::debug!(
@@ -855,7 +857,7 @@ pub(crate) fn write_bids_to_state(
         winning_bids.len(),
         winning_bids.keys().cloned().collect::<Vec<_>>().join(", ")
     );
-    let bid_map = build_bid_map(winning_bids, price_granularity, include_debug_bid);
+    let bid_map = build_bid_map(winning_bids, price_granularity, settings, include_debug_bid);
     let bids_script = build_bids_script(&bid_map);
     *ad_bids_state.lock().expect("should lock bid state") = Some(bids_script);
 }
@@ -1243,6 +1245,7 @@ async fn collect_stream_auction(
         &result.winning_bids,
         price_granularity,
         ad_bids_state,
+        settings,
         settings.debug.inject_adm_for_testing,
     );
 
@@ -1938,6 +1941,7 @@ fn html_escape_for_script(s: &str) -> String {
 pub(crate) fn build_bid_map(
     winning_bids: &std::collections::HashMap<String, Bid>,
     granularity: crate::price_bucket::PriceGranularity,
+    settings: &Settings,
     include_debug_bid: bool,
 ) -> serde_json::Map<String, serde_json::Value> {
     winning_bids
@@ -1987,8 +1991,19 @@ pub(crate) fn build_bid_map(
                 // render it locally when GAM serves the Prebid Universal Creative
                 // — no PBS Cache round trip. The `hb_cache_*` coordinates above
                 // remain as the fallback for an absent `adm`.
-                if let Some(ref adm) = bid.creative {
-                    obj.insert("adm".to_string(), serde_json::Value::String(adm.clone()));
+                //
+                // Run the same creative-processing boundary as the `/auction`
+                // path (see `auction::formats`): sanitize dangerous markup first,
+                // then rewrite URLs to first-party proxies. `sanitize_creative_html`
+                // also enforces the 1 MiB creative cap, returning an empty string
+                // for oversized or unparseable markup — in which case the entry is
+                // omitted and the bridge falls back to the PBS Cache coordinates.
+                if let Some(ref raw_creative) = bid.creative {
+                    let sanitized = crate::creative::sanitize_creative_html(raw_creative);
+                    let adm = crate::creative::rewrite_creative_html(settings, &sanitized);
+                    if !adm.is_empty() {
+                        obj.insert("adm".to_string(), serde_json::Value::String(adm));
+                    }
                 }
                 // Verbose per-bid debug blob only under the testing flag; also
                 // doubles as the client-side gate for the direct GAM-replace path.
@@ -2399,6 +2414,7 @@ pub async fn handle_page_bids(
     let bid_map = build_bid_map(
         &winning_bids,
         co_config.price_granularity,
+        settings,
         settings.debug.inject_adm_for_testing,
     );
 
@@ -3944,8 +3960,16 @@ mod tests {
         };
         use crate::http_util::RequestInfo;
         use crate::price_bucket::PriceGranularity;
+        use crate::settings::Settings;
         use std::collections::HashMap;
 
+        // Default settings are enough for the creative boundary: the sanitize
+        // pass needs no config, and `rewrite_creative_html` only signs URLs it
+        // actually rewrites (none of these fixtures carry proxyable URLs).
+        fn test_settings() -> Settings {
+            Settings::default()
+        }
+
         fn make_config() -> CreativeOpportunitiesConfig {
             CreativeOpportunitiesConfig {
                 gam_network_id: "21765378893".to_string(),
@@ -4049,7 +4073,12 @@ mod tests {
                     "https://ssp/bill",
                 ),
             );
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, false);
+            let map = build_bid_map(
+                &winning_bids,
+                PriceGranularity::Dense,
+                &test_settings(),
+                false,
+            );
             let entry = map.get("atf_sidebar_ad").expect("should have bid entry");
             let obj = entry.as_object().expect("should be object");
             assert_eq!(
@@ -4096,7 +4125,12 @@ mod tests {
             // Production path (include_debug_bid = false): the creative is always
             // included so the bridge can render it locally, but the verbose
             // debug_bid blob is not.
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, false);
+            let map = build_bid_map(
+                &winning_bids,
+                PriceGranularity::Dense,
+                &test_settings(),
+                false,
+            );
             let obj = map
                 .get("atf_sidebar_ad")
                 .expect("should have bid entry")
@@ -4115,7 +4149,97 @@ mod tests {
         }
 
         #[test]
-        fn build_bids_script_escapes_hostile_adm() {
+        fn build_bid_map_sanitizes_hostile_adm() {
+            // The inline-adm path must run the same creative-processing boundary
+            // as the `/auction` path (sanitize → rewrite) before the creative
+            // reaches window.tsjs.bids, so hostile executable markup never lands
+            // in the client-facing `adm` for the Prebid Universal Creative to run.
+            let mut winning_bids = HashMap::new();
+            let mut bid = make_bid(
+                "atf_sidebar_ad",
+                1.50,
+                "kargo",
+                "abc123",
+                "https://ssp/win",
+                "https://ssp/bill",
+            );
+            bid.creative = Some(
+                "<div onclick=\"steal()\"><script>alert(1)</script>\
+                 <a href=\"javascript:evil()\">x</a></div>"
+                    .to_string(),
+            );
+            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
+
+            let map = build_bid_map(
+                &winning_bids,
+                PriceGranularity::Dense,
+                &test_settings(),
+                false,
+            );
+            let adm = map
+                .get("atf_sidebar_ad")
+                .and_then(|v| v.as_object())
+                .and_then(|o| o.get("adm"))
+                .and_then(|v| v.as_str())
+                .expect("should include a sanitized adm");
+
+            assert!(
+                !adm.contains("<script"),
+                "should strip <script> elements from the inline adm"
+            );
+            assert!(
+                !adm.contains("alert(1)"),
+                "should strip inline script bodies from the inline adm"
+            );
+            assert!(
+                !adm.contains("onclick"),
+                "should strip on* event-handler attributes from the inline adm"
+            );
+            assert!(
+                !adm.contains("javascript:"),
+                "should strip javascript: URIs from the inline adm"
+            );
+        }
+
+        #[test]
+        fn build_bid_map_omits_oversized_adm() {
+            // Creatives larger than the sanitize pass's 1 MiB cap are rejected
+            // (empty result), so the inline `adm` is omitted and the pbRender
+            // bridge falls back to the PBS Cache coordinates instead of shipping
+            // an unbounded creative to the client.
+            let mut winning_bids = HashMap::new();
+            let mut bid = make_bid(
+                "atf_sidebar_ad",
+                1.50,
+                "kargo",
+                "abc123",
+                "https://ssp/win",
+                "https://ssp/bill",
+            );
+            bid.creative = Some(format!("<div>{}</div>", "a".repeat(1024 * 1024 + 1)));
+            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
+
+            let map = build_bid_map(
+                &winning_bids,
+                PriceGranularity::Dense,
+                &test_settings(),
+                false,
+            );
+            let obj = map
+                .get("atf_sidebar_ad")
+                .and_then(|v| v.as_object())
+                .expect("should have a bid entry");
+            assert!(
+                obj.get("adm").is_none(),
+                "should omit the inline adm when the creative exceeds the 1 MiB cap"
+            );
+        }
+
+        #[test]
+        fn build_bids_script_escapes_line_separators_in_adm() {
+            // U+2028/U+2029 are valid JSON string content but terminate inline
+            // <script> statements; they survive the sanitize boundary as ordinary
+            // text, so build_bids_script must unicode-escape them.
             let mut winning_bids = HashMap::new();
             let mut bid = make_bid(
                 "s",
@@ -4125,17 +4249,16 @@ mod tests {
                 "https://ssp/win",
                 "https://ssp/bill",
             );
-            // A hostile creative that tries to break out of the <script> and
-            // includes both line/paragraph separators the spec promises to escape.
-            bid.creative = Some("</script><script>alert(1)</script>\u{2028}\u{2029}".to_string());
+            bid.creative = Some("<div>a\u{2028}b\u{2029}c</div>".to_string());
             winning_bids.insert("s".to_string(), bid);
 
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, false);
-            let script = build_bids_script(&map);
-            assert!(
-                !script.contains("</script><script>"),
-                "should not let a hostile adm break out of the script context"
+            let map = build_bid_map(
+                &winning_bids,
+                PriceGranularity::Dense,
+                &test_settings(),
+                false,
             );
+            let script = build_bids_script(&map);
             assert!(
                 !script.contains('\u{2028}') && !script.contains('\u{2029}'),
                 "should unicode-escape both U+2028 and U+2029 in the adm"
@@ -4164,7 +4287,12 @@ mod tests {
             );
             winning_bids.insert("atf_sidebar_ad".to_string(), bid);
 
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, true);
+            let map = build_bid_map(
+                &winning_bids,
+                PriceGranularity::Dense,
+                &test_settings(),
+                true,
+            );
             let obj = map
                 .get("atf_sidebar_ad")
                 .expect("should have bid entry")
@@ -4225,7 +4353,12 @@ mod tests {
                     metadata: Default::default(),
                 },
             );
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, false);
+            let map = build_bid_map(
+                &winning_bids,
+                PriceGranularity::Dense,
+                &test_settings(),
+                false,
+            );
             let obj = map
                 .get("atf_sidebar_ad")
                 .expect("should have bid entry")
@@ -4271,7 +4404,12 @@ mod tests {
                     metadata: Default::default(),
                 },
             );
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, false);
+            let map = build_bid_map(
+                &winning_bids,
+                PriceGranularity::Dense,
+                &test_settings(),
+                false,
+            );
             let obj = map
                 .get("atf_sidebar_ad")
                 .expect("should have bid entry")
@@ -4315,7 +4453,12 @@ mod tests {
                     metadata: Default::default(),
                 },
             );
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, false);
+            let map = build_bid_map(
+                &winning_bids,
+                PriceGranularity::Dense,
+                &test_settings(),
+                false,
+            );
             let obj = map
                 .get("atf_sidebar_ad")
                 .expect("should have bid entry")
@@ -4350,7 +4493,12 @@ mod tests {
                     metadata: Default::default(),
                 },
             );
-            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, false);
+            let map = build_bid_map(
+                &winning_bids,
+                PriceGranularity::Dense,
+                &test_settings(),
+                false,
+            );
             assert!(
                 map.is_empty(),
                 "slot with no price should be excluded from bid map"
diff --git a/crates/trusted-server-core/src/settings.rs b/crates/trusted-server-core/src/settings.rs
index 03cc535c..d6ba227a 100644
--- a/crates/trusted-server-core/src/settings.rs
+++ b/crates/trusted-server-core/src/settings.rs
@@ -1908,12 +1908,17 @@ pub struct DebugConfig {
     #[serde(default)]
     pub auction_html_comment: bool,
 
-    /// Include raw `adm` creative markup in `window.tsjs.bids` for GPT/GAM
-    /// debug rendering through the Prebid Universal Creative bridge.
+    /// Enable the testing-only direct GAM-replace path and the verbose per-bid
+    /// `debug_bid` blob in `window.tsjs.bids`.
     ///
-    /// Use this to validate the server-side auction→GAM targeting→creative
-    /// rendering pipeline while PBS Cache is unavailable. Never enable in
-    /// production — injects raw HTML from SSPs.
+    /// Note: the sanitized winning `adm` is now injected **unconditionally** for
+    /// production inline rendering through the pbRender bridge (see
+    /// [`crate::publisher::build_bid_map`]); this flag no longer gates `adm`.
+    /// What it still gates is the client-side `debug_bid` signal that turns on
+    /// the direct GAM-creative replacement (`injectAdmIntoSlot`), which bypasses
+    /// GAM entirely — useful for validating the auction→creative pipeline while
+    /// PBS Cache is unavailable. The `debug_bid` blob also carries the raw,
+    /// un-sanitized creative for diagnostics, so never enable in production.
     #[serde(default)]
     pub inject_adm_for_testing: bool,
 }
diff --git a/crates/trusted-server-js/lib/src/core/types.ts b/crates/trusted-server-js/lib/src/core/types.ts
index 360e2aa4..44008b4b 100644
--- a/crates/trusted-server-js/lib/src/core/types.ts
+++ b/crates/trusted-server-js/lib/src/core/types.ts
@@ -57,9 +57,21 @@ export interface AuctionBidData {
   hb_cache_path?: string;
   nurl?: string;
   burl?: string;
-  /** Raw creative markup. Only present when `[debug] inject_adm_for_testing = true`. */
+  /**
+   * Sanitized winning creative markup for local rendering through the pbRender
+   * bridge. Present whenever the winning bid carried a creative that passed the
+   * server-side sanitize/rewrite boundary; absent when there was no creative or
+   * it was rejected (e.g. over the 1 MiB cap), in which case the bridge falls
+   * back to the PBS Cache coordinates. This is NOT gated by
+   * `inject_adm_for_testing`.
+   */
   adm?: string;
-  /** Debug-only bid field mirror. Only present when `[debug] inject_adm_for_testing = true`. */
+  /**
+   * Verbose per-bid debug blob (carries the raw, un-sanitized creative among
+   * other fields). Only present when `[debug] inject_adm_for_testing = true`;
+   * its presence is also the client-side gate for the testing-only direct
+   * GAM-replace path.
+   */
   debug_bid?: AuctionDebugBidData;
 }
 
diff --git a/crates/trusted-server-js/lib/src/integrations/gpt/index.ts b/crates/trusted-server-js/lib/src/integrations/gpt/index.ts
index c21e54ac..905b31eb 100644
--- a/crates/trusted-server-js/lib/src/integrations/gpt/index.ts
+++ b/crates/trusted-server-js/lib/src/integrations/gpt/index.ts
@@ -281,7 +281,11 @@ export function safeAdmIframeSrc(src: string): string | undefined {
  *
  * Adapted from PR #241 (github.com/IABTechLab/trusted-server/pull/241).
  * Instead of reading from pbjs, reads adm directly from window.tsjs.bids.
- * Only active when inject_adm_for_testing injects adm server-side.
+ *
+ * This is the testing-only direct-replace path that bypasses GAM entirely. The
+ * sanitized `adm` now ships in production for the pbRender bridge, so `adm`
+ * presence no longer gates it; the caller gates on the per-bid `debug_bid`
+ * signal (present only under `inject_adm_for_testing`) instead.
  *
  * Strategy:
  * 1. If adm contains an <iframe src="..."> with a safe http(s) src, set that
@@ -822,6 +826,36 @@ const TS_DISPLAY_RENDERER =
   'if(d.adUrl&&!d.ad){f.src=d.adUrl;}else{f.srcdoc=d.ad;}' +
   'w.document.body.appendChild(f);};})();';
 
+/**
+ * Extract the renderable creative markup from a PBS Cache GET response.
+ *
+ * Prebid Cache entries are JSON bid objects (`{ "adm": "<div…>", … }`); the
+ * Prebid Universal Creative's own cache path `JSON.parse`s the response and
+ * renders `bidObject.adm`, not the raw response body. This mirrors that
+ * extraction so the bridge hands PUC a creative string rather than a serialized
+ * bid document.
+ *
+ * A non-JSON body is treated as raw creative markup for backward compatibility
+ * with caches that store the creative directly. Returns `undefined` when the
+ * JSON payload carries no usable string `adm` (missing or malformed), so the
+ * caller can decline to render instead of injecting a serialized object.
+ */
+export function extractCachedAdm(body: string): string | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    // Not JSON — a cache that returned the creative markup directly.
+    return body.trim().length > 0 ? body : undefined;
+  }
+  if (parsed && typeof parsed === 'object') {
+    const adm = (parsed as { adm?: unknown }).adm;
+    return typeof adm === 'string' && adm.length > 0 ? adm : undefined;
+  }
+  // A JSON primitive (string/number/bool) is not a valid cached bid object.
+  return undefined;
+}
+
 /**
  * Install the TS → pbRender bridge.
  *
@@ -831,7 +865,9 @@ const TS_DISPLAY_RENDERER =
  *
  * When `adId` matches a TS server-side bid in `window.tsjs.bids` AND the bid
  * has renderable markup, the bridge:
- *   1. Uses debug `adm` directly when present, otherwise fetches from PBS Cache.
+ *   1. Uses the inline `adm` directly when present (the sanitized winning
+ *      creative, now shipped in production), otherwise fetches from PBS Cache
+ *      and extracts `adm` from the cached bid JSON (see `extractCachedAdm`).
  *   2. Replies via the MessageChannel port with a `"Prebid Response"`.
  *   3. Calls `stopImmediatePropagation()` so Prebid.js does not also process
  *      the message and log spurious failures.
@@ -924,7 +960,18 @@ export function installTsRenderBridge(): void {
 
     fetch(cacheUrl, { mode: 'cors' })
       .then((res) => (res.ok ? res.text() : Promise.reject(res.status)))
-      .then((ad) => {
+      .then((body) => {
+        // PBS Cache returns the cached bid as a JSON object; extract its `adm`
+        // the same way the Prebid Universal Creative does before rendering.
+        const ad = extractCachedAdm(body);
+        if (!ad) {
+          // No renderable creative in the cache payload — decline rather than
+          // ship a serialized bid document to PUC. Beacons stay unfired.
+          log.warn(
+            `[tsjs-gpt] pbRender bridge: PBS Cache response for '${slotId}' had no renderable adm`
+          );
+          return;
+        }
         port.postMessage(
           JSON.stringify({
             message: 'Prebid Response',
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
index 1df0138a..162543e7 100644
--- 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
@@ -991,9 +991,12 @@ describe('installTsRenderBridge', () => {
   it('calls stopImmediatePropagation and fetches PBS Cache for a TS bid', async () => {
     const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
     const mockAd = '<div>Test Creative</div>';
+    // PBS Cache (returnCreative=false) returns the cached bid as a JSON object;
+    // the creative lives under `adm`, not as the raw response body. The bridge
+    // must parse it and forward `adm`, mirroring the Prebid Universal Creative.
     fetchStub.mockResolvedValue({
       ok: true,
-      text: () => Promise.resolve(mockAd),
+      text: () => Promise.resolve(JSON.stringify({ adm: mockAd, width: 728, height: 90 })),
     } as Response);
 
     // Capture the bridge's 'message' listener at module-init time.
@@ -1060,6 +1063,74 @@ describe('installTsRenderBridge', () => {
     beaconSpy.mockRestore();
   });
 
+  it('declines to render when the PBS Cache response carries no adm', async () => {
+    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
+    // A returnCreative=false JSON entry with no `adm` (VAST-only, or malformed).
+    // The bridge must NOT forward the serialized bid document to PUC.
+    fetchStub.mockResolvedValue({
+      ok: true,
+      text: () => Promise.resolve(JSON.stringify({ width: 728, height: 90 })),
+    } as Response);
+
+    const bridgeListener = await captureBridgeListener();
+    const stopSpy = vi.fn();
+    const portMessages: string[] = [];
+    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
+    const source = createTrustedSlotIframe();
+
+    bridgeListener(
+      Object.assign(new Event('message'), {
+        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
+        ports: [fakePort],
+        source,
+        stopImmediatePropagation: stopSpy,
+      }) as unknown as MessageEvent
+    );
+    await new Promise<void>((resolve) => setTimeout(resolve, 50));
+
+    // TS owns the adId so Prebid is still stopped, but with nothing renderable
+    // the bridge sends no Prebid Response and fires no win/billing beacons.
+    expect(fetchStub).toHaveBeenCalled();
+    expect(stopSpy).toHaveBeenCalled();
+    expect(portMessages).toHaveLength(0);
+    expect(beaconSpy).not.toHaveBeenCalled();
+    beaconSpy.mockRestore();
+  });
+
+  it('renders a non-JSON PBS Cache body as raw creative markup', async () => {
+    const beaconSpy = vi.spyOn(navigator, 'sendBeacon').mockReturnValue(true);
+    const rawAd = '<div>Raw Cached Creative</div>';
+    // Backward compatibility: a cache that returns the creative markup directly
+    // (not a JSON bid object) is still rendered as-is.
+    fetchStub.mockResolvedValue({
+      ok: true,
+      text: () => Promise.resolve(rawAd),
+    } as Response);
+
+    const bridgeListener = await captureBridgeListener();
+    const stopSpy = vi.fn();
+    const portMessages: string[] = [];
+    const fakePort = { postMessage: (s: string) => portMessages.push(s) };
+    const source = createTrustedSlotIframe();
+
+    bridgeListener(
+      Object.assign(new Event('message'), {
+        data: JSON.stringify({ message: 'Prebid Request', adId: 'test-cache-uuid' }),
+        ports: [fakePort],
+        source,
+        stopImmediatePropagation: stopSpy,
+      }) as unknown as MessageEvent
+    );
+    await new Promise<void>((resolve) => setTimeout(resolve, 50));
+
+    expect(portMessages).toHaveLength(1);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parsed = JSON.parse(portMessages[0]) as Record<string, any>;
+    expect(parsed.ad).toBe(rawAd);
+    expect(beaconSpy).toHaveBeenCalledTimes(2);
+    beaconSpy.mockRestore();
+  });
+
   it('fetches PBS Cache once when two same-adId messages race before the fetch resolves', async () => {
     // Concurrent render double-fire guard: two 'Prebid Request' messages for the
     // same adId can arrive before the first cache fetch settles. The in-flight
diff --git a/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md b/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
index 8dee3f45..395681e8 100644
--- a/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
+++ b/docs/superpowers/specs/2026-07-13-ssat-render-inline-creative-design.md
@@ -56,10 +56,18 @@ the round trip that happens _after_ GAM has already picked the TS line item.
 
 `build_bid_map`:
 
-- **Always** insert `adm` (from `bid.creative`) for a winner when present —
-  there is no runtime reason to withhold it, so it is not parameterized.
+- **Always** insert `adm` for a winner when present — there is no runtime reason
+  to withhold it, so it is not parameterized. The creative is first run through
+  the **same sanitize/rewrite boundary as the `/auction` path** (`auction::formats`):
+  `creative::sanitize_creative_html` then `creative::rewrite_creative_html`.
+  `sanitize_creative_html` also enforces the 1 MiB `MAX_CREATIVE_SIZE` cap,
+  returning empty for oversized or unparseable markup — in which case `adm` is
+  omitted and the bridge falls back to the PBS Cache coordinates. `build_bid_map`
+  therefore takes `&Settings` (needed by `rewrite_creative_html`).
 - Insert the verbose `debug_bid` blob **only** when the testing flag is set. The
-  single `include_adm` param becomes `include_debug_bid`.
+  single `include_adm` param becomes `include_debug_bid`. (The `debug_bid` blob
+  still carries the raw, un-sanitized creative for diagnostics; only the
+  client-facing `adm` is sanitized.)
 
 `hb_cache_host`/`hb_cache_path` remain inserted unconditionally.
 
@@ -69,11 +77,20 @@ the round trip that happens _after_ GAM has already picked the TS line item.
 Cache. Once `adm` is present in production, the local render becomes the default
 and the round trip disappears.
 
+**Cache payload decode:** PBS Cache (`returnCreative=false`) returns the cached
+bid as a **JSON object**, and the Prebid Universal Creative's own cache path
+`JSON.parse`s it and renders `bidObject.adm` — not the raw response body. The
+fallback therefore parses the cache response and extracts the string `adm`
+(`extractCachedAdm`), with raw-markup compatibility for caches that return the
+creative directly, and declines to render (no `"Prebid Response"`, no beacons)
+when the payload has no usable `adm`. It does **not** forward a serialized bid
+document to the PUC.
+
 **Fallback scope (corrected):** the bridge posts the markup to the PUC and
 returns; it receives **no render-success signal**. So the PBS Cache fallback
-fires only when `adm` is **absent or empty** — _not_ when `adm` is present but
-fails to render. Render failures after `adm` is supplied are not currently
-detectable and do not trigger fallback.
+fires only when the inline `adm` is **absent or empty** — _not_ when `adm` is
+present but fails to render. Render failures after `adm` is supplied are not
+currently detectable and do not trigger fallback.
 
 ### 3. Gate the GAM-bypass on `bid.debug_bid` (no new global flag)
 
@@ -94,10 +111,19 @@ change, and keeps production `adm` on the bridge-only (keep-GAM) path.
 
 ### 4. Security
 
-No new escaping code. The `adm` string is part of the bid-map JSON that already
-passes through `html_escape_for_script` + `JSON.parse("…")`, which neutralizes
-`</script>` breakout and `U+2028/2029`. **This is the guarantee trusted-server
-directly provides**, pinned by a hostile-`adm` regression test.
+Two layers, both provided directly by trusted-server:
+
+1. **Creative-processing boundary (server-side).** The inline `adm` runs through
+   the same `sanitize_creative_html` → `rewrite_creative_html` pass as the
+   `/auction` path before it enters the bid map. Sanitization strips executable
+   markup (`<script>`, `on*` handlers, `javascript:`/dangerous `data:` URIs) and
+   enforces the 1 MiB `MAX_CREATIVE_SIZE` cap; rewriting proxies creative URLs to
+   first-party endpoints. Pinned by a hostile-`adm` (script/handler/`javascript:`
+   stripped) and an oversized-`adm` (omitted) regression test.
+2. **Script-context escaping.** The (now sanitized) `adm` is part of the bid-map
+   JSON that passes through `html_escape_for_script` + `JSON.parse("…")`, which
+   neutralizes any residual `</script>` breakout and `U+2028/2029`. Pinned by a
+   line-separator escaping test.
 
 Frame isolation of the rendered creative is **not** guaranteed by TS on the
 bridge path: `injectAdmIntoSlot` sets `sandbox=ADM_IFRAME_SANDBOX`, but the
@@ -107,24 +133,25 @@ Universal Creative implementation, not on TS.
 
 ## Components changed
 
-| Unit                                         | Change                                                                                                                           |
-| -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
-| `build_bid_map` (Rust)                       | Always insert `adm` when `bid.creative` is `Some`. Rename `include_adm` → `include_debug_bid`, gating only the `debug_bid` blob. |
-| `build_bid_map` callers                      | Pass `include_debug_bid = inject_adm_for_testing`.                                                                               |
-| `gpt/index.ts` `injectAdmIntoSlot` call site | Gate on `bid.adm && bid.debug_bid`.                                                                                              |
-| bridge/`ad_init` tests (JS)                  | Rename "debug adm" → "inline/local adm"; confirm existing coverage.                                                              |
+| Unit                                            | Change                                                                                                                                                                                   |
+| ----------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `build_bid_map` (Rust)                          | Sanitize+rewrite `bid.creative` (1 MiB cap) before inserting `adm`; omit when rejected. Takes `&Settings`. Rename `include_adm` → `include_debug_bid`, gating only the `debug_bid` blob. |
+| `build_bid_map` / `write_bids_to_state` callers | Thread `&Settings`; pass `include_debug_bid = inject_adm_for_testing`.                                                                                                                   |
+| `gpt/index.ts` `installTsRenderBridge`          | Decode PBS Cache JSON, extract `adm` (`extractCachedAdm`); decline when absent.                                                                                                          |
+| `gpt/index.ts` `injectAdmIntoSlot` call site    | Gate on `bid.adm && bid.debug_bid`.                                                                                                                                                      |
+| bridge/`ad_init` tests (JS)                     | Rename "debug adm" → "inline/local adm"; realistic `returnCreative=false` cache payload + malformed/raw-markup coverage.                                                                 |
 
 No `build_bids_script` change, no `window.tsjs` flag, no `TsjsApi` change.
 
 ## Data flow (after)
 
 ```
-SSAT auction → winner (bid.creative held) → build_bid_map inserts adm
+SSAT auction → winner (bid.creative held) → build_bid_map sanitizes+rewrites → inserts adm
   → build_bids_script (html_escape_for_script) → window.tsjs.bids
   → hb_pb targeting → GAM competes
       ├ GAM picks TS line item → PUC "Prebid Request"
-      │     → bridge replies with local adm  → RENDER (no round trip) + beacons
-      │     → (adm absent) → PBS Cache fetch  → RENDER (fallback)
+      │     → bridge replies with inline adm  → RENDER (no round trip) + beacons
+      │     → (adm absent) → PBS Cache fetch → decode JSON → extract adm → RENDER (fallback)
       └ GAM has higher demand → GAM serves its own creative
 ```
 
@@ -137,13 +164,17 @@ line items in GAM sees no behavioral change.
 
 ## Testing
 
-- **Rust**: `build_bid_map` includes `adm` for winners on every path; `debug_bid`
-  present only under the testing flag; a hostile `</script>` / `U+2028/2029`
-  `adm` is escaped so `build_bids_script` output stays inside the `<script>`.
+- **Rust**: `build_bid_map` includes a sanitized `adm` for winners on every path;
+  a hostile `adm` has its `<script>`/`on*`/`javascript:` stripped; an oversized
+  (> 1 MiB) `adm` is omitted (bridge falls back to cache); `debug_bid` present
+  only under the testing flag; `U+2028/2029` in `adm` is escaped so
+  `build_bids_script` output stays inside the `<script>`.
 - **JS (vitest)**: `injectAdmIntoSlot` fires only when `bid.debug_bid` is present;
-  existing `ad_init.test.ts` bridge coverage (local-adm-without-cache-fetch,
-  cache-fetch-when-adm-absent, `nurl`/`burl` beacons, dedup) is retained with
-  terminology updated to "inline/local adm" — no duplicate tests.
+  the PBS Cache fallback decodes a realistic `returnCreative=false` JSON payload
+  and forwards its `adm`, renders a non-JSON body as raw markup, and declines a
+  payload with no `adm`; existing bridge coverage (local-adm-without-cache-fetch,
+  `nurl`/`burl` beacons, dedup) is retained with terminology updated to
+  "inline/local adm".
 
 ## Risks / accepted costs
 
@@ -158,7 +189,8 @@ line items in GAM sees no behavioral change.
 
 ## Out of scope
 
-- Size-capping / conditional inline vs cache.
+- A tunable inline-size threshold below the 1 MiB sanitize cap (the cap already
+  omits oversized creatives and defers them to the cache path).
 - Detecting render failure to trigger cache fallback.
 - Bypassing GAM for SSAT winners.
 - Changing the client-side `/auction` render path.

From d0b18b4021d9c4e75bd737a17658ca6fc14100f6 Mon Sep 17 00:00:00 2001
From: prk-Jr <prakashsagwara@gmail.com>
Date: Fri, 17 Jul 2026 13:57:17 +0530
Subject: [PATCH 10/10] Emit absolute first-party URLs for inline SSAT
 creatives

The inline `adm` in window.tsjs.bids is rendered by the Prebid Universal
Creative inside GAM's iframe (f.srcdoc = d.ad), a foreign origin.
rewrite_creative_html emitted root-relative /first-party/... URLs that
resolve against GAM's origin there and 404, and injected the tsjs bundle
into every creative iframe.

Add rewrite_inline_creative_html: emits absolute
https://<publisher.domain>/first-party/... URLs (resolve regardless of the
document base URL or whether PUC honors the custom renderer) and skips the
tsjs bundle injection. Route build_bid_map's inline adm through it; the
first-party /auction path keeps the root-relative rewriter. One shared
rewriter via base_origin/inject_tsjs. Add tests for the absolute-URL shape
and absent tsjs injection at the creative and build_bid_map boundaries.
---
 crates/trusted-server-core/src/creative.rs  | 190 ++++++++++++++++----
 crates/trusted-server-core/src/proxy.rs     |   8 +-
 crates/trusted-server-core/src/publisher.rs |  71 +++++++-
 3 files changed, 223 insertions(+), 46 deletions(-)

diff --git a/crates/trusted-server-core/src/creative.rs b/crates/trusted-server-core/src/creative.rs
index 63a6d93c..e523fd33 100644
--- a/crates/trusted-server-core/src/creative.rs
+++ b/crates/trusted-server-core/src/creative.rs
@@ -83,7 +83,9 @@ pub(super) fn to_abs(settings: &Settings, u: &str) -> Option<String> {
 }
 
 // Helper: rewrite url(...) occurrences inside a CSS style string to first-party proxy.
-pub(super) fn rewrite_style_urls(settings: &Settings, style: &str) -> String {
+// `base_origin` is prefixed onto the proxy path — empty for root-relative output,
+// `https://<domain>` for absolute output (see [`build_proxy_url`]).
+pub(super) fn rewrite_style_urls(settings: &Settings, style: &str, base_origin: &str) -> String {
     // naive url(...) rewrite for absolute/protocol-relative URLs
     let lower = style.to_ascii_lowercase();
     let mut out = String::with_capacity(style.len() + 16);
@@ -120,7 +122,7 @@ pub(super) fn rewrite_style_urls(settings: &Settings, style: &str) -> String {
         };
         let url_val = &style[qs..qe];
         let new_val = if let Some(abs) = to_abs(settings, url_val) {
-            build_proxy_url(settings, &abs)
+            build_proxy_url(settings, &abs, base_origin)
         } else {
             url_val.to_owned()
         };
@@ -186,9 +188,19 @@ fn build_signed_url_for(
     format!("{}?{}", base_path, qs.finish())
 }
 
+/// Build a signed first-party proxy URL, prefixing `base_origin` before the
+/// `/first-party/proxy` path. An empty `base_origin` yields a root-relative URL
+/// (the default, for creatives rendered from the first-party origin); a
+/// `https://<domain>` origin yields an absolute URL that resolves correctly when
+/// the creative is rendered in a foreign origin (e.g. PUC's `srcdoc` under GAM).
 #[inline]
-pub(super) fn build_proxy_url(settings: &Settings, clear_url: &str) -> String {
-    build_signed_url_for(settings, clear_url, "/first-party/proxy", &[])
+pub(super) fn build_proxy_url(settings: &Settings, clear_url: &str, base_origin: &str) -> String {
+    build_signed_url_for(
+        settings,
+        clear_url,
+        &format!("{base_origin}/first-party/proxy"),
+        &[],
+    )
 }
 
 #[inline]
@@ -200,17 +212,24 @@ pub(super) fn build_proxy_url_with_extras(
     build_signed_url_for(settings, clear_url, "/first-party/proxy", extra)
 }
 
+/// Build a signed first-party click URL, prefixing `base_origin` before the
+/// `/first-party/click` path. See [`build_proxy_url`] for the origin semantics.
 #[inline]
-pub(super) fn build_click_url(settings: &Settings, clear_url: &str) -> String {
-    build_signed_url_for(settings, clear_url, "/first-party/click", &[])
+pub(super) fn build_click_url(settings: &Settings, clear_url: &str, base_origin: &str) -> String {
+    build_signed_url_for(
+        settings,
+        clear_url,
+        &format!("{base_origin}/first-party/click"),
+        &[],
+    )
 }
 
 // Note: previously we exposed canonical without token; now we store the full signed
 // click URL in data-tsclick and derive canonicals on the client when needed.
 
 #[inline]
-pub(super) fn proxy_if_abs(settings: &Settings, val: &str) -> Option<String> {
-    to_abs(settings, val).map(|abs| build_proxy_url(settings, &abs))
+pub(super) fn proxy_if_abs(settings: &Settings, val: &str, base_origin: &str) -> Option<String> {
+    to_abs(settings, val).map(|abs| build_proxy_url(settings, &abs, base_origin))
 }
 
 /// Split a srcset/imagesrcset attribute into candidate strings.
@@ -263,7 +282,7 @@ pub(super) fn split_srcset_candidates(s: &str) -> Vec<&str> {
 /// - Proxies absolute or protocol-relative candidates via first-party endpoint
 /// - Preserves descriptors (e.g., `1x`, `1.5x`, `100w`)
 /// - Leaves relative candidates unchanged
-pub(super) fn rewrite_srcset(settings: &Settings, srcset: &str) -> String {
+pub(super) fn rewrite_srcset(settings: &Settings, srcset: &str, base_origin: &str) -> String {
     let mut out_items: Vec<String> = Vec::new();
     for item in split_srcset_candidates(srcset) {
         let it = item.trim();
@@ -274,7 +293,7 @@ pub(super) fn rewrite_srcset(settings: &Settings, srcset: &str) -> String {
         let url = parts.next().unwrap_or("");
         let descriptor = parts.collect::<Vec<_>>().join(" ");
         let rewritten = if let Some(abs) = to_abs(settings, url) {
-            build_proxy_url(settings, &abs)
+            build_proxy_url(settings, &abs, base_origin)
         } else {
             url.to_owned()
         };
@@ -288,9 +307,13 @@ pub(super) fn rewrite_srcset(settings: &Settings, srcset: &str) -> String {
 }
 
 #[inline]
-pub(super) fn proxied_attr_value(settings: &Settings, attr_val: Option<String>) -> Option<String> {
+pub(super) fn proxied_attr_value(
+    settings: &Settings,
+    attr_val: Option<String>,
+    base_origin: &str,
+) -> Option<String> {
     match attr_val {
-        Some(v) => proxy_if_abs(settings, &v),
+        Some(v) => proxy_if_abs(settings, &v, base_origin),
         None => None,
     }
 }
@@ -299,7 +322,7 @@ pub(super) fn proxied_attr_value(settings: &Settings, attr_val: Option<String>)
 /// unified first-party proxy. Relative URLs are left unchanged.
 #[must_use]
 pub fn rewrite_css_body(settings: &Settings, css: &str) -> String {
-    rewrite_style_urls(settings, css)
+    rewrite_style_urls(settings, css, "")
 }
 
 /// Maximum byte length of creative HTML accepted by [`sanitize_creative_html`].
@@ -492,14 +515,53 @@ pub fn sanitize_creative_html(markup: &str) -> String {
     String::from_utf8(out).unwrap_or_default()
 }
 
-/// Rewrite ad creative HTML to first-party endpoints.
+/// Rewrite ad creative HTML to first-party endpoints, for creatives rendered
+/// from the first-party origin (the `/auction` iframe `srcdoc`).
 /// - 1x1 `<img>` pixels → `/first-party/proxy?tsurl=&lt;base-url&gt;&lt;params&gt;&tstoken=&lt;sig&gt;`
 /// - Non-pixel absolute images → `/first-party/proxy?tsurl=&lt;base-url&gt;&lt;params&gt;&tstoken=&lt;sig&gt;`
 /// - `<iframe src>` (absolute or protocol-relative) → `/first-party/proxy?tsurl=&lt;base-url&gt;&lt;params&gt;&tstoken=&lt;sig&gt;`
 /// - Injects the `tsjs-creative` script once at the top of `<body>` to safeguard click URLs inside creatives
 ///   (served from `/static/tsjs=tsjs-creative.min.js`).
+///
+/// The proxy/click URLs are emitted **root-relative** (`/first-party/…`), which
+/// resolves only when the creative's document base URL is the first-party origin.
+/// For creatives handed to a renderer in a foreign origin (e.g. the Prebid
+/// Universal Creative's `srcdoc` under GAM), use [`rewrite_inline_creative_html`].
 #[must_use]
 pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
+    rewrite_creative_html_impl(settings, markup, "", true)
+}
+
+/// Rewrite an inline ad creative for rendering in a **foreign-origin** context —
+/// the Prebid Universal Creative's `f.srcdoc = d.ad`, which runs inside GAM's
+/// iframe. A `srcdoc` document inherits its base URL from the container's
+/// document, so a root-relative `/first-party/…` URL would resolve against GAM's
+/// origin and 404.
+///
+/// Differs from [`rewrite_creative_html`] in the two ways that context requires:
+/// - Proxy/click URLs are emitted **absolute** (`https://<publisher-domain>/first-party/…`)
+///   so they resolve against the publisher origin regardless of the document's
+///   base URL, and independently of whether the custom renderer is honored.
+/// - The `tsjs` bundle is **not** injected into `<body>`: its only job is to
+///   safeguard click URLs, which are already absolute here, and shipping the full
+///   core-plus-integrations bundle into every creative iframe is pure weight.
+#[must_use]
+pub fn rewrite_inline_creative_html(settings: &Settings, markup: &str) -> String {
+    let base_origin = format!("https://{}", settings.publisher.domain);
+    rewrite_creative_html_impl(settings, markup, &base_origin, false)
+}
+
+/// Shared creative rewriter. `base_origin` is prefixed onto first-party proxy and
+/// click paths (empty for root-relative, `https://<domain>` for absolute);
+/// `inject_tsjs` controls the `<body>` tsjs bundle injection. See the two public
+/// wrappers, [`rewrite_creative_html`] and [`rewrite_inline_creative_html`], for
+/// the two supported render contexts.
+fn rewrite_creative_html_impl(
+    settings: &Settings,
+    markup: &str,
+    base_origin: &str,
+    inject_tsjs: bool,
+) -> String {
     // No size parsing needed now; all absolute/protocol-relative URLs are proxied uniformly.
     let mut out = Vec::with_capacity(markup.len() + 64);
     let injected_ts_creative = std::cell::Cell::new(false);
@@ -510,7 +572,7 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                 element!("body", {
                     let injected = injected_ts_creative.clone();
                     move |el| {
-                        if !injected.get() {
+                        if inject_tsjs && !injected.get() {
                             let script_tag = tsjs::tsjs_unified_script_tag();
                             el.prepend(&script_tag, ContentType::Html);
                             injected.set(true);
@@ -521,12 +583,12 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                 // Image src + data-src
                 element!("img", |el| {
                     if let Some(src) = el.get_attribute("src")
-                        && let Some(p) = proxy_if_abs(settings, &src)
+                        && let Some(p) = proxy_if_abs(settings, &src, base_origin)
                     {
                         let _ = el.set_attribute("src", &p);
                     }
                     if let Some(dsrc) = el.get_attribute("data-src")
-                        && let Some(p) = proxy_if_abs(settings, &dsrc)
+                        && let Some(p) = proxy_if_abs(settings, &dsrc, base_origin)
                     {
                         let _ = el.set_attribute("data-src", &p);
                     }
@@ -534,7 +596,9 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                 }),
                 // External scripts
                 element!("script[src]", |el| {
-                    if let Some(p) = proxied_attr_value(settings, el.get_attribute("src")) {
+                    if let Some(p) =
+                        proxied_attr_value(settings, el.get_attribute("src"), base_origin)
+                    {
                         let _ = el.set_attribute("src", &p);
                     }
                     Ok(())
@@ -549,11 +613,13 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                         || rel.contains("preload")
                         || rel.contains("prefetch")
                     {
-                        if let Some(p) = proxied_attr_value(settings, el.get_attribute("href")) {
+                        if let Some(p) =
+                            proxied_attr_value(settings, el.get_attribute("href"), base_origin)
+                        {
                             let _ = el.set_attribute("href", &p);
                         }
                         if let Some(srcset) = el.get_attribute("imagesrcset") {
-                            let rewritten = rewrite_srcset(settings, &srcset);
+                            let rewritten = rewrite_srcset(settings, &srcset, base_origin);
                             if rewritten != srcset {
                                 let _ = el.set_attribute("imagesrcset", &rewritten);
                             }
@@ -563,20 +629,26 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                 }),
                 // Media sources
                 element!("video[src], audio[src], source[src]", |el| {
-                    if let Some(p) = proxied_attr_value(settings, el.get_attribute("src")) {
+                    if let Some(p) =
+                        proxied_attr_value(settings, el.get_attribute("src"), base_origin)
+                    {
                         let _ = el.set_attribute("src", &p);
                     }
                     Ok(())
                 }),
                 // Object/embed
                 element!("object[data]", |el| {
-                    if let Some(p) = proxied_attr_value(settings, el.get_attribute("data")) {
+                    if let Some(p) =
+                        proxied_attr_value(settings, el.get_attribute("data"), base_origin)
+                    {
                         let _ = el.set_attribute("data", &p);
                     }
                     Ok(())
                 }),
                 element!("embed[src]", |el| {
-                    if let Some(p) = proxied_attr_value(settings, el.get_attribute("src")) {
+                    if let Some(p) =
+                        proxied_attr_value(settings, el.get_attribute("src"), base_origin)
+                    {
                         let _ = el.set_attribute("src", &p);
                     }
                     Ok(())
@@ -590,7 +662,9 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                     } else {
                         return Ok(());
                     }
-                    if let Some(p) = proxied_attr_value(settings, el.get_attribute("src")) {
+                    if let Some(p) =
+                        proxied_attr_value(settings, el.get_attribute("src"), base_origin)
+                    {
                         let _ = el.set_attribute("src", &p);
                     }
                     Ok(())
@@ -600,7 +674,9 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                     "image[href], image[xlink\\:href], use[href], use[xlink\\:href]",
                     |el| {
                         for attr in ["href", "xlink:href"] {
-                            if let Some(p) = proxied_attr_value(settings, el.get_attribute(attr)) {
+                            if let Some(p) =
+                                proxied_attr_value(settings, el.get_attribute(attr), base_origin)
+                            {
                                 let _ = el.set_attribute(attr, &p);
                             }
                         }
@@ -612,7 +688,7 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                     if let Some(href) = el.get_attribute("href")
                         && let Some(abs) = to_abs(settings, &href)
                     {
-                        let click = build_click_url(settings, &abs);
+                        let click = build_click_url(settings, &abs, base_origin);
                         let _ = el.set_attribute("href", &click);
                         let _ = el.set_attribute("data-tsclick", &click);
                     }
@@ -621,7 +697,7 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                 // Inline style url(...)
                 element!("[style]", |el| {
                     if let Some(st) = el.get_attribute("style") {
-                        let rewritten = rewrite_style_urls(settings, &st);
+                        let rewritten = rewrite_style_urls(settings, &st, base_origin);
                         if rewritten != st {
                             let _ = el.set_attribute("style", &rewritten);
                         }
@@ -631,7 +707,7 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                 // <style> blocks
                 text!("style", |t| {
                     let s = t.as_str();
-                    let rewritten = rewrite_style_urls(settings, s);
+                    let rewritten = rewrite_style_urls(settings, s, base_origin);
                     if rewritten != s {
                         t.replace(&rewritten, ContentType::Text);
                     }
@@ -640,7 +716,7 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                 // iframes
                 element!("iframe", |el| {
                     if let Some(src) = el.get_attribute("src")
-                        && let Some(p) = proxy_if_abs(settings, src.as_str())
+                        && let Some(p) = proxy_if_abs(settings, src.as_str(), base_origin)
                     {
                         let _ = el.set_attribute("src", &p);
                     }
@@ -649,7 +725,7 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                 // srcset + imagesrcset
                 element!("[srcset]", |el| {
                     if let Some(srcset) = el.get_attribute("srcset") {
-                        let rewritten = rewrite_srcset(settings, &srcset);
+                        let rewritten = rewrite_srcset(settings, &srcset, base_origin);
                         if rewritten != srcset {
                             let _ = el.set_attribute("srcset", &rewritten);
                         }
@@ -658,7 +734,7 @@ pub fn rewrite_creative_html(settings: &Settings, markup: &str) -> String {
                 }),
                 element!("[imagesrcset]", |el| {
                     if let Some(srcset) = el.get_attribute("imagesrcset") {
-                        let rewritten = rewrite_srcset(settings, &srcset);
+                        let rewritten = rewrite_srcset(settings, &srcset, base_origin);
                         if rewritten != srcset {
                             let _ = el.set_attribute("imagesrcset", &rewritten);
                         }
@@ -769,7 +845,8 @@ impl StreamProcessor for CreativeCssProcessor<'_> {
 #[cfg(test)]
 mod tests {
     use super::{
-        rewrite_creative_html, rewrite_srcset, rewrite_style_urls, sanitize_creative_html, to_abs,
+        rewrite_creative_html, rewrite_inline_creative_html, rewrite_srcset, rewrite_style_urls,
+        sanitize_creative_html, to_abs,
     };
 
     fn rewrite_srcset_attr(attr_name: &str, attr_value: &str) -> String {
@@ -854,6 +931,49 @@ mod tests {
         assert_eq!(out.matches("/static/tsjs=tsjs-unified.min.js").count(), 1);
     }
 
+    #[test]
+    fn inline_rewrite_emits_absolute_urls_and_omits_tsjs() {
+        // The inline creative renders in a foreign origin (PUC's srcdoc under
+        // GAM), so proxy/click URLs must be absolute against the publisher origin
+        // — a root-relative `/first-party/…` would resolve against GAM and 404 —
+        // and the tsjs bundle must not be injected into that iframe.
+        let settings = crate::test_support::tests::create_test_settings();
+        let html = "<html><body>\
+             <img src=\"https://cdn.example/pixel.png\">\
+             <a href=\"https://ads.example/click\">go</a>\
+             </body></html>";
+        let out = rewrite_inline_creative_html(&settings, html);
+
+        assert!(
+            out.contains("https://test-publisher.com/first-party/proxy?tsurl="),
+            "expected an absolute first-party proxy URL: {out}"
+        );
+        assert!(
+            out.contains("https://test-publisher.com/first-party/click?tsurl="),
+            "expected an absolute first-party click URL: {out}"
+        );
+        assert!(
+            !out.contains("src=\"/first-party/proxy"),
+            "must not emit a root-relative proxy URL on the inline path: {out}"
+        );
+        assert!(
+            !out.contains("/static/tsjs="),
+            "must not inject the tsjs bundle on the inline path: {out}"
+        );
+    }
+
+    #[test]
+    fn inline_rewrite_preserves_relative_urls() {
+        // Relative URLs already resolve against whatever base the creative is
+        // given; the inline path must leave them untouched, same as the
+        // first-party path.
+        let settings = crate::test_support::tests::create_test_settings();
+        let html = "<body><img src=\"/local/pixel.png\"></body>";
+        let out = rewrite_inline_creative_html(&settings, html);
+        assert!(out.contains("<img src=\"/local/pixel.png\""), "{out}");
+        assert!(!out.contains("/first-party/proxy"), "{out}");
+    }
+
     #[test]
     fn to_abs_conversions() {
         let settings = crate::test_support::tests::create_test_settings();
@@ -920,7 +1040,7 @@ mod tests {
     fn rewrite_style_urls_handles_absolute_and_relative() {
         let settings = crate::test_support::tests::create_test_settings();
         let css = "background:url(https://cdn.example/a.png) no-repeat; mask: url('//cdn.example/m.svg') 0 0 / cover; border-image: url(/local/border.png) 30";
-        let out = rewrite_style_urls(&settings, css);
+        let out = rewrite_style_urls(&settings, css, "");
         // Absolute and protocol-relative rewritten
         assert!(
             out.matches("/first-party/proxy?tsurl=").count() >= 2,
@@ -1175,7 +1295,7 @@ mod tests {
     fn rewrite_srcset_w_and_x_descriptors() {
         let settings = crate::test_support::tests::create_test_settings();
         let srcset = "https://cdn.example/a.png 100w, //cdn.example/b.png 2x, /local/c.png 1x";
-        let out = rewrite_srcset(&settings, srcset);
+        let out = rewrite_srcset(&settings, srcset, "");
         assert!(out.contains(" 100w"));
         assert!(out.contains(" 2x"));
         assert!(out.contains("/local/c.png 1x"));
@@ -1190,7 +1310,7 @@ mod tests {
     fn rewrite_srcset_ignores_non_network_schemes() {
         let settings = crate::test_support::tests::create_test_settings();
         let srcset = "data:image/png;base64,AAAA 1x, https://cdn.example/a.png 2x";
-        let out = rewrite_srcset(&settings, srcset);
+        let out = rewrite_srcset(&settings, srcset, "");
         assert!(out.contains("data:image/png;base64,AAAA 1x"), "{}", out);
         assert!(out.contains("/first-party/proxy?tsurl="), "{}", out);
     }
diff --git a/crates/trusted-server-core/src/proxy.rs b/crates/trusted-server-core/src/proxy.rs
index 9e03f4db..f9747cbd 100644
--- a/crates/trusted-server-core/src/proxy.rs
+++ b/crates/trusted-server-core/src/proxy.rs
@@ -2730,7 +2730,7 @@ mod tests {
         let settings = create_test_settings();
         let clear = "https://cdn.example/asset.js?c=3&b=2&a=1";
         // Simulate creative-generated first-party URL
-        let first_party = creative::build_proxy_url(&settings, clear);
+        let first_party = creative::build_proxy_url(&settings, clear, "");
         // Reconstruct and validate (need absolute URL for parsing)
         let st = reconstruct_and_validate_signed_target(
             &settings,
@@ -2746,7 +2746,7 @@ mod tests {
     fn reconstruct_valid_without_params() {
         let settings = create_test_settings();
         let clear = "https://cdn.example/asset.js";
-        let first_party = creative::build_proxy_url(&settings, clear);
+        let first_party = creative::build_proxy_url(&settings, clear, "");
         let st = reconstruct_and_validate_signed_target(
             &settings,
             &format!("https://edge.example{}", first_party),
@@ -2763,7 +2763,7 @@ mod tests {
             let settings = create_test_settings();
             let clear = "ftp://cdn.example/file.gif";
             // Build a first-party proxy URL with a token for the unsupported scheme
-            let first_party = creative::build_proxy_url(&settings, clear);
+            let first_party = creative::build_proxy_url(&settings, clear, "");
             let req =
                 build_http_request(Method::GET, format!("https://edge.example{}", first_party));
             let err: Report<TrustedServerError> =
@@ -2802,7 +2802,7 @@ mod tests {
         futures::executor::block_on(async {
             let settings = create_test_settings();
             let clear = "https://cdn.example/landing.html?x=1";
-            let first_party = creative::build_click_url(&settings, clear);
+            let first_party = creative::build_click_url(&settings, clear, "");
             let req =
                 build_http_request(Method::GET, format!("https://edge.example{}", first_party));
             let resp = handle_first_party_click(&settings, &noop_services(), req)
diff --git a/crates/trusted-server-core/src/publisher.rs b/crates/trusted-server-core/src/publisher.rs
index 894609e1..a7a561ff 100644
--- a/crates/trusted-server-core/src/publisher.rs
+++ b/crates/trusted-server-core/src/publisher.rs
@@ -1992,15 +1992,21 @@ pub(crate) fn build_bid_map(
                 // — no PBS Cache round trip. The `hb_cache_*` coordinates above
                 // remain as the fallback for an absent `adm`.
                 //
-                // Run the same creative-processing boundary as the `/auction`
-                // path (see `auction::formats`): sanitize dangerous markup first,
-                // then rewrite URLs to first-party proxies. `sanitize_creative_html`
-                // also enforces the 1 MiB creative cap, returning an empty string
-                // for oversized or unparseable markup — in which case the entry is
-                // omitted and the bridge falls back to the PBS Cache coordinates.
+                // Sanitize dangerous markup first, then rewrite URLs to
+                // first-party proxies — the same creative-processing boundary as
+                // the `/auction` path (see `auction::formats`), except the inline
+                // variant. Unlike `/auction`, this `adm` is rendered by the Prebid
+                // Universal Creative inside GAM's iframe (`f.srcdoc = d.ad`), a
+                // foreign origin where root-relative `/first-party/…` URLs resolve
+                // against GAM and 404. `rewrite_inline_creative_html` emits
+                // absolute first-party URLs and omits the tsjs bundle injection.
+                // `sanitize_creative_html` also enforces the 1 MiB creative cap,
+                // returning an empty string for oversized or unparseable markup —
+                // in which case the entry is omitted and the bridge falls back to
+                // the PBS Cache coordinates.
                 if let Some(ref raw_creative) = bid.creative {
                     let sanitized = crate::creative::sanitize_creative_html(raw_creative);
-                    let adm = crate::creative::rewrite_creative_html(settings, &sanitized);
+                    let adm = crate::creative::rewrite_inline_creative_html(settings, &sanitized);
                     if !adm.is_empty() {
                         obj.insert("adm".to_string(), serde_json::Value::String(adm));
                     }
@@ -4235,6 +4241,57 @@ mod tests {
             );
         }
 
+        #[test]
+        fn build_bid_map_rewrites_inline_adm_to_absolute_first_party_urls() {
+            // The inline `adm` is rendered by the Prebid Universal Creative inside
+            // GAM's iframe (`f.srcdoc = d.ad`), a foreign origin. Proxied URLs must
+            // therefore be emitted **absolute** against the publisher domain — a
+            // root-relative `/first-party/proxy` would resolve against GAM and 404.
+            // The tsjs bundle must NOT be injected into that foreign-origin iframe.
+            let mut settings = test_settings();
+            settings.publisher.domain = "example.com".to_string();
+
+            let mut winning_bids = HashMap::new();
+            let mut bid = make_bid(
+                "atf_sidebar_ad",
+                1.50,
+                "examplessp",
+                "abc123",
+                "https://ssp.example.com/win",
+                "https://ssp.example.com/bill",
+            );
+            bid.creative = Some(
+                "<html><body><img src=\"https://cdn.example.com/pixel.png\"></body></html>"
+                    .to_string(),
+            );
+            winning_bids.insert("atf_sidebar_ad".to_string(), bid);
+
+            let map = build_bid_map(&winning_bids, PriceGranularity::Dense, &settings, false);
+            let adm = map
+                .get("atf_sidebar_ad")
+                .and_then(|v| v.as_object())
+                .and_then(|o| o.get("adm"))
+                .and_then(|v| v.as_str())
+                .expect("should include a rewritten adm");
+
+            assert!(
+                adm.contains("https://example.com/first-party/proxy?tsurl="),
+                "should emit an absolute first-party proxy URL for the foreign-origin render context, got: {adm}"
+            );
+            assert!(
+                !adm.contains("src=\"/first-party/proxy"),
+                "should not emit a root-relative proxy URL that 404s under GAM's origin, got: {adm}"
+            );
+            assert!(
+                !adm.contains("https://cdn.example.com/pixel.png"),
+                "should proxy the original absolute CDN URL, got: {adm}"
+            );
+            assert!(
+                !adm.contains("/static/tsjs="),
+                "should not inject the tsjs bundle into a foreign-origin creative iframe, got: {adm}"
+            );
+        }
+
         #[test]
         fn build_bids_script_escapes_line_separators_in_adm() {
             // U+2028/U+2029 are valid JSON string content but terminate inline