diff --git a/.changeset/frames-assets-tier.md b/.changeset/frames-assets-tier.md
new file mode 100644
index 000000000..d6996c476
--- /dev/null
+++ b/.changeset/frames-assets-tier.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+frames: the assets tier (frames savings pass C5) — the head mirror a segment's `assets` record drives (the stylesheet gate, module and typed preloads, inline styles) leaves the eager frames client for the lazy chunk `@solidjs/web/frames/assets`, loaded through the tier mechanism. A segment whose assets record carries stylesheets or inline styles is not ready while the tier is not resident: the server's fallback stays on screen and the reveal happens at max(tier load, stylesheet load) — no segment reveals unstyled. Once the tier is resident only stylesheets gate; inline styles, modules and preloads apply at the record's arrival, and a segment with none of these never waits on the tier. New export path `@solidjs/web/frames/assets` (`@experimental`); `InstallOptions.tiers` loaders resolve `TierModule` (a module with or without `install()`).
diff --git a/.changeset/frames-bind-tier.md b/.changeset/frames-bind-tier.md
new file mode 100644
index 000000000..8e9ffcba3
--- /dev/null
+++ b/.changeset/frames-bind-tier.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+frames: the binding-slot tier (`@solidjs/web/frames/bind`, `@experimental`) — the `_s:*` marker parsers, consumer discovery, the morph's owned-position arms, the per-frame consumer sets and the fill's binding leave the eager frames client as a lazy chunk; `assign` leaves with them. A marker met while the tier is absent holds the frame under frames-rulings 3.1 (hydration-done waits; the install's flush binds). The delegated-event replay window is closed by a bare ` _hk` the server stamps on each document-face element with an `_s:on:*` position (4 bytes each, nothing else stamped): the tier marks the element completed at the bind and drains the queue, so a click before or during the hold reaches the bound handler. Data occurrences now mount with the current record.
diff --git a/.changeset/frames-drop-dead-slot-nodes-writes.md b/.changeset/frames-drop-dead-slot-nodes-writes.md
new file mode 100644
index 000000000..40533e896
--- /dev/null
+++ b/.changeset/frames-drop-dead-slot-nodes-writes.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+frames: drop the three dead `#slotNodes` writes for data occurrences — the only reader (the zombie check) skips data occurrences, so the consumer-element arrays were built and never read
diff --git a/.changeset/frames-live-wire-tier.md b/.changeset/frames-live-wire-tier.md
new file mode 100644
index 000000000..bd2742bba
--- /dev/null
+++ b/.changeset/frames-live-wire-tier.md
@@ -0,0 +1,11 @@
+---
+"@solidjs/web": patch
+---
+
+frames: the live wire moves into a lazy tier (`@solidjs/web/frames/wire`, the sixth chunk). The connection a `live()` loop's response runs under — the open-frame count its end is judged by (a death with frames open vs a completion), the join of a second loop onto an address already live, the supersession cancel, `connection.ended` / `cancel` — the have-list ledger per mount with its encoder, and the resume shape (`Last-Event-ID` + `X-Frame-Have`) load with the chunk. The eager client keeps the arm that awaits the tier's residency before a live response's body is read, so a live connection without the chunk cannot happen; the chunk's import starts at the `live()` call, before its first fetch (preload-at-call, through the new optional `responseHandler.onLive()` hook the sf client fires), and a non-live call never loads it. One accepted degraded case: content applied before the chunk was resident kept no ledger, so that first connect sends no have-list (and no ordinal) and receives a full snapshot.
+
+Public surface: `Frame.have?()` is removed from the `Frame` interface (the ledger is the tier's `haveOf(frame)`, `@internal`); `encodeHaveList` moves from `frame-transport` into the tier (`@internal`; `decodeHaveList` and the `FRAME_HAVE_*` constants stay); the `@solidjs/web/frames/wire` export path is added; `ServerFunctionsClientConfig.responseHandler` gains the optional `onLive()`; `ServerComponentHandler` gains `onLive()`.
+
+Pins: `consistency/tier-wire-preload.spec` and `server-functions-live-loop.spec` — the latter drives `live()`'s reconnect loop from the consumer's side (first-connect failure, the fail-fast 4xx set and 408 / 425 / 429 / `Retry-After`, the cursor as `Last-Event-ID`, the `online` wake, `return()` and a caller's signal at every phase, `live(GET(fn))`, the handler's local answers), closing the loop's branch-coverage gap.
+
+Size: frames eager −965 min / −305 br (10.89 KB); pages −349 / −335 br eager; the `wire.js` chunk 1,922 / 934 (lazy; the live page loads it at its first `live()` call). Caps ratcheted to measured + 10 B.
diff --git a/.changeset/frames-regions-tier.md b/.changeset/frames-regions-tier.md
new file mode 100644
index 000000000..c876f38a2
--- /dev/null
+++ b/.changeset/frames-regions-tier.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+frames: C4 — the regions tier. Nested server-content regions (`{$frame}` slot args resolved to `<solid-frame>` region elements with frames bound over them) leave the eager frames client for the lazy chunk `@solidjs/web/frames/regions` (a new `@experimental` export path), loaded through the tier mechanism: the server announces `regions` where it mints one; a record naming a region met before the tier is resident waits — a fresh mount in the held set (the frame's hold registered under frames-rulings 3.1 on the adopt path, the server interior on screen), a mounted occurrence's new record pending in the store until the install's flush. `InstallOptions.tiers` now types a tier's module as the new exported `TierModule` (its exports are the tier's appliers; `install()` stays optional). Frames eager −1,078 B minified / −237 B brotli; the page scenarios −1,083 B minified; the non-SC scenarios unchanged.
diff --git a/.changeset/frames-residue-1-d-list.md b/.changeset/frames-residue-1-d-list.md
new file mode 100644
index 000000000..1f2dfabe9
--- /dev/null
+++ b/.changeset/frames-residue-1-d-list.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+Frames client, residue pass 1 — the D list (dead / incidental code off the eager client; frames residue pass §2 rows 2b, 2c, 2e, 2f, 2g). `documentAddress` is gone: an adopted mount's address comes with its binding (every serialized reference resolves to the call's binding), and a mount with none — the per-function placeholder rendered directly — binds the function id. `slotsFor` keeps one dispose map: a live range binding's `insert` lives under the fill's own owner where there is one, else under an owner registered the same way, so a re-call disposes whichever path the previous invocation took. The zombie heuristic and the `#slotNodes` map it read are gone — the morph relocates ranges among siblings and recreates nothing (DR-5), so "mounted" is the frame's set. `#revealSegment` has one path: a frame created without `FrameOptions.reveal` reveals through a default seam that inserts the content at once (no boundary) — the content is applied as it is revealed, as on the boundary path — and a placeholder missing its closing comment is not revealed (dev error; `#showFallback` already treated it so). `handler.showing` no longer brands the bare per-function component: the reference a reader holds at t=0 is the bootstrap's binding, branded there. The capture arm (`contentHTML` + the last-unmount capture) stays: `lifecycle-matrix/remount` pins it.
diff --git a/.changeset/frames-residue-1-have-constants.md b/.changeset/frames-residue-1-have-constants.md
new file mode 100644
index 000000000..e2cab1500
--- /dev/null
+++ b/.changeset/frames-residue-1-have-constants.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+`FRAME_HAVE_HEADER` and `FRAME_HAVE_BUDGET` leave the `@solidjs/web/frames` client entry's export list (frames residue pass §2 row 5a). They stay exported from `@solidjs/web/frames/server`, where the header is read; the client sends the have-list itself through the handler's `resume` and nothing consumed the names off the client entry. Removed public surface, `@experimental`.
diff --git a/.changeset/frames-residue-1-lean-reask.md b/.changeset/frames-residue-1-lean-reask.md
new file mode 100644
index 000000000..2a9f35a29
--- /dev/null
+++ b/.changeset/frames-residue-1-lean-reask.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+The lean re-ask (frames residue pass §3.3). The server-function client hands its response handler the call it dispatched as a thunk — `ctx.retry` on `responseHandler.handle`, `info.retry` on `responseHandler.intercept` — the same reference, arguments, declared shape and per-call options, so a `GET`-declared read stays a GET by construction. The frames client's re-ask for an errored boundary's `reset` (frames-rulings 3.3) is that thunk: `callFor(address).retry()`. Gone with it: the frames client's `reask` installer and its reads of the RPC slot and the metadata brand, and `createServerReference(id)` on the client half of the server-function RPC slot (`getServerFunctionRPC()`, `@internal`), which nothing reads any more. `callFor` (`@internal`) now returns the recorded call with its `retry`. The `responseHandler` type in `ServerFunctionsClientConfig` documents the existing `intercept` seam alongside `handle`, both carrying `retry`.
diff --git a/.changeset/frames-residue-3-every-fill-through-insert.md b/.changeset/frames-residue-3-every-fill-through-insert.md
new file mode 100644
index 000000000..f9eb960b4
--- /dev/null
+++ b/.changeset/frames-residue-3-every-fill-through-insert.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+Frames client: every slot fill is placed by `insert` — the fill's output has the core's lifecycle (created under the fill's owner, claimed in place under hydration through `insertExpression`'s claim pass, disposed with the owner) instead of a frame-side copy of it. The Solid binding's static path (`normalizeSlotContent`, `isReactiveContent`, the in-place `settle` test) and the frame runtime's own range writer (`#replaceRange`) are gone; a static fill is one `insert` of a non-function value (no effect created), a reactive one binds the range as before. `createFrame` / `createFrameElement`: the frame element IS the range — the never-used comment-marker range mode of the runtime is removed. **`Slot` (`FrameOptions.slots`, `@experimental`) changes shape:** a callback owns its range — it places or binds its output before `ctx.range.end` over `ctx.existing` — and its return value is no longer read (before: returned nodes were placed by the frame; `undefined` claimed). A slot range missing its end marker (`FRAME_MARKER_CORRUPTED`) is left as the server rendered it instead of being filled at the parent's end.
diff --git a/.changeset/frames-residue-4-sref-table.md b/.changeset/frames-residue-4-sref-table.md
new file mode 100644
index 000000000..e738500f9
--- /dev/null
+++ b/.changeset/frames-residue-4-sref-table.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+frames: residue 4 — a pending `{$ref}` read is owned by the decode table. A slot record's `{$ref}` to a key its response has not delivered yet is answered by that response's `createJSONDataTable` with a promise the table owns (marked `s = 0`, carrying `c`, the callbacks run when it settles), settled by the key's `data` chunk through the table's own `apply` and rejected by `close(error)` when the response ends (L1 — a value that never comes is an error where it is read, not a silence); a version bump drops the superseded table and its reads. The frames host keeps only the `record.pending` count (a fresh mount waits for its record, the covering `<Loading>` pends on the landing alone) and one fan-out helper; `pendingRef` / `settleWait` / the per-store waits are gone. `FrameHostOptions.closeData(frameId, version, error?)` (new, `@experimental`) tells the integration a response ended; the shared host closes that response's table. The transport awaits `prepareData` before a `slot` chunk whose args carry a `{$ref}`, as it does before a `data` chunk, so `resolve` always has a table. Frames eager client −505 min / −174 br (34,272 / 11,367 → 33,767 / 11,193); the lazy decode chunk +420 / +161.
diff --git a/.changeset/frames-tier-mechanism.md b/.changeset/frames-tier-mechanism.md
new file mode 100644
index 000000000..c69d38390
--- /dev/null
+++ b/.changeset/frames-tier-mechanism.md
@@ -0,0 +1,11 @@
+---
+"@solidjs/web": patch
+---
+
+Frames: the server-announced tier mechanism (frames savings pass §2, Phase B — the seam alone; no tier is cut yet, every capability stays eager).
+
+The server learns at render time which frames-client capabilities a response or a document needs — it mints each feature — and announces their names so the client can start the tier's import in parallel with the content instead of at first use: on a frame stream, the `X-Frame-Tiers` response header (the tiers the sync render pass minted) and, for a tier first needed after the head left, an in-band `tiers` member on the next chunk out (`FrameChunk.tiers`, additive); on a document, the `_$HY.r["sc:tiers"]` hydration record (cumulative, re-written at each new mint) plus a `<link rel="modulepreload">` per tier whose chunk URL the integration gave (`frameTransformDirectResult(value, { id, args, tierUrls })` — the server does not know the client's chunks; absent, the record alone carries the name). The sink's `needs(tier)` runs at the mint sites: a binding-slot position read (`bind`), a nested server-content region (`regions`), an assets chunk (`assets`), a traced container in a slot arg (`trace`), a `live` response (`wire`). A sync `renderToString` document announces nothing (no shared render slot); the client detects.
+
+The client (`@solidjs/web/frames`): `installServerComponents(host?, { tiers })` takes the tier → loader map (`() => import(...)`, the module exporting `install()`), reads the document's record and starts each named load; `applyFrameResponse` reads the header before the body and `chunk.tiers` at each chunk, and a `data` chunk awaits the tiers it names before it decodes (its node tree needs them). A fresh mount whose tier is not resident — a data occurrence's `bind`, a region-carrying record's `regions` — waits like a recordless called occurrence: on the adopt path that wait is one more reason in the frame's registered hold (frames-rulings 3.1 — the event-replay window stays open, hydration-done waits), on the stream path the record stays pending in the store; the readiness check itself starts the load when nothing announced it (detection is the fallback), and the install flushes every live frame so the held occurrence mounts with the record it was held on. A name with no loader is resident (eager), which is every name today.
+
+Measured before written (edited dist copies, `scripts/size`): frames eager client +473 B min / +145 B br (≤ +150 budget; the plan's ≈ +100 estimate, ×2.5 pre-estimate ≈ +250); pages +478 min; every non-server-component scenario 0 B. Frames server dist +793 B min; `@solidjs/web`'s own server entry 0 B.
diff --git a/.changeset/frames-trace-update-site-wait.md b/.changeset/frames-trace-update-site-wait.md
new file mode 100644
index 000000000..144db25cb
--- /dev/null
+++ b/.changeset/frames-trace-update-site-wait.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+frames: the trace tier's update-site wait. A MOUNTED occurrence's new slot record whose args carry a `{ $tr }` container-trace marker while the trace tier is absent (a live slot op minting the page's first trace after the shell, a refetch adding a projection arg) now stays pending in the store: the live binding keeps the args it shows, the tier load starts, and the install's flush applies the record as an args change with the marker materialized. Before, `#syncSlots` guarded only the fresh mount (`needsTrace`) and the regions tier at the update site (`needsRegions`), so such a record was pushed into the live binding raw — the marker read as the value. Mirrors the regions tier's update-site wait.
diff --git a/.changeset/frames-traces-tier.md b/.changeset/frames-traces-tier.md
new file mode 100644
index 000000000..2e7ac1597
--- /dev/null
+++ b/.changeset/frames-traces-tier.md
@@ -0,0 +1,6 @@
+---
+"solid-js": patch
+"@solidjs/web": patch
+---
+
+frames: the container-trace materializer is the frames client's traces tier — `@solidjs/web/frames/trace`, loaded through the server-announced tier mechanism (`prepareTier("trace")`), so the store engine leaves every server-component page that never meets a trace (page base −6.6 KB brotli, page live −6.7 KB; frames eager −83 B). `solid-js/internal/container-trace` is a new `solid-js` entry carrying `materializeContainerTrace(marker, claiming?)` (the store engine reached through `@solidjs/signals`, the hydration dispatch `withStoreHydration` and the patch protocol read back from `solid-js`); the materializer leaves `solid-js`'s main and `solid-js/internal` entries. The eager frames client keeps the trigger: the loader entry, the held-set predicate (an adopt-time record whose args carry a `{ $tr }` marker while the tier is absent is held under frames-rulings 3.1 — its server interior on screen, hydration-done waits — and mounts with the record it was held on, a replacement applying as an args change), and the `claiming` hint (`FrameHostOptions.revive(value, claiming?)`), which keys the materializer's parked backlog on the claim again: a fresh mount reads the fold of its whole backlog at once.
diff --git a/.changeset/web-dynamic-component.md b/.changeset/web-dynamic-component.md
new file mode 100644
index 000000000..70d51cd44
--- /dev/null
+++ b/.changeset/web-dynamic-component.md
@@ -0,0 +1,5 @@
+---
+"@solidjs/web": patch
+---
+
+Add `dynamicComponent`, the component-only sibling of `dynamic` (client and server entries). Same contract, semantics and hydration shape as `dynamic` — the two share one implementation — but its source type excludes tag names, and it never references the element runtime: `dynamic` must be able to render a tag, so one `dynamic` on a page retains `createElement`, `spread`, the prop-collection helpers and the SVG/MathML tables for everyone; `dynamicComponent` never does. It is the documented way to mount a server component (`dynamicComponent(() => getStory(id))`); a server-component page mounted through it sheds ≈ 2.2 KB brotli. `dynamic` is unchanged.
diff --git a/documentation/plans/frames-residue-pass.md b/documentation/plans/frames-residue-pass.md
new file mode 100644
index 000000000..5e77aa57a
--- /dev/null
+++ b/documentation/plans/frames-residue-pass.md
@@ -0,0 +1,1437 @@
+# Frames client — the residue pass: from 11.8 to ≤ 10.0 KB brotli (2026-10-06)
+
+Branch `audit/frames-residue` off `wip/frames-tiers-integration` @ `5c5991cbd`
+(PR #3860 = Phase A + B + C3 + C4 + C5; `next` @ `9d89df731`). **A
+measurement-and-design pass, no code changes**: this document and nothing
+else. Companions: `frames-a0-reattribution.md` (the rubric and the morning's
+per-unit tables), `frames-savings-pass.md` (§3's landed paragraphs with their
+measured glue), `frames-rulings.md` ("Public surface"), the PR bodies of
+#3849 / #3860 / #3861 and the closed drafts #3840 #3842 #3844 #3847 #3848
+#3854 #3856 #3857 #3858.
+
+**The question.** The target is **frames eager client ≤ 10.0 KB brotli**
+(`scripts/size` scenario `frames: eager client consumer`). The head is
+**13,083 br / 40,000 min**. C6 (the bind tier, in flight) measures **−1,243**
+on this head → **11,840**. C2 (the wire tier, measured, deferred) is −292.
+What is the measured, itemised path from 11.8 down to ≤ 10.0 — or where
+does it stall?
+
+**The answer, in one paragraph.** The residue proper — the `preview` pull
+form, the D list, the static fill path (R.insert), a leaner re-ask, S-ref's
+pending read moved into the lazy table — is worth **≈ 1,450 br measured** on
+an edited dist with its carriers sketched or estimated, and takes the
+post-C6 client from **11,840 to ≈ 10.4 KB with C2** (≈ 10.7 without).
+**It does not reach 10.0 by itself.** The stall is the transport plus the
+correctness seams Phase A and B added (≈ 1.1 KB br of them, every one
+load-bearing) plus hole-op application (504 br, ruled eager under the 8.0
+reading) plus the router's claims (291 br, Phase D's). Crossing 10.0 needs
+**both** of the two feature moves the plan deferred: **C1 (holes,
+buffer-only, −516 in context / ≈ −450 net)** and **the claims chunk (−299 /
+≈ −280 net)** — together the end state is **≈ 9.67 KB with ≈ 330 B of
+margin**; C1 alone lands at the line with no margin, the claims chunk
+alone ≈ 115 B over. Unifying the tiers' dispatch saves nothing (+6 min / −20 br, measured); the fallback pass,
+the style gate, the hold's owner wrap and the dispose guard are measured
+and left.
+
+_Status: complete (2026-10-06). Every number marked measured was read from an
+edited dist copy through the harness's own bundler (§1); estimates are marked.
+**Residue step 1 landed** (`size/frames-residue-1`, on C6's head): the D list
+without the mirror and the capture arm (2b, 2c, 2e, 2f, 2g), `FRAME_HAVE_*`
+off the client entry (5a), the lean re-ask (6b) — **frames eager 11,901 →
+11,654 br (−757 min / −247 br)**; see §7 for the measured → built table and
+what the step found (2d is pinned; 10 has no export to re-use).
+**Residue step 2 stopped at the carrier budget** (`size/frames-residue-2-pull-form`,
+measured on step 1's head, nothing built): the `preview` pull form's sketch
+deleted the content token, which is the only carrier by which a same-address
+refetch enters the Transaction at all (unsound — #3844's gap (1)); with the
+token kept and the carrier built honestly on the edited dist — per-store
+staging, a lane-correct read, the flight path, nested regions, the commit's
+landing / L1 semantics the chunk replay got for free — it measures **+1,414
+min / +483 br over the −546 ceiling: net −63 br**, against the +242 budget
+and the −300 target. §3.1 "As measured" has the attribution; §7 the row.
+**Residue step 3 landed** (`size/frames-residue-3-insert`, on step 2's head):
+R.insert — every fill through `insert`, the frame runtime's own range
+writer and its never-used comment-marker range mode deleted — **frames
+eager 11,654 → 11,367 br (−978 min / −287 br)**, more than the row's −207
+because the dead range mode (−196 / −67 alone) went with it; see §7c for
+the measured → built table, the `Slot` contract change and the one pin
+re-pinned (C1 (b): the frames rule for a fill that does not claim is now
+the core's mismatch rule).
+**Residue step 4 landed** (`size/frames-residue-4-sref-table`, on step 3's
+head): S-ref's pending read moved into the lazy decode table — a `{$ref}`
+to a key the response has not delivered is the table's promise, settled
+by the key's `data` chunk and rejected when the response ends; frames
+keeps the `record.pending` count — **frames eager 11,367 → 11,193 br
+(−505 min / −174 br)**, the decode chunk (lazy) +420 / +161; the carrier
+measured +374 min / +110 br over a −879 / −280 ceiling, against the row's
++40 br estimate — see §3.2 "As built" and §7d.
+**C2 landed** (`feat/frames-wire-tier`, on step 4's head, 2026-10-07): the
+live wire tier in the `lean` form — the connection, the have-list ledger and
+its encoder, the resume shape in a sixth lazy chunk (`wire.js` 1,922 / 934),
+the eager client keeping the await-residency arm and the
+`responseHandler.onLive` preload hook — **frames eager 11,193 → 10,888 br
+(−965 min / −305 br)**, against §2's −292 (arithmetic from the C2 pass's own
+measurement); the carrier ≈ +467 / +162 over a −1,432 / −472 ceiling. The
+coverage closure the plan tied to it: `live` 26/59 → 57/60 branch sites. See
+§7e._
+
+---
+
+## 0. Sources and method
+
+- **Head.** `wip/frames-tiers-integration` @ `5c5991cbd`, built fresh in this
+  worktree (`pnpm install --frozen-lockfile`; `pnpm turbo run build --force`,
+  27/27; `packages/compiler` `pnpm build`). `scripts/size` reproduces #3860's
+  recorded numbers to the byte on all seven scenarios used here: frames eager
+  **40,000 / 13,083**; page base 119,044 / 37,772; page live 130,915 / 41,427;
+  app hydrating (no stores) 52,794 / 17,838; hydrating + stores 91,858 /
+  29,066; compiled hydrating 99,431 / 31,075; CSR 36,568 / 12,905.
+- **Attribution.** The re-attribution's source-map function-size tool
+  (`tmp-tools/fnmap.mjs`, rebuilt from §7 of that document; `acorn` +
+  `@jridgewell/trace-mapping` over the harness's own Rolldown bundle with a
+  hidden map) charges every byte of the minified entry chunk to the innermost
+  named function in the dist source: **273 units, 40,000 B, 0 B
+  unclassified, reconciles to the byte** (web/frames 35,920; the retained sf
+  slice 3,797; import statements 283). The class map is the morning's
+  (`classes.mjs`) extended by `classes-head.mjs`: the 32 units Phase A / B /
+  C3–C5 added, each tagged with the step that added it; the residue entries
+  of the 40 units those steps changed, re-apportioned against the current
+  source; one new **group** `T.glue` (class T) for the eager bytes the seams
+  left behind — loader entries, residency predicates, the held set, the
+  dispatch helpers — so the glue totals separately.
+- **Measurement.** `tmp-tools/edit.mjs <cut>[+<cut>…]` applies named cuts to
+  a COPY of `frames/dist/client.js` (and, for one cut, the sf client dist),
+  each an exact-string replacement asserted to match once (`node --check`
+  on the result); `tmp-tools/measure-cuts.mjs` bundles the seven scenarios
+  with the copy in place of the dist, through `scripts/size/bundle.mjs`
+  itself. **Every cut leaves the four non-SC scenarios at 0 / 0.** The
+  cumulative path (§4) is measured as one edited copy per row, not summed:
+  brotli is not additive. C6 is included by re-applying its Phase-1
+  `tight-nopair` edit (`c6-edit.mjs`, unchanged) to this head's dist — it
+  applies cleanly and measures **−4,096 / −1,243** (C6's own record on C4's
+  head: −4,130 / −1,256); the bind chunk is external, as the scenario keeps
+  every tier chunk. C2 is **not** re-applied (its edit spans the sf dist with
+  different anchors); its measured net on this very head (`c2-phase1.md`,
+  `lean`: **−934 / −292**) is added arithmetically where marked.
+- Tooling lives under `tmp-tools/` (git-excluded, rebuildable from this
+  section); raw results under the workspace's `.wt-logs/residue-*`.
+
+---
+
+## 1. Attribution now
+
+### 1.1 Class totals, head vs the morning
+
+Frames eager, minified, **residue re-attributed** (the honest column); brotli
+by class **measured by removing the class from an edited copy** where a
+class can be cut cleanly, derived by subtraction where it cannot.
+
+| class | morning (`23176235d`, 43,310 min / 13,770 br) | **head (`5c5991cbd`, 40,000 / 13,083)** | Δ min | br morning (measured) | **br head** |
+| --- | ---: | ---: | ---: | ---: | ---: |
+| **T — transport** | 23,380 (54.0 %) | **27,913 (69.8 %)** — of which `T.glue` 1,116 | +4,533 | 7,773 | **≈ 9,640** (derived; `T.holes` 504 and `T.glue` ≈ 350 measured / est. inside it) |
+| **R — restates core** | 6,655 (15.4 %) | **2,444 (6.1 %)** | −4,211 | 1,863 | **844** (measured: `stage+insert+fallback+stamp`) |
+| **F — feature** | 11,134 (25.7 %) | **7,887 (19.7 %)** | −3,247 | 3,816 | **≈ 2,300** (C6 1,243 + C2's deletion 485 + claims 291 measured; the regions / assets / trace eager remnants ≈ 280 est.) |
+| **D — dead / incidental** | 2,141 (4.9 %) | **1,756 (4.4 %)** | −385 | 318 | **300** (measured: the seven-item D cut) |
+| total | 43,310 | 40,000 | −3,310 | 13,770 | 13,083 |
+
+R + D together: **1,126 br measured** (the morning: 2,181). The morning's
+R fell by two thirds (R.gate, R.dedupe, R.version, R.claim, R.drain,
+R.claimant, R.refwait are gone; R.stage lost its tables and `onStream` but
+kept the `preview` carrier; R.insert is untouched; R.reveal kept the fallback
+pass). **T grew by 4.5 KB min**: the Phase A seams (A1 S-flush, A1b S-ref,
+A2 S-hold, A7 the error face — ≈ 3,700 min of new or grown T units) and B's
+mechanism with the three tiers' triggers (`T.glue`, 1,116 min). F fell by
+the three cut tiers (trace / regions / assets ≈ −3,800) less what each kept
+eager.
+
+By group on the head (min, residue re-attributed): T.wire 6,098 · T.store
+4,821 · F.bind 4,758 · T.slots 4,217 · T.morph 4,181 · T.doc 2,918 ·
+T.holes 1,926 · D 1,756 · F.wire 1,576 · **R.stage 1,572** · **T.glue
+1,116** · T.decode 1,052 · T.flight 789 · **R.insert 622** · T.refs 613 ·
+F.claims 486 · F.regions 477 · F.assets 360 · **R.reveal 190** · T.claim
+182 · F.event 160 · F.trace 70 · R.error 60.
+
+### 1.2 What left, what arrived, what grew (vs the morning's per-unit table)
+
+**Left — 62 units, 6,163 min.** The three cut tiers' eager halves:
+`ensureStylesheet` 423, `applyInlineStyles` 275, `qualifierValue` 260,
+`findHeadElement` 245, `ensurePreload` 238, `ensureModulePreload` 162,
+`#processedAssets` / `#styleFlush` (C5); `collectRegionElements` 248,
+`#bindRegions` 213 + its three thread-ups, `#reconcileRegions` 164,
+`#regionsChange` 123, `renameRegion` 83, `#regionsFor` 80,
+`#discoverRegions` 74, `disposeRegions` 58, `isFrameRef` 51, `#slotRegions`
+(C4); `reviveContainerTraces` 257, `materialize` 173,
+`isContainerTraceMarker` 152, `isMaterializedContainer` 75,
+`setContainerTraceMaterializer` 36 (C3). The R deletions: `#refArgsUnchanged`
+530, `argsEquivalent` 216, `#slotResolvedRefs`, `#refsUnresolved` 104,
+`#resolveRef` 73 (A1b R.dedupe / R.refwait); `hasPendingFragment` 176,
+`gatherClaims` 156 (A2b R.claim); `claimRegionFragments` 153 (A5′
+R.claimant); `recordsPending` 121, `#recordRefresh` (A4 R.drain);
+`clearStreamRecords` 100, `rebase` 24, `#appliedRootValue` (A1 R.version);
+`stageTables` ×5 ≈ 180, `beginStream` 31, `ensureTable` 86,
+`stage.entry.stream` 54, `onStream` 19 (A1b: the per-response cell is
+`tableFor`'s version key); `followAddress.drop` 38, `boundaryComponent.arm` /
+`.settle` / `.onApply`, `adoptBoundary.arm` / `.settle` (A1 R.gate);
+`#isRevealed` 36, `#revealed`, `#fallbackShown` (A3 R.reveal);
+`#errorNotified` (A7). `isAsyncLike` 98 (the duplicate probe — `isAsyncValue`
+is the one left and is live).
+
+**Arrived — 32 units, 2,975 min, by the step that added them.**
+
+| step | units (min) | eager total (min) | the PR's own glue figure |
+| --- | --- | ---: | ---: |
+| **A1** S-flush (#3830) | `createFrameHost.landing` 174, `lands` 43, `handle.begin` 48, `landing` 224 (≈ 90 of it A7's error arm), `boundaryComponent` re-shaped 307 → 228, the landing section of `createFrameHost.apply` ≈ 200 | ≈ 610 | S-flush −187 min net on the frames client (#3849 note) |
+| **A1b** S-ref + the dedupe to the fill's memo (#3844) | `settleArgs` 307, `pendingRef` 232, `settleWait` 214, `sameArg` 305, `Boxed` 38, `tableFor` +83 (version key), the data-arm + end-of-response wait arms of `createFrameHost.apply` ≈ 380, `isCalled` 42 (A0's `#` rule) | ≈ 1,600 | "≈ +330 B min of pending-read machinery" (#3844) — the memo equality (`sameArg`) was never budgeted; the morning estimated the dedupe replacement at ≈ 140 |
+| **A2** S-hold (#3837 / #3840) | `adoptBoundary.hold` 84, `#hold`, `#releaseHold` 41, the `waiting` lines in `#syncSlots` ≈ 60 | ≈ 190 | −109 br frames net (R.claim deletion) |
+| **A3** a reveal is an apply (#3848) | `#revealSegments` 341 (replaces the two sets + `isRevealed` + the retry loop; `#flush` −333) | ≈ 0 net | −45 min / ±0 br |
+| **A5′** ownership by rendering (#3847) | `installRevealHook.hy.fa` 51, `disposedFrames` + `FRAME_SELECTOR` + the dispose guard ≈ 90 | ≈ 140 | −204 min / −51 br net (the C14 guard +116) |
+| **A7** the error face + re-ask (#3848) | `failing` 87, `callFor` 32, `reask` 165, `calls` + two `calls.set` ≈ 50, `landing`'s error arm ≈ 90, the host's reject arms ≈ 60 | ≈ 480 | +747 min / +272 br |
+| **B** the tier mechanism (#3854) | `prepareTier` 163, `tierReady` 25, `needsRegions` 31, `tierLoaders` / `tierLoads` / `liveFrames` 45, `installServerComponents` +60 (`tiers` option, `sc:tiers` read), `handle` +40 (header read), `applyFrames.drain` +40 (`chunk.tiers` await), constructor +20 | ≈ 420 | +473 min / +145 br |
+| **C3** traces tier (#3856) | `carriesTrace` 72, `needsTrace` 38, `tierLoaders.trace` 48, `#heldRecords` 27 + its four arms ≈ 80, the `claiming` thread ≈ 25 | ≈ 290 | +467 min / +156 br (incl. the held-record mount) |
+| **C4** regions tier (#3858) | `tierLoaders.regions` 52, `FrameImpl#get options` 29, `#outer` + the three thread-ups ≈ 80, `R?.bind` ×3 ≈ 50, `needsRegions` at the update site ≈ 20, `preview`'s `R.changed` / `R.frames` ≈ 60 | ≈ 290 | +518 min / +186 br |
+| **C5** assets tier (#3857) | `tierLoaders.assets` 50, the `#segmentReady` style-gate term 115, `#flush`'s assets walk dispatch ≈ 110, the kept record cases (`chunkToRecords` `assets`, `host.write`'s accumulate) ≈ 200 | ≈ 480 | +508 min / +131 br |
+
+`T.glue` on the head, measured as a group by cut where it can be: the
+unified-dispatch experiment (§2, `unify`) rewrites all of it and moves
++6 min / −20 br — **there is no slack in the seams' shape**; their cost is
+the hand-offs themselves.
+
+**Grew (|Δ| ≥ 50, stayed):** `createFrameHost.apply` 182 → **873** (+691:
+the data guard, the waits, the landing, the end-of-response rejection —
+A1 / A1b); `tableFor` +83; `drainRecords.apply` +76 and `drainRecords` +34
+(A4's declared-record arms); `slotArgsProxy.get.make` +71 (`sameArg`
+equality, `Boxed`); `chunkToRecords` +67 (A6's `ops` and `complete.bound`);
+`applyFrames` +58 and `.drain` +33 (B); `showing` +58; `unregister` +57
+(`shown` / `shownVersion` in the capture arm); `installServerComponents` +43
+(B). **Shrank:** `#flush` −333 (A3, C5), `claimRender` −183 (A2b's
+`hydrateWindow` in solid), `#resolveArgs` −151 (C4), `#apply` −145 (A1b's
+dedupe arm), `followAddress` −93, `#revealSegment` −89, `boundaryComponent`
+−79, `preview` −73, `installRevealHook` −72 (A5′'s G9).
+
+### 1.3 R and D on the head, unit by unit
+
+| unit | min | class | measured br (§2) |
+| --- | ---: | --- | ---: |
+| `FrameImpl#preview` | 432 | R.stage | with the carrier: `stage` −542 ceiling |
+| `createServerComponentHandler.stage` (+ `.entry.*`, `.named`, `.settled`, `.binding`, `stagedContent` ×4, `contentAddress`, `CONTENT_TOKEN`) | ≈ 480 | R.stage | — |
+| `createFrameHost.preview` | 157 | R.stage | — |
+| `followAddress` | 92 | R.stage (the token's two halves) | — |
+| `applyFlightResponse.regionOf` + the staged-region arm | ≈ 110 | R.stage | — |
+| `normalizeSlotContent` 274, `slotsFor.get.settle` 143, `isReactiveContent` 111, `#replaceRange` 94 | 622 | R.insert | `insert` −207 |
+| the fallback pass of `#revealSegments` ≈ 130 + `#showFallback` 60 | 190 | R.reveal | `fallback` −79 |
+| the s / v fast-adopt in `slotArgsProxy.get.make` | 60 | R.error | `stamp` −30 |
+| `installServerComponents.g._$SC.r` (+ `.c[i]`) | 207 | D | `mirror` −80 |
+| `documentAddress` (+ its call) | 95 | D | `docaddr` −28 |
+| `slotsFor.get`'s second dispose map (`bindings` beside `fillScopes`) | ≈ 250 attributed; 82 by cut | D | `dispmap` −20 |
+| `FrameImpl#contentHTML` + `unregister`'s capture arm | 72 + 230 | D | `capture` −73 |
+| the zombie heuristic in `#syncSlots` | 104 | D | `zombie` −35 |
+| the imperative (no-`reveal`-hook) branch of `#revealSegment` | 121 | D | `imperative` −27 |
+| `showing`'s `COMPONENT_BINDING` brand | 96 | D | `brand` −22 |
+| the `adopted` fork in `#invokeSlot` | 100 | D (as the morning listed it) | **not cut** — it is the claim-vs-render decision; deletes only when the t = 0 difference goes (A5) |
+| `bindDataOccurrence.write`'s second diff layer | 300 | F.bind (D-like) | leaves with C6 |
+
+---
+
+## 2. Measured candidates
+
+Frames eager Δ min / Δ br against the head (40,000 / 13,083); page base and
+page live Δ br; the four non-SC scenarios are **0 / 0 on every row**. "Ceiling"
+= the item deleted whole with nothing in its place; "carrier" = what must be
+built for the pins to stay green, measured where sketched (`pullcarrier`),
+estimated otherwise (×3 the loader-line rule where a seam is unbuilt — the
+pattern every tier in #3860 showed).
+
+| # | item | class | Δ frames min / br | page base br | page live br | carrier / glue | **net br (est.)** | risk — pins at stake, design, wire |
+| --: | --- | --- | ---: | ---: | ---: | ---: | ---: | --- |
+| 1a | `preview` — the staging **push** half out (commit-only form): `FrameImpl#preview`, `host.preview`, `entry.preview`, `stagedContent.preview` | R.stage | −719 / −216 | −227 | −236 | 0 | — | **not a candidate**: C15 ×4 stay green but `frames-optimistic-hold` ×3 go red (`false/false` in the derivation trace — #3844's finding, re-stated) |
+| 1b | `stage` — **everything** out: the buffer, the token, `stagedContent`, `contentAddress`, `CONTENT_TOKEN`, the token arms of `handle` / `applyFlightResponse`, `followAddress` → a plain rebind effect | R.stage | **−1,643 / −542** | −564 | −558 | — (ceiling) | — | C15 ×4 red, optimistic-hold ×3 red: the refetch's morph lands at body end beside siblings the transaction still holds |
+| 1c | **the `preview` pull form** = 1b + the carrier sketch (§3.1): a staged record set per address in the host written through as chunks arrive, promoted at the commit; a version tick per frame written in the follow's compute half; the live props read the staged record through it | R.stage | ~~−803 / −300~~ **−231 / −63** (step 2, the sound carrier as designed, measured) | −29 | −37 | ~~sketch +840 min / +242 br~~ **+1,414 / +483 over 1b** — the sketch deleted the token (unsound: `dynamic` never delivers a same-address refetch without it) and omitted the flight path, regions, the lane gate and the commit's landing / L1 semantics (§3.1 "As measured") | **−63** | **stopped at the carrier budget (2026-10-06)**: C15 ×4, `frames-optimistic-hold` ×3, `frames-morph-in-transition` ×3, principles §9.2.2; `c17-gate-bound-address`; public surface: `FrameHost.preview` / `Frame.preview` / `stagedContent` / `contentAddress` removed (approved 2026-10-06, "not even beta") |
+| 2a | `_$SC` client mirror | D | −234 / −80 | −70 | −151 | 0 (or ≈ +60 for a minimal `r` without the address arms) | −80 … −60 | **behaviour**: a page whose data scripts carried no reference (so the server never emitted the bootstrap) and a CSR boot have no `_$SC.r` → `handler.component` throws. Needs the server to emit the bootstrap unconditionally on SC pages (≈ +200 B of document output) or the client to keep a minimal `r` |
+| 2b | `documentAddress` | D | −95 / −28 | −49 | −3 | 0 | −28 | an unbound adopted mount (direct `_$SC.r(id)` placeholder, no binding) binds the function id instead of the call's address — a post-load refetch under the address would not reach it; `frames-adopted-*` pins to check. Deletes cleanly only with 2a's server half (the t = 0 record carries the address to the mount) |
+| 2c | the second dispose map (`bindings` → `fillScopes`) | D | −82 / −20 | −76 | −24 | 0 | −20 | safe (identical bookkeeping; both maps dispose the previous invocation under the same key) |
+| 2d | `contentHTML` + the last-unmount capture | D | −272 / −73 | −128 | −72 | 0 | −73 | **behaviour**: a document-adopted boundary's content is not retained for a later mount of the same address (it re-fetches). Unpinned (the morning's note stands); principles §4 row 3 |
+| 2e | the zombie heuristic | D | −104 / −35 | −10 | −34 | 0 | −35 | DR-5: unreachable under identity-first matching; the lifecycle matrix's morph rows are the pins |
+| 2f | the imperative branch of `#revealSegment` | D | −121 / −27 | −65 | −54 | 0 | −27 | **public surface**: `FrameOptions.reveal` is optional on `createFrame` / `createFrameElement` (`@experimental`) — the branch is reachable from a consumer that passes none; a documented "reveal is required" or a default seam |
+| 2g | `showing`'s `COMPONENT_BINDING` brand | D | −96 / −22 | −3 | −22 | 0 | −22 | **behaviour**: a cache-seeded reader at t = 0 whose site later switches calls would remount instead of delivering through `dynamic`'s equals-gate; the adopted-switch pins (`c17` (b), the notes-search shape) to check |
+| **2** | **the D list, together** (2a–2g) | D | **−1,004 / −300** | −289 | −305 | 0 … +60 | **−300 … −240** | the sum of the above |
+| 3 | **R.insert** — every fill through `insert`: `normalizeSlotContent`, `isReactiveContent`, `settle`, `#replaceRange` go; the reactive branch is the only branch | R.insert | **−713 / −207** → **built −978 / −287** (step 3, §7c: the ceiling re-measured on step 2's head −769 / −230; the dead comment-marker range mode of `FrameImpl` −196 / −67 taken with it) | −158 | −193 | ≈ 0 (`insert` is already the reactive branch's call) — built: +10 min / +14 br (the no-gather flag on the second claim window, the transparent owner) | **−287** (built) | **landed (2026-10-06)**. **Public surface**: `Slot`'s return is no longer read — a callback owns its range through `ctx.range` (§7c); the no-range snapshot fallback is removed (a range without its end marker is left as the server rendered it). **Behaviour**: a static fill is an `insert` of a non-function value (no effect created); a fill that does not claim at t=0 is the core's hydration mismatch (C1 (b) re-pinned), not a frame-side replacement |
+| 4a | the fallback pass of `#revealSegments` + `#showFallback` | R.reveal | −330 / −79 | −110 | −117 | DR-4 2c (the document fragment as a store write — "its own plan, ≈ 1.3 KB on whichever side goes") | **−79** only under DR-4 | **design**: what `$dfl` does for the document face; C8, C14 (c), the lifecycle matrix's fallback rows |
+| 4b | the style gate (C5's reveal-readiness term) | F.assets glue | −115 / −25 | −89 | −83 | — | **not deletable** | `tier-assets-ready` ×5 red: the FOUC guard |
+| 5a | `FRAME_HAVE_HEADER` / `FRAME_HAVE_BUDGET` off the client entry's export list | F.wire | −64 / −28 | 0 | 0 | 0 | −28 | **public surface**: two exported constants leave the eager entry (C2's `lean` keeps + re-exports them at +45 br; the tier would import them from the sf client or carry its own copy). The pages already tree-shake them — the cost is the frames scenario's whole-entry measurement |
+| 5b | the declared-record arms in `drainRecords` (A4's client half) | T (A4) | −102 / −31 | −17 | −19 | — | **not deletable** (the declared protocol; the synchronous `s === 1` read keeps an adopt-time claim inside the window); ≈ 10 br golfable |
+| 6a | the whole re-ask path (`reask`, `callFor`, `calls`, the RPC symbols, `landing`'s arm) | T (A7) | **−434 / −154** | −57 | −209 | — (ceiling) | — | `frames-errored-reset-refetch` ×9 red: `reset` would show the error again |
+| 6b | **the lean re-ask**: the sf client hands `ctx.retry` (a thunk re-dispatching the same call with its declared metadata); frames keeps `calls` and `reask = address => callFor(address)?.retry?.()` | T (A7) | **−235 / −74** | −76 | −54 | sf client ≈ +100 min / +30 br (page base and live pay it; frames eager does not — the sf slice this scenario keeps has no `dispatchServerFunction`) | **−74 frames / ≈ −45 pages** | **design** (§3.3): `ServerFunctionsClientConfig`'s `responseHandler` ctx gains `retry` (internal); the nine A7 pins unchanged; GET stays GET by construction |
+| 7 | the C3 hold's `runWithOwner` + `untrack` wrap | T.glue (A2) | −16 / −9 | −10 | −9 | — | **not deletable** | `sharedConfig.holdBoundary` reads `getOwner()` (`hydration.ts:1805`); a chunk-microtask hold has no owner without the wrap |
+| 8a | the nested-region marking in the dispose guard | T (A5′) | −45 / −4 | +34 | +34 | — | −4 | not worth a line |
+| 8b | the whole dispose guard (`disposedFrames`, `hy.fa`'s check) | T (A5′) | −114 / −25 | −5 | +18 | — | **not deletable** | `c14-dispose-clean` (e) red (verified by #3847) |
+| 9 | **unifying the tiers' dispatch**: one `tier(name)` helper (module or start the load), one `waitsOn(record, consumers)` predicate for both sync sites, the assets walk and the style gate through the same helper | T.glue | **+6 / −20** | −18 | −9 | — | **≈ 0** | nothing to gain: the seams' cost is the hand-offs at the sites the code left, not the helpers' shape. The indirection would cost one extra call per readiness check for no bytes |
+| 10 | the s / v fast-adopt in `slotArgsProxy` | R.error | −92 / −30 | −6 | −50 | `readHydratedValue` exported from `solid-js/internal` ≈ +10 | −20 | the frames copy lacks #2997's rejection-observe (the export fixes that too); a declared record's settled promise must still read synchronously at a t = 0 claim (C1 / C9) — the export, not a deletion |
+| 11 | the sf slice's live arm of `deserializeStream` | sf (E.a2) | −154 / −45 | −80 | −74 | — | — | **not frames'**: `shared.ts` serves `live()` for non-frame answers; C2's pass found it cannot move into a frames chunk. An sf-side lazy arm (E.b class) — the page's, not this scenario's |
+| 12 | **S-ref's pending read in the table** — the ceiling: `pendingRef`, `settleWait`, the waits in `apply`, `record.pending`'s arm | T (A1b) | **−884 / −289** → **built −505 / −174** (step 4, §7d: the ceiling re-measured on step 3's head −879 / −280; the carrier +374 / +110 over it — the row's +40 br estimate counted the count and the `.then`, not the `closeData` seam (host + integration ≈ 190 min), the transport's await for a `{$ref}`-carrying slot chunk (61 / 7) or the fan-out helper) | −200 (built) | −157 (built) | decode chunk (lazy) **+420 / +161 built** (pending-on-missing, the stamp, the callbacks, `close`) | **−174** (built) | **landed (2026-10-06)**. The table answers an undelivered key with a promise (marked `s = 0`, carrying `c`) it settles at the key's `data` chunk and rejects at `close` (L1); frames keeps `record.pending` and one `settle` per read; `FrameHostOptions.closeData` added (`@experimental`). C5 (a, b, c, e), C6 (a1), C17 (c), `frames-flight-delivery`, the `{$ref}` rows of the lifecycle matrix green unchanged; `sref-table-pending-read` added (the table's lifecycle; L1 through the shared host) |
+| 13 | **claims + `frame:applied` to the router's chunk** — the ceiling: `claimHandlers` / `claimNode` / `claimTree` / `claimedAttr` / `#claimTree` / `#claimContent`, the `claim` thread through the morph, the `CustomEvent` dispatch | F.claims + F.event | **−890 / −291** | −228 | −344 | ≈ +60 min / +20 br seam (the router installs a sweep hook the morph calls) | **≈ −270** | **public surface**: `FRAME_APPLIED_EVENT` leaves the client entry; the router contract (`CLAIM_SEAM`) becomes "the router sweeps on install and on the seam's call"; plan Phase D's own item |
+| 14 | **C1 — hole-op application as a tier** — the ceiling: `#applyHole`, `#applyAttrs`, `findLiveTarget`, the hole pass, `pumpLiveChannel` + the op log, `applyLiveOp` + the catch-up (the record cases stay) | T.holes (E.a1) | **−1,870 / −504** | −459 | −507 | loader entry + `#flush` dispatch + the pump's dispatch + the applier hand-off ≈ +190 min / **+65 br**; server `needs("holes")` at `createLiveHoles`' first `openBinding` ≈ +30 min | **≈ −440** | **the 8.0 ruling reversed** (holes eager); buffer-only, no hold (plan §1's holes row); `tier-holes-buffer.spec` as the plan drafted it; C13 control arm, C18's pump catch-up arm unchanged |
+| 15 | two golfs: `sameArg`'s `Boxed` arm folded; one content-record helper in `chunkToRecords` | — | −144 / −6 | −41 | −22 | — | ≈ 0 | brotli already folds the repetition — not worth touching |
+| — | **C6** (bind tier, `tight-nopair`, re-applied on this head) | F.bind | **−4,096 / −1,243** | −1,159 | −1,160 | included (C6 P1: glue +1,134 min / +315 br over the deletion) | **−1,243** | in flight |
+| — | **C2** (wire tier, `lean`, measured on this head by its own pass) | F.wire | −934 / −292 | −264 | −258 | included (+576 / +193) | **−292** | deferred; keeps `FRAME_HAVE_*` exported (+45 br — 5a is the rest of it) |
+
+Three measured facts worth lifting out of the table: (i) **the push half
+of `preview` is 216 br and the token carrier 326 br**, so the pull form's
+carrier has to come in under ≈ 240 br to beat commit-only-plus-nothing; the
+sketch did (242, before golfing) but only just; (ii) **S-ref as built costs
+289 br eager** against the morning's ≈ 80 estimate — the pending read was
+built in the host when the table (lazy) is where the key lives; (iii) **the
+D list is 300 br**, every item of it with a small behaviour or surface
+consequence, none of it free.
+
+---
+
+## 3. Designs needed
+
+### 3.1 The `preview` pull form (R.stage — item 1c)
+
+**What the token does today** (#3759, kept by #3844). A refetch of an
+address a mount is SHOWING cannot reach the mount through `dynamic`: the
+call resolves to the same binding, and `dynamic` delivers a kept resolution
+only when its address differs. So the handler stages the response (buffers
+its chunks under the address) and resolves the call to a **token binding**
+whose accessor yields `address\0version`. `dynamic` writes the new accessor
+in the transaction that read the call; `followAddress`'s compute half runs
+in that pass and **pushes** the staged slot args into the live fills
+(`stagedContent.preview` → `host.preview` → `FrameImpl#preview` →
+`update(props)`), so a fill deriving optimistic intent re-derives from the
+new args in the pass that dissolves the intent (§9.2.2); the effect half
+commits the buffer as the store's writes at the commit (C15). The carrier
+is 1,643 min / 542 br; its push half 719 / 216.
+
+**The pull form.** Keep the two things that are load-bearing — the version
+travels through the accessor (`dynamic` must see a new value), and the
+morph waits for the commit — and replace the push with a read:
+
+1. **Host.** A response for a showing address writes through, as every
+   response does, into a **staged record set** on the store
+   (`store.staged = { version, records }`) instead of `records`; `write`
+   decides by "frames are bound and the shown landing is not an error" (the
+   `showing` test moves from the handler into the host). Nothing is
+   buffered in the handler; `stage` / `staged` / `latest` / `settled` /
+   `named` / `stagedContent` / `contentAddress` / `CONTENT_TOKEN` go. The
+   call still resolves to a binding whose accessor yields a **new value** —
+   the plain address with the version appended is the smallest (the token
+   survives as a convention, not as machinery; `contentAddress` becomes a
+   `split` at the two read sites or the accessor returns `[address, version]`).
+2. **Frame.** `followAddress`'s compute half does one thing: `frame.stage(
+   host.staged(address))` — stamps the staged set on the frame and bumps a
+   per-frame **version tick** (`createSignal(0, { ownedWrite: true })`, the
+   `failing` pattern). Its effect half: `frame.rebind(address); frame.commit()`
+   → `host.promote(address)` replaces `records` / `shown` with the staged set
+   and applies it to every bound frame as one write — the morph lands at
+   the commit, exactly where `stagedContent.commit` lands it today.
+3. **Fills.** `liveSlotProps`' source becomes `() => ctx.staged?.() ||
+   args()`; `ctx.staged` reads the frame's tick, then the staged record for
+   the occurrence (unless it names a region — those wait for the commit, as
+   `preview` skips them today), resolved through `#resolveArgs`. A fill's
+   per-prop memo (`sameArg` equality) therefore **reads** the staged args in
+   the pass that delivered the version — A29 stages the derivation with the
+   transaction; no push, no `#slotUpdaters` reach from the handler.
+
+**What it must keep green.** `c15-staging-atomic` ×4 (the root, fill and
+sibling change in one frame; a superseding refetch while staged lands only
+the newest, whole; the control lands at body end) — the promote-at-commit is
+what carries these; `frames-optimistic-hold` ×3 multi-flight arms (the
+`false/false` trace) — the compute-half read is what carries these; the
+single-flight arm and the renamed-region arm (regions wait for the commit,
+as today); `frames-morph-in-transition` ×3; `c17-gate-bound-address` (b)
+(a switch under a staged refetch); `c05` (the staged response decodes into
+its own table — unchanged, tables are version-keyed); the staged-regions
+arm of `applyFlightResponse` (a region for a showing call is staged like a
+refetch — the host's write rule covers it once regions bump per frame).
+**Pins that change:** none by assertion; `FrameHost.preview` / `Frame.preview`
+/ `stagedContent` / `contentAddress` (`@internal`) are removed — approved
+2026-10-06.
+
+**Bytes.** Deletion ceiling −542 br; the sketch's carrier +242 br measured
+(host `staged` / `promote` ≈ 300 min, the frame's `stage` / `commit` /
+`stagedRecord` ≈ 250, the `ctx.staged` read ≈ 100, `write`'s staged branch
+≈ 150); **net −300**, band −250 … −350 after golfing. The three glue rules
+this pass learned apply: budget the carrier at the sketch (+242), not below
+it.
+
+#### As measured — residue step 2 (2026-10-06): stopped at the carrier budget
+
+Branch `size/frames-residue-2-pull-form` on step 1's head (`fce81d2c0`:
+frames eager 35,250 / 11,654; page base 114,422 / 36,488; live 126,294 /
+40,125). Measured before writing, as the step's rule says: the ceiling
+re-applied to this head's dist, then the carrier **as the step would have
+written it** (the same text, not a sketch) applied on top of the ceiling,
+through the harness's own bundler (§0's method; `.wt-logs/res2-edit.mjs`,
+`res2-measure.mjs`). Nothing was written to source; no pin ran against it.
+
+**The sketch is unsound in one place, and it is the place the budget was
+built on.** `pullcarrier` deleted the content token with the buffer — the
+call resolves the bare per-address binding, `followAddress` reads
+`host.staged(address)` off the bare address. But `dynamic` delivers a kept
+resolution only when its `.address` differs from the one it last delivered
+(`web/src/index.ts`, `resolveBinding` / `sameInstance`): a refetch of the
+address a mount SHOWS resolves to the same object, `deliver(address)` is a
+same-value write, and neither the follow effect's compute half nor any fill
+memo runs in the transaction — the content lands when the body ends, beside
+siblings the transaction still holds. That is #3844's gap (1), restated;
+the sketch's text could not have kept C15 (a, b) or any multi-flight arm of
+`frames-optimistic-hold` green. **The token binding stays in any form**
+(`stage`'s mint, `latest`, `settled`, `showing`, one staging target):
+**227 min / 88 br** measured — the first thing the +242 did not count.
+
+**The honest carrier, as designed for the build.** Handler: `showing`
+decides at the header as today; a staged response's chunks reach the host
+flagged (`host.apply(chunk, true)`; the flight path flags by staged root
+prefix, as `regionOf` did); the token binding is minted into `latest` and
+the call settles at body end. Host: `apply(chunk, stage)` writes a flagged
+chunk whose version is newer than the store's into `store.staged = {
+version, records }` under the same policy-A `write` (one response's — a
+newer replaces it; once the store is at the version, the rest writes
+through, as a committed entry did); `settleArgs` through the store's
+version-keyed waits, with `settleWait` re-applying only a record that is
+the store's current one (a staged record's data settles silently and lands
+at the commit); `staged(id)`; `promote(id, version)` = the store's own
+`write` plus the landing tail `apply` runs (shown / open / the pending
+landing settled or rejected / frames applied / L1 for the response's
+undelivered refs), the waits carried across the bump. Frame:
+`#stagedRecord(occurrence)` — the staged set's record, else the parent's
+when this frame's store does not shadow the key (the `inherited` rule
+`preview` had); `ctx.staged()` resolves it through `#resolveArgs` unless it
+adds or renames a region (`R.changed`, as `preview` skipped). Fill:
+`liveSlotProps` reads `staged() && ctx.staged() || args()`, where
+`staged` is the mount's **gate** — `host.staged(address)?.version ===
++version` parsed from the mount's own address accessor (`binding()`), so
+the read is keyed by the signal `dynamic` writes in the transaction's pass
+and is lane-correct: a write-through recompute between the refetch's header
+and its commit (a live op on an adopted boundary, a reveal cascade, a
+`settleWait`) reads the committed accessor value and falls to `args()`.
+Without the gate the staged set is readable from its first chunk to its
+commit — a read outside the pass. Follow: the effect half promotes the
+token's version, rebinds, then promotes each region store below
+(`regions-tier.ts`, the recursion that replaces `frames()`), so a nested
+region's chunks — which the handler's buffer held with the root for free —
+land with the root's commit; `Frame.preview`, `FrameHost.preview`,
+`stagedContent`, `contentAddress`, the entry's buffer and `named` delete.
+
+**Bytes** (frames eager; the four non-SC scenarios 0 / 0 on every row):
+
+| edited dist | min / br | Δ vs head | carrier over the ceiling |
+| --- | ---: | ---: | ---: |
+| ceiling — `stage` whole out (§2 row 1b, re-measured on this head) | 33,605 / 11,108 | **−1,645 / −546** | — |
+| the carrier as designed | 35,212 / 11,651 | −38 / −3 | +1,607 / +543 |
+| … promote through `write` + the shared landing tail (**the lean form; sound**) | 35,019 / 11,591 | **−231 / −63** | **+1,414 / +483** |
+| lean − the token binding (_unsound_: nothing delivers) | 34,792 / 11,503 | −458 / −151 | token = 227 / 88 |
+| lean − the flight path's staging (_unsound_: a mutation's region tears) | 34,843 / 11,537 | −407 / −117 | flight = 176 / 54 |
+| lean − regions (no region promote, no inherited record, no structural check; _unsound_) | 34,867 / 11,538 | −383 / −116 | regions = 152 / 53 |
+| lean − the gate (the fill reads the staged set unguarded; _unsound_: a read outside the pass) | 34,913 / 11,562 | −337 / −92 | gate = 106 / 29 |
+| lean − flight − regions − gate (the unsound floor) | 34,585 / 11,447 | −665 / −207 | +980 / +339 |
+
+Pages, the lean form: base 114,184 / 36,459 (−238 / −29), live 126,061 /
+40,088 (−233 / −37); the ceiling alone −555 / −499.
+
+**Why the sketch was short by half.** The handler's buffer is ≈ 200 min of
+dumb array replayed through `host.apply`, and the replay inherits every
+semantic the host already has — version policy, the landing, L1, per-id
+routing, so nested regions and the flight path's several roots stage for
+free. A host-side staged set has to carry each of those itself (≈ 600 min
+across `apply`'s branch, `promote`, the `write` / `settleWait` guards and the
+region promote), and the pull read (`#stagedRecord` + `ctx.staged` + the gate
++ the `liveSlotProps` / `slotsFor` threading ≈ 750 min) is not smaller than
+the push it replaces (`FrameImpl#preview` + `host.preview` + `entry.preview`
+≈ 700): the push writes the signal **in** the pass and is lane-correct by
+construction, the pull has to buy that with the gate. Keeping the buffer
+and pulling from it instead (a `stagedContent.record(token, id,
+occurrence)` read, the host's `settleArgs` exposed, the same frame-side
+read and gate) measures the same way: ≈ 720 added for ≈ 710 deleted.
+
+**Conclusion.** The deletion ceiling is real (−546) but ≈ 480 of it is
+carrier under any sound form; the honest net is **≈ −60 br**, a fifth of
+the row's −300 and outside the −250 … −350 band. Stopped per the step's
+rule (carrier > +300); §2 row 1c and §4 row 3 are corrected below to the
+measured net. What it would still buy if taken for its own sake: the
+handler loses `staged` / `named` / `stagedContent` module state and the
+flight path's `regions` map; the host gains `staged` / `promote` and
+`apply`'s second parameter (`@experimental` surface added, see the step's
+PR). Not recommended at −63.
+
+### 3.2 S-ref's pending read belongs to the table (item 12)
+
+As built (#3844), the host mints a pending promise per undelivered key per
+response (`pendingRef`), settles it when the key's `data` chunk lands
+(`settleWait`, re-applying every record it was the last open read of), and
+rejects every open wait at `complete` / `:error` (L1) — 884 min / 289 br
+**eager**. The morning's S-ref put pending-on-missing in the **decode
+chunk** (lazy): the table is where the keys live and `createJSONDataTable`
+already knows which keys it has. The design: `table.resolve(ref)` returns a
+promise for an absent key, settled by the table's own `apply` of that key
+and rejected by its `close()` / `abort()` — `deserializeStream` already
+calls `abort` at an unexpected end; the frames host calls `close` at
+`complete`. What stays eager: `record.pending` as a count of promise-valued
+args (so a **fresh mount still waits** for its record to settle rather than
+pending into its covering boundary — the behaviour #3844 chose), one
+`.then` per pending arg to re-apply the record (≈ 120 min / 40 br). Net
+**≈ −250** eager; the decode chunk +≈ 120 min (lazy, reported not counted).
+Pins: C5 (a, b, e), C6 (a1), the `{$ref}` rows of the lifecycle matrix,
+`frames-flight-delivery`, `frames-optimistic-hold`'s `{$ref}` arm. Public
+surface: `FrameHostOptions.resolve` keeps its signature; the table's
+`resolve` contract changes (a promise for a missing key) — the serialization
+package's, `@internal`.
+
+#### As built — residue step 4 (2026-10-06)
+
+Branch `size/frames-residue-4-sref-table` on step 3's head (`8a0b090cf`,
+frames eager 34,272 / 11,367). Measured before writing on an edited dist
+copy of this head — the frames client AND the decode dist, the latter
+routed into the page scenarios so the lazy chunk's growth is read, not
+estimated (`.wt-logs/res4-edit.mjs`, `res4-measure.mjs`; §0's method):
+
+| edited dist | frames eager Δ | page base / live Δ br | decode.js (lazy) Δ | note |
+| --- | ---: | ---: | ---: | --- |
+| the ceiling (§2 row 12's cut re-applied: `pendingRef`, `settleWait`, the waits in `write` / the data arm / the end arm, the `record.pending` test) | **−879 / −280** | −300 / −297 | 0 | the row measured −884 / −289 on #3860's head |
+| the carrier as designed (below) | −485 / −162 | −183 / −208 | **+382 / +140** | glue +394 min / +118 br over the ceiling |
+| … without the transport's slot-chunk await | −546 / −169 | −209 / −218 | +382 / +140 | the await is 61 / 7 — kept (soundness, below) |
+| … with one `applyTo` fan-out shared by `apply` and the settle | **−519 / −170** | −243 / −180 | +382 / +140 | the shape built |
+| **built** | **−505 / −174 → 33,767 / 11,193** | **−200 / −157** → 112,938 / 36,071 and 124,810 / 39,747 | **+420 / +161** → 23,410 / 6,237 | +14 min / −4 br over the copy: the `instanceof` guard and the callbacks (below) |
+
+The stop rule was net < −150 br; the carrier cleared it by 20.
+
+**What the table owns.** `createJSONDataTable.resolve` of a key no `apply`
+has delivered answers with ONE pending read per key — a promise marked
+`s = 0`, carrying `c` (its settle callbacks), owned by the table
+(`then(undefined, noop)`, so a read nobody makes is not an unhandled
+rejection). The key's `apply` settles it (stamped `s = 1` / `v`, the marks a
+fill's prop read adopts synchronously at a t=0 claim — the stamp moved into
+the lazy chunk with the read) and runs its callbacks; `close(error)` rejects
+every read still pending (stamped `s = 2`; the response's error record when
+it ended by one, else an `Error` naming the key) and runs theirs; a second
+`close` is a no-op. A delivered value that is itself a promise carries no
+mark and is taken as the value it is (DR-2's value tier: the fill's own
+boundary holds it).
+
+**What frames kept.** `settleArgs` counts a record's pending reads
+(`record.pending`: `instanceof Promise && s === 0` — `instanceof` before
+the mark, because a decoded value may be a live container whose property
+reads throw not-ready) and pushes one `settle` per read on its `c`: the
+last to settle re-applies the record through one `applyTo(id, version, r)`
+fan-out (shared with `apply`) if the record is still the store's — a bump,
+a re-sent record under the same version or a staged refetch's preview make
+it not. The end arm tells the integration the response ended
+(`FrameHostOptions.closeData(frameId, version, error?)`); the shared host
+closes `tables.get(id)?.get(version)` — never minted for a response that
+carried no data, never a superseded version's. `pendingRef`, `settleWait`,
+the per-store `waits`, `write`'s reset of them, the data arm's lookup and
+the end arm's loop are gone.
+
+**Two things the build found that the edit could not.** (i) The settle
+must be a **callback the table runs at the delivery**, not the promise's
+own `then`: a delivered value that is itself a pending promise is ADOPTED
+by the read (`resolve(value)` follows a thenable), so `.then(settle)` fired
+only when the inner value landed — the fresh mount never ran at delivery
+and the fill's `<Loading>` never showed (`frames-client` "suspends an async
+slot arg", the three `container-args` pins, `frames-container-lazy-codec`
+red). The old `settleWait` re-applied synchronously inside the data arm;
+the callbacks restore exactly that timing. (ii) The mark check must not
+read a property of the value: a pending live container's trap throws
+not-ready on `resolved.s` (REACTIVITY_HALTED in the container pins);
+`instanceof Promise` is a prototype walk (the store proxy has no
+`getPrototypeOf` trap) and is the probe.
+
+**One soundness item the design did not name.** `tableFor` returns no
+table before the codec is resident, so a `{$ref}` resolved ahead of any
+`data` chunk would have had no table to mint its read (the host used to
+answer that case itself). The transport now awaits `prepareData` before a
+`slot` chunk whose args carry a `{$ref}`, as it does before a `data` chunk
+(61 min / 7 br). On the producer's wire this await is already answered —
+the sink emits the data chunk ahead of the record that names it
+(`start → data → slot → html → complete`, probed) — so nothing is delayed
+in production; RFC 11's order-independence holds for hand-framed streams
+(the C5 / C6 shapes) because the slot chunk now queues behind the load.
+
+**Why the glue is +110 br, not +40.** The row budgeted the count and the
+re-apply (≈ 120 min — about what `settleArgs`' pending block costs) and
+nothing for the seam: the response's end has to reach the table (`closeData`
+in the host + the integration ≈ 190 min), the read has to exist before the
+codec (the transport's 61), and brotli no longer folds the end arm's
+rejection against the landing's (the ceiling's −280 vs the row's −289).
+Not golfable below ≈ −170 without changing the seam's shape (the
+`applyTo` helper was the one fold left, −8 br).
+
+### 3.3 The lean re-ask (item 6b)
+
+A7 records the call per address (`calls`, `callFor`) and re-invokes it by
+minting a server reference through the RPC seam, copying the declared
+metadata and honouring `GET` — 165 min for `reask` plus the two symbols,
+because `handle` sees `ctx = { id, meta, args }` and no callable. The leaner
+shape: the sf client's dispatch hands the response handler a **retry
+thunk** in `ctx` (`retry: () => dispatch(id, args, meta)` — the call shape
+it already has in hand, declared metadata included), and frames' re-ask is
+`callFor(address)?.retry?.()`. Frames −235 min / −74 br; the sf client
++≈ 100 min / +30 br (page base and live pay it; the frames eager scenario's
+sf slice has no `dispatchServerFunction`). The nine A7 pins are unchanged
+(GET stays GET by construction — the thunk is the original call). Public
+surface: the handler ctx gains `retry` (internal to the sf client ↔ frames
+seam; `ServerComponentHandlerOptions` unchanged).
+
+### 3.4 The fallback pass (item 4a) — DR-4's structural form
+
+The stream face's `$dfl` analogue: a `seg:<k>:fallback` record materializes
+the placeholder template's content once. 330 min / 79 br. It deletes under
+DR-4 (2c): the document fragment as a write into frame `""`'s store so the
+document runtime's `$dfr` / `$dfl` own both faces — "its own plan, ≈ 1.3 KB
+on whichever side goes", and A0 reverses DR-4's direction (a module `$dfr`
+in solid is ≈ +150 br on every hydrating page). **Leave it**: 79 br is not
+a reason to open DR-4.
+
+### 3.5 C1 — the holes tier (item 14)
+
+The plan's row C1 as drafted, plus what this pass found: the sink announces
+`assets` / `regions` / `wire` / `bind` / `trace` today and **not `holes`**
+— C1 needs `needs("holes")` at `createLiveHoles`' first `openBinding`
+(frame-sink, ≈ +30 min). Client: the chunk carries `#applyHole` /
+`#applyAttrs` (less the owned arms, C6's) / `findLiveTarget` / the hole pass
+/ `pumpLiveChannel` + the op log / `applyLiveOp`; the eager client keeps the
+record cases, one dispatch in `#flush` (`tierLoads.holes?.r?.flush(this,
+…)`), one in `drainRecords` (`?.pump()`), and the applier hand-off in
+`adoptBoundary` (host, id, address). Buffer-only: hole records stay pending
+in the store until the install's flush; the document stream buffers until
+the pump starts; no hold, no 3.1 question. Ceiling −504 br; glue ≈ +65 br
+(three dispatch lines + a loader entry — C5's dispatch glue was +67 br for
+the same count); **net ≈ −440**. The one decision it needs is the 8.0
+reading's reversal (plan §6 decision 1): holes were ruled eager as
+"transport incl. streaming values"; this is the single item that moves the
+end state across 10.0 with margin.
+
+### 3.6 Claims + `frame:applied` to the router (item 13)
+
+Phase D's row as drafted: the router installs `CLAIM_SEAM` and owns the
+sweep; the frames client keeps a ≈ 60-min seam the morph calls at the sites
+it claims today (`#applyRoot`, `#applyHole`, the segment swap, the fallback,
+the adopt-time sweep). Ceiling −291 br; net ≈ −270. Public surface:
+`FRAME_APPLIED_EVENT` leaves the client entry (the router's chunk exports
+it); behaviour: a sweep before the router's chunk loads misses the first
+morph's anchors — the router re-sweeps on install, as for CSR content.
+
+### 3.7 The `_$SC` mirror and `documentAddress` (items 2a, 2b)
+
+The mirror serves two pages: one whose hydration data scripts carried no
+reference (the server emits the bootstrap with the first reference each
+script serializes — a page with SC markup and no serialized reference has
+none), and a CSR boot. Deleting it needs the server to emit the bootstrap
+whenever the render used a server component (≈ +200 B of document output,
+only on SC pages) and `installServerComponents` to require `_$SC` (a dev
+error when absent). `documentAddress` goes with it once the t = 0 record
+carries the address to every mount (the bound path already does; the
+unbound direct-placeholder mount is the one that scans). Together −109 br;
+output-shape change, document face only.
+
+---
+
+## 4. The path to ≤ 10.0 KB
+
+Frames eager brotli, **each row measured as one edited dist** (C6's edit
+re-applied on this head as the base; the residue cuts composed on top; the
+non-SC scenarios 0 on every row). C2 is arithmetic (its own measurement on
+this head, −292), marked. "Glue owed" is the estimated carrier a ceiling row
+still has to pay; the "built" column subtracts it.
+
+| step | item | Δ br (row, measured) | **cumulative, measured** | glue owed (est.) | **built** (cum. − glue) | built, with C2 (−292, arith.) | gate / risk |
+| --- | --- | ---: | ---: | ---: | ---: | ---: | --- |
+| 0 | head `5c5991cbd` | | **13,083** | | | | |
+| 1 | **C6** bind tier (`tight-nopair`, in flight) | −1,243 | **11,840** | 0 (C6's glue is in) | 11,840 | 11,548 | C6's pins; `tier-bind-hold`; the click-replay finding (C6 P1) |
+| 2 | **the D list** (2a–2g) + the s / v stamp (10) + the nested marking (8a) + `FRAME_HAVE_*` off the entry (5a) | −349 | **11,491** | +10 (`readHydratedValue` export); the mirror's server half is output, not client bytes | 11,501 | 11,209 | 2a / 2b need the server to emit the bootstrap unconditionally; 2f / 5a / 10 are public-surface items; 2d / 2g are behaviour changes |
+| 3 | **the `preview` pull form** (1c; carrier sketched **and measured in the row**) | −277 → **−63 as designed** (step 2: the sketch's carrier was unsound and half-counted; §3.1 "As measured") | **11,214** (≈ 11,430 with the honest carrier) | 0 | 11,224 (≈ 11,440) | 10,932 (≈ 11,150) | **stopped** (carrier +483 > +300); C15 ×4, optimistic-hold ×3, morph-in-transition ×3 |
+| 4 | **R.insert** — every fill through `insert` (3) | −196 → **−287 built** (step 3; with the dead range mode) | **11,018** (built: 11,654 → **11,367**, row 3 not taken) | 0 | 11,028 | 10,736 | **landed** (§7c): `Slot` owns its range; C1 (b) re-pinned to the core's rule |
+| 5 | the fallback pass (4a) | −75 | 10,943 | DR-4 (its own plan) | — | — | **not recommended** (§3.4); kept to show it does not matter — the rows below are measured **without** it where marked |
+| 6 | **the lean re-ask** (6b) | −78 | **10,865** (10,940 without row 5) | pages +30 | 10,950 | 10,658 | **design** §3.3 (sf client ctx) |
+| 7 | **S-ref's pending read to the table** (12, ceiling) | −289 → **−174 built** (step 4: the ceiling −280 on step 3's head; the carrier +110 — the `closeData` seam, the transport's await, the count) | **10,576** (≈ 10,637 without row 5; built: 11,367 → **11,193**, rows 3 and 5 not taken) | **+40** frames (built +110); decode chunk +≈ 120 min lazy (built +420 / +161) | ≈ 10,687 | ≈ 10,395 | **landed** (§3.2 "As built", §7d); C5 ×4, C6 (a1), C17 (c), `sref-table-pending-read` |
+| 8 | **claims + `frame:applied` to the router** (13, ceiling) | −299 | **10,277** (≈ 10,338 without row 5) | **+20** seam | ≈ 10,408 | ≈ 10,116 | public surface (`FRAME_APPLIED_EVENT`); the router contract |
+| 9 | **C1 — the holes tier** (14, ceiling) | −516 | **9,761** | **+65** glue; server `needs("holes")` | ≈ 9,896 | ≈ 9,604 | **the 8.0 ruling reversed** |
+| 9′ | rows 1–4 + 6–9 (no fallback pass), measured as one dist | | **9,822** | +135 | **9,957** | **≈ 9,665** | the recommended set, every carrier in |
+| — | everything at its ceiling (no carriers: `stage` whole, `reask` whole, the style gate) | | 9,389 | — | — | ≈ 9,100 | the floor from here, not a build |
+
+(Pages on row 9′: base 119,044 → 108,460 min / 37,772 → **34,701** br; live
+130,915 → 120,332 / 41,427 → **38,355** — before C2's −264 / −258 and the
+glue.)
+
+**Where it crosses — built (glue in), no fallback pass:**
+
+| set | built br | with C2 (−292) | vs 10,000 (with C2) |
+| --- | ---: | ---: | ---: |
+| rows 1–4 + 6 (the residue proper, every carrier in) | ≈ 10,950 | ≈ 10,658 | +658 |
+| + row 7 (S-ref to the table) | ≈ 10,687 | ≈ 10,395 | +395 |
+| + row 8 (claims to the router) | ≈ 10,408 | ≈ 10,116 | **+116 — does not cross** |
+| + row 9 (C1 holes) instead of row 8 | ≈ 10,236 | ≈ 9,944 | **−56 — crosses with no margin** (over by 52 without the `_$SC` mirror + `documentAddress`) |
+| + rows 8 **and** 9 | **≈ 9,957** | **≈ 9,665** | **−335 — crosses, ≈ 330 B of margin** (−43 without C2) |
+| the same without the `_$SC` mirror + `documentAddress` (2a, 2b: −108) | ≈ 10,065 | ≈ 9,773 | −227 |
+
+**The stall.** The residue proper — the pull form, the D list, R.insert, the
+lean re-ask, S-ref to the table — is **≈ 1,450 br** on top of C6 and stops
+at **≈ 10.4 KB with C2** (≈ 10.7 without). Crossing 10.0 with margin needs
+**both** of the two feature moves the plan deferred to Phases C1 / D: the
+holes tier (≈ −450 net) **and** the claims chunk (≈ −280 net); C1 alone
+(with C2 and the mirror) lands ≈ 55 B under — no margin — and the claims
+chunk alone ≈ 115 B over. What stays at ≈ 9.65 is: the
+transport (`T.wire` / `T.store` / `T.slots` / `T.morph` / `T.doc` /
+`T.decode` / `T.flight` / `T.refs` ≈ 22,000 min — the morning's T less its
+hole-op half and less R.insert), the correctness seams Phase A built
+(S-flush's landing node, the error face, S-hold, the version-keyed tables,
+S-ref's pending count — ≈ 2,400 min / ≈ 750 br, every one pinned by the
+contract), B's mechanism with the four tiers' triggers (≈ 1,300 min / ≈ 400
+br — §2's `unify` shows it has no slack), and the eager remnants of the cut
+tiers (the regions drain arm, the assets record cases and gate, the trace
+probe — ≈ 900 min / ≈ 280 br, each a "kept eager" line of its step). None
+of those is deletable without a wire or ruling change. The incremental
+route has exactly two tierable things left (holes, claims) and it needs
+both.
+
+---
+
+## 5. Recommendation
+
+In this order; each row's gate is the plan's (named pins flip or stay
+green, `scripts/size` at or under its cap with the ratchet, the harness's
+two seeds clean):
+
+1. **C6, as designed** (in flight; −1,243). Nothing here changes it.
+2. **The D list without the mirror** (2c, 2d, 2e, 2f, 2g + the stamp export
+   10; ≈ −210 br in context) in one small PR, each item's consequence
+   flagged: the second dispose map and the zombie heuristic are free; the
+   capture arm, the imperative branch and the brand are small behaviour /
+   surface changes to rule on individually. Take `FRAME_HAVE_*` off the
+   entry with C2, not here; take the mirror and `documentAddress` (−108)
+   only with the server's unconditional bootstrap (§3.7). **Landed as
+   residue step 1 (§7)** with 2b and 5a pulled in and 2d / 10 left out:
+   2d is pinned, 10 has no export to re-use.
+3. **The `preview` pull form** (§3.1; −277 with its carrier). The one design
+   with a real payoff and a real risk surface — build it against the carrier
+   sketch's budget (+242 br), with C15 ×4 and optimistic-hold ×3 as the
+   gate. It also simplifies the handler (no `stage` / `latest` / `named` /
+   token) and `applyFlightResponse` (regions bump per frame, no staged-region
+   map). **Stopped (residue step 2, §3.1 "As measured" / §7):** the token
+   cannot go (it is the delivery), the honest carrier is +483 br over the
+   −546 ceiling, net −63; not recommended at that price.
+4. **R.insert** (−196) with the marker-less `createFrame` path ruled (an
+   anchor requirement on `createFrame`, documented). **Landed as residue
+   step 3 (§7c): −287 built** — the no-range fallback removed (a range
+   without its end marker is left as rendered), the `Slot` contract made
+   "the fill owns its range", the runtime's dead comment-marker range mode
+   deleted with it (the frame element IS the range); C1 (b) re-pinned to
+   the core's mismatch rule — the one ruling the step took, flagged in the
+   PR.
+5. **S-ref to the table** (§3.2; ≈ −250 built) — a decode-chunk change plus
+   a host simplification; worth it on its own terms (the pending read lives
+   where the keys live). **Landed as residue step 4 (§7d): −174 built** —
+   the ceiling held (−280) but the carrier is +110, not +40: the response's
+   end has to reach the table (`closeData`), the read has to exist before
+   the codec (the transport awaits it for a `{$ref}`-carrying slot chunk),
+   and the settle is a callback at the delivery, not the promise's `then`
+   (a delivered promise value is adopted). The decode chunk grew +161 br
+   (lazy).
+6. **The lean re-ask** (§3.3; −78 frames, +30 pages). **Landed in residue
+   step 1 (§7): −99 frames, and the pages shrink too (−30 / −65).**
+7. **C2** (−292), taking `FRAME_HAVE_*` off the entry with it (−28 more if
+   the two constants leave the client surface).
+8. **C1** (§3.5; ≈ −450 built) — the first decision item: it reverses the
+   8.0 reading.
+9. **Claims to the router** (§3.6; ≈ −280 built) — the second decision item
+   and Phase D's; it needs the router's own chunk to ride.
+
+**End state with 1–9 built and every carrier in: ≈ 9.67 KB (≈ 9.77 without
+the mirror).** With 1–7 only: ≈ 10.4 — over. With 1–8 (C1 but not claims):
+≈ 9.94 with the mirror, ≈ 10.05 without — at the line, no margin. With 1–7
++ 9 (claims but not C1): ≈ 10.12 — over. **The target is reachable
+incrementally, but only with both remaining tiers, and the margin is one
+mid-sized item (≈ 330 B).**
+
+**Leave:** the fallback pass (DR-4 is not worth 79 br), the style gate, the
+declared-record arms, the hold's owner wrap, the dispose guard, the two
+golfs, and the unification of the tier dispatch (measured at zero).
+
+---
+
+## 6. Caveats
+
+- **Brotli context.** The path rows are measured as single edited copies, so
+  the cumulative column is real; the "with C2" column is arithmetic (C2's
+  own measurement on this head, −292), and the per-item single-cut figures
+  in §2 do not sum to the combined rows (they are each against the
+  unchanged head). The ±30 br drift between the sum of singles and the
+  combined rows is the usual context effect.
+- **The pull-form carrier is a sketch**, not a working implementation: it
+  parses, carries no dangling identifier, and has the shape §3.1 describes,
+  but no pin ran against it. Its +242 br is the budget to build against,
+  not a ceiling — B's first honest cut golfed from +233 to +145; C3–C5's did
+  not golf below their first cut.
+- **The ceilings of rows 7–9** (S-ref to the table, claims, holes) have their
+  glue estimated (+40 / +20 / +65 br) from the pattern this pass measured on
+  C3–C5 (one dispatch line ≈ 20–25 br; a loader entry ≈ 11–15 br). They are
+  not ×3-of-a-loader-line estimates — they count the hand-offs — but they
+  are estimates.
+- **C6 is re-applied, not re-measured by C6**: its `tight-nopair` edit
+  applies cleanly to this head's dist and measures −1,243 here against
+  −1,256 on C4's head. C6 as it lands may differ by its own golfing; the
+  path's row 1 is C6's to confirm.
+- **The D list's behaviour items** (the capture arm, the brand, the
+  imperative branch, `documentAddress`) were measured, not pinned: §2 names
+  the pins to check for each. The morning's "unpinned" for the capture arm
+  stands; the brand and the imperative branch may have pins this pass did
+  not run.
+- **Class totals in brotli** are measured for R (844) and D (300) by cut;
+  F (≈ 2,300) and T (≈ 9,640) are derived — F from C6 + C2's deletion +
+  claims measured plus the three tiers' eager remnants estimated, T by
+  subtraction.
+- **`FRAME_HAVE_*`'s 28 br is the scenario's**, not a page's: the pages
+  tree-shake the two exports already; the frames eager scenario measures
+  the whole entry with its export list, so an exported constant costs it
+  what it would cost a consumer that keeps the whole module.
+- Nothing here changes an engine or a wire; the two wire-adjacent items
+  (`needs("holes")`, the unconditional bootstrap) are named as the decisions
+  they are.
+
+---
+
+## 7. Landed — residue step 1 (2026-10-06)
+
+Branch `size/frames-residue-1` on C6's head (`feat/frames-bind-tier` @
+`e7d6e9e34`: frames eager **36,007 / 11,901**; page base 115,087 / 36,647;
+page live 126,964 / 40,286). §5's rows 2 and 6, plus 5a pulled forward from
+row 7 (it needs nothing of C2). Every item measured on an edited dist copy
+of THIS head before writing (the same method as §0; single cuts against the
+head, the combination as one copy), then the real build. min / br.
+
+| item | §2 row | measured, alone | **built** (in the combination) | note |
+| --- | --- | ---: | ---: | --- |
+| `documentAddress` + its call | 2b | −95 / −44 | in | a mount with no binding binds the function id; `adopted-claim-args-address.spec` mounts the binding (the production shape) and asserts the store |
+| the second dispose map | 2c | −73 / −24 | in | the range binding's `insert` under the fill's owner where there is one, else its own, registered in `fillScopes` |
+| the capture arm (`contentHTML` + last-unmount) | 2d | −272 / −90 | **not taken** | **pinned** — `lifecycle-matrix/remount` › "away/back over a t=0 adopted boundary: the interior captured at unmount re-materializes instantly"; §2 called it unpinned. Deleting it shows the covering `<Loading>`'s fallback across an away/back of an SSR'd boundary while the refetch is in flight — a ruling, not a cut |
+| the zombie heuristic + `#slotNodes` | 2e | −186 / −68 | in | the map's only reader was the check (C6 had already dropped the data-occurrence writes), so the map went with it — hence more than §2's −104 / −35 |
+| the imperative branch of `#revealSegment` | 2f | ceiling −121 / −30; **default seam −34 / −19** | in (the seam) | `FrameOptions.reveal` stays optional: `revealAtOnce` inserts `content()` before the closing comment at once. One reveal path; a placeholder without its closing comment is not revealed (the boundary path threw on the null anchor before) |
+| `showing`'s brand | 2g | −95 / −20 | in | c16 / c17 / the hydration suite green: the t=0 reference is the bootstrap's binding, branded there |
+| the D list together (2b, 2c, 2e, 2f-seam, 2g) | 2 | **−721 / −210** | | |
+| `FRAME_HAVE_*` off the client entry | 5a | −63 / −25 (pages 0 / 0) | in | removed public surface; the server entry keeps both; no consumer in the repo or the router's dist |
+| the lean re-ask | 6b | **−260 / −99** frames; pages −230 / −30, −235 / −65 | in | the sf client's `ctx.retry` / `info.retry` thunks cost the pages ≈ +80 min and the pages still shrink — better than §3.3's +30 br estimate, which did not count the RPC-seam code the pages also shed. `createServerReference` left the RPC slot |
+| the s / v stamp | 10 | — | **skipped** | `readHydratedValue` is module-private in `solid/src/client/hydration.ts` (`(initP, refresh, options)`, with a loading-window arm); exporting it is a new `solid-js/internal` export, not a 0-B re-export. The frames copy still lacks #2997's rejection-observe for `s === 2` — a correctness note for the maintainer, not a size item |
+| **everything, one edited copy** | | **−1,045 / −342** (with 2d) → ≈ −250 br without | **−757 / −247 → 35,250 / 11,654** | pages −665 / −159 and −670 / −161; non-SC 0 / 0 |
+
+**Running number: frames eager 11,654 br — 1,654 B above ≤ 10.0 KB.** §4's
+row 2 estimated −349 for the step with the mirror, the stamp and the capture
+arm; without those three the step came in at −247 as built (the row's
+remaining items measured −210 + −25 + −99 as singles and −342 in context
+_with_ the capture arm; brotli context cost ≈ 30 B against the singles'
+sum, as §6 says it would).
+
+Left for later steps, from this one: the `_$SC` mirror + `documentAddress`'s
+server half (§3.7 — the mirror alone, now that `documentAddress` is gone);
+the capture arm, which needs a ruling on the away/back behaviour of an
+SSR'd boundary; the stamp, which needs a `solid-js/internal` export.
+
+## 7b. Measured, not landed — residue step 2 (2026-10-06): the `preview` pull form
+
+Branch `size/frames-residue-2-pull-form` on step 1's head (`fce81d2c0`,
+frames eager **35,250 / 11,654**). §5 row 3, measured before writing per the
+step's rule (ceiling, then the carrier as it would be written, both on an
+edited dist copy through the harness's bundler) — and **stopped at the
+carrier budget**: the rule was "if the carrier exceeds +300 br, stop and
+report the design". Nothing of the form reached source; the step's one
+source change is a pin.
+
+| item | measured on this head | note |
+| --- | ---: | --- |
+| the ceiling — `stage` whole out (§2 row 1b) | **−1,645 / −546** (pages −555 / −499) | matches the row's −542 |
+| the sketch's carrier (`pullcarrier`, §2 row 1c) | +840 / +242 (the row's figure) | **unsound**: it deleted the content token; `dynamic` delivers a kept resolution only when its address differs, so without the token a same-address refetch never runs the follow's compute half or any fill memo in the transaction (#3844's gap (1); C15 (a, b), the optimistic-hold multi-flight arms) |
+| the carrier as the step would have written it (§3.1 "As measured") | **+1,414 / +483** over the ceiling → **−231 / −63 net** (pages −29 / −37) | token 227 / 88 · flight-path staging 176 / 54 · nested regions 152 / 53 · the lane gate 106 / 29 · the host's staged set with promote's landing / L1 / waits ≈ the rest; every one load-bearing |
+| the unsound floor (no flight, no regions, no gate) | +980 / +339 | still over the +300 budget |
+| **built** | **—** | stopped; frames eager stays **11,654** |
+
+**Pin added (by name, green on the push form):** `c15-staging-atomic` (e) —
+the gap #3844 named: a same-address refetch enters the transaction (the
+fill derives the new arg in its pass — `seen` is `["one", "two"]` while the
+DOM, `frame:applied` and the frame's version still show v1), and the commit
+lands it whole. Any carrier of the staging — push or pull — must keep both
+halves.
+
+What this changes in the path (§4): row 3's −277 becomes ≈ −60 as a sound
+build, so the residue proper (rows 2–4, 6) stalls ≈ 215 B higher than §4
+says; crossing 10.0 still needs C1 and the claims chunk, with ≈ 120 B of
+margin instead of ≈ 330. The push form stays, as #3844 left it.
+
+## 7c. Landed — residue step 3 (2026-10-06): R.insert, every fill through `insert`
+
+Branch `size/frames-residue-3-insert` on step 2's head (`f12708386`, frames
+eager **35,250 / 11,654**; page base 114,422 / 36,488; live 126,294 /
+40,125). §5 row 4. Measured before writing on an edited dist copy through
+the harness's bundler (§0's method; `.wt-logs/res3-edit.mjs`,
+`res3-measure.mjs`): the ceiling, then the carrier as the step would write
+it, in two forms — with the frame runtime's range writer kept for the raw
+`Slot` contract, and without it. min / br; the four non-SC scenarios 0 / 0
+on every row.
+
+| edited dist | frames eager Δ | page base / live Δ br | note |
+| --- | ---: | ---: | --- |
+| the ceiling (§2 row 3's cut re-applied: `normalizeSlotContent`, `isReactiveContent`, `settle`, the no-range fallback, `#replaceRange` + its two call sites) | **−769 / −230** | −195 / −172 | the row measured −713 / −207 on #3860's head |
+| the carrier, `#replaceRange` KEPT (the raw `Slot` "return nodes" contract preserved; one `insert(end.parentNode, value, end, [...existing])`; a range without an end marker left as rendered) | −600 / −160 | −185 / −166 | compatibility costs **69 br** |
+| the carrier, `#replaceRange` gone (the `Slot` callback owns its range) | **−791 / −229** | −233 / −210 | |
+| the dead comment-marker range mode of `FrameImpl` alone (`#start` / `#end` null on both constructors; `#parent`, `#firstContent`, `#clearContent`, the `end` bounds passed as null) | −196 / −67 | −3 / −99 | not in §2 — found while making "the frame element is the range" literal |
+| **the carrier without `#replaceRange` + the range mode, one copy** | **−988 / −301** | −268 / −247 | |
+| **built** | **−978 / −287 → 34,272 / 11,367** | **−217 / −221** → 113,443 / 36,271 and 125,315 / 39,904 | +10 min / +14 br over the copy: the no-gather flag on the fill's second claim window and the transparent binding owner (below) |
+
+**What `insert` now owns.** Every fill of the Solid binding is
+`insert(end.parentNode, value, end, [...ctx.existing])` under the fill's
+owner (its own for a stream-mounted fill; a transparent owner minted for a
+live-render one, registered in `fillScopes` so a re-call disposes the
+previous binding before the next renders). A static value is placed once
+with no effect (`insertExpression` with no render effect); a reactive one
+binds the range as before; a stream re-call reconciles the new output
+against the previous (`existing` seeds the tracked array); an adopted fill
+places inside a claim window, so `insertExpression`'s claim pass carries
+the claim: in-place output moves nothing, and a render whose nodes never
+entered the DOM is the core's hydration mismatch — the server's nodes stay,
+hydration reports them unclaimed. Deleted: `normalizeSlotContent` (274),
+`isReactiveContent` (111), `settle` (the in-place test with its `contains`
+lenience), the no-range snapshot fallback, `#replaceRange` (94) and the
+returned-nodes path (`#invokeSlot`'s return, the two `#syncSlots` sites,
+`regions.bind`'s `start` re-scan), and the runtime's comment-marker range
+mode — `FrameImpl(element, options)`; the frame element IS the range.
+
+**Two things the build found that the edit could not.** (i) The fill's
+second claim window (the one around the `insert`) must **not gather**: the
+first window's gather is still in the registry, and gathering the prefix
+again put every key the evaluation had just claimed back as unclaimed —
+20 hydrate files red with "unclaimed server-rendered node" until
+`claimRender` took a `bound` flag (the reactive path had the same latent
+re-gather; it was masked because its content claims inside the second
+window). (ii) The minted binding owner must be **transparent**: a
+non-transparent `createOwner()` inside the hydrate pass consumes a child id
+from the adopting component's counter, so a keyed sibling after the frame
+keyed differently depending on whether a fill mounted at t=0 or after a
+hold (`container-trace-hold-id-determinism` — '4' vs '6'). The reactive
+path's old `createOwner()` had this consumption too; it is gone for every
+fill now.
+
+**The one pin re-pinned — a ruling for the maintainer.** `c01-claim-once`
+(b) asserted that a fill answering the t=0 claim with FRESH nodes (built
+outside the claim walk) is replaced into the range by the frame — the
+server node leaves the document. That was `settle` + `#replaceRange`'s
+rule, and it is exactly what R.insert deletes: under `insert`, a claim pass
+moves nothing, so the fresh render is dropped, the server node stays, and
+hydration reports it unclaimed — the rule every compiled hole already has.
+Arm (b) now pins that (the server node stays, nothing duplicated, one
+"unclaimed" warning naming `sc-<fid>-item#1-`), the contract's C1 text
+reads "left as the server rendered it and reported" for the second arm,
+and the PR names it first under Pins. Everything else green unchanged:
+C1 (a, c), C9 ×3, C10 ×3, C14, the hydrate suite (87 / 446), the lifecycle
+matrix, `tier-bind-hold`, `adopted-swap-post-done`, `boundary-arrival`;
+web client 129 / 1,194, server 159 / 1,511; harness 500 × {3289, 91501}
+SC arm 0, generic arm (`CONSISTENCY_IGNORE=C1,C9,C19,E`) 0.
+
+**Public surface** (`@experimental`): `Slot` is `(props, ctx) => void` —
+the callback places or binds its output before `ctx.range.end` over
+`ctx.existing`; a returned node is no longer placed (before: `Node |
+Node[] | undefined`, nodes placed by the frame, `undefined` = claim). The
+four raw-frame tests (`lifecycle-matrix/call-driven-slots` ×2,
+`server/frame-hn` ×2) place through `ctx.range`. `createFrame(boundary:
+Element, options?)` / `createFrameElement(options)` signatures unchanged;
+the internal constructor is `FrameImpl(element, options)`.
+`SlotContext.range` is documented as absent for a range whose end marker
+is missing (that range is left as the server rendered it; dev already
+reports `FRAME_MARKER_CORRUPTED` at discovery — before, the Solid binding
+filled it at the parent's end from a snapshot).
+
+**Running number: frames eager 11,367 br — 1,367 B above ≤ 10.0 KB.**
+§4's row 4 estimated −196; built −287 with the range mode. The residue
+proper's remaining rows: S-ref to the table (§3.2, ≈ −250), then C2, C1,
+the claims chunk.
+
+## 7d. Landed — residue step 4 (2026-10-06): S-ref's pending read in the decode table
+
+Branch `size/frames-residue-4-sref-table` on step 3's head (`8a0b090cf`,
+frames eager **34,272 / 11,367**; page base 113,443 / 36,271; live 125,315
+/ 39,904; the lazy `decode.js` chunk of the page scenarios 22,990 / 6,076).
+§5 row 5 / §2 row 12. Measured before writing on edited dist copies of the
+frames client and the decode entry through the harness's bundler
+(`.wt-logs/res4-edit.mjs`, `res4-measure.mjs`); the four non-SC scenarios
+0 / 0 on every row. min / br.
+
+| item | measured on this head | note |
+| --- | ---: | --- |
+| the ceiling — the host's pending-read machinery out whole (`pendingRef`, `settleWait`, the waits in `write` / the data arm / the end arm, `record.pending`'s test) | **−879 / −280** (pages −300 / −297) | the row measured −884 / −289 on #3860's head; unsound alone (a record applies with `undefined` for an undelivered key) |
+| the carrier as designed: the table's pending read (`s = 0`, stamped `s`/`v`, `close`), the count + one settle per read, `closeData` host + integration, the transport's await for a `{$ref}`-carrying slot chunk | −485 / −162; decode +382 / +140 | +394 min / +118 br over the ceiling — the row estimated +120 / +40 |
+| the transport's await alone | 61 / 7 | kept: without it a `{$ref}` resolved ahead of the codec has no table to mint its read |
+| one `applyTo` fan-out shared by `apply` and the settle | −519 / −170 | the shape built; the one fold left |
+| **built** | **−505 / −174 → 33,767 / 11,193**; pages **−200 / −157** → 36,071 and 39,747; **decode.js +420 / +161** → 23,410 / 6,237 (lazy, reported not counted) | +14 min / −4 br over the copy: the settle as the table's callback (not the read's `then`), the `instanceof` guard — §3.2 "As built" |
+
+**The table's behaviour** (`createJSONDataTable`, `@internal` on the
+integration-facing type): a `{$ref}` to a key no `apply` has delivered is
+a promise the table owns, marked `s = 0`, carrying `c`; the key's `apply`
+settles it (stamped `s = 1` / `v`) and runs `c`; `close(error)` rejects what
+is still pending (stamped `s = 2`; the response's error, else an `Error`
+naming the key) and runs `c`; idempotent. **What frames deleted:**
+`pendingRef`, `settleWait`, the per-store `waits` and `write`'s reset of
+them, the data arm's wait lookup, the end arm's rejection loop, the error
+string. **What it kept:** `record.pending` (a fresh mount waits for its
+record; the covering `<Loading>` pends on the landing alone; a mounted
+occurrence's prop pends and holds — A17), one `settle` per read that
+re-applies the record if it is still the store's, and `applyTo`.
+
+**Two things the build found** (§3.2 "As built"): the settle must be the
+table's callback at the delivery — a delivered promise value is adopted by
+the read, so its `then` fires at the inner value (five pins red:
+`frames-client` DR-2, `container-args` ×3, `frames-container-lazy-codec`);
+and the mark must be read behind `instanceof Promise` — a pending live
+container's property trap throws not-ready.
+
+**Pins.** C5 (a, b, c, d, e), C6 (a1, a2, b1, b2, c, control), C17 (c), the
+`{$ref}` rows of the lifecycle matrix (`call-driven-args` ×13 refs,
+`container-args`), `frames-flight-delivery`, `adopted-slot-late-record`,
+c01, c03 (a), c04 (b), c09 (c), c10 (b), c14 (a), c19 (b, c, e), every
+`frames-*` / `hydration/*` suite green unchanged. **Added:**
+`consistency/sref-table-pending-read` — (a) the table's lifecycle (one read
+per key, the mark, the stamp, callbacks at delivery even for a
+promise-valued key, `close()` naming the key, `close(error)` with the
+response's own, idempotence); (b) L1 through the production shared host (a
+never-delivered key rejects at `complete`; the fill's read throws to the
+nearest `<Errored>` naming the key; nothing fabricated reached the fill);
+(c) the control (delivered before `complete`; nothing rejects). No earlier
+pin reached the rejection. Web client 129 / 1,194; hydrate + consistency
+88 / 449; server 159 / 1,511; `types` + `test-types` clean; harness 500 ×
+{3289, 91501}: SC arm 0, generic arm (`CONSISTENCY_IGNORE=C1,C9,C19,E`) 0.
+
+**Public surface** (`@experimental` / `@internal`): `FrameHostOptions.
+closeData?(frameId, version, error?)` added — the host tells the
+integration a response ended; `FrameHostOptions.resolve` keeps its
+signature, its answer for an undelivered key is now the table's pending
+read (the integration no longer returns `undefined` for "not delivered");
+`FrameHostOptions.prepareData` is awaited before a `slot` chunk carrying a
+`{$ref}` as well as before a `data` chunk; `JSONDataTable.close(error?)`
+added and `resolve`'s pending read documented (`@internal` behaviour on the
+integration-facing type). Behaviour, no surface: the L1 error names the
+key (`Stream ended without delivering {$ref: "k"}`; before: `Frame stream
+ended without delivering a {$ref}.`).
+
+**Running number: frames eager 11,193 br — 1,193 B above ≤ 10.0 KB.**
+§4's row 7 estimated −250 built; −174 landed. The residue proper is done
+(rows 2, 4, 6, 7 landed; row 3 stopped); what remains is C2 (−292), C1
+(≈ −440) and the claims chunk (≈ −270) — the two decision items.
+
+---
+
+## 7e. Landed — C2 (2026-10-07): the live wire tier, `lean`
+
+Branch `feat/frames-wire-tier` on step 4's head (`55eb4c346`, frames eager
+**33,767 / 11,193**; page base 112,938 / 36,071; live 124,810 / 39,747).
+§2's C2 row (−292, arithmetic) and the savings plan's §3 row C2. The
+maintainer's ruling: the `lean` form, with `FRAME_HAVE_*` already off the
+entry (5a), the hook on `responseHandler.onLive` (not a config key),
+`Frame.have?()` leaving the public `Frame` interface (approved class), the
+trace update-site wait landed apart (#3861). Re-measured before writing on
+edited dist copies of the frames client and the sf client through the
+harness's bundler (`.wt-logs/c2b-edit.mjs`, `c2b-measure.mjs`) — the
+step 1–4 base had moved under the phase-1 edits (the sync loop,
+`insert`-placed fills, the table-owned pending read), so every anchor was
+re-derived; the four non-SC scenarios 0 / 0 on every row. min / br.
+
+| item | measured on this head | note |
+| --- | ---: | --- |
+| the ceiling (`del`) — the wire out whole: `connections` / `hold` / the join-or-hold arm, `resume` + `encodeHaveList`, the ledger (`#have` / `have()` / `#recordHave`), `applyFrames`' connection wiring, `isEventStream` + the reader selection | **−1,432 / −472** (pages −1,404 / −483 and −1,399 / −464) | unsound alone: a live response read as a plain stream, no reconnect |
+| `lean` — the tier owns the connection, the ledger and the resume; the client keeps the await-residency arm, `onLive`, `resume` delegating, `#recordHave` forwarding through `tierLoads.wire?.r` | **−965 / −310** (pages −979 / −285 and −946 / −300) | the carrier ≈ +467 / +162 over the ceiling |
+| the hook alone (`onLive` fired by `live()`'s `makeIterable`) | ≈ 20 / 15 (page live +85 br) | the config-key form measured ≈ 45 br heavier on the pages |
+| the ledger's residue (`#recordHave` ×3 forwarding) | ≈ 112 / 27 | kept: the digests are known only to the client's apply |
+| the field residue (the record fields the ledger reads) | ≈ 106 / 14 | kept: they feed the apply too |
+| **built** | **−965 / −305 → 32,802 / 10,888**; pages **−349 / −335** → 35,722 and 39,412; **`wire.js` 1,922 / 934** (lazy, reported not counted) | +0 min / +5 br over the copy |
+
+**What the tier owns** (`frames/src/wire-tier.ts` → `@solidjs/web/frames/wire`,
+`@internal`): `connect(response, wire, address, binding, host, bump, begin)`
+— a live response's connection: the join of a second loop onto an address
+whose connection is not done (one wire per address; the second loop reads
+the same store), else `bump` / `begin`; the reader (`wire.open(body)` for
+an event stream — the loop's `EventStreamReader`, which records each event's
+`id:` as the position — else a `ChunkReader`), proxied so a drained body
+applies nothing further; the open-frame count the body's end is judged by
+(`start` opens, `complete` / a keyless `error` closes; a nested region's
+chunks ride inside its parent's) — an end with frames open is a death the
+loop reconnects from, with none a completion; `connection.ended` / `cancel`
+(supersession by a later response for the address cancels the reader,
+which ends the drain as a clean body end); `have(frame, key, record)` /
+`haveOf(frame)` — the have-list ledger per mount (RFC 11 §9.5): the root
+apply resets it to the root digest plus the holes' (`""` → `{ "": digest,
+…holes }`), a hole / attr / reveal apply sets its key; `encodeHaveList`
+(the `FRAME_HAVE_HEADER` / `FRAME_HAVE_BUDGET` literals bundled — they were
+already off the entry); `resume(host, info, versions)` → `{ position:
+String(version), headers: { [FRAME_HAVE_HEADER]: encoded } }` for an
+address the host shows, else `undefined`; `cancel(host, address)`.
+**What the client kept:** `applyFrames` takes `options[LIVE_WIRE]` as its
+reader (one line); `handle`'s live arm — `prepareTier("wire").then(() =>
+tierLoads.wire.r.connect(…))` — awaits residency, never reads the body
+without the tier; `onLive() { prepareTier("wire") }`; `resume(info)`
+delegating; `bump` ending with `tierLoads.wire?.r?.cancel(host, address)`;
+`#recordHave(key, record)` forwarding to `tierLoads.wire?.r?.have(this,
+key, record)` at its three sites. **The hook:** `live()`'s `makeIterable`
+fires `handler.onLive()` before the first fetch, per call — the import
+races only the request, and the arm awaits it, so a live connection
+without the chunk is impossible by construction; a non-live call never
+loads it.
+
+**The degraded case, accepted.** Content applied before the chunk was
+resident (`#recordHave` forwarded to nothing) kept no ledger, and `resume`
+— the tier's — answers nothing while the tier is absent: that first
+connect sends neither `X-Frame-Have` nor `Last-Event-ID` and gets a full
+snapshot. The plan's row described it as "the ordinal with no have-list";
+the `lean` form drops the ordinal too, and the server never read it for a
+frame render (`liveSource` compares `Last-Event-ID` to a value digest a
+frame answer does not have; only `decodeHaveList(X-Frame-Have)` is read in
+the frame sink) — the same full snapshot either way. Pinned as accepted in
+`tier-wire-preload.spec` (3): the plain call's content lands with its
+digests while the tier is gated, the live call's first connect carries
+neither header, the tier's release lands the live root, the reconnect
+after a death carries `Last-Event-ID` and the live root's ledger.
+
+**Pins.** `consistency/tier-wire-preload.spec` (3) — the hook starts the
+import synchronously at the call, before any fetch; the arm awaits
+residency (chunks sent, nothing applied, the fallback shown, no status) and
+the release lands the content; `X-Frame-Tiers: wire` on a live response
+joins the same load (the loader called once); a non-live call never loads
+the tier and its refetch bumps nothing of the tier's; reconnect through the
+tier with `Last-Event-ID` and the have-list, the morph in place, the
+completion closing; the degraded first connect. `frames-live-resume`
+re-pointed to the tier's `haveOf` / `encodeHaveList`; `frames-live` and
+`frames-live-showing` warm the tier (`beforeAll(() => prepareTier("wire"))`
+— resident cells). **The coverage closure** the savings plan tied to this
+row: `server-functions-live-loop.spec` (19, client suite) drives `live()`'s
+loop over hand-framed bodies — the codec's chunk stream and the same
+payloads as server-sent events with `id:` lines — ending as the test says
+(cleanly, dropping, hanging until the request's signal): the
+non-server-function throw, a handler without `intercept`, a first-connect
+failure as the call's rejection (no status, no retry), a death reconnecting
+on the `online` wake with the reader's cursor as `Last-Event-ID`, the
+fail-fast 4xx closing with the error, 408 / 425 / 429 retrying, `Retry-After`
+naming the wait, `return()` mid-connect (the arriving stream closed, the
+wire severed) / mid-backoff (the sleep cut) / mid-seed (a late local answer
+not yielded), `invoke`'s signal mid-stream (a rejection, ended for good) /
+mid-backoff (the sleep woken, the connect refused), a host without a global
+`EventTarget`, `live(GET(fn))` at the live address over GET, the handler's
+local answers (a hit at the call yielded first and adopted; a deferred hit
+awaited, settling to a value or to nothing; a miss at the call but a hit at
+connect — one value, no wire). `live`'s per-function branch coverage by the
+audit's §2.4 method (v8, client + hydrate suites, merged): **26/59 sites
+fully covered (91/129 paths) on the base → 57/60 (129/132)**; the three
+left are `return()` landing between a value's arrival and its read, and
+the `resume` / seed arms' stopped-while-pending elses. Web client 130 /
+1,218; hydrate + consistency 89 / 452; server 159 / 1,511; solid 42 / 833;
+`types` + `test-types` clean; harness 500 × {3289, 91501}: SC arm 0,
+generic arm (`CONSISTENCY_IGNORE=C1,C9,C19,E`) 0.
+
+**Public surface.** **Removed:** `Frame.have?(): Record<string, string> |
+undefined` from the public `Frame` interface (the ledger is the tier's
+`haveOf(frame)`; approved class). **Moved:** `encodeHaveList` from
+`frame-transport` to the tier (`@internal`); `decodeHaveList` and the
+`FRAME_HAVE_*` constants stay in `frame-transport` (off the client entry
+since step 1). **Added:** the `@solidjs/web/frames/wire` export path (the
+chunk; its exports `@internal`); `responseHandler.onLive?()` on the sf
+client's `ServerFunctionsClientConfig.responseHandler` (optional; fired at
+a `live()` call before its first fetch); `ServerComponentHandler.onLive()`.
+`ServerFunctionsClientConfig` itself gains no key.
+
+**Running number: frames eager 10,888 br — 888 B above ≤ 10.0 KB.** §2's
+C2 row said −292; −305 landed. The live page's total transfer is honest:
+39,412 eager + 934 for the chunk it loads at its first `live()` call =
+40,345 br against the base's 39,747 (+598 — the chunk carries the whole
+connection, where the row's `est.` ≈ 470 br priced the dispatch alone).
+What remains is C1 (≈ −440) and the claims chunk (≈ −270).
+
+---
+
+## Appendix A — every unit on the head (273 units, 40,000 B; by whole unit)
+
+Class and group per `classes-head.mjs`; units Phase A / B / C added are
+listed with their step in §1.2.
+
+| unit | module | min B | class | group |
+| --- | --- | --: | --- | --- |
+| `FrameImpl##syncSlots` | web/frames | 1241 | T | T.slots |
+| `<module>:web/frames` | web/frames | 978 | T | T.wire |
+| `reconcileChildren` | web/frames | 942 | T | T.morph |
+| `chunkToRecords` | web/frames | 882 | T | T.store |
+| `createFrameHost.apply` | web/frames | 873 | T | T.store |
+| `slotsFor.get` | web/frames | 860 | T | T.slots |
+| `FrameImpl##flush` | web/frames | 813 | T | T.store |
+| `bindDataOccurrence.write` | web/frames | 652 | F | F.bind |
+| `FrameImpl##applyAttrs` | web/frames | 606 | T | T.holes |
+| `stableString` | web/server-functions | 601 | T | T.wire |
+| `adoptBoundary` | web/frames | 590 | T | T.doc |
+| `installServerComponents` | web/frames | 564 | T | T.doc |
+| `ChunkReader#next` | web/server-functions | 558 | T | T.wire |
+| `createServerComponentHandler.handle` | web/frames | 535 | T | T.wire |
+| `applyFrames.drain` | web/frames | 494 | T | T.wire |
+| `ChunkReader#readChunk` | web/server-functions | 492 | T | T.wire |
+| `morphAttributes` | web/frames | 490 | T | T.morph |
+| `FrameImpl##invokeSlot` | web/frames | 483 | T | T.slots |
+| `deserializeStream` | web/server-functions | 446 | T | T.decode |
+| `ownedPositions` | web/frames | 444 | F | F.bind |
+| `bindDataOccurrence` | web/frames | 443 | F | F.bind |
+| `FrameImpl#preview` | web/frames | 432 | R | R.stage |
+| `createServerComponentHandler.applyFlightResponse` | web/frames | 418 | T | T.flight |
+| `adoptBoundary.drainRecords` | web/frames | 401 | T | T.doc |
+| `bindDataOccurrence.valuesFor` | web/frames | 396 | F | F.bind |
+| `applyFrames` | web/frames | 390 | T | T.wire |
+| `createServerComponentHandler` | web/frames | 380 | T | T.wire |
+| `FrameImpl##revealSegment` | web/frames | 358 | T | T.morph |
+| `FrameImpl##revealSegments` | web/frames | 341 | T | T.morph |
+| `collectSlots` | web/frames | 340 | T | T.slots |
+| `consumersEqual` | web/frames | 333 | F | F.bind |
+| `createFrameHost.write` | web/frames | 316 | T | T.store |
+| `createFrameHost.unregister` | web/frames | 310 | T | T.store |
+| `createFrameHost.settleArgs` | web/frames | 307 | T | T.store |
+| `sameArg` | web/frames | 305 | T | T.slots |
+| `<unmapped>` | <unmapped> | 283 | T | T.wire |
+| `installRevealHook` | web/frames | 282 | T | T.doc |
+| `morphOwnedStyle` | web/frames | 274 | F | F.bind |
+| `normalizeSlotContent` | web/frames | 274 | R | R.insert |
+| `slotPositions` | web/frames | 261 | F | F.bind |
+| `morphOwnedClass` | web/frames | 256 | F | F.bind |
+| `documentBoundary` | web/frames | 251 | T | T.doc |
+| `FrameImpl#dispose` | web/frames | 244 | T | T.store |
+| `FrameImpl#rebind` | web/frames | 235 | T | T.store |
+| `flushGrafts` | web/frames | 233 | T | T.morph |
+| `createFrameHost.pendingRef` | web/frames | 232 | T | T.store |
+| `textPosition` | web/frames | 229 | F | F.bind |
+| `boundaryComponent` | web/frames | 228 | T | T.doc |
+| `findLiveTarget` | web/frames | 228 | T | T.holes |
+| `FrameImpl##applyRoot` | web/frames | 228 | T | T.morph |
+| `FrameImpl#constructor` | web/frames | 228 | T | T.store |
+| `landing` | web/frames | 224 | T | T.store |
+| `FrameImpl##segmentReady` | web/frames | 222 | T | T.morph |
+| `slotEntry` | web/frames | 220 | F | F.bind |
+| `errorFromTrailer` | web/server-functions | 218 | T | T.wire |
+| `createFrameHost.register` | web/frames | 218 | T | T.store |
+| `FrameImpl##resolveArgs` | web/frames | 215 | T | T.slots |
+| `createFrameHost.settleWait` | web/frames | 214 | T | T.store |
+| `slotArgsProxy.get.make` | web/frames | 211 | T | T.slots |
+| `FrameImpl##applied` | web/frames | 200 | F | F.event |
+| `tableFor` | web/frames | 188 | T | T.decode |
+| `deliverFlightData` | web/server-functions | 185 | T | T.flight |
+| `FrameImpl##unmountSlot` | web/frames | 184 | T | T.slots |
+| `claimRender` | web/frames | 182 | T | T.claim |
+| `FrameImpl##applyHole` | web/frames | 181 | T | T.holes |
+| `FrameImpl#apply` | web/frames | 181 | T | T.store |
+| `createServerComponentHandler.resume` | web/frames | 178 | F | F.wire |
+| `createServerComponentHandler.bump` | web/frames | 176 | T | T.wire |
+| `pumpLiveChannel.pump` | web/frames | 175 | T | T.holes |
+| `createFrameHost.landing` | web/frames | 174 | T | T.store |
+| `createServerComponentHandler.showing` | web/frames | 174 | T | T.doc |
+| `createServerComponentHandler.stage` | web/frames | 171 | R | R.stage |
+| `compatible` | web/frames | 170 | T | T.morph |
+| `installServerComponents.g._$SC.r` | web/frames | 168 | D | D |
+| `installServerComponents.reask` | web/frames | 165 | T | T.wire |
+| `createChunk` | web/server-functions | 163 | T | T.wire |
+| `prepareTier` | web/frames | 163 | T | T.glue |
+| `adoptRange` | web/frames | 160 | T | T.morph |
+| `claimTree` | web/frames | 157 | F | F.claims |
+| `createFrameHost.preview` | web/frames | 157 | R | R.stage |
+| `morphNode` | web/frames | 156 | T | T.morph |
+| `applyOwned` | web/frames | 155 | F | F.bind |
+| `applyFrames.end` | web/frames | 155 | T | T.wire |
+| `FrameImpl##showFallback` | web/frames | 155 | T | T.morph |
+| `bindDataOccurrence.writeText` | web/frames | 153 | F | F.bind |
+| `createFrameHost` | web/frames | 150 | T | T.store |
+| `pumpLiveChannel` | web/frames | 148 | T | T.holes |
+| `findPlaceholder` | web/frames | 144 | T | T.morph |
+| `slotsFor.get.settle` | web/frames | 143 | R | R.insert |
+| `stashRange` | web/frames | 139 | T | T.morph |
+| `encodeHaveList` | web/frames | 136 | F | F.wire |
+| `findRangeStart` | web/frames | 130 | T | T.morph |
+| `moveRangeBefore` | web/frames | 130 | T | T.morph |
+| `slotsFor.get.evaluate` | web/frames | 128 | T | T.slots |
+| `applyFrames.connection.cancel` | web/frames | 127 | F | F.wire |
+| `makeFrameElement` | web/frames | 127 | F | F.regions |
+| `adoptBoundary.drainRecords.apply` | web/frames | 126 | T | T.doc |
+| `afterMarker` | web/frames | 125 | T | T.slots |
+| `eachInRange` | web/frames | 123 | T | T.slots |
+| `ServerComponentPlugin.deserialize` | web/frames | 121 | T | T.refs |
+| `ChunkReader#constructor` | web/server-functions | 119 | T | T.wire |
+| `isAsyncValue` | web/frames | 119 | D | D |
+| `findBoundaryElement` | web/frames | 116 | T | T.doc |
+| `awaitBoundary` | web/frames | 115 | T | T.doc |
+| `hashArguments` | web/server-functions | 115 | T | T.wire |
+| `configureServerFunctionsClient` | web/server-functions | 113 | T | T.wire |
+| `rangeClose` | web/frames | 112 | T | T.morph |
+| `isReactiveContent` | web/frames | 111 | R | R.insert |
+| `indexBoundaries` | web/frames | 108 | T | T.doc |
+| `<module>:web/server-functions` | web/server-functions | 101 | T | T.wire |
+| `flightCodec` | web/frames | 101 | T | T.refs |
+| `FrameImpl##recordHave` | web/frames | 101 | F | F.wire |
+| `revealSeam` | web/frames | 100 | T | T.slots |
+| `slotArgsProxy.get` | web/frames | 99 | T | T.slots |
+| `slotsFor` | web/frames | 97 | T | T.slots |
+| `hasFlightMetadata` | web/server-functions | 96 | T | T.flight |
+| `isEventStream` | web/server-functions | 96 | F | F.wire |
+| `FrameImpl##removeSlotRecord` | web/frames | 94 | T | T.slots |
+| `FrameImpl##replaceRange` | web/frames | 94 | R | R.insert |
+| `createServerComponentHandler.bindingFor` | web/frames | 93 | T | T.wire |
+| `followAddress` | web/frames | 92 | R | R.stage |
+| `documentAddress` | web/frames | 91 | D | D |
+| `createServerComponentHandler.applyFlightResponse.version` | web/frames | 91 | T | T.flight |
+| `createFrameHost.serialize` | web/frames | 90 | T | T.refs |
+| `consumersOf` | web/frames | 89 | F | F.bind |
+| `applyFrames.errorRecord` | web/frames | 89 | T | T.wire |
+| `failing` | web/frames | 87 | T | T.store |
+| `loadCodec` | web/frames | 86 | T | T.decode |
+| `parseFragment` | web/frames | 86 | T | T.morph |
+| `ServerComponentPlugin.serialize` | web/frames | 86 | T | T.refs |
+| `isSlotMarker` | web/frames | 85 | T | T.slots |
+| `slotStartId` | web/frames | 85 | T | T.slots |
+| `boundaryScope` | web/frames | 84 | T | T.slots |
+| `adoptBoundary.hold` | web/frames | 84 | T | T.glue |
+| `liveSlotProps` | web/frames | 84 | T | T.slots |
+| `boundaryMayArrive` | web/frames | 82 | T | T.doc |
+| `createFrameElement` | web/frames | 81 | T | T.store |
+| `slotArgsProxy.getOwnPropertyDescriptor` | web/frames | 79 | T | T.slots |
+| `installServerComponents.intercept` | web/frames | 79 | T | T.doc |
+| `parse.async` | web/frames | 79 | T | T.refs |
+| `removeUntil` | web/frames | 77 | T | T.morph |
+| `claimHandlers` | web/frames | 76 | F | F.claims |
+| `FrameImpl##resolveSlotRecord` | web/frames | 76 | T | T.slots |
+| `ChunkReader#drain` | web/server-functions | 75 | T | T.wire |
+| `slotArgsProxy` | web/frames | 75 | T | T.slots |
+| `createFrameHost.storeFor` | web/frames | 73 | T | T.store |
+| `carriesTrace` | web/frames | 72 | T | T.glue |
+| `FrameImpl##revealSegment.content` | web/frames | 72 | T | T.morph |
+| `FrameImpl##resetStreamState` | web/frames | 72 | T | T.store |
+| `FrameImpl#contentHTML` | web/frames | 72 | D | D |
+| `slotsFor.get.bind` | web/frames | 71 | T | T.slots |
+| `FrameImpl##runSlotCleanups` | web/frames | 71 | T | T.slots |
+| `deserializeStream.interpretChunk` | web/server-functions | 71 | T | T.decode |
+| `FrameImpl##claimContent` | web/frames | 69 | F | F.claims |
+| `FrameImpl##findPlaceholder` | web/frames | 69 | T | T.morph |
+| `placeRange` | web/frames | 69 | T | T.morph |
+| `createServerComponentHandler.hold` | web/frames | 68 | F | F.wire |
+| `parseServerComponent` | web/frames | 66 | T | T.refs |
+| `preservesOpen` | web/frames | 66 | T | T.morph |
+| `propOf` | web/frames | 65 | T | T.slots |
+| `segmentName` | web/frames | 64 | T | T.store |
+| `deserializeStream.end` | web/server-functions | 63 | F | F.wire |
+| `createServerComponentHandler.applyFlightResponse.regionOf` | web/frames | 63 | R | R.stage |
+| `FrameImpl##firstContent` | web/frames | 61 | T | T.morph |
+| `createServerComponentHandler.componentFor` | web/frames | 59 | T | T.wire |
+| `getFlightDataConsumer` | web/server-functions | 58 | T | T.flight |
+| `createFrameHost.get` | web/frames | 57 | T | T.store |
+| `isPlaceholderStart` | web/frames | 57 | T | T.morph |
+| `adoptBoundary.applyLiveOp` | web/frames | 56 | T | T.holes |
+| `FrameImpl##claimTree` | web/frames | 56 | F | F.claims |
+| `isFrameElement` | web/frames | 55 | T | T.store |
+| `createServerComponentHandler.stage.entry.commit` | web/frames | 52 | R | R.stage |
+| `createServerComponentHandler.stage.entry.preview` | web/frames | 52 | R | R.stage |
+| `FrameImpl##resolveSlot` | web/frames | 52 | T | T.slots |
+| `createServerComponentHandler.named` | web/frames | 52 | R | R.stage |
+| `bindDataOccurrence.write.st.ref` | web/frames | 52 | F | F.bind |
+| `tierLoaders.regions` | web/frames | 52 | T | T.glue |
+| `claimNode` | web/frames | 51 | F | F.claims |
+| `getFrameHost` | web/frames | 51 | T | T.decode |
+| `installRevealHook.hy.fa` | web/frames | 51 | T | T.doc |
+| `createServerComponentHandler.stage.entry.apply` | web/frames | 50 | R | R.stage |
+| `tierLoaders.assets` | web/frames | 50 | T | T.glue |
+| `FrameImpl##scoped` | web/frames | 49 | T | T.slots |
+| `isTextStart` | web/frames | 49 | F | F.bind |
+| `bindDataOccurrence.release` | web/frames | 49 | F | F.bind |
+| `createServerComponentHandler.applyFlightResponse.target.apply` | web/frames | 49 | T | T.flight |
+| `getFrameHost.applyData` | web/frames | 48 | T | T.decode |
+| `createServerComponentHandler.begin` | web/frames | 48 | T | T.wire |
+| `frameAddress` | web/server-functions | 48 | T | T.wire |
+| `tierLoaders.trace` | web/frames | 48 | T | T.glue |
+| `createFrame` | web/frames | 46 | T | T.store |
+| `FrameImpl##materialize` | web/frames | 46 | T | T.morph |
+| `ServerComponentPlugin.test` | web/frames | 46 | T | T.refs |
+| `applyFrames.end.sweep` | web/frames | 46 | T | T.wire |
+| `getFlightDataSourceIds` | web/server-functions | 43 | T | T.flight |
+| `createFrameHost.lands` | web/frames | 43 | T | T.store |
+| `isCalled` | web/frames | 42 | T | T.slots |
+| `FrameImpl##releaseHold` | web/frames | 41 | T | T.glue |
+| `FrameImpl##parent` | web/frames | 40 | T | T.morph |
+| `isFrameStreamResponse` | web/frames | 40 | T | T.wire |
+| `getFrameHost.resolve` | web/frames | 40 | T | T.decode |
+| `ChunkReader#cancel` | web/server-functions | 39 | T | T.wire |
+| `installServerComponents.g._$SC.r.g._$SC.c[i]` | web/frames | 39 | D | D |
+| `contentAddress` | web/frames | 38 | R | R.stage |
+| `needsTrace` | web/frames | 38 | T | T.glue |
+| `claimedAttr` | web/frames | 37 | F | F.claims |
+| `FrameImpl##clearContent` | web/frames | 37 | T | T.morph |
+| `FrameImpl#get error` | web/frames | 37 | T | T.store |
+| `createServerComponentHandler.applyFlightResponse.onOutcome` | web/frames | 36 | T | T.flight |
+| `createFrameElement.dispose` | web/frames | 33 | T | T.store |
+| `FrameImpl##collectSlots` | web/frames | 33 | T | T.slots |
+| `installServerComponents.g._$SC.impl` | web/frames | 33 | T | T.doc |
+| `slotArgsProxy.ownKeys` | web/frames | 33 | T | T.slots |
+| `callFor` | web/frames | 32 | T | T.wire |
+| `needsRegions` | web/frames | 31 | T | T.glue |
+| `FrameImpl##invokeSlot.ctx.onUpdate` | web/frames | 29 | T | T.slots |
+| `FrameImpl#get options` | web/frames | 29 | T | T.glue |
+| `FrameImpl#get version` | web/frames | 29 | T | T.store |
+| `isBoundaryId` | web/frames | 29 | T | T.doc |
+| `getServerFunctionsCodec` | web/server-functions | 28 | T | T.decode |
+| `createServerComponentHandler.stagedContent.preview` | web/frames | 28 | R | R.stage |
+| `FrameImpl##appliedHoles` | web/frames | 27 | T | T.holes |
+| `FrameImpl##heldRecords` | web/frames | 27 | T | T.glue |
+| `FrameImpl##mountedSlots` | web/frames | 27 | T | T.slots |
+| `FrameImpl##slotArgs` | web/frames | 27 | T | T.slots |
+| `FrameImpl##slotCleanups` | web/frames | 27 | T | T.slots |
+| `FrameImpl##slotConsumers` | web/frames | 27 | F | F.bind |
+| `FrameImpl##slotNodes` | web/frames | 27 | T | T.slots |
+| `FrameImpl##slotRebinders` | web/frames | 27 | F | F.bind |
+| `FrameImpl##slotUpdaters` | web/frames | 27 | T | T.slots |
+| `FrameImpl#get store` | web/frames | 27 | T | T.store |
+| `afterRange` | web/frames | 26 | T | T.slots |
+| `createServerComponentHandler.stagedContent.commit` | web/frames | 26 | R | R.stage |
+| `installServerComponents.component` | web/frames | 25 | T | T.doc |
+| `tierReady` | web/frames | 25 | T | T.glue |
+| `asyncArg` | web/frames | 24 | T | T.refs |
+| `Boxed#constructor` | web/frames | 24 | T | T.slots |
+| `configureServerFunctionsCodec` | web/server-functions | 24 | T | T.decode |
+| `installServerComponents.showing` | web/frames | 24 | T | T.doc |
+| `FrameImpl##invokeSlot.ctx.onCleanup` | web/frames | 23 | T | T.slots |
+| `FrameImpl##store` | web/frames | 23 | T | T.store |
+| `FrameImpl#have` | web/frames | 22 | F | F.wire |
+| `createServerComponentHandler.resolveServerComponent` | web/frames | 22 | T | T.wire |
+| `placeholderId` | web/frames | 21 | T | T.morph |
+| `createServerComponentHandler.settled` | web/frames | 21 | R | R.stage |
+| `slotEnd` | web/frames | 21 | T | T.slots |
+| `deserializeStream.end.sweep` | web/server-functions | 21 | F | F.wire |
+| `createServerComponentHandler.binding` | web/frames | 20 | T | T.wire |
+| `slotArgsProxy.has` | web/frames | 20 | T | T.slots |
+| `afterText` | web/frames | 19 | F | F.bind |
+| `createServerComponentHandler.bindingFor.binding` | web/frames | 16 | T | T.wire |
+| `createServerComponentHandler.stage.binding` | web/frames | 16 | R | R.stage |
+| `ChunkReader` | web/server-functions | 15 | T | T.wire |
+| `FrameImpl` | web/frames | 15 | T | T.store |
+| `Boxed` | web/frames | 14 | T | T.slots |
+| `createServerComponentHandler.applyFlightResponse.start` | web/frames | 13 | T | T.flight |
+| `applyFrames.end.close` | web/frames | 12 | F | F.wire |
+| `stagedContent.preview` | web/frames | 12 | R | R.stage |
+| `stagedContent.commit` | web/frames | 10 | R | R.stage |
+| `deserializeStream.end.close` | web/server-functions | 9 | F | F.wire |
+| `FrameImpl##disposed` | web/frames | 6 | T | T.store |
+| `FrameImpl##hasContent` | web/frames | 6 | T | T.store |
+| `FrameImpl##appliedError` | web/frames | 3 | T | T.store |
+| `FrameImpl##appliedRoot` | web/frames | 3 | T | T.store |
+| `FrameImpl##element` | web/frames | 3 | T | T.store |
+| `FrameImpl##end` | web/frames | 3 | T | T.store |
+| `FrameImpl##have` | web/frames | 3 | F | F.wire |
+| `FrameImpl##hold` | web/frames | 3 | T | T.glue |
+| `FrameImpl##options` | web/frames | 3 | T | T.store |
+| `FrameImpl##outer` | web/frames | 3 | T | T.glue |
+| `FrameImpl##slots` | web/frames | 3 | T | T.slots |
+| `FrameImpl##start` | web/frames | 3 | T | T.store |
+| `FrameImpl##version` | web/frames | 3 | T | T.store |
+
+by seam (whole units tagged):
+  A1     1590
+  A1b    1362
+  A3      341
+  A7      284
+  B       219
+  C3      185
+  A2      128
+  C4       84
+  A5       51
+  C5       50
+  A0       42
+
diff --git a/documentation/plans/frames-savings-pass.md b/documentation/plans/frames-savings-pass.md
index 7dc23231e..6e8d8f308 100644
--- a/documentation/plans/frames-savings-pass.md
+++ b/documentation/plans/frames-savings-pass.md
@@ -88,18 +88,22 @@ _or_ acting without it is a bounded delay with the right thing on screen
 meanwhile. For every runtime tier: the exact race, the symptom if it were
 lost, the mechanism that bounds it, and the pin that proves it. "3.1
 participant" means the hold registers as a pending boundary through
-`initBoundaryResume` (ruling 3.1 / 3.2 — hydration-done waits for it, the
-event-replay window stays open); "runtime wait" means a post-first-flush
-buffer with no hydration involvement.
-
-| tier                     | the race (what arrives before what)                                                                                                                                                                                                     | symptom if lost                                                                                                                                                                                    | bound                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | class                                                                                                                           | pin                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **holes** (E.a1)         | a `hole` / `attr` chunk — or an op on the document's `sc:live` stream — arrives before `tier-holes.js` has loaded. Always after the frame's first flush (holes are later yields; the markup that carries the `lh:` markers came first). | the frame freezes at its first yield (wrong content, silent).                                                                                                                                      | **buffer, no hold.** Stream face: `chunkToRecords` writes `hole:<k>` / `attr:<k>` into the store regardless; `#flush`'s hole pass runs only when the tier is resident, and records it cannot apply **stay pending** (store-model: any later flush retries). The tier's load triggers one `flush()` on every registered frame. Document face: the `sc:live` `ReadableStream` buffers until `pumpLiveChannel` runs (after the load); the op log replays to adopters. The announcement (§2) starts the fetch at the header / at t = 0, so in practice the chunk is resident before the first later yield.     | runtime wait                                                                                                                    | **existing:** C13 control arm (one hole alone applies), C18's pump-catch-up arm (ops before the adopter replay). **New:** `tier-holes-buffer.spec` — (a) stream: a `hole` chunk delivered before the tier resolves applies after it, nothing applied twice; (b) document: ops written to `sc:live` before the pump starts land after it; (c) a frame disposed during the wait applies nothing. The 3.1 question does not arise (post-first-flush).                                      |
-| **live wire** (E.a2)     | a `live()` loop's first response (SSE framing, `LIVE_WIRE` in the call context) reaches `handle` before `tier-wire.js` has loaded.                                                                                                      | the response is read as a plain frame stream: no join/hold, no reconnect with a have-list; a reconnect lands as a full snapshot (today's post-adoption connect already does). Degraded, not wrong. | **preload-at-call.** `live(fn)`'s client decorator fires a hook the frames client installs (`configureServerFunctionsClient({ onLive })` — frames already imports `configureServerFunctionsClient`, so the dependency direction holds) that calls `prepareTier("wire")` **before** the first `fetch`; `handle`'s `LIVE_WIRE` arm awaits the same promise before reading the body, so a live connection without the chunk is impossible by construction. No buffer, no hold.                                                                                                                                | runtime wait (none in practice — the import and the request race only against each other, and the dispatch awaits the import)   | **existing:** the live suite (`server-functions-live-*`, `frames-live-*`; `live` is 22/61 branches covered — the audit's hot spot, §6.4). **New:** `tier-wire-preload.spec` — the first live response is held until the tier resolves; a response that completes before the tier never reaches the plain reader; `resume` sends the have-list on the first reconnect.                                                                                                                   |
-| **traces** (S1 re-based) | an adopt-time record whose literal args carry a `{ $tr, $ta }` marker — or a `data` chunk whose node tree holds the trace plugin's node — before `container-trace.js` (the materializer + the store engine) has loaded.                 | the fill runs with an inert marker object (`TypeError` or wrong content); on the codec face the chunk decodes a marker instead of a container.                                                     | **announce + hold.** Document: the server knows it serialized a trace (the serializer stamps it) → `modulepreload` at t = 0 + the `sc:tiers` record; the occurrence is **held** (S1's `#argsUnprepared` → the general held set) with its server interior on screen, the mount being the hydration attach; it mounts with the record it was held on (S1 commit 3). Codec: `prepareData` scans the node tree and awaits the tier before the chunk decodes (S1 as built; the header flag makes the scan a confirmation). The claim reads the snapshot; the backlog lands after done (3.6 (iii), S1 commit 3). | **3.1 participant** (document face: the hold is an adopt-time occurrence deferred — registers through `initBoundaryResume`, A2) | **existing (S1):** `frames-container-lazy-codec` (loads before decode / loads nothing), `frames-container-lazy-document` (held with the interior on screen, then mounted), `hydration/welcome-status-lazy` (claims in place, no key misses), `container-trace-hold-{id-determinism, interruption, record-retention, snapshot}`. **Re-pin:** `container-trace-hold-hydration-end` under 3.1 — _hydration waits for the load; the mount claims before done_ (rulings 3.1 "Consequences"). |
-| **regions**              | a `slot:` record naming a `{$frame}` ref — or a `data-fid` region element inside adopted content — before `tier-regions.js` has loaded.                                                                                                 | the fill receives the raw `{$frame}` ref (wrong content); an occluded region cannot mount from the store.                                                                                          | **announce + hold.** The sink knows at render it passed server content as a prop (`{$frame}` minted) → announced. Adopt path: the occurrence is held in the same set as traces (its interior stays on screen; `#resolveArgs` runs after the load). Stream path: the record stays pending in the store until the load's flush (buffer).                                                                                                                                                                                                                                                                     | **3.1 participant** on the adopt path; runtime wait on the stream path                                                          | **existing:** `frames-regions-*`, the lifecycle matrix's region rows. **New:** `tier-regions-hold.spec` — adopt-time `{$frame}` occurrence held, interior intact, mounts after the load with the held record; a stream record with a region ref applies after the load; hydration-done waits (3.1).                                                                                                                                                                                     |
-| **assets**               | a `reveal` for a segment whose `seg:<k>:assets` record names stylesheets (or `waitForStyles`) before `tier-assets.js` has loaded. Stream face only — the document face keeps the core's `$dfs`.                                         | **without a bound: FOUC** — the segment reveals unstyled, then the sheet lands. With the bound: the fallback stays on screen longer.                                                               | **announce + reveal-readiness term.** The sink knows at render that a fragment is style-gated → announced in the header; `#segmentReady` gains one term: "the segment's `assets` record names styles **and** the tier is not resident → not ready". The fallback — the server's `<Loading>` outcome — stays; the reveal happens at max(tier load, stylesheet load), and the stylesheet's own load dominates on every network. A segment without stylesheets never waits. Modules / preloads / inline styles are not reveal-gating today and stay so.                                                       | runtime wait (the segment swap is post-first-flush)                                                                             | **existing:** `frames-assets-*` (`waitForStyles`, the style gate; note `ensureStylesheet` / `applyInlineStyles` have **0 client tests** — the audit's gap, to be pinned in C5 regardless of tiering). **New:** `tier-assets-ready.spec` — a `reveal` for a style-gated segment before the tier resolves keeps the fallback; reveals once the tier and the sheet are both in; an unstyled segment in the same stream reveals immediately.                                                |
-| **binding slots**        | `_s:` markers (attribute / class / style / text positions, `_s:on:*` handlers, `_s:ref`) in markup — document or stream — before `tier-bind.js` has loaded.                                                                             | positions sit at the server's values (inert attributes, classes, text); **handlers are not attached — a click in the window is lost** unless the hydration event-replay window is still open.      | **announce + hold.** The sink knows at render it emitted `_s:` (binding positions are minted by the slot props' proxy) → announced at t = 0 / in the header. Adopt path: an occurrence with `ctx.positions` is **held** (same set), which keeps `_$HY.done` false and the delegated-event replay buffer open until attach — the click is replayed. Stream path: the occurrence stays pending in the store until the load's flush. The audit's §7 Q5 (one chunk load before a post-load stream's first binding) is accepted for B.3 and applies here.                                                       | **3.1 participant** on the adopt path; runtime wait on the stream path                                                          | **existing:** `frames-binding-slot-*`, `slot-positions-*`, the #3704 / #3714 suites. **New:** `tier-bind-hold.spec` — held occurrence's positions untouched until the load; attach after; **a click dispatched during the hold replays after attach**; hydration-done waits (3.1); a stream occurrence binds after the load.                                                                                                                                                            |
+`initBoundaryResume` (ruling 3.1 / 3.2 — hydration-done waits for it);
+"runtime wait" means a post-first-flush buffer with no hydration
+involvement. **A 3.1 hold does not keep the delegated-event replay window
+open** (corrected at C6, below): the bootstrap queues an event only under
+a not-yet-completed `_hk` element, and a server component's interior has
+none (it renders under NoHydration) — the window an element needs is its
+own stamp.
+
+| tier                     | the race (what arrives before what)                                                                                                                                                                                                     | symptom if lost                                                                                                                                                                                    | bound                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | class                                                                                                                           | pin                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **holes** (E.a1)         | a `hole` / `attr` chunk — or an op on the document's `sc:live` stream — arrives before `tier-holes.js` has loaded. Always after the frame's first flush (holes are later yields; the markup that carries the `lh:` markers came first). | the frame freezes at its first yield (wrong content, silent).                                                                                                                                      | **buffer, no hold.** Stream face: `chunkToRecords` writes `hole:<k>` / `attr:<k>` into the store regardless; `#flush`'s hole pass runs only when the tier is resident, and records it cannot apply **stay pending** (store-model: any later flush retries). The tier's load triggers one `flush()` on every registered frame. Document face: the `sc:live` `ReadableStream` buffers until `pumpLiveChannel` runs (after the load); the op log replays to adopters. The announcement (§2) starts the fetch at the header / at t = 0, so in practice the chunk is resident before the first later yield.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | runtime wait                                                                                                                    | **existing:** C13 control arm (one hole alone applies), C18's pump-catch-up arm (ops before the adopter replay). **New:** `tier-holes-buffer.spec` — (a) stream: a `hole` chunk delivered before the tier resolves applies after it, nothing applied twice; (b) document: ops written to `sc:live` before the pump starts land after it; (c) a frame disposed during the wait applies nothing. The 3.1 question does not arise (post-first-flush).                                                                                                                                                                                                                                                                                                                                            |
+| **live wire** (E.a2)     | a `live()` loop's first response (SSE framing, `LIVE_WIRE` in the call context) reaches `handle` before `tier-wire.js` has loaded.                                                                                                      | the response is read as a plain frame stream: no join/hold, no reconnect with a have-list; a reconnect lands as a full snapshot (today's post-adoption connect already does). Degraded, not wrong. | **preload-at-call.** `live(fn)`'s client decorator fires a hook the frames client installs (`configureServerFunctionsClient({ onLive })` — frames already imports `configureServerFunctionsClient`, so the dependency direction holds) that calls `prepareTier("wire")` **before** the first `fetch`; `handle`'s `LIVE_WIRE` arm awaits the same promise before reading the body, so a live connection without the chunk is impossible by construction. No buffer, no hold. **Built (2026-10-07, C2):** the hook is `responseHandler.onLive` (not a `configureServerFunctionsClient` key — the frames handler is the one thing that wants it, and it measured ≈ 45 br lighter on the pages); `live()`'s `makeIterable` fires it before the first fetch, the handler's `handle` live arm awaits `prepareTier("wire")` then hands the response to the tier's `connect`. **One degraded case stands, accepted:** content applied before the chunk was resident recorded no have-list, and `resume` (the tier's) answers nothing while the tier is absent — that first connect sends neither `X-Frame-Have` nor `Last-Event-ID` and gets a full snapshot; pinned in `tier-wire-preload.spec`.                                                                                                                                                                                                                                                                                                                              | runtime wait (none in practice — the import and the request race only against each other, and the dispatch awaits the import)   | **existing:** the live suite (`server-functions-live-*`, `frames-live-*`; `live` is 22/61 branches covered — the audit's hot spot, §6.4). **New:** `tier-wire-preload.spec` — the first live response is held until the tier resolves; a response that completes before the tier never reaches the plain reader; `resume` sends the have-list on the first reconnect.                                                                                                                                                                                                                                                                                                                                                                                                                         | **Built:** `consistency/tier-wire-preload.spec` (3) and `server-functions-live-loop.spec` (19, the coverage closure: `live` 26/59 → 57/60 branch sites); `frames-live-resume` re-pointed to the tier. |
+| **traces** (S1 re-based) | an adopt-time record whose literal args carry a `{ $tr, $ta }` marker — or a `data` chunk whose node tree holds the trace plugin's node — before `container-trace.js` (the materializer + the store engine) has loaded.                 | the fill runs with an inert marker object (`TypeError` or wrong content); on the codec face the chunk decodes a marker instead of a container.                                                     | **announce + hold.** Document: the server knows it serialized a trace (the serializer stamps it) → `modulepreload` at t = 0 + the `sc:tiers` record; the occurrence is **held** (S1's `#argsUnprepared` → the general held set) with its server interior on screen, the mount being the hydration attach; it mounts with the record it was held on (S1 commit 3). Codec: `prepareData` scans the node tree and awaits the tier before the chunk decodes (S1 as built; the header flag makes the scan a confirmation). The claim reads the snapshot; the backlog lands after done (3.6 (iii), S1 commit 3).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **3.1 participant** (document face: the hold is an adopt-time occurrence deferred — registers through `initBoundaryResume`, A2) | **existing (S1):** `frames-container-lazy-codec` (loads before decode / loads nothing), `frames-container-lazy-document` (held with the interior on screen, then mounted), `hydration/welcome-status-lazy` (claims in place, no key misses), `container-trace-hold-{id-determinism, interruption, record-retention, snapshot}`. **Re-pin:** `container-trace-hold-hydration-end` under 3.1 — _hydration waits for the load; the mount claims before done_ (rulings 3.1 "Consequences").                                                                                                                                                                                                                                                                                                       |
+| **regions**              | a `slot:` record naming a `{$frame}` ref — or a `data-fid` region element inside adopted content — before `tier-regions.js` has loaded.                                                                                                 | the fill receives the raw `{$frame}` ref (wrong content); an occluded region cannot mount from the store.                                                                                          | **announce + hold.** The sink knows at render it passed server content as a prop (`{$frame}` minted) → announced. Adopt path: the occurrence is held in the same set as traces (its interior stays on screen; `#resolveArgs` runs after the load). Stream path: the record stays pending in the store until the load's flush (buffer).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **3.1 participant** on the adopt path; runtime wait on the stream path                                                          | **existing:** `frames-regions-*`, the lifecycle matrix's region rows. **New:** `tier-regions-hold.spec` — adopt-time `{$frame}` occurrence held, interior intact, mounts after the load with the held record; a stream record with a region ref applies after the load; hydration-done waits (3.1).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| **assets**               | a `reveal` for a segment whose `seg:<k>:assets` record names stylesheets (or `waitForStyles`) before `tier-assets.js` has loaded. Stream face only — the document face keeps the core's `$dfs`.                                         | **without a bound: FOUC** — the segment reveals unstyled, then the sheet lands. With the bound: the fallback stays on screen longer.                                                               | **announce + reveal-readiness term.** The sink knows at render that a fragment is style-gated → announced in the header; `#segmentReady` gains one term: "the segment's `assets` record names styles **and** the tier is not resident → not ready". The fallback — the server's `<Loading>` outcome — stays; the reveal happens at max(tier load, stylesheet load), and the stylesheet's own load dominates on every network. A segment without stylesheets never waits. Modules / preloads are not reveal-gating today and stay so. **Built (2026-10-06, C5, and its follow-up the same day):** the term is `(assets.styles                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |                                                                                                                                 | assets.inlineStyles) && !tierReady("assets")?.gate(assets.styles                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |                                                                                                                                                                                                       | [], this)`in`#segmentReady`— a segment whose record carries stylesheets **or inline styles** holds while the tier is absent (the inline`<style>` is the tier's to land, so revealing before the install was exactly the unstyled window the term prevents); once resident only stylesheets gate, and inline styles apply in the assets walk at the record's arrival, ahead of the segments in the same flush. The follow-up cost +22 min / +14 br on frames eager (measured on the edited dist first). | runtime wait (the segment swap is post-first-flush) | **existing:** `frames-assets-*` (`waitForStyles`, the style gate; note `ensureStylesheet` / `applyInlineStyles` have **0 client tests** — the audit's gap, to be pinned in C5 regardless of tiering). **New:** `tier-assets-ready.spec` — a `reveal` for a style-gated segment before the tier resolves keeps the fallback; reveals once the tier and the sheet are both in; an unstyled segment in the same stream reveals immediately. **Built:** `consistency/tier-assets-ready.spec` (9 — the inline-style hold and the resident same-flush arm added by the follow-up) and the two coverage pins in `frames-assets-client.spec` (17), committed first. |
+| **binding slots**        | `_s:` markers (attribute / class / style / text positions, `_s:on:*` handlers, `_s:ref`) in markup — document or stream — before `tier-bind.js` has loaded.                                                                             | positions sit at the server's values (inert attributes, classes, text); **handlers are not attached — a click in the window is lost** unless the hydration event-replay window is still open.      | **announce + hold + stamp** (corrected at C6, 2026-10-06). The sink knows at render it emitted `_s:` (binding positions are minted by the slot props' proxy) → announced at t = 0 / in the header. Adopt path: the frame is **held** at the walk (a marker met with the tier absent — same set): hydration-done waits under 3.1, the interior stays as the server left it, and the install's flush binds. **The hold does NOT bound the replay window** — the C6 probe found a click during the hold was never queued at all: the bootstrap queues under the nearest not-yet-completed `_hk` element, and a server component's interior (NoHydration) has none; `_$HY.done` staying false changes nothing for an element with no key. **Option (a), ruled:** the server stamps a bare ` _hk` on each element with an `_s:on:*` position — only those, document face only (4 bytes per element; the stream face has no window: the bootstrap stopped capturing at `_$HY.done`), no key allocated (nothing gathers or claims it); the tier marks the element completed at the bind and drains the queue (`runHydrationEvents`). The two halves ship together: a stamp the tier did not complete is worse than none (the delegated handler leaves a queued event to the replay — even a post-bind click would be lost). Stream path: the occurrence stays pending in the store until the load's flush. The audit's §7 Q5 (one chunk load before a post-load stream's first binding) is accepted for B.3 and applies here. | **3.1 participant** on the adopt path (hydration-done); the ` _hk` stamp for the replay window; runtime wait on the stream path | **existing:** `frames-binding-slots`, `hydration/binding-slot-adoption`, `server/frame-binding-slots` (now with the stamp pin: event-slot consumers only, document face only). **Landed:** `consistency/tier-bind-hold.spec` (6) — un-announced: the frame held, positions untouched, hydration waits, binds at the install, no orphan `_hk`; **replay arm (i):** a click queued BEFORE `hydrate()` replays into the bound handler at the install; **replay arm (ii):** a click (and an `input`) DURING the hold is queued and replays at the bind; the mutant without the stamp loses both (pinned); a record replaced during the hold is the one the fill sees (current-record mount, once); announced → the import starts at install. The client-half mutant (no completion) fails 4 of 6. |
 
 **Fallback I consider not acceptable without its bound: assets.** The
 reveal-readiness term is what makes the tier safe — without it the first
@@ -114,10 +118,14 @@ the mirror through `web`'s own asset registry via `client.ts`'s existing
 import edge, which replaces ≈ 750 B of untested mirror with calls into
 code every hydrating page already ships.
 
-**Second-most visible: bind's dead-handler window** — bounded only because
-the adopt-path hold is a 3.1 participant (the replay buffer stays open).
-This is why the hold must register, not merely wait: a bare `await` would
-let `_$HY.done` flip and the click fall on the floor. C6 depends on A2's
+**Second-most visible: bind's dead-handler window** — bounded by the
+` _hk` stamp on event-slot consumers (C6, option (a)), NOT by the hold:
+the hold registering under 3.1 is what makes hydration-done wait for the
+bind, but the replay buffer is per-element — the bootstrap queues only
+under a not-yet-completed `_hk`, and the hold cannot give an unkeyed
+element one. (The earlier reading here — "the replay buffer stays open" —
+was wrong: the C6 probe's click during the hold was never queued.) C6
+still depends on A2's
 S-hold for this reason — and by the ruled order A2 precedes every tier.
 
 **No tier holds on hydration-done for the stream face.** Every stream-path
@@ -241,6 +249,48 @@ and the links; the consistency laws un-ignored for the tiers.
 read, not configured); `ServerComponentHandlerOptions` gains nothing. The
 header name and the hydration key are wire (above).
 
+**Landed (2026-10-06, `feat/frames-tier-mechanism`, measured before
+written on edited dist copies per re-attribution §7).** Frames eager
+**+473 min / +145 br** against the ≈ +100 br estimate (the ×2.5
+pre-estimate was ≈ +250; the first honest cut of the client code measured
++745 / +233 and was golfed to the shape that shipped: the load table a
+plain object, a name with no loader minting no promise, the registry of
+live frames the install flushes, the header read and the codec await
+folded into one `Promise.all`); pages +478 min (brotli +177 base / +158
+live — layout; the gate's minified rule applies); the four non-SC
+scenarios **0 B**. The frames server dist +793 min (est. ≈ 300–450;
+`needs` / `announce` / `documentNeeds` / the pipe hook / nine mint sites /
+the `tierUrls` plumbing); `@solidjs/web`'s own server entry 0. What
+differs from the sketch above: (i) `installServerComponents` **does** gain
+an option — `{ tiers }`, the name → loader map (decision 3's (ii): the
+client resolves chunk URLs, the server announces names), the seam the
+test-only tier module plugs into since no real tier has a chunk yet;
+(ii) the document face's `sc:tiers` is re-written cumulative at each mint
+(the hydration serializer parses a value when written, and a later
+component's tier would otherwise be lost) and the `modulepreload` goes
+through `registerAsset("module", url)` with a URL only the integration
+can supply (`frameTransformDirectResult(value, { id, args, tierUrls })`);
+(iii) the in-band form is **a `tiers` member on the next chunk out**
+(`FrameChunk.tiers`), so the trace mint — which precedes the serializer's
+synchronous emission of the record's initial node — lands on the very
+`data` chunk that needs it, and the client's codec face awaits
+`chunk.tiers` without a node scan; the header carries the sync pass's
+mints (a pending projection's slot call is a hole re-pulled after the
+pass, so its trace rides in-band); (iv) `prepareTier` / `installTier` are
+internal (the install is the load's own continuation; `prepareTier` is
+exported from the frames runtime module, not the public entry — the 9 B
+br export is the maintainer's to grant when a tier exists to warm); (v) a
+sync `renderToString` document announces nothing (no shared render slot
+to dedupe on — the client detects); (vi) the held set's predicates in
+this step are `bind` (positions) and `regions` (`record.regions`); the
+trace predicate lands with C3, where S1's marker scan is. Pins:
+`test/server/tier-announce.spec.tsx` (14), `test/consistency/tier-prepare.spec.tsx`
+(8 — the 3.1 hold with two frames and one install, the stream path's
+buffer-and-retry, idempotence, the record / header / in-band reads, the
+codec await). Artifacts: 5 of 150 re-recorded (`frame-live-document-*`
+×3 announce `wire`, `welcome-status-*` ×2 announce `trace`); none that
+mints nothing changed.
+
 ---
 
 ## 3. Steps
@@ -307,32 +357,37 @@ live +120 br with −138 min (over their caps by 143 / 115 B brotli, held by
 the gate's minified rule). Frames eager measures 14 B over its 13.79 KB
 cap on the same terms; no frames / page cap moved.
 
-| #      | step                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | Δ br (frames eager / page base / page live / compiled hydrating)                                                                                                                                                                                                                                            | chunks created                                                                                                                                                     | gates (pins flip; size)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | depends on                                                                                                                   | surface                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| ------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **A0** | **C18 — classification waits for the drain** (rulings step 1, 3d / 3.5; **in flight**). The predicate is one term in `adoptBoundary.recordsPending`: a `prop#n` occurrence is classified only after every delivered record has drained. The only page-halting red; lands as the rulings specified it. A1 then makes the mechanism moot (one write per drain; `#` decides the class — C18 becomes unrepresentable) and the pins stay as the assertion of the pending read.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **≈ +15 / +15 / +15 / 0** (the rulings' ≈ +50 min / +15 br; ≈ +25 br with the batched drain, which A1 supersedes)                                                                                                                                                                                           | none                                                                                                                                                               | **flip:** C18 ×3. Size: ±0.02 KB on every scenario (frames eager ≤ 13.8).                                                                                                                                                                                                                                                                                                                                                                                                                                                    | #3813 landed                                                                                                                 | none                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| **A1** | **S-flush + the R deletions it unlocks.** `content = createMemo(() => host.landing(binding()))` — one reactive node per bound address resolved at the version's first root / error write (the host's `landing(address)`: a promise for a cold store, the value for a warm one); the enclosing `<Loading>` pends on it, a switch is a new flight (`_inFlight` supersession, 1.6 (i) by construction), a refetch's landing is staged by the Transaction that read it (G7 closes). Deletes: **R.gate** (`arm`/`release`/`settle`/`setGate`/`mountGate`, the adopted twin), **R.stage** (`stage` / `stageTables` / `stagedContent` / `CONTENT_TOKEN` / `STAGED_DATA` / `FrameImpl#preview` / `#regionsChange` / `host.preview`; the chunk buffer-until-`complete` stays, one write), **R.version** (2a: one applied record keyed by identity; `#appliedRoot`), **R.dedupe** (per-prop memos in `slotArgsProxy`; `argsEquivalent` / `#refArgsUnchanged` / `#slotResolvedRefs` go), **R.error**'s latch. Files: `frames/src/client.ts` (`boundaryComponent`, `adoptBoundary`, `followAddress`), `frame-transport.ts` (`stage*`, `handle`), `frame-client.ts` (`#apply`, `#flush`, `preview`, `#syncSlots`' dedupe arms).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | **≈ −1,150 / ≈ −1,150 / ≈ −1,150 / 0** (`est.` from the measured R total −1,863 with every feature kept, scaled to the 4,170 of 6,655 R-min these groups are; S-flush's own glue ≈ +110–190 min / +40 br is inside this)                                                                                    | none                                                                                                                                                               | **flip:** C5 (a, b, e) with the per-response data cell (1.2), C6 (b2), C7 (c), C17 (a); **C17 (c) re-pins** to 1.6 (i) `waiting → B`; C6 (b1) inverts (asserts the opposite of A0). Size: frames eager ≤ 12.7 KB (from 13.78), page base ≤ 43.7, live ≤ 47.5.                                                                                                                                                                                                                                                                | A0                                                                                                                           | **removed / changed:** `ServerComponentHandlerOptions.onStream`, `FrameHostOptions.resolve` / `FrameHost.resolve`, `FrameHost.preview` / `Frame.preview`, `STAGED_DATA` — the rulings' step-4 list. **New:** `FrameHost.landing(address)` (internal).                                                                                                                                                                                                     |
-| **A2** | **C3 via `initBoundaryResume` — S-hold** (the rulings' 3a, pulled forward: **this is what lets any later hold register**). `hydrateWindow(id, fn, roots?)` factored out of `resumeBoundaryHydration`; `initBoundaryResume`'s registration reachable from the adopter (`sharedConfig.resumeBoundary`); `adoptBoundary` registers the adopted frame's owner while `#syncSlots` leaves any adopt-time occurrence deferred (the held set — one registration per frame, 3.2) and releases when a sync leaves none or the frame disposes. The #2968 `setTimeout` poll becomes the registration with the drain's end as its bound (3.5); the resumed fill re-enters hydration through the window and claims under the producer's keys (C1 / C9 stay green). **With it, 3e ported onto `next`** (the detached root + the parked backlog beyond the snapshot, 3.6 (iii), without S1's `claiming` plumbing — the rulings' "else ≈ +90 / +25" arm, because S1 no longer lands first and the Phase A gate counts C19), and 3.2's release order (claim → hold release → done → backlog) pinned. Deletes **R.claim** (the range-scoped registry beside `gatherHydratable(el, root)`) and the counter half of **R.drain**. **Landed in two parts** — #3837 (`holdBoundary`) and #3840 (`hydrateWindow` + the R.claim deletion; the park unconditional, rulings 3.6 "Landed") — measured **frames −109 br / hydrating +105 br** against the −130 / +40 estimate; the maintainer accepted the hydrating cost (2026-10-06; caps raised under a Size-Exception at the next integration PR), and **every further solid-side seam (S-adopted next) is to be measured on an edited dist copy before it is written.**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **≈ −130 / ≈ −130 / ≈ −130 / ≈ +40** (`est.`: R.claim ≈ 472 min + R.drain's defer ≈ 270 min ≈ −215 br of cuts; the registration ≈ +100 min frames ≈ +60 br incl. the `hold` option; the 3e port ≈ +90 min / +25 br; solid `hydrateWindow` + the reach ≈ +40–65 min ≈ +12–20 br, the detached root ≈ +20 br) | none                                                                                                                                                               | **flip:** C3 (a) + the harness's C3 replay; C19 ×2 (3e); S1's C3 (b) flips at C3 (the traces tier). Size: frames eager ≤ 12.55; **app hydrating / compiled hydrating +≈ 40 br — the first cap raise, the maintainer's** (compiled hydrating is at its cap on this head: 30,943 vs 30.93 KB).                                                                                                                                                                                                                                 | A1 (the deferred set is right only once the drain is one write and the landing node exists)                                  | **solid:** `sharedConfig.resumeBoundary` or an `internal` export of the registration — no new counter, no new done path (3.1 ruled; the draft's `holdHydration` withdrawn); the detached projection root (3e). **frames:** `FrameOptions.hold(): () => void` (internal, wired by `adoptBoundary`).                                                                                                                                                        |
-| **A3** | **C2 / C4 — a reveal is an apply (S-reveal, interim 2b).** `fr.subscribe((_, parent) => el.contains(parent) && frame.sync(parent))` — a document `$df` into adopted content syncs the frame (2.3, 2.4); a bare `children` mounts at the revealed range (C2 b); a `#`-named occurrence found recordless is a pending read (C2 a2, through A2's hold). Deletes **R.reveal**'s readiness / retry model (`#segmentReady`'s retry loop, the `#revealed` / `#fallbackShown` second set) — the segment swap's DOM half stays (T.morph). DR-4's structural form (2c, the document fragment as a store write) is its own plan and not this step. **Landed** (2026-10-06, `fix/frames-a7-a3-error-throws-reveal-deletion`, with A7): the document-face half was #3837's (the empty write from the reveal cascade); the stream face's own half here — a revealed segment's content is applied as it is revealed, nested segments included (`#revealSegments(root)`), so `#flush` makes one pass and the second ledger (`#revealed` / `#fallbackShown` / `isRevealed`) deletes; the applied state is the content record / fallback gate by identity in the one applied map. **Measured −45 B min / ±0 br** on the frames eager client against A7's head: the fallback pass and the style gate — half the estimate's bytes — stay (F.assets keeps the gate; the pass keeps the reveal-before-fallback order). Pinned: two nested arms in the lifecycle matrix, one inside a pending boundary's detached content (which never revealed before).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **≈ −115 / ≈ −115 / ≈ −115 / 0** (`est.`: R.reveal 467 min ≈ −140 br; the one-liner +58 min / +23 br, measured as `Tglue-reveal` − `L8`)                                                                                                                                                                    | none                                                                                                                                                               | **flip:** C2 (a2, b) + the harness's C2 replay; C4 (d) (the ledger is the store; the drain is one write). Size: frames eager ≤ 12.45.                                                                                                                                                                                                                                                                                                                                                                                        | A1, A2                                                                                                                       | a `Frame` sync hook for the document reveal — internal, through the spread-cast options seam `adoptBoundary` already uses (rulings' list)                                                                                                                                                                                                                                                                                                                 |
-| **A4** | **C5 / C6 / C17 residue — S-record, S-ref.** **S-ref:** the codec table answers an undelivered `{$ref}` with a pending promise rejected at `complete` / `:error` (L1 — closes the silent-ref hole, re-attribution §5.3 item 1); a record's refs resolve through the table current at its apply (1.3) — the per-response data cell (1.2, ≈ 140 min, replacing `stageTables`) that A1 left as the C5 condition. **S-record:** the server half — the document sink writes `sc:slot:<fid>:<occ>` as a **declared** pending ref at the marker (as `registerFragment` writes `<id>_fr`) and settles it with the args, so `readHydratedValue`'s `.then` path carries the wait — or the solid write hook on `_$HY.r` (+40 B); either removes the poll's last reason. Deletes **R.refwait** (`#refsUnresolved`, the threaded `resolve`) and the poll half of **R.drain**.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | **≈ −15 / ≈ −15 / ≈ −15 / 0** (`est.`: R.refwait 145 min + the poll ≈ 120 min ≈ −75 br; the cell ≈ +45 br + reject-at-complete ≈ +15; decode chunk +≈ 60 B min for pending-on-missing — lazy, not counted)                                                                                                  | `decode.js` +≈ 60 B (S-ref)                                                                                                                                        | **flip:** C6 (a1); C5 (a, b, e) if A1 shipped them conditional; C17 (c) confirmed under 1.6 (i). Size: frames eager ≤ 12.45 (±).                                                                                                                                                                                                                                                                                                                                                                                             | A1 (the landing node), A2 (a pending read is a hold)                                                                         | **server:** the declared slot record (output shape, +≈ 30 B/record) **or solid:** the `_$HY.r` write hook (+40 B) — one of the two, the maintainer's pick (the declared record is recommended: it is A5's shape).                                                                                                                                                                                                                                         |
-| **A5** | **C12 (c) client half + `claimRegionFragments` — S-adopted, S-key.** **S-adopted:** `_adoptedRoots: Set<Element>` in `hydration.ts`; `fragmentPolicy` swaps an unclaimed fragment after `_hydrationDone` when its `pl-` placeholder is inside an adopted root (`_$HY.fr.adopt(el)` / `unadopt(el)` from `adoptBoundary`, ≈ 30 B frames) — G4 closes and **`claimRegionFragments`** (R.claimant) deletes. **S-key:** `whenRevealed` published on `_$HY.fr` (+≈ 15 B solid) and the SC reference carries its covering fragment key (+≈ 30 B server); `installRevealHook`'s rescan and `boundaryWaiters` (D) collapse into `whenRevealed(key).then(...)`. **C12 (c) client half:** the adopted face shows what the server rendered (A0 withdraws the pin's expectation, 3.3); post-done the swap goes through S-adopted rather than freezing the fallback — the pin's **server half** (the sink's error markup) is A6's draft. **Landed as A5′ (2026-10-06, ruled 12:55: _a placeholder inside a server component's element is the frame's content by rendering, not by adoption_).** Measured before written: A5 as specified came in at **+504 min** solid on hydrating (no stores) (S-adopted +221 / S-key +283), so the shape changed — **(h)** an ownership predicate `_$HY.fa(placeholder)` the ledger's `fragmentPolicy` asks (geometry: the `pl-*` inside a live `data-fid` element), no `_adoptedRoots`, no claim, no replay, `_$HY.fr.claim`/`release` removed; **G9** by collapsing `documentBoundary`'s wait onto the intercept's `awaitBoundary` (`boundaryWaiters` deleted); the exhaustion fix (`fragmentPending` reads a revealed fragment from `_$HY.v` before its `_fr` stamp — the real producer order); a C14 guard (`disposedFrames`, a boundary disposed in place disowns its placeholders). **Measured:** hydrating (no stores) **+50 min / +5 br** (est. ≈ +20 min solid), frames eager **−204 / −51** (est. −135 min / ≈ −65 br; the pre-guard (h)+G9 edit measured −320 — the C14 guard is the ≈ +116 between), page base **−156 / −81**, live **−156 / +3**. **S-key not built** (reachability: the hydrating flow never reaches the late-boundary wait — a client `<Loading>` twin's resume gates it; the intercept has no key to collapse onto; nested splices need covering-chain semantics; measured frames half −18 min for +283 solid). | **≈ −65 / ≈ −65 / ≈ −65 / ≈ +5** (`est.`: R.claimant 153 min + `boundaryWaiters` ≈ 110 min + the rescan's rebind ≈ 80 min ≈ −95 br; frames glue ≈ +30 br; solid `_adoptedRoots` + `whenRevealed` ≈ +20 min net of the detached root already paid in A2)                                                     | none                                                                                                                                                               | **flip:** C12 (c) client arm (shows the server's outcome; swaps post-done); the G4 and G9 timing pins (new: `adopted-swap-post-done.spec`, `boundary-arrival.spec`). Size: frames eager ≤ 12.35; hydrating scenarios +≈ 5 (inside A2's raise).                                                                                                                                                                                                                                                                               | A2 (the adopted frame's registration is what `fr.adopt` keys off), A3                                                        | **solid:** `_$HY.fr.adopt/unadopt`, `whenRevealed` on `_$HY.fr`. **server:** the fragment key on the SC reference (+30 B of output).                                                                                                                                                                                                                                                                                                                      |
-| **A6** | **Server-half drafts — design, no wire change in this step.** (i) **C13's sweep delimiter** (R7): a multi-record `FrameChunk` member `{ type: "ops", ops: [...] }` the sink emits per sweep and the client applies as one write — the only wire item in the rulings' list, drafted as an RFC 11 addendum with the client's one-write apply (A1's shape already applies a write atomically). (ii) **The plain-response streaming bound** (§6 decision 4): `complete` gains `bound: "yields" \| "time"`; the sink ends a plain response at the bound. (iii) **C12 (c)'s error template**: the document face renders a rejected server `<Loading>`'s error outcome into the fragment (3.3's server half) instead of the blank. Each is a design note + a `test.fails` pin written against the draft; the server PRs follow the drafts and flip C13 (a, b) and C12 (c)'s server arm — Phase A is taken as done when the drafts are reviewed and those PRs are open.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 0 (design)                                                                                                                                                                                                                                                                                                  | —                                                                                                                                                                  | the three drafts reviewed; pins written (`.fails`). **Phase A gate taken here:** 22 reds green / unrepresentable except the three server-half arms, drafts attached; harness clean on two seeds; frames eager ≈ 12.3 < 13.77.                                                                                                                                                                                                                                                                                                | A1–A5                                                                                                                        | **wire (drafted, not shipped):** the `ops` chunk member; `complete.bound`. Decision 4.                                                                                                                                                                                                                                                                                                                                                                    |
-| **B**  | **The tier mechanism** (§2): `sink.needs(tier)` at the five mint sites; `X-Frame-Tiers` at first flush; `sc:tiers` record + `modulepreload` links on the document face; `prepareTier(name)` + `installTier`; the **held set is A2's registered set** — a tier's adopt-path hold is one more reason an occurrence is deferred, so it registers under 3.1 from day one. No tier is cut yet — this step is the seam alone, measured. S1's `prepareData` / `prepareArgs` are not in the tree (S1 has not merged); the general seam is built directly and S1 re-bases onto it at C3.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | **≈ +100 / ≈ +100 / ≈ +100 / 0** gross (`est.`); server ≈ +300–450 min. S1's two faces (+543 min / +134 br) are never shipped — the ≈ −35 net the earlier draft credited here appears at C3 instead, as "S1 re-based costs less than S1 as built".                                                          | none new                                                                                                                                                           | `tier-announce.spec`, `tier-prepare.spec` (new); artifacts re-recorded once. Size: frames eager ≤ 12.45.                                                                                                                                                                                                                                                                                                                                                                                                                     | **the Phase A gate**; A2 (the holds register), A1 (the `landing` node is what an installed tier's `flush()` wakes)           | **wire (additive):** `X-Frame-Tiers`, `_$HY.r["sc:tiers"]`, the links. Decision 3.                                                                                                                                                                                                                                                                                                                                                                        |
-| **C1** | **Holes tier** (E.a1; cheapest, buffer-only). `tier-holes.js` = `#applyHole`, `#applyAttrs` (less its owned-position arms, which are bind's), `findLiveTarget`, the hole pass, `pumpLiveChannel` + the op log + `applyLiveOp`. The eager client keeps `chunkToRecords`' `hole` / `attr` cases (records must land in the store before the tier is resident) and a one-line dispatch in `#flush`. Under the **8.0 reading** this step is skipped and holes stay eager (§6 decision 1).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | **−546 / −508 / −508 / 0** (measured: `T+holes` → `L8`; page `T+holes` → `L8`; live page the same cut)                                                                                                                                                                                                      | `tier-holes.js` ≈ 1,900 min / **≈ 620 br** (`est.`: the 2,116-min cut as its own module + the install glue)                                                        | `tier-holes-buffer.spec` (new, §1); C13 control + C18 catch-up arms unchanged; `frames-live-holes-*`, `document-live-*` green through the tier. Size: frames eager ≤ 11.9.                                                                                                                                                                                                                                                                                                                                                   | B                                                                                                                            | none (the record shapes and `sc:live` are unchanged; the hole appliers were never exported)                                                                                                                                                                                                                                                                                                                                                               |
-| **C2** | **Live wire tier** (E.a2; preload-at-call). `tier-wire.js` = `connections` / `hold` / the join-or-hold arm of `handle`, `resume` + `encodeHaveList` / `FRAME_HAVE_*`, the have-list ledger (`#have` / `have()` / `#recordHave` and the record fields that feed it), `applyFrames`' connection wiring + `connection.cancel`, `isEventStream` + the SSE reader selection, `deserializeStream`'s live arm. The eager client keeps a one-line `LIVE_WIRE` dispatch in `handle` and `bump`'s cancel hook (a no-op without the tier). `live()`'s decorator fires the `onLive` hook (set by frames through `configureServerFunctionsClient`) that calls `prepareTier("wire")` before its first fetch; the arm awaits it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **−433 / −355 / −355 / 0** (measured: `T+wire` → `L8`; the live page keeps the chunk lazy — its eager measurement drops the same bytes)                                                                                                                                                                     | `tier-wire.js` ≈ 1,300 min / **≈ 470 br** (`est.`)                                                                                                                 | `tier-wire-preload.spec` (new); the live suite green; the audit's `live` branch gap (22/61) closed to ≥ 45/61 in the same PR (the tier's own tests). Size: frames eager ≤ 11.5; live page unchanged ±50 (the chunk is reported, not counted).                                                                                                                                                                                                                                                                                | B; independent of C1                                                                                                         | `ServerFunctionsClientConfig.onLive` (new, internal hook on `configureServerFunctionsClient`); `FRAME_HAVE_HEADER` / `FRAME_HAVE_BUDGET` are exported constants today and move to the tier's module — **re-export from the eager entry** to keep the surface, or flag the move                                                                                                                                                                            |
-| **C3** | **Traces tier = S1 re-based** (§5; S1 merges **here**, not first). The materializer entry (`solid-js/internal/container-trace`) and `loadContainers` as S1 built them; S1's `prepareData` / `prepareArgs` / `#argsUnprepared` become B's `prepareTier("trace")` + A2's registered held set; the codec-face node scan stays as the un-announced fallback behind the header flag; the eager half of F.trace (`reviveContainerTraces` / `materialize` / `isContainerTraceMarker` / `isMaterializedContainer` / `setContainerTraceMaterializer` / `getFrameHost.revive`) moves into `container-trace.js`'s `installTier`, leaving a ≈ 150-min trigger. S1's commit 3 re-bases onto A2's park: the `claiming` hint (`revive(value, claiming?)`) and the held-record mount land here, the detached root and the backlog are already on `next`. **`container-trace-hold-hydration-end` re-pins under 3.1 at merge** (A2 is in). The +134 B frames exception S1 as built would have needed **never needs granting**: B's seam is already paid and the tier cut is a saving.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | **≈ −250 / ≈ −6,640 / ≈ −6,600 / 0** (S1's measured page savings −6,390 / −6,352 plus F.trace's eager half: 843 attributed, −289 measured as `T+trace` → `L8`, less the trigger ≈ −250; S1's +134 on frames does not recur — its two faces are B's seam)                                                    | `container-trace.js` 24.3 KB / **7.86 KB br measured** (S1) + the eager half (≈ +700 min / +200 br → ≈ 8.1 KB br)                                                  | S1's seven surviving pins green through the general seam (`frames-container-lazy-{codec,document}`, `hydration/welcome-status-lazy`, `container-trace-hold-{id-determinism, interruption, record-retention, snapshot}`); **re-pin** `container-trace-hold-hydration-end` (_hydration waits for the load; the mount claims before done_); **flip** S1's C3 (b); the `.fails` id-drift pin → 3.4 (3c). Size: frames eager ≤ 11.25; page base ≤ 36.0, live ≤ 39.8 (S1's caps 38.45 / 42.12 are superseded by these at landing). | B, A2 (the hold registers; the park is on `next`), A3                                                                        | S1's: `revive(value, claiming?)`, `setContainerTraceMaterializer(…, claiming?)`, the entry, `withStoreHydration` / `applyPatches` / `forwardIteratorReturn` `@internal` on the main entry; **not shipped:** S1's `prepareData` / `prepareArgs` (replaced by `prepareTier` before they exist on `next`). `reviveContainerTraces` / `setContainerTraceMaterializer` move behind the tier — **flag**: re-export lazily-resolving wrappers or accept the move |
-| **C4** | **Regions tier.** `tier-regions.js` = `#bindRegions` / `#regionsFor` / `#discoverRegions` / `collectRegionElements` / `disposeRegions` / `makeFrameElement` / `isFrameRef`, the `{$frame}` arm of `#resolveArgs`, the `resolveSlot` / `resolveSlotRecord` / `removeSlotRecord` thread-up, `tableFor`'s prefix walk, `drainRecords`' `sc:region:` arm. The eager client keeps the `{$frame}` detection in `#resolveArgs` (one `isFrameRef` test → hold, registered). The rename machinery (`renameRegion` / `#reconcileRegions`, D) deletes outright — it is not moved.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **−489 / ≈ −480 / ≈ −480 / 0** (measured on frames: `T+regions` → `L8`; pages `est.` at the same cut)                                                                                                                                                                                                       | `tier-regions.js` ≈ 1,900 min / **≈ 540 br** (`est.`)                                                                                                              | `tier-regions-hold.spec` (new); `frames-regions-*`, lifecycle matrix region rows green; principles §4 row 19 (the rename compensations) deleted with D. Size: frames eager ≤ 10.75.                                                                                                                                                                                                                                                                                                                                          | B, A2 (the adopt-path hold registers — no 3.1 gap to flag)                                                                   | none (`createFrameElement` stays eager — it is `@experimental` public API, re-attribution §5.3 item 5)                                                                                                                                                                                                                                                                                                                                                    |
-| **C5** | **Assets tier.** `tier-assets.js` = `ensureStylesheet` / `ensurePreload` / `ensureModulePreload` / `applyInlineStyles` / `qualifierValue` / `findHeadElement` / `PRELOAD_QUALIFIERS` / `#processedAssets` / `#styleFlush` / the assets pass; the eager client keeps `chunkToRecords`' `assets` case, `host.write`'s `seg::assets` accumulate, and the `#segmentReady` term. **Pin the two untested functions first** (`ensureStylesheet`, `applyInlineStyles` — the audit's 0-coverage gap) in the same PR. Alternative under decision 2: S10's route-through-`web` instead of a tier.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **−684 / ≈ −665 / ≈ −665 / 0** (measured on frames: `T+assets` → `L8`; the `noassets` full-client cut −665)                                                                                                                                                                                                 | `tier-assets.js` ≈ 2,400 min / **≈ 760 br** (`est.`)                                                                                                               | `tier-assets-ready.spec` (new, the FOUC guard); `frames-assets-*` green; the two new coverage pins. Size: frames eager ≤ 10.05.                                                                                                                                                                                                                                                                                                                                                                                              | B                                                                                                                            | none                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| **C6** | **Binding-slot tier** (E.c; largest, last of the tiers — its fallback needs the 3.1 hold for the event-replay window, which A2 provides). `tier-bind.js` = `bindDataOccurrence` (+ `valuesFor` / `write` / `release` / `writeText`; its second diff layer above `assign` — ≈ 300 B, D — deletes rather than moves), `slotPositions` / `slotEntry` / `textPosition` / `consumersOf` / `consumersEqual` / `ownedPositions` / `morphOwnedClass` / `morphOwnedStyle` / `applyOwned`, the `_s:` branch of `collectSlots`, the consumer-rebind arm of `#syncSlots`, the owned-position arms of `morphAttributes` / `reconcileChildren` / `#applyAttrs`, the `ctx.positions` branch of `slotsFor`; **`assign` leaves the eager frames client with it** (the page then keeps `assign` only through `dynamic`'s string tag — B.3, D).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | **−1,546 / −2,504 / −2,542 / 0** (frames measured `T+bind` → `L8`; pages: the audit's E.c measurement — `assign` leaves on the page too)                                                                                                                                                                    | `tier-bind.js` ≈ 5,000 min / **≈ 1,650 br** on frames (`est.`); on a page it carries `assign` as well (≈ +3,000 min / +900 br) unless B.3 has already made it lazy | `tier-bind-hold.spec` (new, incl. the click-replay arm); `frames-binding-slot-*`, `slot-positions-*`, #3704 / #3714 suites green. Size: frames eager ≤ 8.5 (both readings), page base ≤ 32.35, live ≤ 36.1.                                                                                                                                                                                                                                                                                                                  | B, **A2** (the hold registers; the replay window stays open); C3 (the `installTier` shape proven on the biggest chunk first) | none public (the `_s:` marker grammar is unchanged; `bindDataOccurrence` was never exported)                                                                                                                                                                                                                                                                                                                                                              |
-| **D**  | **Packaging remnants from the SC audit, if still relevant after tiering.** **S2 / C** `preserveModules` for `solid-js` / `@solidjs/web` (0 on single-entry scenarios; the enabler): lets the store **hydration adapters** (≈ 2.6 KB min, the ≈ 1.3 KB br S1 fell short of B.2's floor by) follow the engine into `container-trace.js`, and lets **B.3** (`dynamic`'s string-tag branch lazy, `staticElement` behind the seam) take `assign` off the page. **B.3:** page −2,372 / −2,391 br (audit measured), frames 0. **E.b** (sf natural-encoding bodies, codec-args message, `Retry-After` / trailer parsing lazy): −65 frames / −476 base / −519 live (audit floor). **E.c's other half** is C6. **Lazy codec:** already a chunk (22,986 / 6,074) — nothing to do. **Claims + event** (F.claims, F.event, 331 br): not a frames tier — they ride the router's chunk (the router installs `CLAIM_SEAM`); the frames client keeps the ≈ 60-B seam.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | **≈ −400 / ≈ −4,100 / ≈ −4,200 / 0** (`est.`: claims+event −331 frames; B.3 −2,372, the adapters ≈ −1,300, E.b −476 on page base)                                                                                                                                                                           | `dynamic-static.js` ≈ 8,000 min / ≈ 2.4 KB br; the sf natural-body chunk ≈ 1,600 min / ≈ 480 br; the router's claims chunk ≈ 900 min / ≈ 330 br                    | the audit's S2 band (single-entry scenarios ≤ ±50 B); B.3's hydration specs; `CLAIM_SEAM` tests with the router. Size: frames eager ≤ 8.1, page base ≤ 28.2, live ≤ 31.8.                                                                                                                                                                                                                                                                                                                                                    | C3, C6 (so what leaves with the engine and with `assign` is known)                                                           | B.3: `dynamic`'s string-tag branch becomes async-loading on first use (behaviour change accepted in audit §7 Q5 / B.3); the `CLAIM_SEAM` install moves to the router                                                                                                                                                                                                                                                                                      |
-| **E**  | **Budget restatement — principles §6 as per-tier lines** (§4's table is the draft). One line per eager default (both readings written, one picked), one per tier chunk, the page lines, the ratchet rule unchanged ("a ceiling increase requires a new mechanism row citing its axiom"), `floor-caps.json` gains the tier chunks as reported-not-counted lines with their own caps.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 0                                                                                                                                                                                                                                                                                                           | —                                                                                                                                                                  | `check-floor-caps` clean on `next`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | all                                                                                                                          | —                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| #      | step                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Δ br (frames eager / page base / page live / compiled hydrating)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | chunks created                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | gates (pins flip; size)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | depends on                                                                                                                                                                       | surface                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **A0** | **C18 — classification waits for the drain** (rulings step 1, 3d / 3.5; **in flight**). The predicate is one term in `adoptBoundary.recordsPending`: a `prop#n` occurrence is classified only after every delivered record has drained. The only page-halting red; lands as the rulings specified it. A1 then makes the mechanism moot (one write per drain; `#` decides the class — C18 becomes unrepresentable) and the pins stay as the assertion of the pending read.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | **≈ +15 / +15 / +15 / 0** (the rulings' ≈ +50 min / +15 br; ≈ +25 br with the batched drain, which A1 supersedes)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | none                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **flip:** C18 ×3. Size: ±0.02 KB on every scenario (frames eager ≤ 13.8).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | #3813 landed                                                                                                                                                                     | none                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| **A1** | **S-flush + the R deletions it unlocks.** `content = createMemo(() => host.landing(binding()))` — one reactive node per bound address resolved at the version's first root / error write (the host's `landing(address)`: a promise for a cold store, the value for a warm one); the enclosing `<Loading>` pends on it, a switch is a new flight (`_inFlight` supersession, 1.6 (i) by construction), a refetch's landing is staged by the Transaction that read it (G7 closes). Deletes: **R.gate** (`arm`/`release`/`settle`/`setGate`/`mountGate`, the adopted twin), **R.stage** (`stage` / `stageTables` / `stagedContent` / `CONTENT_TOKEN` / `STAGED_DATA` / `FrameImpl#preview` / `#regionsChange` / `host.preview`; the chunk buffer-until-`complete` stays, one write), **R.version** (2a: one applied record keyed by identity; `#appliedRoot`), **R.dedupe** (per-prop memos in `slotArgsProxy`; `argsEquivalent` / `#refArgsUnchanged` / `#slotResolvedRefs` go), **R.error**'s latch. Files: `frames/src/client.ts` (`boundaryComponent`, `adoptBoundary`, `followAddress`), `frame-transport.ts` (`stage*`, `handle`), `frame-client.ts` (`#apply`, `#flush`, `preview`, `#syncSlots`' dedupe arms).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **≈ −1,150 / ≈ −1,150 / ≈ −1,150 / 0** (`est.` from the measured R total −1,863 with every feature kept, scaled to the 4,170 of 6,655 R-min these groups are; S-flush's own glue ≈ +110–190 min / +40 br is inside this)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | none                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **flip:** C5 (a, b, e) with the per-response data cell (1.2), C6 (b2), C7 (c), C17 (a); **C17 (c) re-pins** to 1.6 (i) `waiting → B`; C6 (b1) inverts (asserts the opposite of A0). Size: frames eager ≤ 12.7 KB (from 13.78), page base ≤ 43.7, live ≤ 47.5.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | A0                                                                                                                                                                               | **removed / changed:** `ServerComponentHandlerOptions.onStream`, `FrameHostOptions.resolve` / `FrameHost.resolve`, `FrameHost.preview` / `Frame.preview`, `STAGED_DATA` — the rulings' step-4 list. **New:** `FrameHost.landing(address)` (internal).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| **A2** | **C3 via `initBoundaryResume` — S-hold** (the rulings' 3a, pulled forward: **this is what lets any later hold register**). `hydrateWindow(id, fn, roots?)` factored out of `resumeBoundaryHydration`; `initBoundaryResume`'s registration reachable from the adopter (`sharedConfig.resumeBoundary`); `adoptBoundary` registers the adopted frame's owner while `#syncSlots` leaves any adopt-time occurrence deferred (the held set — one registration per frame, 3.2) and releases when a sync leaves none or the frame disposes. The #2968 `setTimeout` poll becomes the registration with the drain's end as its bound (3.5); the resumed fill re-enters hydration through the window and claims under the producer's keys (C1 / C9 stay green). **With it, 3e ported onto `next`** (the detached root + the parked backlog beyond the snapshot, 3.6 (iii), without S1's `claiming` plumbing — the rulings' "else ≈ +90 / +25" arm, because S1 no longer lands first and the Phase A gate counts C19), and 3.2's release order (claim → hold release → done → backlog) pinned. Deletes **R.claim** (the range-scoped registry beside `gatherHydratable(el, root)`) and the counter half of **R.drain**. **Landed in two parts** — #3837 (`holdBoundary`) and #3840 (`hydrateWindow` + the R.claim deletion; the park unconditional, rulings 3.6 "Landed") — measured **frames −109 br / hydrating +105 br** against the −130 / +40 estimate; the maintainer accepted the hydrating cost (2026-10-06; caps raised under a Size-Exception at the next integration PR), and **every further solid-side seam (S-adopted next) is to be measured on an edited dist copy before it is written.**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | **≈ −130 / ≈ −130 / ≈ −130 / ≈ +40** (`est.`: R.claim ≈ 472 min + R.drain's defer ≈ 270 min ≈ −215 br of cuts; the registration ≈ +100 min frames ≈ +60 br incl. the `hold` option; the 3e port ≈ +90 min / +25 br; solid `hydrateWindow` + the reach ≈ +40–65 min ≈ +12–20 br, the detached root ≈ +20 br)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | none                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **flip:** C3 (a) + the harness's C3 replay; C19 ×2 (3e); S1's C3 (b) flips at C3 (the traces tier). Size: frames eager ≤ 12.55; **app hydrating / compiled hydrating +≈ 40 br — the first cap raise, the maintainer's** (compiled hydrating is at its cap on this head: 30,943 vs 30.93 KB).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | A1 (the deferred set is right only once the drain is one write and the landing node exists)                                                                                      | **solid:** `sharedConfig.resumeBoundary` or an `internal` export of the registration — no new counter, no new done path (3.1 ruled; the draft's `holdHydration` withdrawn); the detached projection root (3e). **frames:** `FrameOptions.hold(): () => void` (internal, wired by `adoptBoundary`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| **A3** | **C2 / C4 — a reveal is an apply (S-reveal, interim 2b).** `fr.subscribe((_, parent) => el.contains(parent) && frame.sync(parent))` — a document `$df` into adopted content syncs the frame (2.3, 2.4); a bare `children` mounts at the revealed range (C2 b); a `#`-named occurrence found recordless is a pending read (C2 a2, through A2's hold). Deletes **R.reveal**'s readiness / retry model (`#segmentReady`'s retry loop, the `#revealed` / `#fallbackShown` second set) — the segment swap's DOM half stays (T.morph). DR-4's structural form (2c, the document fragment as a store write) is its own plan and not this step. **Landed** (2026-10-06, `fix/frames-a7-a3-error-throws-reveal-deletion`, with A7): the document-face half was #3837's (the empty write from the reveal cascade); the stream face's own half here — a revealed segment's content is applied as it is revealed, nested segments included (`#revealSegments(root)`), so `#flush` makes one pass and the second ledger (`#revealed` / `#fallbackShown` / `isRevealed`) deletes; the applied state is the content record / fallback gate by identity in the one applied map. **Measured −45 B min / ±0 br** on the frames eager client against A7's head: the fallback pass and the style gate — half the estimate's bytes — stay (F.assets keeps the gate; the pass keeps the reveal-before-fallback order). Pinned: two nested arms in the lifecycle matrix, one inside a pending boundary's detached content (which never revealed before).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | **≈ −115 / ≈ −115 / ≈ −115 / 0** (`est.`: R.reveal 467 min ≈ −140 br; the one-liner +58 min / +23 br, measured as `Tglue-reveal` − `L8`)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | none                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **flip:** C2 (a2, b) + the harness's C2 replay; C4 (d) (the ledger is the store; the drain is one write). Size: frames eager ≤ 12.45.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | A1, A2                                                                                                                                                                           | a `Frame` sync hook for the document reveal — internal, through the spread-cast options seam `adoptBoundary` already uses (rulings' list)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| **A4** | **C5 / C6 / C17 residue — S-record, S-ref.** **S-ref:** the codec table answers an undelivered `{$ref}` with a pending promise rejected at `complete` / `:error` (L1 — closes the silent-ref hole, re-attribution §5.3 item 1); a record's refs resolve through the table current at its apply (1.3) — the per-response data cell (1.2, ≈ 140 min, replacing `stageTables`) that A1 left as the C5 condition. **S-record:** the server half — the document sink writes `sc:slot:<fid>:<occ>` as a **declared** pending ref at the marker (as `registerFragment` writes `<id>_fr`) and settles it with the args, so `readHydratedValue`'s `.then` path carries the wait — or the solid write hook on `_$HY.r` (+40 B); either removes the poll's last reason. Deletes **R.refwait** (`#refsUnresolved`, the threaded `resolve`) and the poll half of **R.drain**.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | **≈ −15 / ≈ −15 / ≈ −15 / 0** (`est.`: R.refwait 145 min + the poll ≈ 120 min ≈ −75 br; the cell ≈ +45 br + reject-at-complete ≈ +15; decode chunk +≈ 60 B min for pending-on-missing — lazy, not counted)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `decode.js` +≈ 60 B (S-ref)                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **flip:** C6 (a1); C5 (a, b, e) if A1 shipped them conditional; C17 (c) confirmed under 1.6 (i). Size: frames eager ≤ 12.45 (±).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | A1 (the landing node), A2 (a pending read is a hold)                                                                                                                             | **server:** the declared slot record (output shape, +≈ 30 B/record) **or solid:** the `_$HY.r` write hook (+40 B) — one of the two, the maintainer's pick (the declared record is recommended: it is A5's shape).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| **A5** | **C12 (c) client half + `claimRegionFragments` — S-adopted, S-key.** **S-adopted:** `_adoptedRoots: Set<Element>` in `hydration.ts`; `fragmentPolicy` swaps an unclaimed fragment after `_hydrationDone` when its `pl-` placeholder is inside an adopted root (`_$HY.fr.adopt(el)` / `unadopt(el)` from `adoptBoundary`, ≈ 30 B frames) — G4 closes and **`claimRegionFragments`** (R.claimant) deletes. **S-key:** `whenRevealed` published on `_$HY.fr` (+≈ 15 B solid) and the SC reference carries its covering fragment key (+≈ 30 B server); `installRevealHook`'s rescan and `boundaryWaiters` (D) collapse into `whenRevealed(key).then(...)`. **C12 (c) client half:** the adopted face shows what the server rendered (A0 withdraws the pin's expectation, 3.3); post-done the swap goes through S-adopted rather than freezing the fallback — the pin's **server half** (the sink's error markup) is A6's draft. **Landed as A5′ (2026-10-06, ruled 12:55: _a placeholder inside a server component's element is the frame's content by rendering, not by adoption_).** Measured before written: A5 as specified came in at **+504 min** solid on hydrating (no stores) (S-adopted +221 / S-key +283), so the shape changed — **(h)** an ownership predicate `_$HY.fa(placeholder)` the ledger's `fragmentPolicy` asks (geometry: the `pl-*` inside a live `data-fid` element), no `_adoptedRoots`, no claim, no replay, `_$HY.fr.claim`/`release` removed; **G9** by collapsing `documentBoundary`'s wait onto the intercept's `awaitBoundary` (`boundaryWaiters` deleted); the exhaustion fix (`fragmentPending` reads a revealed fragment from `_$HY.v` before its `_fr` stamp — the real producer order); a C14 guard (`disposedFrames`, a boundary disposed in place disowns its placeholders). **Measured:** hydrating (no stores) **+50 min / +5 br** (est. ≈ +20 min solid), frames eager **−204 / −51** (est. −135 min / ≈ −65 br; the pre-guard (h)+G9 edit measured −320 — the C14 guard is the ≈ +116 between), page base **−156 / −81**, live **−156 / +3**. **S-key not built** (reachability: the hydrating flow never reaches the late-boundary wait — a client `<Loading>` twin's resume gates it; the intercept has no key to collapse onto; nested splices need covering-chain semantics; measured frames half −18 min for +283 solid).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | **≈ −65 / ≈ −65 / ≈ −65 / ≈ +5** (`est.`: R.claimant 153 min + `boundaryWaiters` ≈ 110 min + the rescan's rebind ≈ 80 min ≈ −95 br; frames glue ≈ +30 br; solid `_adoptedRoots` + `whenRevealed` ≈ +20 min net of the detached root already paid in A2)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | none                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | **flip:** C12 (c) client arm (shows the server's outcome; swaps post-done); the G4 and G9 timing pins (new: `adopted-swap-post-done.spec`, `boundary-arrival.spec`). Size: frames eager ≤ 12.35; hydrating scenarios +≈ 5 (inside A2's raise).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | A2 (the adopted frame's registration is what `fr.adopt` keys off), A3                                                                                                            | **solid:** `_$HY.fr.adopt/unadopt`, `whenRevealed` on `_$HY.fr`. **server:** the fragment key on the SC reference (+30 B of output).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| **A6** | **Server-half drafts — design, no wire change in this step.** (i) **C13's sweep delimiter** (R7): a multi-record `FrameChunk` member `{ type: "ops", ops: [...] }` the sink emits per sweep and the client applies as one write — the only wire item in the rulings' list, drafted as an RFC 11 addendum with the client's one-write apply (A1's shape already applies a write atomically). (ii) **The plain-response streaming bound** (§6 decision 4): `complete` gains `bound: "yields" \| "time"`; the sink ends a plain response at the bound. (iii) **C12 (c)'s error template**: the document face renders a rejected server `<Loading>`'s error outcome into the fragment (3.3's server half) instead of the blank. Each is a design note + a `test.fails` pin written against the draft; the server PRs follow the drafts and flip C13 (a, b) and C12 (c)'s server arm — Phase A is taken as done when the drafts are reviewed and those PRs are open.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 0 (design)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | —                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | the three drafts reviewed; pins written (`.fails`). **Phase A gate taken here:** 22 reds green / unrepresentable except the three server-half arms, drafts attached; harness clean on two seeds; frames eager ≈ 12.3 < 13.77.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | A1–A5                                                                                                                                                                            | **wire (drafted, not shipped):** the `ops` chunk member; `complete.bound`. Decision 4.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| **B**  | **The tier mechanism** (§2): `sink.needs(tier)` at the five mint sites; `X-Frame-Tiers` at first flush; `sc:tiers` record + `modulepreload` links on the document face; `prepareTier(name)` + `installTier`; the **held set is A2's registered set** — a tier's adopt-path hold is one more reason an occurrence is deferred, so it registers under 3.1 from day one. No tier is cut yet — this step is the seam alone, measured. S1's `prepareData` / `prepareArgs` are not in the tree (S1 has not merged); the general seam is built directly and S1 re-bases onto it at C3. **Landed** (2026-10-06, `feat/frames-tier-mechanism`, measured before written — §2 "Landed"): frames eager **+473 min / +145 br** (≤ the +150 budget; est. ≈ +100, ×2.5 pre-estimate ≈ +250), pages +478 min, non-SC scenarios 0; frames server dist +793 min. `installServerComponents` gained `{ tiers }` (the client's loader map); the in-band form is `FrameChunk.tiers` on the next chunk out; the document face writes `sc:tiers` cumulative and a `modulepreload` only when `frameTransformDirectResult` is given `tierUrls` (decision 3 sub-item). Pins `tier-announce.spec` (14) / `tier-prepare.spec` (8); 5 of 150 artifacts re-recorded.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | **≈ +100 / ≈ +100 / ≈ +100 / 0** gross (`est.`); server ≈ +300–450 min. S1's two faces (+543 min / +134 br) are never shipped — the ≈ −35 net the earlier draft credited here appears at C3 instead, as "S1 re-based costs less than S1 as built". **Measured: +145 / +177 / +158 / 0** br (+473 / +478 / +478 / 0 min); server +793 min.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | none new                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `tier-announce.spec`, `tier-prepare.spec` (new); artifacts re-recorded once. Size: frames eager ≤ 12.45. **Landed:** both specs green; 5 artifacts; frames eager 13,949 br (the 12.45 gate assumed Phase A savings that did not materialize — the cap is the maintainer's).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **the Phase A gate**; A2 (the holds register), A1 (the `landing` node is what an installed tier's `flush()` wakes)                                                               | **wire (additive):** `X-Frame-Tiers`, `_$HY.r["sc:tiers"]`, the links. Decision 3. **Landed:** also `installServerComponents(host?, { tiers })`, `frameTransformDirectResult`'s `tierUrls`, `FRAME_TIERS_HEADER` (server entry), `FrameChunk.tiers` (`TierAnnouncement`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| **C1** | **Holes tier** (E.a1; cheapest, buffer-only). `tier-holes.js` = `#applyHole`, `#applyAttrs` (less its owned-position arms, which are bind's), `findLiveTarget`, the hole pass, `pumpLiveChannel` + the op log + `applyLiveOp`. The eager client keeps `chunkToRecords`' `hole` / `attr` cases (records must land in the store before the tier is resident) and a one-line dispatch in `#flush`. Under the **8.0 reading** this step is skipped and holes stay eager (§6 decision 1).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | **−546 / −508 / −508 / 0** (measured: `T+holes` → `L8`; page `T+holes` → `L8`; live page the same cut)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | `tier-holes.js` ≈ 1,900 min / **≈ 620 br** (`est.`: the 2,116-min cut as its own module + the install glue)                                                                                                                                                                                                                                                                                                                                                                                 | `tier-holes-buffer.spec` (new, §1); C13 control + C18 catch-up arms unchanged; `frames-live-holes-*`, `document-live-*` green through the tier. Size: frames eager ≤ 11.9.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | B                                                                                                                                                                                | none (the record shapes and `sc:live` are unchanged; the hole appliers were never exported)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| **C2** | **Live wire tier** (E.a2; preload-at-call). `tier-wire.js` = `connections` / `hold` / the join-or-hold arm of `handle`, `resume` + `encodeHaveList` / `FRAME_HAVE_*`, the have-list ledger (`#have` / `have()` / `#recordHave` and the record fields that feed it), `applyFrames`' connection wiring + `connection.cancel`, `isEventStream` + the SSE reader selection, `deserializeStream`'s live arm. The eager client keeps a one-line `LIVE_WIRE` dispatch in `handle` and `bump`'s cancel hook (a no-op without the tier). `live()`'s decorator fires the `onLive` hook (set by frames through `configureServerFunctionsClient`) that calls `prepareTier("wire")` before its first fetch; the arm awaits it. **Landed (2026-10-07, `feat/frames-wire-tier`, on R4's head `55eb4c346`) — the `lean` form, as ruled:** `frames/src/wire-tier.ts` → `@solidjs/web/frames/wire` (`frames/dist/wire.js`), the sixth lazy chunk. The tier owns the connection (`connect`: the open-frame count the body's end is judged by — a death with frames open vs a completion; the join of a second loop onto a live address; `connection.ended` / `cancel`), the supersession cancel `bump` reaches through `tierLoads.wire?.r?.cancel`, the have-list ledger per mount (`have` / `haveOf`, fed by the client's `#recordHave` through the same slot) with `encodeHaveList` and the `FRAME_HAVE_*` literals bundled, and the resume shape (`resume` → `{ position, headers }`). The eager client keeps: `applyFrames` reading `options[LIVE_WIRE]` as its reader; `handle`'s live arm — `prepareTier("wire").then(() => tierLoads.wire.r.connect(...))`; `onLive() { prepareTier("wire") }`; `resume` delegating. The hook rides `responseHandler.onLive` (no new `ServerFunctionsClientConfig` key — ≈ −45 br on the pages against the config-key form), fired by `live()`'s `makeIterable` before the first fetch. **Degraded first connect, accepted:** content applied before the chunk was resident kept no ledger, and with `resume` fully delegated the first connect sends neither a have-list nor a `Last-Event-ID` while the tier is absent — a full snapshot (the server ignores the ordinal for frame renders; only `X-Frame-Have` is read). Measured before writing on this head: ceiling (`del`) −1,432 / −472; `lean` −965 / −310 frames eager; the carrier ≈ +467 min / +162 br (the hook ≈ 20 / 15; the ledger residue ≈ 112 / 27; the field residue ≈ 106 / 14).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | **Measured: −305 / −349 / −335 / 0** br (−965 / −935 / −907 / 0 min) against R4's head 55eb4c346 — plan estimate −433 / −355 / −355; vs `next` @ 9d89df731 −2,899 / −9,160 / −9,183 / 0 (the hydrating scenarios' +110 / +142 / +52 br vs `next` are the base's A0 exceptions, 0 vs base). **Frames eager 32,802 min / 10,888 br — 888 B above the ≤ 10 KB target.** The live page LOADS the chunk at its first `live()` call: its total transfer is 39,412 + 933 = 40,345 br against the base's 39,747 (+598 — the chunk's own weight plus the carrier, the price of the eager −335)                                                                                                                                                                                                                                                                                                                                                                                                                                | `wire.js` 1,922 min / **934 br** (reported, not counted; `est.` was ≈ 1,300 / 470 — the tier carries the whole connection, not the dispatch alone)                                                                                                                                                                                                                                                                                                                                          | `consistency/tier-wire-preload.spec` (3: the hook starts the import at the call, before the first fetch; the arm awaits residency; the header `X-Frame-Tiers: wire`; a non-live call never loads the tier; reconnect through the tier with `Last-Event-ID` + the have-list; the degraded first connect — no have-list, no ordinal — pinned as accepted); `frames-live-resume` re-pointed to the tier's `haveOf` / `encodeHaveList`; `frames-live` / `frames-live-showing` warm the tier (`prepareTier("wire")`); **the coverage closure:** `server-functions-live-loop.spec` (19, client suite — the loop driven over hand-framed chunk / SSE bodies: first-connect failure, the fail-fast 4xx set and 408 / 425 / 429 / Retry-After, the cursor as `Last-Event-ID`, the `online` wake, `return()` mid-connect / mid-backoff / mid-seed, `invoke`'s signal mid-stream / mid-backoff, `live(GET(fn))`, the handler's local answers), `live` per-function branch coverage (the audit's §2.4 method, client + hydrate) **26/59 sites (91/129 paths) on the base → 57/60 sites (129/132 paths)**; web client 130 / 1,218, hydrate + consistency 89 / 452, server 159 / 1,511, solid 42 / 833, `types` + `test-types` clean; harness 500 × {3289, 91501} 0 (SC and generic arms)                                                                                                                                                                                                                                                                                                                                                                                                            | B; independent of C1                                                                                                                                                             | **Removed:** `Frame.have?()` (the ledger is the tier's `haveOf(frame)`; approved class); **moved:** `encodeHaveList` from `frame-transport` to the tier (`@internal`; `decodeHaveList` and the `FRAME_HAVE_*` constants stay where they were — off the client entry since residue 1); **added:** `@solidjs/web/frames/wire` export path (the chunk; `@internal` surface), `responseHandler.onLive?()` (optional; fired at a `live()` call before its first fetch), `ServerComponentHandler.onLive()`; `ServerFunctionsClientConfig` unchanged                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| **C3** | **Traces tier = S1 re-based** (§5; S1 merges **here**, not first). The materializer entry (`solid-js/internal/container-trace`) and `loadContainers` as S1 built them; S1's `prepareData` / `prepareArgs` / `#argsUnprepared` become B's `prepareTier("trace")` + A2's registered held set; the codec-face node scan stays as the un-announced fallback behind the header flag; the eager half of F.trace (`reviveContainerTraces` / `materialize` / `isContainerTraceMarker` / `isMaterializedContainer` / `setContainerTraceMaterializer` / `getFrameHost.revive`) moves into `container-trace.js`'s `installTier`, leaving a ≈ 150-min trigger. S1's commit 3 re-bases onto A2's park: the `claiming` hint (`revive(value, claiming?)`) and the held-record mount land here, the detached root and the backlog are already on `next`. **`container-trace-hold-hydration-end` re-pins under 3.1 at merge** (A2 is in). The +134 B frames exception S1 as built would have needed **never needs granting**: B's seam is already paid and the tier cut is a saving. **Landed (2026-10-06, `feat/frames-traces-tier`, measured before written on edited dist copies per re-attribution §7).** The chunk is `@solidjs/web/frames/trace` (frames/src/trace-tier.ts — a NEW `@solidjs/web` export path: the tier module imports solid's `solid-js/internal/container-trace` entry and the plugin's client half, and its `install()` sets the materializer on the plugin's shared state and the shared host's `revive`); `installTier` is B's `install()`, unchanged in shape. The eager client keeps the trigger alone: the loader entry, the container probe read off the plugin's registered state, the held-set predicate (`needsTrace`: the `{ $tr }` marker walk, run only while the tier is not resident — a resident tier means a decoded arg may be a live container whose traps throw), the `claiming` thread and the held-record mount (`#heldRecords`, S1 commit 3's, generalized to every adopt-path hold). S1's codec-face node scan (`prepareData(chunk)`) **dropped**: B's in-band `tiers` rides the very `data` chunk that carries the node, so the scan was unreachable behind it (keeping it measured +79 min / +25 br); the un-announced codec face (a producer predating the tier) decodes the inert marker — a skew one package never ships. The park is keyed on the claim again (3.6 "Landed" closed): `revive(value, claiming)` from the adopt-time mount; a fresh mount pays no beat. **Update-site wait landed (fix PR):** `#syncSlots` holds a MOUNTED occurrence's new `{ $tr }` record pending while the tier is absent (the live binding keeps its args, the load starts, the install's flush applies it) — the fresh-mount hold's twin, mirroring C4's `needsRegions` update-site wait; +12 min / +3 br frames eager.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | **≈ −250 / ≈ −6,640 / ≈ −6,600 / 0** (S1's measured page savings −6,390 / −6,352 plus F.trace's eager half: 843 attributed, −289 measured as `T+trace` → `L8`, less the trigger ≈ −250; S1's +134 on frames does not recur — its two faces are B's seam. **Measured: −83 / −6,612 / −6,726 / 0** br (−484 / −24,069 / −24,161 / 0 min) against B's head; the deletion alone −239 / −8,016 / −8,031 br on an edited copy (F.trace's eager half −951 min; the engine, the materializer and the shared symbols out of the pages), the trigger +467 min / +156 br on frames (loader entry + probe +160 / +45, the held-set predicate +126 / +67, `claiming` +6 / −9, the held-record mount +175 / +53) — ≈ ×3 the ≈ 150-min estimate, which counted the loader alone; the predicate and the held-record mount were S1's and never budgeted. Page brotli lands ≈ 1.2 KB above the edited-copy figure because the real chunk pins its shared imports (store symbols, `withStoreHydration`'s adapters) in the eager graph.) | `container-trace.js` 24.3 KB / **7.86 KB br measured** (S1) + the eager half (≈ +700 min / +200 br → ≈ 8.1 KB br) **Measured: `trace.js` 25,409 min / 8,170 br** (page base; 8,158 on live)                                                                                                                                                                                                                                                                                                 | S1's seven surviving pins green through the general seam (`frames-container-lazy-{codec,document}`, `hydration/welcome-status-lazy`, `container-trace-hold-{id-determinism, interruption, record-retention, snapshot}`); **re-pin** `container-trace-hold-hydration-end` (_hydration waits for the load; the mount claims before done_); **flip** S1's C3 (b); the `.fails` id-drift pin → 3.4 (3c). Size: frames eager ≤ 11.25; page base ≤ 36.0, live ≤ 39.8 (S1's caps 38.45 / 42.12 are superseded by these at landing). **Landed:** the seven pins green through the general seam (the hold re-armed per test by dropping the tier's load — `tierLoads`, the runtime's test seam); hydration-end re-pinned; C3 (b) was never `.fails` on `next` (the eager materializer made it pass) — it now asserts the hold and the 3.1 order; the id-drift pin stays `.fails` under 3.4 (unfixed on `next`); new `tier-trace-hold.spec` (§1's pin: un-announced hold + held-record mount, announced start-at-install, the codec wait). Harness 500 × 2 seeds: SC 0, generic (`C1,C9,C19,E` ignored) 0. Caps lowered (the ratchet): page base 44.89 → **38.61 KB**, live 48.60 → **42.16 KB**; frames eager's cap stays 13.79 (still 76 B over by Phase A's and B's bytes; its recorded minified lowered to 42,968, so the gate passes by the minified rule).                                                                                                                                                                                                                                                                                                                                 | B, A2 (the hold registers; the park is on `next`), A3                                                                                                                            | S1's: `revive(value, claiming?)`, `setContainerTraceMaterializer(…, claiming?)`, the entry, `withStoreHydration` / `applyPatches` / `forwardIteratorReturn` `@internal` on the main entry; **not shipped:** S1's `prepareData` / `prepareArgs` (replaced by `prepareTier` before they exist on `next`). `reviveContainerTraces` / `setContainerTraceMaterializer` move behind the tier — **flag**: re-export lazily-resolving wrappers or accept the move. **Landed:** the move accepted (both were `@internal` module exports, never on the public entry); new export path `@solidjs/web/frames/trace` (`install()`); `FrameHost.revive` documented as assignable after creation (the tier's install sets it); `solid-js` loses `materializeContainerTrace` from `solid-js/internal` and the main entry (the new subpath carries it); `tierLoads` exported from the internal runtime module for the specs.                                                                                                                                                                                                                                                                                                                                                                                                                |
+| **C4** | **Regions tier.** `tier-regions.js` = `#bindRegions` / `#regionsFor` / `#discoverRegions` / `collectRegionElements` / `disposeRegions` / `makeFrameElement` / `isFrameRef`, the `{$frame}` arm of `#resolveArgs`, the `resolveSlot` / `resolveSlotRecord` / `removeSlotRecord` thread-up, `tableFor`'s prefix walk, `drainRecords`' `sc:region:` arm. The eager client keeps the `{$frame}` detection in `#resolveArgs` (one `isFrameRef` test → hold, registered). The rename machinery (`renameRegion` / `#reconcileRegions`, D) deletes outright — it is not moved. **Landed (2026-10-06, `feat/frames-regions-tier`, measured before written on edited dist copies per re-attribution §7).** The chunk is `@solidjs/web/frames/regions` (frames/src/regions-tier.ts — a NEW `@solidjs/web` export path): the per-frame region cache (a `WeakMap` the tier keeps, not a frame field), discovery in an adopted interior (`collectRegionElements`, the range walk), the `{$frame}` arm of arg resolution (`resolve`: mint / reuse / rename), the bind of a frame over each region element (`bind`: `createFrame` from the eager entry with the parent linked as `options.parent`, so the slot-resolution thread-up is private access across instances — no closure per region), disposal, and the staged preview's two region reads (`changed` / `frames`). The module's exports ARE its appliers: `prepareTier` records the installed module in a dispatch table (`tierModules`) and the frame calls through it; no `install()`. The eager client keeps: `needsRegions` (one test on the host's `record.regions` note → the fresh-mount hold under 3.1, AND the same wait at the update site — a mounted occurrence's new record naming a region while the tier is absent stays pending in the store, the live binding keeps its args; the check starts the load), the `sc:region:` drain arm in client.ts (an occluded region's html lands in the store regardless; the frame the tier binds seeds from it), the `tierModules` table, the loader entry, an `options` getter on the frame (`@internal`). Already gone on the base: `isFrameRef` (the host's inline `$frame` note is the detection), `tableFor`'s prefix walk and `#reconcileRegions` (A1b). **The rename machinery was NOT deleted — moved into the tier (`rename`, the rename arm of `resolve`), flagged:** it is live, not dead — a single-flight response renders a boundary's regions under the call's address while a direct response and the document render them under the function id, so a flight refresh of a shown boundary renames every region (`#regionsChange`/`preview` anticipates exactly this); two pins assert the rebind (`lifecycle-matrix/call-driven-args` › regions, `frames-optimistic-hold` › the renamed region). Deleting it would leave the refreshed region's content stale; it deletes with S7's normalization (principles §5.3), which is not this step. Eager cost of keeping it: 0 (it rides the chunk).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | **−489 / ≈ −480 / ≈ −480 / 0** (measured on frames: `T+regions` → `L8`; pages `est.` at the same cut) **Measured: −237 / −281 / −261 / 0** br (−1,078 / −1,083 / −1,083 / 0 min) against C3's head; the deletion alone −423 / −484 / −346 br (−1,596 min) on an edited copy — less than the −489 because the `sc:region:` drain arm and B's predicate stay and A1b had already taken the prefix walk and `#reconcileRegions`; the glue +518 min / +186 br on frames (the edited-copy cut measured +498 / +173 and landed at −250 br; TypeScript's TS18030 — no private name in an optional chain — forced the longer `#outer && #outer.#x()` thread-up form, +33 min). Glue ≈ ×3.3 the ≈ 150-min line, reported; it is 44% of the deletion (the brief's "not more than half"). Vs `next` 9d89df731: −158 / −6,565 / −6,709 br.                                                                                                                                                                                       | `tier-regions.js` ≈ 1,900 min / **≈ 540 br** (`est.`) **Measured: `regions.js` 1,872 min / 805 br** (page base; 802 on live) — min on the estimate, brotli higher: a 1.9 KB standalone chunk has little to share against. It bundles its own copy of frame-client's pure DOM helpers (`eachInRange`, `makeFrameElement`, `isFrameElement`, ≈ 300 min) and carries a bare `import "solid-js"` (frame-client's one import, kept by Rollup as an external side effect; the app has it loaded). | `tier-regions-hold.spec` (new); `frames-regions-*`, lifecycle matrix region rows green; principles §4 row 19 (the rename compensations) deleted with D. Size: frames eager ≤ 10.75. **Landed:** new `consistency/tier-regions-hold.spec` (4: un-announced `{$frame}` in an adopted record → held under 3.1, interior and region content on screen, mounts with the held record, the ADOPTED region element discovered and bound (a later chunk to its wire id morphs it), no TypeError, hydration-done after; announced → the import starts at install; an occluded region's `sc:region:` record drained before the tier seeds the frame the tier binds — shows the html when placed, nothing re-delivered; stream face, a MOUNTED occurrence's region-naming record waits and applies at the install into the live binding). `tier-prepare`'s regions test releases the real module (the fake `{ install }` cannot resolve a region). Resident cells warm with `prepareTier("regions")`: `lifecycle-matrix/call-driven-args`, `frames-hn-client`, `frames-occlusion-client`, `frames-optimistic-hold`, `frames-used-region-client`; `test/server/frame-hn` (the runtime without the entry) registers the loader itself. Harness 500 × 2 seeds: SC 0, generic (`C1,C9,C19,E` ignored) 0. Caps lowered (the ratchet): frames eager 13.79 → **13.64 KB** (first time under the cap since Phase A), page base 38.61 → **38.33 KB**, live 42.16 → **41.90 KB**. Principles §4 row 19 NOT removed — re-dispositioned (above).                                                                                                                                                               | B, A2 (the adopt-path hold registers — no 3.1 gap to flag)                                                                                                                       | none (`createFrameElement` stays eager — it is `@experimental` public API, re-attribution §5.3 item 5) **Landed:** new export path `@solidjs/web/frames/regions` (`@experimental`; exports `resolve` / `bind` / `unmount` / `changed` / `frames` — the appliers; no `install`); `InstallOptions.tiers`' module type widened to the new exported `TierModule` (`{ install?(): void; [applier: string]: unknown }` — the old `{ install?(): void }` is a TypeScript weak type a real tier module cannot satisfy); `FrameImpl` gains an `@internal` `options` getter (not on `Frame`); frame-client's `eachInRange` / `makeFrameElement` / `isFrameElement` exported `@internal` for the tier (not on the public entry); the internal `resolveSlot` / `resolveSlotRecord` / `removeSlotRecord` options (never on `FrameOptions`) replaced by `parent`. `createFrameElement` unchanged. Wire unchanged; 0 of 150 artifacts changed.                                                                                                                                                                                                                                                                                                                                                                                            |
+| **C5** | **Assets tier.** `tier-assets.js` = `ensureStylesheet` / `ensurePreload` / `ensureModulePreload` / `applyInlineStyles` / `qualifierValue` / `findHeadElement` / `PRELOAD_QUALIFIERS` / `#processedAssets` / `#styleFlush` / the assets pass; the eager client keeps `chunkToRecords`' `assets` case, `host.write`'s `seg::assets` accumulate, and the `#segmentReady` term. **Pin the two untested functions first** (`ensureStylesheet`, `applyInlineStyles` — the audit's 0-coverage gap) in the same PR. Alternative under decision 2: S10's route-through-`web` instead of a tier. **Landed (2026-10-06, `feat/frames-assets-tier`, measured before written on edited dist copies per re-attribution §7; the two coverage pins committed first, against the code as it was).** The chunk is `@solidjs/web/frames/assets` (frames/src/assets-tier.ts — a NEW `@solidjs/web` export path): the whole head mirror (`ensureStylesheet` / `ensurePreload` / `ensureModulePreload` / `applyInlineStyles` / `qualifierValue` / `findHeadElement` / `PRELOAD_QUALIFIERS`), the per-frame flush a pending sheet wakes (`#styleFlush` → a `WeakMap` in the tier), and the assets pass over one record — modules, typed preloads, **and inline styles** (moved off the reveal: they land at the record's arrival when the tier is resident, before the segment's content as the document face orders them; at the install when it was absent). The tier is import-free and has no `install()`: its exports **are** the dispatch — `prepareTier` stamps the load's `r` with the module (B's `true` → the module; truthy either way), and the eager client calls `gate(styles, frame)` from `#segmentReady` and `apply(record)` from `#flush`'s walk off that stamp. The eager client keeps `chunkToRecords`' `assets` case, `host.write`'s accumulate, the walk over `:assets` records (deduped through the applied map — `#processedAssets` deleted), and the **reveal-readiness term**: `assets.styles && !tierReady("assets")?.gate(assets.styles, this) → not ready` — a style-gated segment is not ready while the tier is absent (`tierReady` starts the load if nothing announced it; the server's fallback stays) and, once resident, until every sheet has settled; the reveal is at max(tier load, stylesheet load). A segment without stylesheets never consults the tier; a stream with no asset records never loads it; an un-announced record met by the walk starts the load and stays pending until the install's flush.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | **−684 / ≈ −665 / ≈ −665 / 0** (measured on frames: `T+assets` → `L8`; the `noassets` full-client cut −665) **Measured: −534 / −628 / −496 / 0** br (−1,913 / −1,926 / −1,926 / 0 min) against C3's head `89954fa1b`; vs `next` @ `9d89df731` −455 / −6,912 / −6,944 / 0. The deletion alone −666 / −681 / −627 br (−2,419 min: the whole F.assets group, record cases included) on an edited copy; what stays eager costs +508 min / +131 br on frames — the kept record cases +208 / +64 (the plan's own list), the readiness term + loader entry + `r = module` + the walk's dispatch +300 / +67 — over the ≈ +150-min line, reported in the PR. A folded variant (the walk riding the hole/attr loop, content before its inline style within one flush) measured −562 br and was not taken: the separate walk before the segments keeps a segment's `<style>` ahead of its content for 27 br.                                                                                                                    | `tier-assets.js` ≈ 2,400 min / **≈ 760 br** (`est.`) **Measured: `assets.js` 2,040 min / 783 br** (both pages)                                                                                                                                                                                                                                                                                                                                                                              | `tier-assets-ready.spec` (new, the FOUC guard); `frames-assets-*` green; the two new coverage pins. Size: frames eager ≤ 10.05. **Landed:** `frames-assets-client.spec` (the two coverage pins, 17 — committed first against the eager code, then re-run through the resident tier; what they found about today's code: the sheet is requested at the **reveal** record, not at the assets record — a grouped reveal's fragment starts its fetch late; the reveal chunk's `waitForStyles` is wire-only, the client gates on the record; `error` settles like `load`; a document-owned link counts as settled; one waiter per frame; a disposed frame's settle is inert); `consistency/tier-assets-ready.spec` (7: in-band announced style-gated fragment before the tier → the fallback stays, no link, no unstyled frame, the install requests the sheet, the reveal at its load; the sheet already in the document → the reveal at the install; an unstyled segment reveals with the tier absent, an inline-only one HOLDS (follow-up) and reveals at the install with its style landed first; a stream with no asset records never loads it; preloads buffer until the install and apply once; `X-Frame-Tiers` starts the import before the body; `sc:tiers` at install). A mutant without the term fails 5 of 7. `preload-links-frame-client` warms the tier. Harness 500 × 2 seeds: SC 0, generic (`C1,C9,C19,E` ignored) 0; 0 of 150 artifacts changed (the server is untouched). Caps lowered (the ratchet): frames eager 13.79 → **13.35 KB** (under its cap for the first time since Phase A; recorded minified 41,055), page base 38.61 → **37.98**, live 42.16 → **41.67**. | B                                                                                                                                                                                | none **Landed:** new export path `@solidjs/web/frames/assets` (`@experimental`; exports `gate`, `apply`, the entry types — no `install`); `InstallOptions.tiers`' loaders now resolve `TierModule` (`{ install?(): void } & object`, a new type export on `@solidjs/web/frames`) so a module without `install` type-checks; `tierLoads[name].r` is the module, not `true` (`@internal`); the mirror's functions were module-private — nothing public moved. Behaviour: inline styles land at the record's arrival (document-face parity) rather than at the reveal; with the tier absent, a segment carrying them holds like a style-gated one and reveals at the install, style first (the follow-up — the earlier "not reveal-gating" ruling predated the tier; the bounded unstyled window it allowed was the FOUC the term prevents).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| **C6** | **Binding-slot tier** (E.c; largest, last of the tiers — its fallback needs the 3.1 hold for the event-replay window, which A2 provides). `tier-bind.js` = `bindDataOccurrence` (+ `valuesFor` / `write` / `release` / `writeText`; its second diff layer above `assign` — ≈ 300 B, D — deletes rather than moves), `slotPositions` / `slotEntry` / `textPosition` / `consumersOf` / `consumersEqual` / `ownedPositions` / `morphOwnedClass` / `morphOwnedStyle` / `applyOwned`, the `_s:` branch of `collectSlots`, the consumer-rebind arm of `#syncSlots`, the owned-position arms of `morphAttributes` / `reconcileChildren` / `#applyAttrs`, the `ctx.positions` branch of `slotsFor`; **`assign` leaves the eager frames client with it** (the page then keeps `assign` only through `dynamic`'s string tag — B.3, D). **Landed (2026-10-06, `feat/frames-bind-tier`, measured before written on edited dist copies per re-attribution §7; the maintainer's Phase 2 ruling: the incremental path continues with a frames eager target of ≤ 10 KB br, the replay window closed by option (a)).** The chunk is `@solidjs/web/frames/bind` (frames/src/bind-tier.ts — a NEW `@solidjs/web` export path, built twice: `bind.js` and `bind.dev.js` under the `development` condition so the dev findings — `BINDING_SLOT_POSITION`, the fill-shape / text-shape warnings — ride the dev chunk only): the consumer walk (`text` / `positions` — the `_s:` branch of `collectSlots` dispatches to them), the per-frame consumer sets and rebinders (`sync` / `rebinder` / `unmount` — `#slotConsumers` / `#slotRebinders` became a `WeakMap` the tier keeps), the owned-position arms of the morph (`owned` / `apply` — `ownedPositions` / `morphOwnedClass` / `morphOwnedStyle` / `applyOwned`), and the fill's bind (`bind` — `bindDataOccurrence` with `valuesFor` / `write` / `release` / `writeText`, plus option (a): `completed.add(element)` + `runHydrationEvents()` for an element with handler positions). The module's exports are its appliers (no `install`), reached through `tierLoads.bind.r`. The eager client keeps: the marker detection at the walk (`hasSlotMarker` — a marker met with the tier absent is a note on the found map, and the sync holds under 3.1), `isAsyncValue` (moved to frame-client.ts as the one `@internal` helper the tier shares through the entry), `shapeOf` / `slotShapeFinding` (dev-only, tree-shaken from the production entry), the loader entry — and, **a deviation from the "nopair" variant:** `reconcileChildren`'s text-pair arm stays eager. Deleting it breaks a pin (frames-binding-slots "a refetch re-sends the empty pairs: the morph keeps the client's text (and its node)"): reconciled as ordinary nodes the client's text node is removed and, the start marker being unchanged, the consumer set compares equal — no rebind, text lost; a tier dispatch point there would cost what the arm costs (measured +109 min / +39 br either way). `assign` left the eager frames client (the tier imports it from `@solidjs/web`; the page already carries it). **Rolldown note:** a tier chunk that reaches `solid-js` / `@solidjs/web` without importing the entry chunk makes Rolldown split the shared runtime out of the page's entry (the live page's `action` / `isPending` / `latest` trigger it; the harness then reports a bogus 56 KB entry beside a 71 KB shared chunk); `bind-tier.ts` importing `isAsyncValue` from the entry is the edge that keeps the chunk attached — the regions / trace / assets tiers had it through their own entry imports. | **−1,546 / −2,504 / −2,542 / 0** (frames measured `T+bind` → `L8`; pages: the audit's E.c measurement — `assign` leaves on the page too) **Measured: −1,185 / −1,100 / −1,110 / 0** br (−4,005 / −3,969 / −3,963 / 0 min) against the integration base 6b7213d64 (`wip/frames-tiers-integration` @ 5c5991cbd + #3861); vs `next` @ 9d89df731 −1,886 / −8,235 / −8,309 / 0. Measured-before-written on the edited dist (tight-nopair): −1,244 / −1,154 / −1,167; the built head's gap to it is the kept pair arm (+39 br) and the `isAsyncValue` entry edge. Option (a): 0 eager, +106 min / +48 br in the chunk (est. ≈ 40). The pages' delta is smaller than the audit's E.c because `assign` never left the page (B.3 has not run — `dynamic` keeps it). **Frames eager absolute: 11,901 br — 1,901 B above the ≤ 10 KB target.**                                                                                                                                                                                  | `tier-bind.js` ≈ 5,000 min / **≈ 1,650 br** on frames (`est.`); on a page it carries `assign` as well (≈ +3,000 min / +900 br) unless B.3 has already made it lazy **Measured: `bind.js` 4,771 min / 1,844 br** (both pages; `assign` is imported from `@solidjs/web`, not carried — the page has it); `bind.dev.js` 11,065 raw.                                                                                                                                                            | `tier-bind-hold.spec` (new, incl. the click-replay arm); `frames-binding-slot-*`, `slot-positions-*`, #3704 / #3714 suites green. Size: frames eager ≤ 8.5 (both readings), page base ≤ 32.35, live ≤ 36.1. **Landed:** `consistency/tier-bind-hold.spec` (6 — §1's bind row lists the arms; the stamp-less mutant pinned, the completion-less mutant fails 4 of 6); `server/frame-binding-slots` gains the stamp pin (event-slot consumers only, document face only, 4 bytes) and 8 document-face expectations carry ` _hk`; `tier-prepare`'s bind arm releases the real module; resident cells warm with `prepareTier("bind")`: `frames-binding-slots`, `hydration/binding-slot-adoption`. Harness 500 × 2 seeds: SC 0, generic (`C1,C9,C19,E` ignored) 0. Artifacts: 1 of 150 re-recorded (`welcome-status-streamed` — C3's drift from `frame-container-plugin.ts`, not the stamp: no artifact carries an `_s:on:` element). Caps lowered (the ratchet): frames eager 13.10 → **11.92 KB**, page base 37.79 → **36.66**, live 41.44 → **40.30**.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | B, **A2** (the hold registers — hydration-done waits; **the replay window is the stamp's, not the hold's** — §1); C3 (the `installTier` shape proven on the biggest chunk first) | none public (the `_s:` marker grammar is unchanged; `bindDataOccurrence` was never exported) **Landed:** new export path `@solidjs/web/frames/bind` (`@experimental`; exports `text` / `positions` / `sync` / `rebinder` / `unmount` / `owned` / `apply` / `bind` — the appliers; no `install`); **output-shape change:** a bare ` _hk` on every document-face element with an `_s:on:*` position (4 bytes each; ref-only and attribute-only consumers unstamped; the stream face unstamped); `isAsyncValue` re-exported `@internal` from `@solidjs/web/frames` (the chunk's entry edge); `SLOT_TEXT` / `shapeOf` / `slotShapeFinding` exported `@internal` from frame-client (not on the public entry). **Behaviour:** a data occurrence mounts with the CURRENT record (was: the held one, then the replacement as an args change); a data occurrence's fresh mount now also waits on the regions / trace tiers when its record names them (one predicate for both classes — previously template-only); the walk no longer skips a text pair's interior (walked as ordinary nodes; the pair's own position is the tier's); event-slot consumers' pre-bind events queue and replay (head-of-line: an event on a consumer that never binds — no client fill for its prop — holds the queue until hydration-done drops it). |
+| **R1** | **Residue step 1** (`documentation/plans/frames-residue-pass.md` §5 rows 2 and 6 + 5a; the first step after the five tiers). **Landed** (`size/frames-residue-1`, on C6's head): the D list without the mirror — `documentAddress` (an adopted mount's address comes with its binding; an unbound placeholder mount binds the function id), the second dispose map folded into `fillScopes`, the zombie heuristic + `#slotNodes` (DR-5: the morph recreates nothing), the imperative branch of `#revealSegment` replaced by a default seam (`revealAtOnce`; `FrameOptions.reveal` stays optional; a placeholder without its closing comment is not revealed), `showing`'s brand on the bare per-function component; `FRAME_HAVE_HEADER` / `FRAME_HAVE_BUDGET` off the client entry's export list (the server entry keeps them); the lean re-ask — the sf client hands its handler the dispatched call as `ctx.retry` / `info.retry`, frames' re-ask is `callFor(address).retry()`, the RPC-seam re-ask and `createServerReference` on the RPC slot deleted. **Not taken:** the capture arm (pinned by `lifecycle-matrix/remount` — away/back over an SSR'd boundary shows the captured interior while the refetch flies; a ruling), the s / v stamp (`readHydratedValue` is module-private — a new `solid-js/internal` export, not a re-export), the `_$SC` mirror (needs the server's unconditional bootstrap). Every item measured on an edited dist before writing (residue doc §7).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | **Measured: −247 / −159 / −161 / 0** br (−757 / −665 / −670 / 0 min) against C6's head e7d6e9e34; vs `next` @ 9d89df731 −2,133 / −8,394 / −8,470 / 0. **Frames eager 35,250 min / 11,654 br — 1,654 B above the ≤ 10 KB target.** Singles on the edited dist: D list −721 / −210, `FRAME_HAVE_*` −63 / −25, lean re-ask −260 / −99 (pages −30 / −65 — the sf thunks ≈ +80 min and the pages still shrink).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | none (no chunk; the sf client grows ≈ 80 min for the thunks, the pages shrink net)                                                                                                                                                                                                                                                                                                                                                                                                          | the nine A7 pins (`frames-errored-reset-refetch`) + `hydration/frames-adopted-error-outward` green unchanged; `adopted-claim-args-address` mounts the binding and asserts the store; web client 129 / 1,194, hydrate + consistency 87 / 445, server 159 / 1,511 green; `test-types` clean; harness 500 × {3289, 91501}: SC arm 0, generic arm (`CONSISTENCY_IGNORE=C1,C9,C19,E`) 0. Size: caps lowered to measured + 10 B — frames eager 11.92 → **11.67**, page base 36.66 → **36.50**, live 40.30 → **40.14**; no cap raised.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | C6 (the head it was measured on); nothing of C2                                                                                                                                  | **removed:** `FRAME_HAVE_HEADER` / `FRAME_HAVE_BUDGET` from `@solidjs/web/frames` (client entry; `@experimental`), `createServerReference(id)` from the client half of `getServerFunctionRPC()` (`@internal`); **changed:** `callFor` (`@internal`) returns `{ id, meta, args, retry }`; `responseHandler.handle`'s ctx and `responseHandler.intercept`'s info (the latter now on the `ServerFunctionsClientConfig` type) carry `retry()`; `handler.showing` no longer brands the component; `FrameOptions.reveal` omitted → the default seam                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| **R2** | **Residue step 2 — the `preview` pull form** (residue doc §3.1 / §5 row 3). **Stopped at the carrier budget, nothing built** (`size/frames-residue-2-pull-form`, on R1's head `fce81d2c0`). Measured before writing on an edited dist: the deletion ceiling (`stage` whole out — the buffer, the token, `stagedContent` / `contentAddress`, `FrameImpl#preview` / `host.preview`, the token arms of `handle` / `applyFlightResponse`) is **−1,645 / −546**; the carrier **as the step would have written it** — the token binding kept (the sketch deleted it: `dynamic` delivers a kept resolution only when its address differs, so without the token a same-address refetch never enters the transaction — #3844's gap (1), unsound), the host's per-store staged set (`apply(chunk, stage)`, `staged(id)`, `promote(id, version)` through the store's own `write` + landing tail), the fill's lane-correct read (`ctx.staged()` gated by the mount's address accessor), the flight path's per-root staging, nested regions promoted with the root — is **+1,414 / +483** over the ceiling. The sketch's +242 omitted the token (88 br), the flight path (54), regions (53), the gate (29) and promote's landing / L1 / waits semantics the chunk replay got for free. The step's rule was carrier > +300 → stop. **Pin added:** `c15-staging-atomic` (e), the gap #3844 named — a same-address refetch enters the transaction (the fill derives the new arg in its pass while the DOM, `frame:applied` and the frame's version hold v1) and lands whole at the commit; green on the push form.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | **Measured: −231 / −29 / −37 / 0** br as the sound form (−63 frames eager — a fifth of the row's −300, outside its −250 … −350 band); the unsound floor without flight / regions / gate still +980 / +339 over the ceiling. **Built: none; frames eager stays 35,250 / 11,654.**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | none                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | C15 ×5 (the new (e) arm), `frames-optimistic-hold` ×6, `frames-morph-in-transition` ×3 green on the push form (unchanged); no size change                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | R1 (the head it was measured on)                                                                                                                                                 | **none changed**; the form would have removed `FrameHost.preview` / `Frame.preview` / `stagedContent` / `contentAddress` (approved) and ADDED `FrameHost.staged(id)` / `FrameHost.promote(id, version?)` / `FrameHost.apply(chunk, stage?)` / `SlotContext.staged()` (`@experimental`) — named here so the trade is visible if the form is ever taken at −63                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| **R3** | **Residue step 3 — R.insert, every fill through `insert`** (residue doc §2 row 3 / §5 row 4; §7c). **Landed** (`size/frames-residue-3-insert`, on R2's head `f12708386`). Every fill of the Solid binding is one `insert(end.parentNode, value, end, [...existing])` under the fill's owner — a static value placed once with no effect, a reactive one bound as before, an adopted fill claimed through `insertExpression`'s claim pass, disposal the owner's. Deleted: the binding's static path (`normalizeSlotContent`, `isReactiveContent`, the in-place `settle`, the no-range snapshot fallback — a range without its end marker is left as rendered), the runtime's own range writer (`#replaceRange`, the returned-nodes path through `#syncSlots` / `#invokeSlot` / `regions.bind`'s re-scan), and the runtime's never-used comment-marker range mode (`#start` / `#end`; the frame element IS the range, `FrameImpl(element, options)`). Two things the build found: the fill's second claim window must not re-gather (it put the keys the evaluation had claimed back as unclaimed), and the minted binding owner must be transparent (a non-transparent one consumed an ambient id inside the hydrate pass — keyed siblings after the frame keyed by timing). **One pin re-pinned, a ruling:** `c01-claim-once` (b) — a fill answering the t=0 claim with fresh nodes is the core's hydration mismatch (the server node stays, nothing duplicated, hydration reports it unclaimed), not a frame-side replacement; the contract's C1 text amended. Measured before writing on an edited dist: ceiling −769 / −230; the carrier without `#replaceRange` −791 / −229 (with it kept −600 / −160 — compatibility costs 69 br); the range mode −196 / −67; together −988 / −301.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | **Measured: −287 / −217 / −221 / 0** br (−978 / −979 / −979 / 0 min) against R2's head f12708386; vs `next` @ 9d89df731 −2,420 / −8,611 / −8,691 / 0 (the hydrating scenarios' +110 / +142 / +52 br vs `next` are the base's A0 exceptions, 0 vs base). **Frames eager 34,272 min / 11,367 br — 1,367 B above the ≤ 10 KB target.**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | none                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | C1 (a, c), C9 ×3, C10 ×3, C14, `adopted-swap-post-done`, `boundary-arrival`, `tier-bind-hold`, the lifecycle matrix, the hydrate suite (87 / 446) green unchanged; C1 (b) re-pinned (above); the four raw-frame tests place through `ctx.range`; web client 129 / 1,194, server 159 / 1,511, `types` + `test-types` clean; harness 500 × {3289, 91501}: SC arm 0, generic arm (`CONSISTENCY_IGNORE=C1,C9,C19,E`) 0. Size: caps lowered to measured + 10 B — frames eager 11.67 → **11.38**, page base 36.50 → **36.29**, live 40.14 → **39.92**; no cap raised.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | R2 (the head)                                                                                                                                                                    | **changed:** `Slot` (`FrameOptions.slots`, `@experimental`) is `(props, ctx) => void` — the callback owns its range (places or binds before `ctx.range.end` over `ctx.existing`); a returned node is no longer placed (before: `Node \| Node[] \| undefined`, placed by the frame / `undefined` = claim). `SlotContext.range` documented absent for a range missing its end marker (left as rendered; before, filled at the parent's end from a snapshot). `createFrame` / `createFrameElement` signatures unchanged. **Behaviour:** a fill that does not claim at t=0 follows the core's mismatch rule (C1 (b))                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| **R4** | **Residue step 4 — S-ref's pending read in the decode table** (residue doc §2 row 12 / §3.2 / §5 row 5; §7d). **Landed** (`size/frames-residue-4-sref-table`, on R3's head `8a0b090cf`). A slot record's `{$ref}` to a key its response has not delivered is answered by that response's `createJSONDataTable` with a pending read the table owns — one promise per key, marked `s = 0`, carrying `c` (its settle callbacks); the key's `data` chunk settles it through the table's own `apply` (stamped `s = 1` / `v`, the hydration serializer's marks a fill's prop read adopts synchronously) and `close(error)` rejects what is still pending when the response ends (stamped `s = 2`; L1 — the error names the key); a bump drops the superseded table with its reads. Frames keeps the COUNT and nothing else: `settleArgs` counts a record's pending reads (`record.pending` — a fresh mount waits for its record, the covering `<Loading>` pends on the landing alone; a mounted occurrence's prop pends and holds) and pushes one `settle` per read that re-applies the record through one `applyTo` fan-out if it is still the store's; the end arm tells the integration the response ended (`closeData`) and the shared host closes that response's table. Deleted: `pendingRef`, `settleWait`, the per-store `waits`, the data arm's lookup, the end arm's loop. The transport awaits `prepareData` before a `slot` chunk whose args carry a `{$ref}` (the table must exist to mint the read; on the producer's wire the data precedes the record, so nothing is delayed). Two things the build found: the settle must be the table's callback at the delivery, not the read's `then` (a delivered promise value is adopted — the DR-2 and container pins went red on `.then`); the mark is read behind `instanceof Promise` (a pending container's property trap throws). Measured before writing: ceiling −879 / −280; the carrier +394 / +118 over it (the row estimated +40 br — the `closeData` seam, the transport's await and the fan-out were not in it); golfed −519 / −170.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | **Measured: −174 / −200 / −157 / 0** br (−505 / −505 / −505 / 0 min) against R3's head 8a0b090cf; vs `next` @ 9d89df731 −2,594 / −8,811 / −8,848 / 0 (the hydrating scenarios' +110 / +142 / +52 br vs `next` are the base's A0 exceptions, 0 vs base). **Frames eager 33,767 min / 11,193 br — 1,193 B above the ≤ 10 KB target.**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | none new; the lazy `decode.js` chunk grows +420 min / +161 br (22,990 / 6,076 → 23,410 / 6,237; reported, not counted)                                                                                                                                                                                                                                                                                                                                                                      | C5 ×5, C6 ×6, C17 (c), the `{$ref}` rows of the lifecycle matrix, `frames-flight-delivery`, `adopted-slot-late-record`, c01 / c03 (a) / c04 (b) / c09 (c) / c10 (b) / c14 (a) / c19 (b, c, e), every `frames-*` / `hydration/*` suite green unchanged; **added** `consistency/sref-table-pending-read` (the table's lifecycle; L1 through the shared host — no earlier pin reached the rejection); web client 129 / 1,194, hydrate + consistency 88 / 449, server 159 / 1,511, `types` + `test-types` clean; harness 500 × {3289, 91501}: SC arm 0, generic arm (`CONSISTENCY_IGNORE=C1,C9,C19,E`) 0. Size: caps lowered to measured + 10 B — frames eager 11.38 → **11.21**, page base 36.29 → **36.09**, live 39.92 → **39.76**; no cap raised.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | R3 (the head)                                                                                                                                                                    | **added:** `FrameHostOptions.closeData?(frameId, version, error?)` (`@experimental`) — the host tells the integration a response ended; `JSONDataTable.close(error?)` (`@internal` behaviour on the integration-facing type). **changed:** `FrameHostOptions.resolve` keeps its signature but its answer for an undelivered key is the table's pending read (an integration no longer returns `undefined` for "not delivered"); `FrameHostOptions.prepareData` is awaited before a `{$ref}`-carrying `slot` chunk too; `JSONDataTable.resolve` of a missing key is a promise marked `s = 0` carrying `c`. **Behaviour:** the L1 error names the key                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| **D**  | **Packaging remnants from the SC audit, if still relevant after tiering.** **S2 / C** `preserveModules` for `solid-js` / `@solidjs/web` (0 on single-entry scenarios; the enabler): lets the store **hydration adapters** (≈ 2.6 KB min, the ≈ 1.3 KB br S1 fell short of B.2's floor by) follow the engine into `container-trace.js`, and lets **B.3** (`dynamic`'s string-tag branch lazy, `staticElement` behind the seam) take `assign` off the page. **B.3:** page −2,372 / −2,391 br (audit measured), frames 0. **E.b** (sf natural-encoding bodies, codec-args message, `Retry-After` / trailer parsing lazy): −65 frames / −476 base / −519 live (audit floor). **E.c's other half** is C6. **Lazy codec:** already a chunk (22,986 / 6,074) — nothing to do. **Claims + event** (F.claims, F.event, 331 br): not a frames tier — they ride the router's chunk (the router installs `CLAIM_SEAM`); the frames client keeps the ≈ 60-B seam.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | **≈ −400 / ≈ −4,100 / ≈ −4,200 / 0** (`est.`: claims+event −331 frames; B.3 −2,372, the adapters ≈ −1,300, E.b −476 on page base)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | `dynamic-static.js` ≈ 8,000 min / ≈ 2.4 KB br; the sf natural-body chunk ≈ 1,600 min / ≈ 480 br; the router's claims chunk ≈ 900 min / ≈ 330 br                                                                                                                                                                                                                                                                                                                                             | the audit's S2 band (single-entry scenarios ≤ ±50 B); B.3's hydration specs; `CLAIM_SEAM` tests with the router. Size: frames eager ≤ 8.1, page base ≤ 28.2, live ≤ 31.8.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | C3, C6 (so what leaves with the engine and with `assign` is known)                                                                                                               | B.3: `dynamic`'s string-tag branch becomes async-loading on first use (behaviour change accepted in audit §7 Q5 / B.3); the `CLAIM_SEAM` install moves to the router                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| **E**  | **Budget restatement — principles §6 as per-tier lines** (§4's table is the draft). One line per eager default (both readings written, one picked), one per tier chunk, the page lines, the ratchet rule unchanged ("a ceiling increase requires a new mechanism row citing its axiom"), `floor-caps.json` gains the tier chunks as reported-not-counted lines with their own caps.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | —                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | `check-floor-caps` clean on `next`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | all                                                                                                                                                                              | —                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
 
 **Dependency check under the new order.** S-hold (A2) now precedes
 everything that holds: B's held set is A2's registered set; C3's, C4's and
 C6's adopt-path holds register from their first landing (the earlier
 draft's "ship the hold as a plain wait first, flagged" for regions is
 gone); S1's hydration-end re-pin is taken at C3's merge because A2 is
-already on `next`; bind's click-replay arm (§1) is provable at C6 for the
-same reason. Within A: A1 precedes A2 (the deferred set is right only once
+already on `next`; bind's click-replay arm (§1) was expected to follow
+for the same reason — it did not (the hold is not the window; the stamp
+is — C6, §1). Within A: A1 precedes A2 (the deferred set is right only once
 the drain is one write and the landing node exists), A2 precedes A3 (a
 recordless `#`-occurrence is a pending read through the hold), A3 precedes
 A5 (the adopted swap and the reveal sync share the ledger subscription),
@@ -359,6 +414,43 @@ at each landing (the ratchet). Pages (KB br): base 44.82 → A1 43.7 → A5
 ruling C1 is skipped; the 7.8 gates from C1 on read +546 (frames) / +508
 (pages).
 
+**Phases B + C3–C5 — landed together (2026-10-06,
+`wip/frames-tiers-integration`, the tiers integration PR; B → C3 → C4
+linear on the Phase A base `0aab93230`, C5 cherry-picked over C4).**
+Measured against `next` @ `9d89df731`, both built fresh and measured with
+the integrated head's harness (the `next` figures match #3854's to the
+byte): frames eager **13,083 br / 40,000 min** (**−704 / −3,414**); page
+base **37,772 / 119,044** (**−7,110 / −26,713**); page live **41,427 /
+130,915** (**−7,168 / −26,805**); the non-SC scenarios 0 / 0 against the
+Phase A base (they carry Phase A's +110 / +142 / +52 br against `next`);
+`renderToString` +4 min / −9 br (C3's `materialize` parameter). Lazy
+chunks, reported not counted: `trace.js` 25,419 min / 8,176 br,
+`regions.js` 1,872 / 805, `assets.js` 2,040 / 783. The caps ratchet to
+13.10 / 37.79 / 41.44 KB. Against the gates in the paragraph above (B
+12.45 → C3 11.25 → C4 10.75 → C5 10.05; pages 34.85 / 38.65 after C5) the
+measured head reads ≈ 3 KB higher on every line, and the gap decomposes
+the same way on each: Phase A's projected saving (≈ 1.45 KB frames, ≈ 1.4
+KB pages) came in as a small cost instead (+14 B over the frames cap, +151
+/ +120 br on the pages, §3 A6 row); C1 / C2 / C6 are not in (≈ 0.55 KB
+frames, ≈ 0.85 KB pages of the planned path); the rest is the glue
+overrun. **The glue overran at every seam while every deletion held.**
+B's mechanism +145 br against ≈ +100 est. (×1.45 after golfing, ×2.3
+before); C3's trigger glue **+467 min** against the ≈ 150-min line (the
+held-set predicate and the held-record mount were S1's and never budgeted;
+the deletion −951 min held); C4's **+518 min** against 150 (the dispatch
+table and loader entry, the five hand-off sites, the update-site wait, the
+staged preview's reads, the `options` getter and `parent` thread-up; the
+deletion −1,596 held); C5's **+300 min** against 150 (the readiness term,
+the loader entry, the walk's dispatch; the deletion −2,419 held). Every
+tier's seam came in at ≈ 3× its estimate — the estimate counted the loader
+line alone and none of the hand-offs a lazy chunk needs at the sites it
+left — so C2 and C6 should be budgeted at 3× the loader line. The
+integration's own glue is **+1 min**: C4's installed-module table folded
+into C5's resident stamp (`tierLoads[name].r` is the module; truthy =
+resident), and `TierModule` is C4's index-signature interface (`{
+install?(): void; [applier: string]: unknown }` — what lets a loader whose
+module has no `install` typecheck), which C5's assets module satisfies.
+
 ---
 
 ## 4. End state
@@ -376,28 +468,28 @@ the seams' glue in):
 
 Tier chunks (lazy, reported not counted; br):
 
-| tier                      | chunk br (est. unless marked)                                                                            | load class                     | hold                              |
-| ------------------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------ | --------------------------------- |
-| `tier-holes.js`           | ≈ 620                                                                                                    | detect-from-markup (announced) | buffer only                       |
-| `tier-wire.js`            | ≈ 470                                                                                                    | preload-at-call                | none                              |
-| `container-trace.js`      | **7,860 measured** (S1) → ≈ 8,100 with the eager half moved in; ≈ 8,800 if the adapters follow (Phase D) | announced                      | 3.1 participant (adopt path)      |
-| `tier-regions.js`         | ≈ 540                                                                                                    | announced                      | 3.1 participant (adopt path)      |
-| `tier-assets.js`          | ≈ 760                                                                                                    | announced                      | reveal-readiness term             |
-| `tier-bind.js`            | ≈ 1,650 (frames); ≈ 2,550 on a page carrying `assign` until B.3                                          | announced                      | 3.1 participant (adopt path)      |
-| `dynamic-static.js` (B.3) | ≈ 2,400                                                                                                  | first string-tag `dynamic`     | async first render (accepted, Q5) |
-| sf natural body (E.b)     | ≈ 480                                                                                                    | first natural-encoding call    | none                              |
-| `decode.js`               | 6,074 measured                                                                                           | first `data` chunk             | the chunk awaits it (today)       |
-| router claims             | ≈ 330                                                                                                    | the router installs it         | re-sweep on install               |
+| tier                      | chunk br (est. unless marked)                                                                                       | load class                     | hold                                                      |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------- | ------------------------------ | --------------------------------------------------------- |
+| `tier-holes.js`           | ≈ 620                                                                                                               | detect-from-markup (announced) | buffer only                                               |
+| `tier-wire.js`            | ≈ 470 — **landed 934** (`wire.js`; the whole connection, not the dispatch alone)                                    | preload-at-call                | none                                                      |
+| `container-trace.js`      | **7,860 measured** (S1) → ≈ 8,100 with the eager half moved in; ≈ 8,800 if the adapters follow (Phase D)            | announced                      | 3.1 participant (adopt path)                              |
+| `tier-regions.js`         | ≈ 540                                                                                                               | announced                      | 3.1 participant (adopt path)                              |
+| `tier-assets.js`          | ≈ 760                                                                                                               | announced                      | reveal-readiness term                                     |
+| `tier-bind.js`            | ≈ 1,650 (frames); ≈ 2,550 on a page carrying `assign` until B.3 — **landed 1,844** (`assign` imported, not carried) | announced                      | 3.1 participant (adopt path); the ` _hk` stamp for replay |
+| `dynamic-static.js` (B.3) | ≈ 2,400                                                                                                             | first string-tag `dynamic`     | async first render (accepted, Q5)                         |
+| sf natural body (E.b)     | ≈ 480                                                                                                               | first natural-encoding call    | none                                                      |
+| `decode.js`               | 6,074 measured                                                                                                      | first `data` chunk             | the chunk awaits it (today)                               |
+| router claims             | ≈ 330                                                                                                               | the router installs it         | re-sweep on install                                       |
 
 Pages (br; the whole page, lazy chunks not counted):
 
-| scenario                  | today (head / audit)      | after Phases A–C (correctness + tiers; `est.` from the measured `L8` page cuts + the seams)                                                                      | after Phase D (+ B.3, adapters, E.b) | vs today             | the SC audit's floors                                              |
-| ------------------------- | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------- | ------------------------------------------------------------------ |
-| page base                 | 44,823 / 44,762           | **≈ 32.3 KB** (`L8` page 30,901 measured + the adapters S1 leaves eager ≈ +1,300 + seams ≈ +150) — 8.0 reading ≈ 32.8                                            | **≈ 28.1 KB**                        | **−16.7 KB (−37 %)** | packaging only ≈ 31.4; S10 end ≈ 29.5–30                           |
-| page live                 | 48,576 / 48,436           | **≈ 36.1 KB** (`L8` page live 34,620 measured + adapters + seams; the holes and wire chunks load lazily on this page and are reported, not counted) — 8.0 ≈ 36.6 | **≈ 31.8 KB**                        | **−16.8 KB (−35 %)** | packaging only ≈ 35.5; S10 end ≈ 33.5                              |
-| app hydrating (no stores) | 17,705                    | **≈ 17,750** (+≈ 45: S-hold's `hydrateWindow` + the registration reach, S-adopted, `whenRevealed`)                                                               | unchanged                            | +45                  | — (the rulings estimated +8 for 3a alone; the other two seams add) |
-| compiled hydrating        | 30,943 (at its 30.93 cap) | **≈ 30,990** (the same +≈ 45)                                                                                                                                    | unchanged                            | +45                  | **cap raise needed — the maintainer's**                            |
-| frames eager              | 13,770                    | ≈ 7,600 (7.8 reading; the C6 gate is 8.5 before the residual R / D cuts land) / ≈ 8,150 (8.0)                                                                    | **≈ 7,250 / ≈ 7,800**                | **−6.5 KB (−47 %)**  | ≈ 10,500                                                           |
+| scenario                  | today (head / audit)      | after Phases A–C (correctness + tiers; `est.` from the measured `L8` page cuts + the seams)                                                                      | measured after B + C3–C5 (2026-10-06; vs `next` @ `9d89df731`)                                              | after Phase D (+ B.3, adapters, E.b) | vs today             | the SC audit's floors                                              |
+| ------------------------- | ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ------------------------------------ | -------------------- | ------------------------------------------------------------------ |
+| page base                 | 44,823 / 44,762           | **≈ 32.3 KB** (`L8` page 30,901 measured + the adapters S1 leaves eager ≈ +1,300 + seams ≈ +150) — 8.0 reading ≈ 32.8                                            | **37,772** (119,044 min; **−7,110 br**; C1 / C2 / C6 and Phase D still to come)                             | **≈ 28.1 KB**                        | **−16.7 KB (−37 %)** | packaging only ≈ 31.4; S10 end ≈ 29.5–30                           |
+| page live                 | 48,576 / 48,436           | **≈ 36.1 KB** (`L8` page live 34,620 measured + adapters + seams; the holes and wire chunks load lazily on this page and are reported, not counted) — 8.0 ≈ 36.6 | **41,427** (130,915 min; **−7,168 br**)                                                                     | **≈ 31.8 KB**                        | **−16.8 KB (−35 %)** | packaging only ≈ 35.5; S10 end ≈ 33.5                              |
+| app hydrating (no stores) | 17,705                    | **≈ 17,750** (+≈ 45: S-hold's `hydrateWindow` + the registration reach, S-adopted, `whenRevealed`)                                                               | 17,838 (+110 vs `next` — Phase A's, 0 vs the Phase A base)                                                  | unchanged                            | +45                  | — (the rulings estimated +8 for 3a alone; the other two seams add) |
+| compiled hydrating        | 30,943 (at its 30.93 cap) | **≈ 30,990** (the same +≈ 45)                                                                                                                                    | 31,075 (+52 — Phase A's)                                                                                    | unchanged                            | +45                  | **cap raise needed — the maintainer's**                            |
+| frames eager              | 13,770                    | ≈ 7,600 (7.8 reading; the C6 gate is 8.5 before the residual R / D cuts land) / ≈ 8,150 (8.0)                                                                    | **13,083** (40,000 min; **−704 br**; chunks `trace.js` 8,176 / `regions.js` 805 / `assets.js` 783 br, lazy) | **≈ 7,250 / ≈ 7,800**                | **−6.5 KB (−47 %)**  | ≈ 10,500                                                           |
 
 ### 4.1 Measured (2026-10-06)
 
@@ -448,11 +540,11 @@ this plan's tier model: it built the lazy chunk, the hold, and the
 consistency fixes for the one tier whose chunk is big enough to have
 forced the question. Under the general mechanism:
 
-| commit                                                                            | survives as-is                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | re-shapes under the general mechanism (B / C3)                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | pins                                                                                                                                                                                                                                                                                                                                                                                            |
-| --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **1 — `8629a93be`** the lazy materializer via `solid-js/internal/container-trace` | the **entry** (its own dist entry, the `@internal` seams it reads back from the main module — `withStoreHydration`, `applyPatches`, `forwardIteratorReturn`; the server's inert stubs); `loadContainers` as the dynamic import kept external; the frames container plugin materializing at decode                                                                                                                                                                                                                                                                                                                         | `FrameHostOptions.prepareData(chunk)` → `needsContainerTraceMaterializer(chunk) && prepareTier("trace")` (the node scan stays as the un-announced fallback; the header flag makes it a confirmation); `prepareArgs(record)` → the general **held set** predicate (a marker literal is one of the three hold reasons: trace / `{$frame}` / `positions`); `#argsUnprepared` → the held set; the eager half of F.trace (`reviveContainerTraces`, `materialize`, the marker tests) moves into the chunk's `installTier` | `frames-container-lazy-codec`, `frames-container-lazy-document`, `hydration/welcome-status-lazy` — unchanged in assertion; their load trigger becomes `prepareTier`                                                                                                                                                                                                                             |
-| **2 — `ef6147557`** caps lowered to S1's measured + 10 B                          | the **ratchet itself** (lowering at landing)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | the values re-set at each later landing; the frames-eager +134 exception S1 could not take is **never granted**: B's shared seam lands before S1 merges and costs less than S1's two faces (≈ −35 net, credited at C3)                                                                                                                                                                                                                                                                                              | `check-floor-caps` clean on `next`                                                                                                                                                                                                                                                                                                                                                              |
-| **3 — `9927ddddd`** a held container-trace fill hydrates like a resident one      | **all three fixes**: the detached root for the projection (solid; id determinism); the parked backlog beyond the snapshot until `onHydrationEnd` with the `claiming` hint (`revive(value, claiming?)` → `reviveContainerTraces(value, claiming?)` → `materializer(marker, claiming?)`) — this is ruling 3.6 (iii), the rulings' step "3e" — the detached root and the backlog are ported onto `next` in A2, the `claiming` hint lands with S1 at C3; the held-record mount (an occurrence held on an unresolved ref or unprepared arg mounts with the record it was held on and applies a replacement as the args change) | the held-record mount **generalizes**: it is the mechanism every announced tier's adopt-path hold uses (regions, bind), not trace-specific — `#heldRecords` keyed by occurrence becomes the held set of B (A2's registered set); the park's release order (claim → hold release → done → backlog) is **pinned with 3a** (rulings 3.2 "Ordering to pin with it")                                                                                                                                                     | `container-trace-hold-{id-determinism, interruption, record-retention, snapshot}` — survive as-is; **`container-trace-hold-hydration-end` re-pins under 3.1** at C3's merge (A2 already in) (_hydration waits for the load; the mount claims before done_ — same claim assertions, opposite order); the `.fails` id-drift pin (a keyed sibling after a frame) is ruling 3.4's and flips with 3c |
+| commit                                                                            | survives as-is                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | re-shapes under the general mechanism (B / C3)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | pins                                                                                                                                                                                                                                                                                                                                                                                            |
+| --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **1 — `8629a93be`** the lazy materializer via `solid-js/internal/container-trace` | the **entry** (its own dist entry, the `@internal` seams it reads back from the main module — `withStoreHydration`, `applyPatches`, `forwardIteratorReturn`; the server's inert stubs); `loadContainers` as the dynamic import kept external; the frames container plugin materializing at decode                                                                                                                                                                                                                                                                                                                         | `FrameHostOptions.prepareData(chunk)` → **nothing** (landed at C3: B's `chunk.tiers` on the `data` chunk that carries the node is the codec face's whole trigger; the node scan was measured and dropped — see row C3); `prepareArgs(record)` → the general **held set** predicate (a marker literal is one of the three hold reasons: trace / `{$frame}` / `positions`); `#argsUnprepared` → the held set; the eager half of F.trace (`reviveContainerTraces`, `materialize`, the marker tests) moves into the chunk's `installTier` | `frames-container-lazy-codec`, `frames-container-lazy-document`, `hydration/welcome-status-lazy` — unchanged in assertion; their load trigger becomes `prepareTier`                                                                                                                                                                                                                             |
+| **2 — `ef6147557`** caps lowered to S1's measured + 10 B                          | the **ratchet itself** (lowering at landing)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | the values re-set at each later landing; the frames-eager +134 exception S1 could not take is **never granted**: B's shared seam lands before S1 merges and costs less than S1's two faces (≈ −35 net, credited at C3)                                                                                                                                                                                                                                                                                                                | `check-floor-caps` clean on `next`                                                                                                                                                                                                                                                                                                                                                              |
+| **3 — `9927ddddd`** a held container-trace fill hydrates like a resident one      | **all three fixes**: the detached root for the projection (solid; id determinism); the parked backlog beyond the snapshot until `onHydrationEnd` with the `claiming` hint (`revive(value, claiming?)` → `reviveContainerTraces(value, claiming?)` → `materializer(marker, claiming?)`) — this is ruling 3.6 (iii), the rulings' step "3e" — the detached root and the backlog are ported onto `next` in A2, the `claiming` hint lands with S1 at C3; the held-record mount (an occurrence held on an unresolved ref or unprepared arg mounts with the record it was held on and applies a replacement as the args change) | the held-record mount **generalizes**: it is the mechanism every announced tier's adopt-path hold uses (regions, bind), not trace-specific — `#heldRecords` keyed by occurrence becomes the held set of B (A2's registered set); the park's release order (claim → hold release → done → backlog) is **pinned with 3a** (rulings 3.2 "Ordering to pin with it")                                                                                                                                                                       | `container-trace-hold-{id-determinism, interruption, record-retention, snapshot}` — survive as-is; **`container-trace-hold-hydration-end` re-pins under 3.1** at C3's merge (A2 already in) (_hydration waits for the load; the mount claims before done_ — same claim assertions, opposite order); the `.fails` id-drift pin (a keyed sibling after a frame) is ruling 3.4's and flips with 3c |
 
 **When it merges: at C3 — re-based, after Phases A and B. S1 as built is
 NOT merged first.** The reason is the one the ruling turns on. S1's
@@ -477,6 +569,27 @@ What S1 **does not** become: the general mechanism's model. S1 detects
 stays as the fallback, so S1's behaviour on an un-announced response is
 exactly the plan's fallback behaviour, already pinned.
 
+**Landed (2026-10-06, C3 — `feat/frames-traces-tier`).** S1 re-based as
+above: commit 1's entry shipped unchanged (`solid-js/internal/container-trace`,
+the three `@internal` seams on the main entry, the server stubs) and its two
+host faces did not (`prepareData(chunk)` dropped with the node scan;
+`prepareArgs` / `#argsUnprepared` became `needsTrace` in A2's held set);
+commit 2's ratchet re-applied at the landing (page caps 38.61 / 42.16 KB);
+commit 3's `claiming` hint and held-record mount ported (`#heldRecords`
+generalizes to every adopt-path hold — `bind`, `regions`, `trace`), its
+hydration-end pin re-pinned under 3.1, its other four pins green with the
+hold re-armed per test through the runtime's `tierLoads` seam instead of
+S1's `force`. The plugin's client half rides the tier chunk, not the eager
+client: S1's eager half (`reviveContainerTraces`, `materialize`, the marker
+test, `isMaterializedContainer`, the module-load install) is what the −239
+br on frames eager is. S1 re-based costs **−83 br** on frames against B's
+head where S1 as built cost +134 against its own — the "≈ −35 net" this
+section credited came in at −217, because B's seam carried only the
+`bind` / `regions` predicates and the trace predicate's +67 br landed here
+with the −239 cut. One pin of S1's seven changed in assertion
+(`hydration-end`); the un-announced codec face is no longer convergent
+(the node scan is gone) and is flagged as such in row C3.
+
 ---
 
 ## 6. Open decisions for the maintainer
@@ -521,6 +634,52 @@ Each a yes/no with a recommendation.
    what turns the register's races from "likely" into "theoretical".
    **Ruled 2026-10-06: yes** — `modulepreload` + `_$HY.r["sc:tiers"]` +
    `X-Frame-Tiers`, as additive wire.
+   - **Sub-item for the maintainer (B, 2026-10-06): how the client finds
+     a tier's chunk URL.** The server does not know the client bundle's
+     chunks, so B built both halves of the recommended answer and they
+     compose: **(i)** the integration passes the URLs —
+     `frameTransformDirectResult(value, { id, args, tierUrls: { bind:
+"/assets/tier-bind-abc.js", … } })` (SolidStart from its manifest; the
+     document emits a `<link rel="modulepreload">` per announced tier only
+     when its URL is given, through the render's own asset registry so it
+     joins the shell head before the flush and dedupes with manifest links)
+     — and **(ii)** the client resolves tiers itself —
+     `installServerComponents(host, { tiers: { bind: () => import("…") } })`,
+     the built-in table once a tier's chunk exists — and starts each import
+     from the `sc:tiers` record at install (later than the preload's t = 0,
+     earlier than any adopt-time sync). Names ride the wire always
+     (record, header, in-band); links only with URLs; the import map on the
+     client always. The alternative not built: resolving the URL on the
+     server through `ctx.resolveAssets` with a frames-owned module key —
+     the manifest's key shape is the integration's (Vite's relative source
+     path, SolidStart's bridge), so guessing it from `@solidjs/web` would
+     couple the frames server to one bundler. **Accept (i)+(ii), or name a
+     third?** Also to confirm: `prepareTier` stays unexported from the
+     public client entry until a tier exists to warm (9 B br), and a sync
+     `renderToString` document announces nothing (no shared render slot;
+     the client detects — adding `live: {}` to the sync context would be a
+     core change on the `renderToString` floor).
+   - **As built through C3–C5 (the tiers integration PR, 2026-10-06):**
+     (i) + (ii) ship together and three tiers ride them. The client's
+     built-in table (`tierLoaders` in the frames client entry) carries
+     `trace` → `@solidjs/web/frames/trace`, `regions` →
+     `@solidjs/web/frames/regions`, `assets` → `@solidjs/web/frames/assets`
+     — three new export paths, each its own rollup entry, loaded by
+     `prepareTier(name)` off the `sc:tiers` record at install, off
+     `X-Frame-Tiers` / `chunk.tiers` on a stream, or from the readiness
+     check that finds the tier absent (the un-announced fallback). An
+     integration replaces an entry through `installServerComponents(host,
+{ tiers })`; the loader's module type is `TierModule` (`{ install?():
+     void; [applier: string]: unknown }` — a tier whose exports are its
+     appliers, `regions` / `assets`, has no `install` and the index
+     signature is what lets it typecheck). The `modulepreload` still
+     depends on `tierUrls` and no integration passes them yet — SolidStart's
+     manifest bridge is the first consumer; until then the record alone
+     announces and the import starts at install. `prepareTier` stays
+     unexported from the public entry (three tiers exist to warm now — the
+     9 B is the maintainer's call); the sync `renderToString` document
+     still announces nothing. **Still open: accept (i)+(ii) as the
+     answer, or name a third.**
 4. **The plain-response streaming bound** — _"presumably not infinitely"_:
    should the server end a plain (non-`live`) response after a bound, with
    detectable truncation, `live` being the declared way past it? —
diff --git a/documentation/server-components/frames-consistency-contract.md b/documentation/server-components/frames-consistency-contract.md
index a31510091..024164123 100644
--- a/documentation/server-components/frames-consistency-contract.md
+++ b/documentation/server-components/frames-consistency-contract.md
@@ -65,22 +65,32 @@ named `c<nn>-<slug>.spec.tsx`; each test title names its arm.
 
 Every server-rendered node inside a frame's content is, by quiescence,
 either claimed exactly once (by the hydrate pass or by the fill that owns its
-range) or removed by a deliberate replacement — never claimed by two passes,
-never left in the document beside a fresh clone of itself; a boundary element
-is adopted by at most one frame.
+range) or — when the fill's render did not claim it — left as the server
+rendered it and reported as unclaimed (the core's hydration-mismatch rule:
+a claim pass moves nothing) — never claimed by two passes, never left in the
+document beside a fresh clone of itself; a boundary element is adopted by at
+most one frame. _(Until residue step 3 the second arm read "or removed by a
+deliberate replacement": the frame placed a fill's output itself and
+replaced the range when the output was not in place. Every fill is placed by
+`insert` now, so the frames rule IS the core's.)_
 
 - **Mechanism:** `frames/src/client.ts:claimRender` (the claim window —
   `sharedConfig.hydrateWindow`, the re-entry a streamed boundary's resume
   takes: the range's keys gathered by the producer prefix into the registry
   of the root the frame adopted under; A2b replaced the range-scoped
-  registry handed over from the root registry), `client.ts:slotsFor.settle`
-  (the in-place check that turns a render into a claim),
-  `frame-client.ts:FrameImpl.#replaceRange`, `client.ts:adoptBoundary` +
+  registry handed over from the root registry — one gather per fill: the
+  window that places the output gathers nothing, so the keys the evaluation
+  claimed are not put back), `client.ts:slotsFor`'s `insert` of the fill's
+  output inside that window (`web/src/client.ts:insertExpression`'s claim
+  pass: in-place output is a claim, a render whose nodes never entered the
+  DOM leaves the server's in place), `client.ts:adoptBoundary` +
   `claimedBoundaries` (one adopter per element), `client.ts:documentBoundary`
   (a second mount goes fresh).
 - **Pin:** `c01-claim-once.spec.tsx` — arms: (a) two occurrences claim once
   each with no key miss and node identity preserved; (b) a fill that returns
-  fresh nodes replaces, leaving no server node of the range behind; (c) a
+  fresh nodes at the claim is a hydration mismatch — the server node stays,
+  nothing is duplicated, hydration reports it unclaimed (re-pinned in
+  residue step 3; it asserted the frame's replacement before); (c) a
   second mount of the same function while the first adopted mounts fresh and
   the adopted element is untouched. `c01-claim-window-roots.spec.tsx` (A2b):
   a claim the frame makes after another `hydrate()` root replaced the live
@@ -374,7 +384,11 @@ land at that transaction's commit — never when the body finishes arriving.
   (a) the body completes before the sibling releases; (b) the sibling
   releases first, the body completes after; (c) a second refetch supersedes
   the first while staged; (control) a refetch holding nothing else lands at
-  body end.
+  body end; (e) the gap #3844 named, by name — a same-address refetch
+  enters the transaction (the fill derives the new arg in that pass while
+  the DOM, `frame:applied` and the frame's version still show v1) and
+  lands whole at its commit; any carrier of the staging, push or pull,
+  must keep both halves (residue pass §3.1 "As measured").
 - **Verdict:** **holds on `next`** (4/4). Nothing of the staged version is
   visible, applied (`frame:applied`) or versioned in the host before the
   commit; root, fill and sibling change in one frame in both orders; a
@@ -426,7 +440,7 @@ address's late chunks never release it.
 
 | #   | invariant                          | mechanism (carrier)                                                    | pin                               | `next`            |
 | --- | ---------------------------------- | ---------------------------------------------------------------------- | --------------------------------- | ----------------- |
-| C1  | claim once / replace / one adopter | `claimRender`, `slotsFor.settle`, `#replaceRange`, `claimedBoundaries` | `c01-claim-once`                  | holds             |
+| C1  | claim once / mismatch stays / one adopter | `claimRender`, `slotsFor`'s `insert` (the core's claim pass), `claimedBoundaries` | `c01-claim-once`                  | holds             |
 | C2  | no inert server content            | `#syncSlots`, `adoptBoundary` reveal cascade                           | `c02-revealed-occurrence-mounts`  | **red** (a2, b)   |
 | C3  | done counts every hold             | `_pendingBoundaries` vs `#recordRefresh`/`#refsUnresolved`             | `c03-hydration-done-counts-holds` | **red** (a)       |
 | C4  | record applies once, any order     | `drainRecords`, `write`, `argsEquivalent`, `#appliedHoles`             | `c04-record-applies-once`         | **red** (d)       |
diff --git a/documentation/server-components/frames-rulings.md b/documentation/server-components/frames-rulings.md
index 5600b993a..3d6b6b1e2 100644
--- a/documentation/server-components/frames-rulings.md
+++ b/documentation/server-components/frames-rulings.md
@@ -1055,7 +1055,11 @@ server's node.**
   child, two after a keyed sibling — per S1's note); the client's `adoptBoundary`
   consumes none. S1's `.fails` pin: `container-trace-hold-id-determinism` "a
   keyed sibling after the frame claims the server's node". Independent of any
-  hold; pre-existing on `next`.
+  hold; pre-existing on `next`. **The pin is on the tree since C3**
+  (2026-10-06, `test/hydration/container-trace-hold-id-determinism.spec.tsx`,
+  ported with S1's hold specs): still red on a resident run, still `.fails`,
+  with this ruling named as the reading it waits on (3c) — C3 changed
+  nothing in what the server or the adopter consumes.
 - **Decides.** That pin. A parity bug under C10's rule read one level up (the
   frame's own ids, not the fill's) — fix without a new ruling, but it needs the
   server's consumption pinned first (it varies by position), and the fix may be
@@ -1185,6 +1189,29 @@ update it is. The claim pass never rewrites a hole.**
   `claiming` hint (S1's `revive(value, claiming?)`, threaded from the
   adopt-time mount) arrives at plan step C3 with S1 and converts the park
   back to keyed-on-claim then.
+- **Landed (2026-10-06, C3 — `feat/frames-traces-tier`): the park is
+  keyed on the claim again.** The hint is threaded as S1 had it —
+  `#invokeSlot`'s `adopted` → `#resolveArgs(occurrence, record, claiming)` →
+  `FrameHostOptions.revive(value, claiming)` → `reviveContainerTraces(value,
+claiming)` → `materialize(marker, claiming)` → `materializeContainerTrace
+(marker, claiming)` (now `solid-js/internal/container-trace`, the traces
+  tier's entry) — and the materializer parks only when `claiming` is true:
+  every adopt-time mount of an adopt frame (t = 0, under the tier's hold,
+  at a fragment's reveal, on a frame adopted after done — `ctx.adopted` is
+  the one invocation a consumer may answer with a claim, so it is exactly
+  the set of claims; the "no hydration state says claim" problem the
+  unconditional port worked around does not arise, since the hint is the
+  frame's, not the pass's). A fresh mount — a stream re-call, a codec-face
+  decode — reads the fold of its whole backlog at once and pays no beat.
+  The release order 3.2 pins holds through the tier's hold: the late claim
+  under `needsTrace` materializes with `claiming`, the frame's hold releases
+  after that sync, done after the hold, the backlog after done
+  (`container-trace-hold-{snapshot,hydration-end}`, `tier-trace-hold`;
+  solid's `container-trace.spec` pins the keyed park itself: a fresh mount
+  during hydration parks nothing either). The +4 B this costs on the
+  `@solidjs/web` server floor is `materialize`'s second parameter in the
+  codec plugin the SSR runtime bundles (within the minified allowance;
+  brotli −9).
 
 - **Mechanism today.** `web/src/client.ts:insertExpression` under hydration is
   a claim pass, not a mutation pass (C1/C9: nothing moves);
diff --git a/documentation/server-components/server-components-principles.md b/documentation/server-components/server-components-principles.md
index d5405ef05..d90c2fbf9 100644
--- a/documentation/server-components/server-components-principles.md
+++ b/documentation/server-components/server-components-principles.md
@@ -719,7 +719,7 @@ exists to undo another mechanism's consequences; deletes with its cause.
 | 16 | `#refArgsUnchanged` value-compare | A5 | **Done (Stage 2):** the #547 `$frame`-addition leniency deleted with unified records; the plain value-compare stays (it is the dedupe, not the patch). |
 | 17 | `$ref`/`$frame` arg resolution + per-stream tables | A1/A3 | Derived; table scoping revisited under per-address stores (§5.2). |
 | 18 | Region discovery from markup (`#discoverRegions`) | A5 | **Done (Stage 2, first half):** with A5, used regions have records on every transport; discovery remains only as claim wiring — and membership is now structural (outermost dotted id in this interior), not producer-prefix-matched, so address-keyed mounts adopt fn-id-prefixed markup. |
-| 19 | Region bind/rebind/`renameRegion` (wire-id renames) | A3 | Compensatory: regions become store substructure keyed `(parent address, occurrence, arg)` (§5.3); wire-relative renames delete. |
+| 19 | Region bind/rebind/`renameRegion` (wire-id renames) | A3 | Compensatory: regions become store substructure keyed `(parent address, occurrence, arg)` (§5.3); wire-relative renames delete **with that normalization — not before it.** Frames savings pass C4 (2026-10-06) found the rename LIVE, not dead: a single-flight response renders a shown boundary's regions under the call's address while a direct response and the document render them under the function id, so a flight refresh renames every region of the boundary (`preview`'s region check anticipates it; `lifecycle-matrix/call-driven-args` › regions and `frames-optimistic-hold` pin the rebind). C4 moved bind / rename into the regions tier chunk (`@solidjs/web/frames/regions`: `bind`, `rename`, the rename arm of `resolve`) — 0 eager bytes — and left the deletion to S7's store-boundary normalization. |
 | 20 | `hy.r` occlusion absorption (adopt-time fake chunks) | A5/A6 | Compensatory. Deletes: occluded content is ordinary records in the one buffer, drained by the one consumer (DR-4). |
 | 21 | Segment reveal + placeholder discovery (`#revealSegment`) | A6 | Derived — and becomes the only implementation (DR-4). |
 | 22 | Stylesheet gating + modulepreload | A6/L1 | Derived — unchanged, one instance instead of two. |
@@ -2156,7 +2156,7 @@ const toggleAll = action(function* (ids: string[], completed: boolean) {
   yield toggleAllTodos(ids, completed);
 });
 
-const Todos = dynamic(() => getTodos(filter()));
+const Todos = dynamicComponent(() => getTodos(filter()));
 
 <Todos
   row={p => ({ class: { completed: done(p) }, hidden: !!pending.byId[p.id]?.removed })}
@@ -2573,9 +2573,10 @@ amended here:
   are the same `liveSlotProps` proxy content occurrences get, so a
   re-emitted record updates the instance in place. The
   per-occurrence owner is unconditional here (content fills scope
-  only stream-mounted invocations, for the zombie-heuristic reason
-  recorded in `slotsFor`): an element occurrence places no nodes, so
-  nothing can be misread, and the spread's effect must die with the
+  only stream-mounted invocations — a live-render fill's ambient
+  owner, the reconstructed boundary's content computation, already
+  has the right lifetime; see `slotsFor`): an element occurrence
+  places no nodes, and the spread's effect must die with the
   occurrence. Fill-returned handlers go through client `spread`'s
   own delegation (the "open" item above closes this way — the
   one-owner rule keeps `_bnd` and a fill off the same position).
@@ -2589,8 +2590,8 @@ amended here:
   the server's value and re-imposes the owned names' live state on
   top (a class the fill toggled on stays on through a server class
   change; an owned style property survives the attribute rewrite).
-  A replaced element is a zombie mount (its node left the tree) and
-  the fill remounts on the fresh node; an unmounted occurrence
+  A replaced element is a consumer change (the fill rebinds on the
+  fresh node, see §9.2.3); an unmounted occurrence
   releases its ownership so the element is wholly the server's from
   the next morph on.
 - *No regions in attribute slots.* An element occurrence has no
@@ -3207,6 +3208,20 @@ the text above, the build is right and the text is amended here:
   them, so a kept un-keyed element carries one listener, not one per
   occurrence that ever bound it, and a dropped occurrence's handler
   never fires through its disposed fill.
+- *The replay-window stamp (frames savings pass C6, option (a)).* On
+  the document face an element with an `_s:on:*` position — only
+  those; a ref-only or attribute-only consumer carries nothing — is
+  written with a bare ` _hk` after its markers (4 bytes, no key). The
+  binding runtime is a lazy tier, so the hydration bootstrap must
+  queue the element's events until its handlers bind: it queues only
+  under a not-yet-completed `_hk` element, and a server component's
+  interior (NoHydration) has none of its own. Bare, the stamp is
+  nothing's to gather or claim (prefix gathers match keyed values;
+  the root's ambient sweep leaves frame interiors to their fills);
+  the tier marks the element completed at the bind and drains the
+  queue. The stream face writes no stamp — the bootstrap stopped
+  capturing at `_$HY.done`, so a response's html has no window to
+  keep open.
 - *A repeated call is one occurrence per render, on both faces —
   keyed or not.* Found by the first todos port, which emitted eleven
   `sc:slot:…row#<id>` records per row (one per position read through
@@ -3224,14 +3239,14 @@ the text above, the build is right and the text is amended here:
   compared. A placed range never registers: two identical positional
   markup calls stay two ranges (pinned). No wire change: ids stay
   `prop#<n>`.
-- *A data occurrence's nodes are its consumers, and it is never a
-  zombie.* The client's slot discovery collects `_s:*` elements into
-  per-occurrence consumer lists `[{ element, positions }]` alongside
-  the range walk. The occurrence's "nodes" are those elements (so the
-  existing bookkeeping sees them), but the zombie rule — output whose
-  node left the tree remounts fresh — does not apply: a replaced
-  consumer is a *consumer change*, and an occurrence no element
-  reads is simply not found and unmounts at the sync's end. Consumer
+- *A data occurrence's nodes are its consumers.* The client's slot
+  discovery collects `_s:*` elements into per-occurrence consumer
+  lists `[{ element, positions }]` alongside the range walk. The
+  occurrence's "nodes" are those elements: a replaced consumer is a
+  *consumer change*, and an occurrence no element reads is simply
+  not found and unmounts at the sync's end. (No mount's output is
+  ever checked for having left the tree — the morph recreates
+  nothing, DR-5; "mounted" is the frame's set.) Consumer
   sets compare structurally per sync; a change without an args
   change rebinds in place through a per-occurrence rebinder (the
   fill's computation stays; new elements and positions take their
diff --git a/documentation/server-components/server-components.md b/documentation/server-components/server-components.md
index 23d0fc0a7..ee46dac40 100644
--- a/documentation/server-components/server-components.md
+++ b/documentation/server-components/server-components.md
@@ -130,22 +130,23 @@ thing here.
 
 ## Using it from the client
 
-There is no server-component API on the client. `dynamic` — the same
-utility you'd use to swap any component — is the whole surface:
+There is no server-component API on the client. `dynamicComponent` — the
+component-only form of `dynamic`, the same utility you'd use to swap any
+component — is the whole surface:
 
 ```tsx
-import { dynamic } from "@solidjs/web";
+import { dynamicComponent } from "@solidjs/web";
 
 function StoryPage(props) {
   const [collapsedAll, setCollapsedAll] = createSignal(false);
 
   // The source is tracked: when props.storyId changes it re-calls the
   // server function. Every call for the same (function, args) resolves to
-  // the IDENTICAL component — a refetch passes dynamic's equals-gate, so
+  // the IDENTICAL component — a refetch passes the equals-gate, so
   // nothing remounts and the stream morphs the boundary in place. A new
   // storyId resolves that story's own boundary and the site swaps to it,
   // seeded from retained content when the story has shown before.
-  const Story = dynamic(() => getStory(props.storyId));
+  const Story = dynamicComponent(() => getStory(props.storyId));
 
   return (
     <Story
@@ -223,7 +224,7 @@ own:
 
 - **Wrap the section function in `query`** and route-level `preload` warms
   it on intent — the response's chunks buffer until a boundary mounts,
-  then drain. The `dynamic()` read resolves through the same cached
+  then drain. The `dynamicComponent()` read resolves through the same cached
   in-flight call, and a later fresh cache hit re-materializes the boundary
   from retained state with no request at all — back/forward navigation
   renders like a bfcache restore.
@@ -365,7 +366,7 @@ must not break:
 ### What a router does with this
 
 A router integration is thin by design: translate URL changes into
-server-function calls and let a `dynamic` source (or
+server-function calls and let a `dynamicComponent` source (or
 `applyFrameResponse(response, host, { as })` directly) read them — the
 router names nothing, because the calls themselves name the boundaries
 (invariant 3). Wrapping the section functions in the router's `query`
diff --git a/documentation/solid-2.0/03-control-flow.md b/documentation/solid-2.0/03-control-flow.md
index 646112ef3..5f786c056 100644
--- a/documentation/solid-2.0/03-control-flow.md
+++ b/documentation/solid-2.0/03-control-flow.md
@@ -228,6 +228,7 @@ const Article = dynamic(() => loadArticle(params.id), { deferStream: true });
 #### Notes
 
 - The source evaluation is shared across all mounted instances of the returned component, so using one `dynamic(...)` in many places doesn't duplicate work.
+- Because a source may answer with a tag name, one `dynamic` on a page retains the element runtime (`spread`, the attribute helpers, the namespace tables) for everyone; `dynamicComponent(source)` is the same primitive for a source that only ever answers with a component — a server component mount ([RFC 11](11-server-components.md#using-one)) — and never does.
 
 ### Client-only components: `clientOnly`
 
diff --git a/documentation/solid-2.0/10-server-functions.md b/documentation/solid-2.0/10-server-functions.md
index 29ee8c416..d279e87f8 100644
--- a/documentation/solid-2.0/10-server-functions.md
+++ b/documentation/solid-2.0/10-server-functions.md
@@ -243,7 +243,7 @@ export const feed = live(
 );
 
 // client
-const Feed = dynamic(() => feed(props.room));
+const Feed = dynamicComponent(() => feed(props.room));
 ```
 
 The client's binding reconnects on death through `live`'s loop; the document render takes first values from the component's sources and hands off (the brand on the component marks the frame's scope); hydration adopts the document's markup and the loop reconnects from there. How frames make the resume _quiet_ — a stable binding identity per address, conditional re-emission by hole — is frames' business, recorded in `documentation/server-components/server-components-principles.md` §9.5. What is RFC-10-level is that liveness has one declaration, one loop, and one status surface across both tiers.
diff --git a/documentation/solid-2.0/11-server-components.md b/documentation/solid-2.0/11-server-components.md
index aa6e65479..f5cbf0f83 100644
--- a/documentation/solid-2.0/11-server-components.md
+++ b/documentation/solid-2.0/11-server-components.md
@@ -6,7 +6,7 @@
 
 ## Summary
 
-A **server component is a function returned from a server function** — there is no new component API, no new directive, and no `"use client"`. The server function’s _arguments_ are the server’s inputs (ids, filters); the returned component’s _props_ are client positions (**slots**) the server marks but never renders. On the client, `dynamic` is the entire consumption surface: a server-function call that resolves to a frame stream produces a **stable per-call component** — one boundary per (function, arguments), the same per-args rule a query cache keys values by — so refetches of the same call never remount: server content **morphs in place** underneath and client state inside the boundary (focus, inputs, toggles, video) survives server updates. A call with different arguments resolves its own boundary; the site swaps to it, re-materialized instantly from retained state when that call has shown before.
+A **server component is a function returned from a server function** — there is no new component API, no new directive, and no `"use client"`. The server function’s _arguments_ are the server’s inputs (ids, filters); the returned component’s _props_ are client positions (**slots**) the server marks but never renders. On the client, `dynamicComponent` — `dynamic`'s component-only form — is the entire consumption surface: a server-function call that resolves to a frame stream produces a **stable per-call component** — one boundary per (function, arguments), the same per-args rule a query cache keys values by — so refetches of the same call never remount: server content **morphs in place** underneath and client state inside the boundary (focus, inputs, toggles, video) survives server updates. A call with different arguments resolves its own boundary; the site swaps to it, re-materialized instantly from retained state when that call has shown before.
 
 The governing invariant is **single-copy**: server content travels as HTML, values the client needs travel as data records, and nothing travels as both. The acceptance test is literal — view-source the page or a navigation response and search for any piece of content; it appears exactly once.
 
@@ -64,7 +64,7 @@ A complete working setup (no Vite, no metaframework) is `examples/hackernews`; i
 ## Motivation
 
 - **Islands fall apart on navigation; RSC ships everything twice.** Islands architectures give a lean initial page but degenerate to full-page loads or bespoke protocols when you navigate. RSC-style server components keep rich composition but serialize the rendered tree alongside the HTML — every piece of server content pays twice. This design — _lakes, not islands_ — keeps one copy: the server owns and streams content, the client owns islands of interactivity **inside** it, and neither re-sends what the other has.
-- **No new API surface.** Every prior server-components design grew a parallel component model. Here the entire client surface is `dynamic` + server functions (RFC 10) plus one `installServerComponents()` call. Boundary identity is **derived, never declared** — the call’s intrinsic (function, arguments) address keys the boundary, mirroring a data layer’s cache keys by construction, so panes over different calls are independent with nothing annotated and multi-instance mounting fans one stream out to every mounted frame.
+- **No new API surface.** Every prior server-components design grew a parallel component model. Here the entire client surface is `dynamicComponent` + server functions (RFC 10) plus one `installServerComponents()` call. Boundary identity is **derived, never declared** — the call’s intrinsic (function, arguments) address keys the boundary, mirroring a data layer’s cache keys by construction, so panes over different calls are independent with nothing annotated and multi-instance mounting fans one stream out to every mounted frame.
 - **Client state must survive server updates.** The failure mode that kills server-driven UIs is the refetch that blows away a half-typed reply. Policy here is structural: refetching into the same boundary morphs server content in place; teardown is disposal, never a version bump.
 
 ## Detailed design
@@ -102,7 +102,7 @@ async function getStory(id: number) {
 
 ```tsx
 function StoryPage(props) {
-  const Story = dynamic(() => getStory(props.storyId));
+  const Story = dynamicComponent(() => getStory(props.storyId));
   return (
     <Story comment={p => <CollapsibleComment cid={p.cid}>{p.children}</CollapsibleComment>}>
       <ShareBar />
@@ -111,7 +111,9 @@ function StoryPage(props) {
 }
 ```
 
-Navigation is a prop change: the tracked source re-calls the server function. A same-arguments refetch resolves the _same_ component reference (equals-gated — `dynamic` never remounts) and the stream morphs the boundary; a new `storyId` resolves that story’s own boundary and the site swaps to it — instantly, from retained content, when the story has shown before. Client-only state never reaches the server. State _inside_ a boundary belongs to its call (`CollapsibleComment`’s toggles reset per story — story 1’s collapse state never bleeds into story 2), while state _outside_ the boundary (`StoryPage`’s own signals) survives every navigation. First load composes with `<Loading>`; refetches don’t re-fallback.
+`dynamicComponent` is `dynamic` for a source that only ever answers with a component ([RFC 03](03-control-flow.md#dynamic-components-the-dynamic-factory)): the same contract and the same implementation, minus the tag arm — `dynamic` has to be able to render a tag name, so one `dynamic` on a page retains the element runtime (`spread` and the attribute helpers) for everyone; a server-component page that mounts with `dynamicComponent` never pays for it.
+
+Navigation is a prop change: the tracked source re-calls the server function. A same-arguments refetch resolves the _same_ component reference (equals-gated — `dynamicComponent` never remounts) and the stream morphs the boundary; a new `storyId` resolves that story’s own boundary and the site swaps to it — instantly, from retained content, when the story has shown before. Client-only state never reaches the server. State _inside_ a boundary belongs to its call (`CollapsibleComment`’s toggles reset per story — story 1’s collapse state never bleeds into story 2), while state _outside_ the boundary (`StoryPage`’s own signals) survives every navigation. First load composes with `<Loading>`; refetches don’t re-fallback.
 
 ### What routers get
 
diff --git a/packages/solid/package.json b/packages/solid/package.json
index 3386e2b38..ae10e76d4 100644
--- a/packages/solid/package.json
+++ b/packages/solid/package.json
@@ -104,6 +104,10 @@
       "types": "./types/internal.d.ts",
       "default": "./dist/internal.js"
     },
+    "./internal/container-trace": {
+      "types": "./types/client/container-trace.d.ts",
+      "default": "./dist/container-trace.js"
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
diff --git a/packages/solid/rollup.config.js b/packages/solid/rollup.config.js
index df2edad6e..ebf72d22f 100644
--- a/packages/solid/rollup.config.js
+++ b/packages/solid/rollup.config.js
@@ -85,5 +85,20 @@ export default [
   // protocol is `@solidjs/signals` (external, the app's one instance) and the
   // server-scope seams are read back from "solid-js" (external, so the
   // platform/tier conditions pick the same main build the app runs).
-  build("src/internal.ts", "internal", ["solid-js", "@solidjs/signals"], false, false)
+  build("src/internal.ts", "internal", ["solid-js", "@solidjs/signals"], false, false),
+  // `solid-js/internal/container-trace`: the container-trace materializer,
+  // its own entry because the main build is one flat module — any binding in
+  // it that reaches the store engine welds the engine to whoever imports the
+  // binding. This entry reaches `createProjection` through `@solidjs/signals`
+  // (external, per-module files) and reads the hydration dispatch and the
+  // patch protocol back from "solid-js" (external), so an app bundler can
+  // give the engine to the lazy chunk `@solidjs/web/frames`' traces tier
+  // loads it in. No tier-specific code of its own, so one build.
+  build(
+    "src/client/container-trace.ts",
+    "container-trace",
+    ["solid-js", "@solidjs/signals"],
+    false,
+    false
+  )
 ];
diff --git a/packages/solid/src/client/container-trace.ts b/packages/solid/src/client/container-trace.ts
new file mode 100644
index 000000000..8d1875fca
--- /dev/null
+++ b/packages/solid/src/client/container-trace.ts
@@ -0,0 +1,258 @@
+/**
+ * `solid-js/internal/container-trace` — the client half of the container tier
+ * at the slot border (DR-2 case 3): a server projection crosses a
+ * serialization boundary as its TRACE and materializes back into a live local
+ * projection. NOT public API (the `solid-js/internal` namespace): consumed by
+ * `@solidjs/web/frames`' traces tier (`@solidjs/web/frames/trace`), which the
+ * frames client loads lazily — the server announces the tier when it
+ * serializes a trace, and an un-announced marker in a record's args starts
+ * the load itself (frames savings pass §2) — so the store engine
+ * (`createProjection` and everything `@solidjs/signals/store` drags in, ~8 KB
+ * brotli) stays out of a server-component page that never meets one.
+ *
+ * Its own dist entry, not a member of `solid-js`: that build is one flat
+ * module, so any binding in it that references the engine welds the engine to
+ * the eager chunk the moment anything imports the binding — a lazy
+ * `import("solid-js/internal")` would split off a facade and leave the engine
+ * where it was. This module reaches `createProjection` through
+ * `@solidjs/signals` (per-module files the app bundler can assign to this
+ * chunk) and takes the hydration dispatch and the patch protocol from
+ * `solid-js` by name, so it behaves exactly as the wrapper did at every call
+ * site while retaining nothing of the engine on the eager side.
+ */
+import {
+  createProjection as coreProjection,
+  createRoot as coreRoot,
+  createSignal as coreSignal,
+  getOwner,
+  NotReadyError,
+  runWithOwner,
+  type Store
+} from "@solidjs/signals";
+// Read back from the main entry (external: the app's one instance, whose
+// `enableHydration()` filled the adapter slot `withStoreHydration` reads).
+// Property reads, not named imports, so a server-tier resolution of this
+// entry (which has none of these) stays inert until something calls it.
+import * as core from "solid-js";
+
+// The seams, typed here because the main entry marks them `@internal`
+// and strips them from its declarations — `sharedConfig` is public, listed
+// for the same member-read discipline (the same arrangement as
+// src/internal.ts). Each is a member read ON THE NAMESPACE BINDING at the
+// call — never `const x = core` — so the bundler rewrites them to named
+// imports of the one `solid-js` instance; a namespace that escapes into a
+// variable retains every export of the flat main module (measured: +32 KB
+// minified on the page, the store wrappers' engine edge included).
+interface Seams {
+  withStoreHydration<T>(
+    coreFn: (fn: any, seed: any, options?: any) => T,
+    fn: any,
+    seed: any,
+    options?: any
+  ): T;
+  applyPatches(target: any, patches: any[]): void;
+  forwardIteratorReturn(it: any, value?: any): any;
+  sharedConfig: { onHydrationEnd?: (callback: () => void) => void };
+}
+const applyPatches = (target: any, patches: any[]) =>
+  (core as unknown as Seams).applyPatches(target, patches);
+const forwardIteratorReturn = (it: any, value?: any) =>
+  (core as unknown as Seams).forwardIteratorReturn(it, value);
+
+/** The projection constructor with solid's hydration dispatch — what `createProjection` from `solid-js` does, minus the wrapper's own engine edge. */
+const createProjection = (fn: (draft: any) => any, seed: any): Store<any> =>
+  (core as unknown as Seams).withStoreHydration(coreProjection as any, fn, seed);
+
+/**
+ * A root with NO parent. Materialization runs at arg-read, under whatever
+ * owner is reading — during hydration an id-carrying one — and a root
+ * created there inherits the next child id, shifting every key the reader
+ * mints after it: a trace revived at t=0 consumed one root id while one
+ * revived by a late claim (no ambient owner) consumed none, and a keyed
+ * sibling after the frame hydrated under different keys in the two runs.
+ * The store is shared and memoized per trace; it belongs to no reader's id
+ * space.
+ */
+const detachedRoot = <T>(init: () => T): T => runWithOwner(null, () => coreRoot(init))!;
+
+/** Run `callback` once hydration has completed — now (a microtask) when none is in progress. */
+function afterHydration(callback: () => void) {
+  const onHydrationEnd = (core as unknown as Seams).sharedConfig.onHydrationEnd;
+  onHydrationEnd ? onHydrationEnd(callback) : queueMicrotask(callback);
+}
+
+/**
+ * Materialize a container TRACE — snapshot then patch batches, the
+ * continuation protocol a server projection serializes as when it crosses a
+ * boundary (hydration resume in solid-js; the slot border via the serializer's
+ * container plugin) — into a live local projection. The result reads like
+ * the server value did: not-ready until the snapshot lands, then a
+ * read-only store the batches keep updating, done when the trace ends.
+ *
+ * Created under a detached root (see `detachedRoot`): revival can run inside
+ * a render effect's owner, and the store is memoized per trace (see the
+ * plugin's WeakMap) — a store owned by its first reader would be disposed by
+ * that reader's re-render while other readers still hold it, and one rooted
+ * under it would take a hydration id from it. Consumption is pull-driven and
+ * the trace is response-bounded, so the projection settles on its own; GC
+ * collects the pair with the trace.
+ *
+ * Materialized for a CLAIM (`claiming` — the reader is about to hydrate
+ * server markup rendered from this value: a frame's adopt-time mount, at
+ * t=0 or deferred under its hold, frames-rulings 3.1 / 3.2), a replayed
+ * backlog beyond the snapshot is PARKED until hydration ends
+ * (`onHydrationEnd`; the next microtask when no pass is in progress — what
+ * a claim made after hydration-done gets). The snapshot is the state the
+ * server's markup shows; the claim renders the fill against that markup and
+ * trusts it — a text hole is never rewritten during a claim — so a store
+ * already past the markup left the DOM diverged from it for good (the trace
+ * had nothing further to emit). Applied after the claim, the backlog re-runs
+ * the fill's reads outside hydration and the DOM catches up: the same
+ * parking solid's store-shaped async-iterable hydration applies to a
+ * buffered backlog (frames-rulings 3.6 (iii), "the consumer parks"). The
+ * release order is the one 3.2 pins: claim, the frame's hold release, done,
+ * then the backlog. Materialized for a FRESH mount (no server markup to
+ * agree with — a stream re-call, a codec-face decode), nothing is parked:
+ * the first read is the fold of the whole backlog. Live emissions land
+ * after the claim by construction either way. A failure applies in order,
+ * after everything queued before it, so it, too, waits on a parked backlog.
+ *
+ * Consumed by the serialization layer (`@solidjs/web/frames`). Declared, not
+ * stripped: this entry's whole surface is the seam, and the subpath's
+ * namespace is what makes it non-public.
+ */
+export function materializeContainerTrace(
+  marker: {
+    $tr: AsyncIterable<any> | { __SEROVAL_STREAM__: true };
+    $ta?: number;
+  },
+  claiming?: boolean
+): Store<any> {
+  const src = marker.$tr as any;
+  // Raw seroval stream (the wire shape since the stream-mint protocol):
+  // `.on()` replays buffered emissions SYNCHRONOUSLY, so a snapshot the
+  // document already delivered is applied before the first read — the store
+  // reads as READY during hydration's synchronous claim walk, matching the
+  // page's settled markup. The async-iterable branch below (pre-stream
+  // payloads) can only surface its buffer through microtasks, which made a
+  // settled-inline boundary suspend at the walk and hydrate a phantom
+  // fallback over settled markup (the chat welcome/status meter miss).
+  if (src != null && src.__SEROVAL_STREAM__ === true) {
+    const queue: any[] = [];
+    let failed: { error: any } | undefined;
+    let cursor = 0;
+    let first = true;
+    // How far into the queue a compute may apply: everything, except a
+    // claim's replayed backlog beyond the snapshot, parked until hydration
+    // ends (see above).
+    let limit = Infinity;
+    // Everything lives under the root (see the block comment below):
+    // materialization runs at arg-read inside a reader's render scope, and
+    // a version signal owned by that reader would be disposed by its
+    // re-render while the memoized store lives on.
+    return detachedRoot(() => {
+      const [version, setVersion] = coreSignal(0);
+      // Subscribe before creating the projection: the buffered replay runs
+      // synchronously inside on(), filling the queue the first compute
+      // drains. Replayed values must NOT bump the version — the replay can
+      // run inside an owned render scope where reactive writes are illegal,
+      // and the projection doesn't exist yet to need waking. Only live
+      // emissions (stream callbacks on later tasks) bump.
+      let live = false;
+      const bump = () => live && setVersion(n => n + 1);
+      src.on({
+        next(value: any) {
+          queue.push(value);
+          bump();
+        },
+        // The trace ended: the last applied state latches (same contract as
+        // the iterable path's `done`).
+        return() {},
+        throw(error: any) {
+          failed = { error };
+          bump();
+        }
+      });
+      live = true;
+      // The park (see above): decided here, because the projection's first
+      // compute runs at creation. Released at hydration end with a version
+      // bump, so the compute drains the backlog as one ordinary update.
+      if (claiming && queue.length > 1) {
+        limit = 1;
+        afterHydration(() => {
+          limit = Infinity;
+          bump();
+        });
+      }
+      return createProjection(
+        (draft: any) => {
+          version();
+          while (cursor < queue.length && cursor < limit) {
+            const value = queue[cursor++];
+            if (first) {
+              first = false;
+              // Full authoritative snapshot into a fresh {}/[] seed — pure
+              // writes, no draft reads (see the iterable branch below).
+              if (Array.isArray(value)) {
+                for (let i = 0; i < value.length; i++) draft[i] = value[i];
+                draft.length = value.length;
+              } else {
+                Object.assign(draft, value);
+              }
+            } else {
+              applyPatches(draft, value);
+            }
+          }
+          // In order: after everything queued before it has applied.
+          if (failed && cursor === queue.length) throw failed.error;
+          // Nothing buffered yet (revival raced ahead of the record's data
+          // script): pending until the snapshot lands, marked on the
+          // projection's own node — the version bump reruns this compute.
+          if (first) throw new NotReadyError(getOwner());
+        },
+        (marker.$ta ? [] : {}) as any
+      );
+    })!;
+  }
+  // A root, not a bare null owner: the projection's async machinery routes
+  // its pending/error states through the owner's queue, and with no owner
+  // at all the internal NotReadyError (the "pending until snapshot" mark)
+  // surfaces as an unhandled error in dev. The root is never disposed —
+  // the projection settles itself when the trace ends and is collected
+  // with the store.
+  return detachedRoot(() =>
+    createProjection(
+      (draft: any) => ({
+        [Symbol.asyncIterator]() {
+          const srcIt = src[Symbol.asyncIterator]();
+          let first = true;
+          return {
+            next: () =>
+              Promise.resolve(srcIt.next()).then((res: any) => {
+                if (res.done) return { done: true as const, value: undefined };
+                if (first) {
+                  first = false;
+                  // The first yield is the full authoritative snapshot. The
+                  // seed is a fresh empty {}/[] minted here, so this is pure
+                  // writes — no reads of the draft, which is still PENDING
+                  // (reading a pending proxy throws NotReadyError, which
+                  // would reject this step and error the projection).
+                  if (Array.isArray(res.value)) {
+                    for (let i = 0; i < res.value.length; i++) draft[i] = res.value[i];
+                    draft.length = res.value.length;
+                  } else {
+                    Object.assign(draft, res.value);
+                  }
+                } else {
+                  applyPatches(draft, res.value);
+                }
+                return { done: false as const, value: undefined };
+              }),
+            return: (value?: any) => forwardIteratorReturn(srcIt, value)
+          };
+        }
+      }),
+      (marker.$ta ? [] : {}) as any
+    )
+  )!;
+}
diff --git a/packages/solid/src/client/hydration.ts b/packages/solid/src/client/hydration.ts
index 0bc296868..1c5441ddc 100644
--- a/packages/solid/src/client/hydration.ts
+++ b/packages/solid/src/client/hydration.ts
@@ -762,7 +762,14 @@ function hasLoadingWindow(options: any): boolean {
   );
 }
 
-function forwardIteratorReturn(it: any, value?: any) {
+/**
+ * Forward an iterator's `return()`: the source's own answer when it is a
+ * promise, otherwise a synchronously-settling thenable of the done result
+ * (the hydration resume path must not wait a microtask for it).
+ *
+ * @internal — shared with `solid-js/internal/container-trace`.
+ */
+export function forwardIteratorReturn(it: any, value?: any) {
   const returned = it.return?.(value);
   return returned && typeof returned.then === "function"
     ? returned
@@ -819,7 +826,16 @@ function normalizeIterator(it: any, deferFirst?: boolean) {
   };
 }
 
-function applyPatches(target: any, patches: any[]) {
+/**
+ * Apply a projection's recorded patch batch — `[path, value]` writes,
+ * `[path]` deletes, `[path, value, 1]` splice-inserts — to a draft. The
+ * continuation protocol a server projection serializes as (hydration
+ * resume below; a container trace at the slot border, consumed by
+ * `solid-js/internal/container-trace`).
+ *
+ * @internal
+ */
+export function applyPatches(target: any, patches: any[]) {
   for (const patch of patches) {
     const path = patch[0];
     let current = target;
@@ -1261,198 +1277,6 @@ function hydrateStoreFromAsyncIterable(
   );
 }
 
-/**
- * Materialize a container TRACE — snapshot then patch batches, the
- * continuation protocol a server projection serializes as when it crosses a
- * boundary (hydration resume above; the slot border via the serializer's
- * container plugin) — into a live local projection. The result reads like
- * the server value did: not-ready until the snapshot lands, then a
- * read-only store the batches keep updating, done when the trace ends.
- *
- * Created under a DETACHED root (see `detachedRoot`): revival can run inside
- * a render effect's owner, and the store is memoized per trace (see the
- * plugin's WeakMap) — a store owned by its first reader would be disposed by
- * that reader's re-render while other readers still hold it, and one rooted
- * under it would take a hydration id from it. Consumption is pull-driven and
- * the trace is response-bounded, so the projection settles on its own; GC
- * collects the pair with the trace.
- *
- * A replayed backlog beyond the snapshot is PARKED until hydration ends
- * (frames-rulings 3.6 (iii), "the consumer parks"): the first reads see the
- * snapshot alone. A trace is materialized at a fill's arg-read, and when
- * that fill CLAIMS adopted markup — the document's pass, a frame's deferred
- * claim under its hold (3.1 / 3.2), a claim at a fragment's reveal or by a
- * frame adopted after done — the snapshot is the state the server rendered
- * that markup from; the claim renders against it and trusts it — a text
- * hole is never rewritten during a claim — so a store already past the
- * markup left the DOM diverged from it for good (the trace had nothing
- * further to emit). Applied after the claim, the backlog re-runs the fill's
- * reads outside hydration and the DOM catches up: the same parking
- * `hydrateStoreFromAsyncIterable` gives a buffered backlog. The release
- * order is the one 3.2 pins: claim, the frame's hold release, done, then
- * the backlog — and the next microtask when no hydration is in progress,
- * which is what a claim made after hydration-done gets, and what a FRESH
- * mount pays for not being told apart: its backlog lands one beat after
- * its snapshot, before any paint. Live emissions land after the claim by
- * construction. A failure applies in order, after everything queued before
- * it, so it, too, waits on a parked backlog.
- *
- * @internal — consumed by the serialization layer (@solidjs/web).
- */
-export function materializeContainerTrace(marker: {
-  $tr: AsyncIterable<any> | { __SEROVAL_STREAM__: true };
-  $ta?: number;
-}): Store<any> {
-  const src = marker.$tr as any;
-  // Raw seroval stream (the wire shape since the stream-mint protocol):
-  // `.on()` replays buffered emissions SYNCHRONOUSLY, so a snapshot the
-  // document already delivered is applied before the first read — the store
-  // reads as READY during hydration's synchronous claim walk, matching the
-  // page's settled markup. The async-iterable branch below (pre-stream
-  // payloads) can only surface its buffer through microtasks, which made a
-  // settled-inline boundary suspend at the walk and hydrate a phantom
-  // fallback over settled markup (the chat welcome/status meter miss).
-  if (src != null && src.__SEROVAL_STREAM__ === true) {
-    const queue: any[] = [];
-    let failed: { error: any } | undefined;
-    let cursor = 0;
-    let first = true;
-    // How far into the queue a compute may apply: everything, except a
-    // claim's replayed backlog beyond the snapshot, parked until hydration
-    // ends (see above).
-    let limit = Infinity;
-    // Everything lives under the detached root (see the block comment
-    // below): materialization runs at arg-read inside a reader's render
-    // scope, and a version signal owned by that reader would be disposed by
-    // its re-render while the memoized store lives on.
-    return detachedRoot(() => {
-      const [version, setVersion] = coreSignal(0);
-      // Subscribe before creating the projection: the buffered replay runs
-      // synchronously inside on(), filling the queue the first compute
-      // drains. Replayed values must NOT bump the version — the replay can
-      // run inside an owned render scope where reactive writes are illegal,
-      // and the projection doesn't exist yet to need waking. Only live
-      // emissions (stream callbacks on later tasks) bump.
-      let live = false;
-      const bump = () => live && setVersion(n => n + 1);
-      src.on({
-        next(value: any) {
-          queue.push(value);
-          bump();
-        },
-        // The trace ended: the last applied state latches (same contract as
-        // the iterable path's `done`).
-        return() {},
-        throw(error: any) {
-          failed = { error };
-          bump();
-        }
-      });
-      live = true;
-      // The park (see above). Decided here, unconditionally: the
-      // projection's first compute runs at creation, so the decision cannot
-      // wait for the first read, and materialization runs at arg-read —
-      // before the frame opens its claim window and, for a claim made after
-      // hydration-done (an occurrence inside a server `<Loading>` whose
-      // fragment reveals after done; a frame adopted late), with no
-      // hydration state that says "claim" at all. Serving the snapshot
-      // first costs a fresh mount one beat (the next microtask, before any
-      // paint) and nothing else. Released at hydration end with a version
-      // bump, so the compute drains the backlog as one ordinary update.
-      if (queue.length > 1) {
-        limit = 1;
-        onHydrationEnd(() => {
-          limit = Infinity;
-          bump();
-        });
-      }
-      return createProjection(
-        (draft: any) => {
-          version();
-          while (cursor < queue.length && cursor < limit) {
-            const value = queue[cursor++];
-            if (first) {
-              first = false;
-              // Full authoritative snapshot into a fresh {}/[] seed — pure
-              // writes, no draft reads (see the iterable branch below).
-              if (Array.isArray(value)) {
-                for (let i = 0; i < value.length; i++) draft[i] = value[i];
-                draft.length = value.length;
-              } else {
-                Object.assign(draft, value);
-              }
-            } else {
-              applyPatches(draft, value);
-            }
-          }
-          // In order: after everything queued before it has applied.
-          if (failed && cursor === queue.length) throw failed.error;
-          // Nothing buffered yet (revival raced ahead of the record's data
-          // script): pending until the snapshot lands, marked on the
-          // projection's own node — the version bump reruns this compute.
-          if (first) throw new NotReadyError(getOwner());
-        },
-        (marker.$ta ? [] : {}) as any
-      );
-    });
-  }
-  // A root, not a bare null owner: the projection's async machinery routes
-  // its pending/error states through the owner's queue, and with no owner
-  // at all the internal NotReadyError (the "pending until snapshot" mark)
-  // surfaces as an unhandled error in dev. The root is never disposed —
-  // the projection settles itself when the trace ends and is collected
-  // with the store.
-  return detachedRoot(() =>
-    createProjection(
-      (draft: any) => ({
-        [Symbol.asyncIterator]() {
-          const srcIt = src[Symbol.asyncIterator]();
-          let first = true;
-          return {
-            next: () =>
-              Promise.resolve(srcIt.next()).then((res: any) => {
-                if (res.done) return { done: true as const, value: undefined };
-                if (first) {
-                  first = false;
-                  // The first yield is the full authoritative snapshot. The
-                  // seed is a fresh empty {}/[] minted here, so this is pure
-                  // writes — no reads of the draft, which is still PENDING
-                  // (reading a pending proxy throws NotReadyError, which
-                  // would reject this step and error the projection).
-                  if (Array.isArray(res.value)) {
-                    for (let i = 0; i < res.value.length; i++) draft[i] = res.value[i];
-                    draft.length = res.value.length;
-                  } else {
-                    Object.assign(draft, res.value);
-                  }
-                } else {
-                  applyPatches(draft, res.value);
-                }
-                return { done: false as const, value: undefined };
-              }),
-            return: (value?: any) => forwardIteratorReturn(srcIt, value)
-          };
-        }
-      }),
-      (marker.$ta ? [] : {}) as any
-    )
-  );
-}
-
-/**
- * A root with NO parent, for the container-trace materializer. It runs at
- * arg-read, under whatever owner is reading — during hydration an
- * id-carrying one — and a root created there inherits the next child id,
- * shifting every key the reader mints after it: a trace revived at t=0
- * consumed one root id while one revived by a late claim (no ambient owner)
- * consumed none, and a keyed sibling after the frame hydrated under
- * different keys in the two runs. The store is shared and memoized per
- * trace; it belongs to no reader's id space.
- */
-function detachedRoot<T>(init: () => T): T {
-  return runWithOwner(null, () => coreRoot(init))!;
-}
-
 // --- Hydration-aware implementations ---
 
 // The shared pre-hydration gate lifecycle for the ssrSource branches
@@ -2319,6 +2143,34 @@ export const createProjection: <T extends object = {}>(
 
 type NoFn<T> = T extends Function ? never : T;
 
+/**
+ * The hydration dispatch the store-family wrappers above share
+ * (`createProjection`, `createStore`, `createOptimisticStore`), for a caller
+ * that brings its own core primitive: under hydration the generic store
+ * adapter runs with `coreFn`, otherwise `coreFn` runs directly. Exists so a
+ * store-family node can be built from a module that must NOT reference the
+ * wrappers — `solid-js/internal/container-trace` reaches `createProjection`
+ * through `@solidjs/signals` so the store engine stays in its lazy chunk
+ * (every wrapper here is welded to the engine by its core import, and this
+ * dist is one flat module) while behaving under hydration exactly as the
+ * wrapper does. `coreFn` is the caller's, so referencing this retains the
+ * adapter, never the engine (the same retention story as the slot itself).
+ *
+ * @internal
+ */
+export function withStoreHydration<T>(
+  coreFn: (fn: any, seed: any, options?: any) => T,
+  fn: any,
+  seed: any,
+  options?: any
+): T {
+  // `hydrating` can only be true once enableHydration() installed the
+  // adapter slot (see createOptimistic above for the retention story).
+  return sharedConfig.hydrating
+    ? _hydrateStoreLike!(coreFn, fn, seed, options)
+    : coreFn(fn, seed, options);
+}
+
 /**
  * Creates a deeply-reactive store backed by a Proxy. Reads track each
  * property accessed; only the parts that change trigger updates.
diff --git a/packages/solid/src/index.ts b/packages/solid/src/index.ts
index 279fff7c4..c3a7e63d3 100644
--- a/packages/solid/src/index.ts
+++ b/packages/solid/src/index.ts
@@ -115,7 +115,13 @@ export {
 // (src/internal.ts): exported here at runtime so that entry shares this
 // module's state, `@internal` so they are stripped from the declarations.
 /** @internal */
-export { materializeContainerTrace, sharedConfig } from "./client/hydration.js";
+export { sharedConfig } from "./client/hydration.js";
+// The container-trace materializer's seams (`solid-js/internal/container-trace`,
+// a separate dist entry so the store engine it builds on stays in a lazy
+// chunk): the store wrappers' hydration dispatch and the projection patch
+// protocol. Runtime exports so that entry shares this module's state.
+/** @internal */
+export { withStoreHydration, applyPatches, forwardIteratorReturn } from "./client/hydration.js";
 /** @internal */
 export { $DEVCOMP } from "./client/core.js";
 // The boundary primitives behind `Errored`, `Loading` and `Reveal`: exported
diff --git a/packages/solid/src/internal.ts b/packages/solid/src/internal.ts
index 2e8a49c7c..761e98c01 100644
--- a/packages/solid/src/internal.ts
+++ b/packages/solid/src/internal.ts
@@ -26,6 +26,11 @@
  *    read back the same way (real on both entries), for renderers that
  *    build boundaries without the components, and so are `sharedConfig`
  *    (the hydration/SSR coordination object) and the `$DEVCOMP` brand.
+ *
+ * Not here: the container-trace materializer. It lives in its own entry,
+ * `solid-js/internal/container-trace`, so the store engine it builds on can
+ * be a lazy chunk — a re-export from this (eagerly imported) module would
+ * weld the engine back into the main chunk.
  */
 import * as core from "solid-js";
 import type { Accessor, RevealOrder, ServerErrorHook, ServerErrorSite } from "solid-js";
@@ -122,12 +127,6 @@ export const getProjectionTrace: (
 export const shareAsyncIterable: <T>(source: AsyncIterable<T>) => AsyncIterable<T> =
   core.shareAsyncIterable;
 
-/** Client: rebuild a store from a serialized container-trace marker. Server: stub. */
-export const materializeContainerTrace: (marker: {
-  $tr: AsyncIterable<any> | { __SEROVAL_STREAM__: true };
-  $ta?: number;
-}) => unknown = core.materializeContainerTrace as any;
-
 /** The primitive behind `<Errored>`: `fn()`, or `fallback(error, reset)` once something under it throws. */
 export const createErrorBoundary: <T, U>(
   fn: () => T,
diff --git a/packages/solid/src/server/index.ts b/packages/solid/src/server/index.ts
index 285e68c92..568291479 100644
--- a/packages/solid/src/server/index.ts
+++ b/packages/solid/src/server/index.ts
@@ -162,12 +162,24 @@ export { ssrHandleError, ssrScope } from "./hydration.js";
 // is unchanged.
 import { installServerWithOrigin } from "./shared.js";
 
-/**
- * @internal — client-only (see client/hydration.ts). The server stub is
- * inert: nothing delivers a trace TO a server, so a marker passes through.
- */
-export function materializeContainerTrace(marker: unknown): unknown {
-  return marker;
+// The container-trace materializer's seams (client/hydration.ts; consumed by
+// `solid-js/internal/container-trace`, a client-only entry). Mirrored here
+// for export parity, inert: nothing delivers a trace TO a server, so the
+// dispatch is the core primitive and nothing applies a patch batch.
+/** @internal */
+export function withStoreHydration<T>(
+  coreFn: (fn: any, seed: any, options?: any) => T,
+  fn: any,
+  seed: any,
+  options?: any
+): T {
+  return coreFn(fn, seed, options);
+}
+/** @internal */
+export function applyPatches(_target: any, _patches: any[]): void {}
+/** @internal */
+export function forwardIteratorReturn(it: any, value?: any): any {
+  return Promise.resolve(it.return ? it.return(value) : { done: true, value });
 }
 
 // Observe / dev — same shape as the client entry. Both literals are replaced
diff --git a/packages/solid/test/container-trace.spec.ts b/packages/solid/test/container-trace.spec.ts
index 9f50d61aa..9d9a3fa39 100644
--- a/packages/solid/test/container-trace.spec.ts
+++ b/packages/solid/test/container-trace.spec.ts
@@ -8,7 +8,8 @@
 import { afterEach, describe, expect, test } from "vitest";
 import { createOwner } from "@solidjs/signals";
 import { createRoot, createRenderEffect, flush } from "../src/index.js";
-import { enableHydration, materializeContainerTrace, sharedConfig } from "../src/index.js";
+import { enableHydration, sharedConfig } from "../src/index.js";
+import { materializeContainerTrace } from "../src/client/container-trace.js";
 
 /**
  * A hand-cranked RAW seroval stream (the wire shape since the stream-mint
@@ -215,11 +216,14 @@ describe("materializeContainerTrace — id neutrality", () => {
   });
 });
 
-// The park (frames-rulings 3.6 (iii), "the consumer parks"): a replayed
+// The park (frames-rulings 3.6 (iii), "the consumer parks"): materialized for
+// a CLAIM (`claiming`, the frames client's adopt-time mount), a replayed
 // backlog beyond the snapshot applies after hydration ends — the first reads
 // see the snapshot, what the server's markup was rendered from — so a claim
 // pass over that markup reads the state it shows, and the backlog lands
-// after the claim as the update it is.
+// after the claim as the update it is. Keyed on the claim since the traces
+// tier (plan step C3): a fresh mount — nothing on screen to agree with —
+// reads the fold of its whole backlog at once and pays no beat.
 describe("materializeContainerTrace — the parked backlog", () => {
   afterEach(() => {
     sharedConfig.hydrating = false;
@@ -237,11 +241,11 @@ describe("materializeContainerTrace — the parked backlog", () => {
     return stream;
   };
 
-  test("during hydration the snapshot serves; the backlog lands at hydration end, as one update", () => {
+  test("materialized for a claim during hydration: the snapshot serves; the backlog lands at hydration end, as one update", () => {
     enableHydration();
     (globalThis as any)._$HY = { events: [], completed: new WeakSet(), r: {} };
     sharedConfig.hydrating = true;
-    const store: any = materializeContainerTrace({ $tr: ahead(), $ta: 0 } as any);
+    const store: any = materializeContainerTrace({ $tr: ahead(), $ta: 0 } as any, true);
     const reads: string[] = [];
     createRoot(() => {
       createRenderEffect(
@@ -259,8 +263,8 @@ describe("materializeContainerTrace — the parked backlog", () => {
     expect(reads).toEqual(["Ada/0", "Ada (edited)/2"]);
   });
 
-  test("with no hydration in progress the backlog lands on the next microtask", async () => {
-    const store: any = materializeContainerTrace({ $tr: ahead(), $ta: 0 } as any);
+  test("a claim with no hydration in progress (a frame's late claim): the snapshot serves; the backlog lands on the next microtask", async () => {
+    const store: any = materializeContainerTrace({ $tr: ahead(), $ta: 0 } as any, true);
     expect(store.name).toBe("Ada");
     expect(store.edits).toBe(0);
     await Promise.resolve();
@@ -269,6 +273,21 @@ describe("materializeContainerTrace — the parked backlog", () => {
     expect(store.edits).toBe(2);
   });
 
+  test("a fresh mount parks nothing: the first read is the fold of the whole backlog", () => {
+    const store: any = materializeContainerTrace({ $tr: ahead(), $ta: 0 } as any);
+    expect(store.name).toBe("Ada (edited)");
+    expect(store.edits).toBe(2);
+  });
+
+  test("a fresh mount during hydration parks nothing either (the park is the claim's, not the pass's)", () => {
+    enableHydration();
+    (globalThis as any)._$HY = { events: [], completed: new WeakSet(), r: {} };
+    sharedConfig.hydrating = true;
+    const store: any = materializeContainerTrace({ $tr: ahead(), $ta: 0 } as any);
+    expect(store.name).toBe("Ada (edited)");
+    expect(store.edits).toBe(2);
+  });
+
   test("a snapshot alone is not a backlog: live emissions apply as they land", () => {
     const stream = makeStream();
     stream.next({ name: "Ada" });
@@ -282,7 +301,7 @@ describe("materializeContainerTrace — the parked backlog", () => {
   test("a failure in the backlog applies in order, after the parked patches", async () => {
     const stream = ahead();
     stream.throw(new Error("boom"));
-    const store: any = materializeContainerTrace({ $tr: stream, $ta: 0 } as any);
+    const store: any = materializeContainerTrace({ $tr: stream, $ta: 0 } as any, true);
     // Parked: the snapshot reads, the failure has not surfaced.
     expect(store.name).toBe("Ada");
     await Promise.resolve();
diff --git a/packages/solid/test/internal-surface.spec.ts b/packages/solid/test/internal-surface.spec.ts
index b64530640..224f5a668 100644
--- a/packages/solid/test/internal-surface.spec.ts
+++ b/packages/solid/test/internal-surface.spec.ts
@@ -36,7 +36,6 @@ const INTERNAL = [
   "inServerComponentScope",
   "creationStamp",
   "getProjectionTrace",
-  "materializeContainerTrace",
   // boundary primitives behind Errored/Loading/Reveal (#3709)
   "createErrorBoundary",
   "createLoadingBoundary",
@@ -46,6 +45,12 @@ const INTERNAL = [
   "$DEVCOMP"
 ];
 
+// The container-trace materializer's seams: exported from the client entry at
+// runtime (so `solid-js/internal/container-trace` shares this module's
+// state), `@internal`, and declared NOWHERE public — that entry types them
+// itself. Checked against the main declarations only.
+const CONTAINER_TRACE_SEAMS = ["withStoreHydration", "applyPatches", "forwardIteratorReturn"];
+
 const typesDir = resolve(import.meta.dirname, "../types");
 const read = (file: string) => readFileSync(resolve(typesDir, file), "utf8");
 // `\b` cannot bound a name that starts with `$`; bound on identifier characters.
@@ -57,7 +62,9 @@ test.each([
   ["server", "server/index.d.ts"]
 ])("no internal name reaches the %s entry's declarations", (_tier, file) => {
   const declarations = read(file);
-  const leaked = INTERNAL.filter(name => mentions(declarations, name));
+  const leaked = [...INTERNAL, ...CONTAINER_TRACE_SEAMS, "materializeContainerTrace"].filter(name =>
+    mentions(declarations, name)
+  );
   expect(leaked).toEqual([]);
 });
 
@@ -66,3 +73,12 @@ test("solid-js/internal's declarations carry the protocol and the seams", () =>
   const missing = INTERNAL.filter(name => !mentions(declarations, name));
   expect(missing).toEqual([]);
 });
+
+// The materializer is its own entry (the store engine it builds on must be
+// assignable to a lazy chunk, which a re-export from the flat main module or
+// from `solid-js/internal` would prevent); the subpath declares it, and
+// neither eager entry does.
+test("solid-js/internal/container-trace declares the materializer; solid-js/internal does not", () => {
+  expect(mentions(read("client/container-trace.d.ts"), "materializeContainerTrace")).toBe(true);
+  expect(mentions(read("internal.d.ts"), "materializeContainerTrace")).toBe(false);
+});
diff --git a/packages/web/frames/src/assets-tier.ts b/packages/web/frames/src/assets-tier.ts
new file mode 100644
index 000000000..266eab54d
--- /dev/null
+++ b/packages/web/frames/src/assets-tier.ts
@@ -0,0 +1,212 @@
+/**
+ * `@solidjs/web/frames/assets` — the frames client's ASSETS tier (frames
+ * savings pass §3 row C5): what a segment's `seg:<k>:assets` record does to
+ * the document head, loaded on demand through the tier mechanism
+ * (`prepareTier("assets")`, frame-client.ts).
+ *
+ * What rides in this chunk, and so leaves the eager frames client: the
+ * import-free mirror of the client asset registry's head conventions
+ * (`ensureStylesheet` / `ensurePreload` / `ensureModulePreload` /
+ * `applyInlineStyles`, `findHeadElement`'s attribute-compared lookup and
+ * head.ts's `qualifierValue`), the per-frame flush a pending stylesheet
+ * wakes, and the assets pass over a record (modules, typed preloads, inline
+ * styles). The eager client keeps the record itself (`chunkToRecords`'
+ * `assets` case, the host's `seg::assets` accumulate), the pass's walk over
+ * the store, and the reveal's READINESS TERM: a segment whose assets record
+ * carries stylesheets or inline styles while this tier is not resident is
+ * not ready — the server's `<Loading>` fallback stays on screen; the reveal
+ * happens at max(tier load, stylesheet load) (frames savings pass §1,
+ * "assets": no FOUC, no blank). Once the tier is resident only stylesheets
+ * gate: inline styles apply at the record's arrival (the walk runs ahead of
+ * the segments in the same flush), modules and preloads likewise, and a
+ * segment with none of these never waits on the tier.
+ *
+ * The module's exports ARE its dispatch: `prepareTier` stamps the load with
+ * the module once it has resolved (`tierLoads.assets.r`), and the eager
+ * client calls `gate` from `#segmentReady` and `apply` from `#flush`'s
+ * assets walk off that stamp. No `install()`: the tier registers nothing
+ * and imports nothing of the client — it needs no shared instance, only
+ * the frame handed to `gate` (its `apply` is the flush a settled sheet
+ * triggers).
+ *
+ * The server announces this tier wherever it emits an assets chunk
+ * (`sink.needs("assets")` — the shell's pre-flush assets, a style-gated
+ * fragment's, a late module / preload; frame-sink.ts): `X-Frame-Tiers` /
+ * `chunk.tiers` on a stream, `_$HY.r["sc:tiers"]` + a `modulepreload` on a
+ * document — so the load is a warm start; an un-announced record starts it
+ * from the readiness check or the walk and the segment waits (the same DOM,
+ * later).
+ * @experimental
+ */
+import type { Frame } from "./frame-client.js";
+
+/** A stylesheet entry as the sink writes it: a url, or `{ href, attrs }`. */
+export type StylesheetEntry = string | { href: string; attrs?: Record<string, string> };
+/** A typed preload entry (`<link rel="preload">`): request-qualifying attributes, optional href. */
+export interface PreloadEntry {
+  href?: string;
+  attrs: Record<string, string>;
+}
+/** An inline style entry (`<style data-asset>`). */
+export interface InlineStyleEntry {
+  id: string;
+  content?: string;
+  attrs?: Record<string, string>;
+}
+/** The head-affecting members of a `seg:<k>:assets` record. */
+export interface AssetsRecord {
+  modules?: string[];
+  styles?: StylesheetEntry[];
+  inlineStyles?: InlineStyleEntry[];
+  preloads?: PreloadEntry[];
+}
+
+// Minimal, import-free mirror of the client asset registry's conventions
+// (client.js acquireAsset): data-asset ids for inline styles, attribute-
+// compared lookup instead of selector interpolation, adopt elements already
+// in the document. The Solid binding can swap in the ref-counted registry
+// later; the gate only needs "are this segment's stylesheets loaded, and
+// call me back when they settle".
+
+// Mirrors head.ts without importing it into the standalone frame client.
+const PRELOAD_QUALIFIERS = ["as", "crossorigin", "type", "media", "imagesrcset", "imagesizes"];
+
+// Mirrors head.ts's qualifierValue — keep them in step. `as` folds ASCII
+// case; an empty source set or size reads as absent (registration never
+// emits one); `crossorigin` is three states, not a string range, so `""`, a
+// bare attribute and `anonymous` are one request. Frame `attrs` are already
+// canonical strings, but the document may carry any spelling.
+function qualifierValue(name: string, value: string | null) {
+  if (value == null) return null;
+  if (name === "imagesrcset" || name === "imagesizes") return value === "" ? null : value;
+  if (name === "as") return value.replace(/[A-Z]/g, c => String.fromCharCode(c.charCodeAt(0) + 32));
+  if (name !== "crossorigin") return value;
+  return value.length === 15 && value.toLowerCase() === "use-credentials"
+    ? "use-credentials"
+    : "anonymous";
+}
+
+/** Attribute-compared head lookup so href/id values never need escaping. */
+function findHeadElement(
+  selector: string,
+  attr: string,
+  value: string | null,
+  qualifiers?: Record<string, string>
+) {
+  candidate: for (const node of document.head.querySelectorAll(selector)) {
+    if (node.getAttribute(attr) !== value) continue;
+    if (!qualifiers) return node;
+    for (let i = 0; i < PRELOAD_QUALIFIERS.length; i++) {
+      const name = PRELOAD_QUALIFIERS[i];
+      if (
+        qualifierValue(name, node.getAttribute(name)) !==
+        qualifierValue(name, qualifiers[name] ?? null)
+      )
+        continue candidate;
+    }
+    return node;
+  }
+  return null;
+}
+
+/** Ensure one typed preload exists, preserving request-qualifying attributes. */
+function ensurePreload(entry: PreloadEntry) {
+  const attrs = entry.attrs;
+  const href = entry.href;
+  if (findHeadElement('link[rel="preload"]', "href", href || null, attrs)) return;
+  const link = document.createElement("link");
+  link.rel = "preload";
+  for (const name in attrs) link.setAttribute(name, attrs[name]);
+  if (href) link.setAttribute("href", href);
+  document.head.appendChild(link);
+}
+
+/**
+ * Ensure a stylesheet link exists and report whether it has settled. A link
+ * this loader created tracks waiters until load/error (error unblocks too —
+ * same policy as the document runtime's $dfc gate); a link that was
+ * already in the document counts as settled. `entry` is a url string or an
+ * attributed record `{ href, attrs }` (fetch-metadata attributes carried by
+ * useHead stylesheets).
+ */
+function ensureStylesheet(entry: StylesheetEntry, onSettle: () => void) {
+  const href = typeof entry === "string" ? entry : entry.href;
+  let link = findHeadElement('link[rel="stylesheet"]', "href", href) as any;
+  if (!link) {
+    link = document.createElement("link");
+    link.rel = "stylesheet";
+    if (typeof entry !== "string" && entry.attrs) {
+      for (const name in entry.attrs) link.setAttribute(name, entry.attrs[name]);
+    }
+    link.href = href;
+    const waiters = new Set<() => void>();
+    link._$frWaiters = waiters;
+    const settle = () => {
+      link._$frWaiters = null;
+      for (const fn of waiters) fn();
+    };
+    link.addEventListener("load", settle);
+    link.addEventListener("error", settle);
+    document.head.appendChild(link);
+  }
+  const waiters = link._$frWaiters;
+  if (waiters == null) return true; // settled, or document-owned
+  waiters.add(onSettle);
+  return false;
+}
+
+/** Ensure a modulepreload link exists for `href` (deduped, adopt existing). */
+function ensureModulePreload(href: string) {
+  if (findHeadElement('link[rel="modulepreload"]', "href", href)) return;
+  const link = document.createElement("link");
+  link.rel = "modulepreload";
+  link.href = href;
+  document.head.appendChild(link);
+}
+
+/** Insert inline-style entries into the head, deduped by data-asset id. */
+function applyInlineStyles(inlineStyles: InlineStyleEntry[]) {
+  for (const entry of inlineStyles) {
+    if (findHeadElement("style[data-asset]", "data-asset", entry.id)) continue;
+    const el = document.createElement("style");
+    el.setAttribute("data-asset", entry.id);
+    if (entry.attrs) {
+      for (const name in entry.attrs) el.setAttribute(name, entry.attrs[name]);
+    }
+    el.textContent = entry.content || "";
+    document.head.appendChild(el);
+  }
+}
+
+// The flush a settled stylesheet wakes, one per frame: a pending link holds
+// at most one waiter per frame across repeated readiness checks (the
+// waiters are a Set — identity dedupes). An empty write at the frame's own
+// version is the re-flush (`prepareTier`'s install does the same); a
+// disposed frame's `apply` is a no-op.
+const flushers = new WeakMap<Frame, () => void>();
+
+/**
+ * The stylesheet gate for one segment (`#segmentReady`'s style term, once
+ * the tier is resident): ensure every named sheet is in the head — pending
+ * links are inserted now, even while another prerequisite is missing, so
+ * the load overlaps the rest of the stream — and report whether all have
+ * settled. `frame` is re-flushed when a pending one settles.
+ */
+export function gate(entries: StylesheetEntry[], frame: Frame): boolean {
+  let flush = flushers.get(frame);
+  if (!flush) flushers.set(frame, (flush = () => frame.apply({ version: frame.version!, r: {} })));
+  let ready = true;
+  for (const entry of entries) ready = ensureStylesheet(entry, flush) && ready;
+  return ready;
+}
+
+/**
+ * The assets pass for one record (`#flush`'s walk, once per record identity
+ * per mount): module preloads, typed preloads, inline styles. Stylesheets
+ * are the gate's (`gate`) — never applied here.
+ */
+export function apply(record: AssetsRecord): void {
+  if (record.modules) for (const href of record.modules) ensureModulePreload(href);
+  if (record.preloads) for (const entry of record.preloads) ensurePreload(entry);
+  if (record.inlineStyles) applyInlineStyles(record.inlineStyles);
+}
diff --git a/packages/web/frames/src/bind-tier.ts b/packages/web/frames/src/bind-tier.ts
new file mode 100644
index 000000000..e848f2fe3
--- /dev/null
+++ b/packages/web/frames/src/bind-tier.ts
@@ -0,0 +1,549 @@
+/**
+ * `@solidjs/web/frames/bind` — the frames client's BIND tier (frames
+ * savings pass §3 row C6): binding-slot positions (server-components-
+ * principles §9.2.3), loaded on demand through the tier mechanism
+ * (`prepareTier("bind")`, frame-client.ts).
+ *
+ * A binding slot is a slot call READ AS DATA — `const row = props.row(args)`
+ * — whose properties the server component binds at positions of its own
+ * markup: an attribute, a class name or style property, a handler, a ref,
+ * a text child. Each consuming element carries one marker per position
+ * (`_s:<attribute>="<occurrence>:<key>[=<name>]"`, `_s:on:<event>`,
+ * `_s:ref`; a text position is a comment pair `<!--_s:t=occ:key-->…
+ * <!--/_s:t-->`), the occurrence is the CALL (one data context, any number
+ * of consumers), and the client runs the fill once per occurrence and
+ * writes each position from the object it returns.
+ *
+ * What rides in this chunk, and so leaves the eager frames client: the
+ * marker grammar's readers — the entry parser, the consumer discovery the
+ * slot sync's walk dispatches to (`positions` for an element's markers,
+ * `text` for a text position's start) — the morph's OWNED-POSITION arms
+ * (`owned` / `apply`: a position the client writes is left alone by the
+ * morph, owned class names and style properties re-imposed over the
+ * server's string), the per-frame consumer set and rebinder (`sync` /
+ * `rebinder` / `unmount`: the sync hands the set it found at the mount and
+ * on every re-sync; the tier compares and calls the mount's rebinder on a
+ * change), and the binding itself (`bind`: the fill, the render effect
+ * over every consumer, `assign`'s per-position diff — `@solidjs/web`'s
+ * `assign` is this chunk's import, not the eager client's). The eager
+ * client keeps the marker constants, one test (whether a node carries a
+ * marker at all) and the morph's text-pair arm (a position's text survives
+ * a morph by not being reconciled): its walk NOTES a marker met while this
+ * tier is absent and the frame HOLDS on the note (frames-rulings 3.1 on
+ * the adopt path — the server interior stays on screen, positions at the
+ * server's values), the load started by the readiness check; the
+ * install's flush re-walks with the tier in place and the occurrences
+ * mount.
+ *
+ * The delegated-event REPLAY WINDOW (option (a) of the C6 ruling): a
+ * consumer with a handler position (`_s:on:*`) is stamped `_hk` by the
+ * server (ssrClaim, document face), so the hydration bootstrap files its
+ * events behind the element's own completion instead of the nearest page
+ * element's — which the page root's pass completes long before any frame
+ * tier lands. The bind completes the element and calls
+ * `runHydrationEvents`: a click before `hydrate()`, or during the hold,
+ * replays into the handler the bind just attached. The frame's hold alone
+ * does NOT bound that window (it bounds hydration-done); the stamp does.
+ *
+ * The module's exports ARE its dispatch: `prepareTier` stamps the load
+ * with the module (`tierLoads.bind.r`) and the eager client calls the
+ * appliers off the stamp. No `install()`: the tier registers nothing — its
+ * per-frame state is keyed by the frame handed in. It imports the eager
+ * client ENTRY for `isAsyncValue` (the shared instance, external in the
+ * dist build — rollup.config.js's externalizeFramesClient resolves
+ * `./client.js` to `@solidjs/web/frames`), as the traces and regions tiers
+ * do for theirs; the import is also what keeps an app's bundler attaching
+ * this chunk to the entry's graph: a lazy chunk that reaches `solid-js`
+ * and `@solidjs/web` WITHOUT importing the chunk that loads it is split
+ * from them (Rolldown 1.2 moves the shared runtime into a third chunk on
+ * the live page — measured, C6), one that imports it shares them in
+ * place. frame-client.js's constants and dev shape finders (`SLOT_MARKER`,
+ * `SLOT_TEXT`, `shapeOf`, `slotShapeFinding`) bundle here as their own copy
+ * — importless, no instance to agree with.
+ *
+ * The server announces this tier wherever a slot is read as data (the slot
+ * proxy's `needs("bind")`, frame-sink.ts): `X-Frame-Tiers` / `chunk.tiers`
+ * on a stream, `_$HY.r["sc:tiers"]` + a `modulepreload` on a document — so
+ * the load is a warm start; an un-announced marker starts it from the walk
+ * and the frame waits (the same DOM, later).
+ * @experimental
+ */
+import { createRenderEffect, createSignal, onCleanup, untrack } from "solid-js";
+// `assign` MUST be the shared @solidjs/web instance (external in
+// rollup.config.js): it binds delegated handlers into the app's own event
+// tables.
+import { assign, runHydrationEvents } from "@solidjs/web";
+import { sharedConfig } from "solid-js/internal";
+// The eager frames client — the SHARED instance the app runs (see above).
+import { isAsyncValue } from "./client.js";
+// Own copies: the marker constants and the dev-only shape finders.
+import { SLOT_MARKER, SLOT_TEXT, shapeOf, slotShapeFinding } from "./frame-client.js";
+
+// Build-time literal (see diagnostics.ts): dev-only guidance folds out of
+// the prod chunk (`bind.js`); the dev chunk (`bind.dev.js`, the
+// `development` export condition) keeps it.
+const IS_DEV = "_SOLID_DEV_" as unknown as boolean;
+
+// === The marker grammar's readers ===
+
+/**
+ * One marker entry, `<occurrence>:<key>[=<name>]`, as `[occurrence,
+ * { pos, key, name }]`, or null. Keys and names are percent-encoded on the
+ * wire (they are client-controlled strings landing in a `,`/`:`/`=`-delimited
+ * grammar) and decoded here.
+ */
+function slotEntry(entry: string, pos: string): [string, any] | null {
+  const colon = entry.indexOf(":");
+  if (colon < 1) return null;
+  const eq = entry.indexOf("=", colon);
+  return [
+    entry.slice(0, colon),
+    {
+      pos,
+      key: decodeURIComponent(eq === -1 ? entry.slice(colon + 1) : entry.slice(colon + 1, eq)),
+      name: eq === -1 ? undefined : decodeURIComponent(entry.slice(eq + 1))
+    }
+  ];
+}
+
+/** An occurrence's consumer list, created on first use; null when a slot
+ *  range claimed the id (the dev range check reports it). */
+function consumersOf(elements: Map<string, any>, occurrence: string): any[] | null {
+  let consumers = elements.get(occurrence);
+  if (consumers === undefined) elements.set(occurrence, (consumers = []));
+  return Array.isArray(consumers) ? consumers : null;
+}
+
+/**
+ * Register a text start marker's position on its parent element's consumer
+ * entry for the occurrence — the one its attribute markers opened, if any,
+ * so an element is one consumer however its positions are spelled. The slot
+ * sync's walk dispatches here (frame-client.ts `collectSlots`).
+ */
+export function text(start: Comment, elements: Map<string, any>): void {
+  const parsed = slotEntry(start.data.slice(SLOT_TEXT.length), "text");
+  const consumers = parsed && consumersOf(elements, parsed[0]);
+  if (!consumers) return;
+  const element = start.parentNode;
+  let consumer;
+  for (let i = consumers.length; i-- && !consumer; )
+    if (consumers[i].element === element) consumer = consumers[i];
+  consumer || consumers.push((consumer = { element, positions: [] }));
+  parsed![1].start = start;
+  consumer.positions.push(parsed![1]);
+}
+
+/**
+ * Parse one element's `_s:*` markers into positions grouped by occurrence:
+ * `{ [occurrence]: [{ pos, key, name }] }`, or null. `pos` is the marker's
+ * position as written (`class`, `hidden`, `on:click`, `ref`), `name` the
+ * class name / style property for a member position.
+ */
+function slotPositions(el: Element): Record<string, any[]> | null {
+  const attrs = el.attributes;
+  let out: Record<string, any[]> | null = null;
+  for (let i = 0; i < attrs.length; i++) {
+    const attr = attrs[i];
+    if (!attr.name.startsWith(SLOT_MARKER)) continue;
+    const pos = attr.name.slice(SLOT_MARKER.length);
+    for (const entry of attr.value.split(",")) {
+      const parsed = slotEntry(entry, pos);
+      if (!parsed) continue;
+      out || (out = Object.create(null));
+      (out![parsed[0]] || (out![parsed[0]] = [])).push(parsed[1]);
+    }
+  }
+  return out;
+}
+
+/**
+ * An element's positions join each occurrence's consumer list, in document
+ * order. The slot sync's walk dispatches here for every server element with
+ * attributes (frame-client.ts `collectSlots`).
+ */
+export function positions(el: Element, elements: Map<string, any>): void {
+  const byOccurrence = slotPositions(el);
+  if (byOccurrence !== null) {
+    for (const occurrence in byOccurrence) {
+      const consumers = consumersOf(elements, occurrence);
+      if (consumers) consumers.push({ element: el, positions: byOccurrence[occurrence] });
+    }
+  }
+}
+
+/** Whether a data occurrence's consumer set changed (elements or positions). */
+function consumersEqual(a: any[], b: any[]): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x.element !== y.element || x.positions.length !== y.positions.length) return false;
+    for (let j = 0; j < x.positions.length; j++) {
+      const p = x.positions[j];
+      const q = y.positions[j];
+      if (p.pos !== q.pos || p.key !== q.key || p.name !== q.name || p.start !== q.start)
+        return false;
+    }
+  }
+  return true;
+}
+
+// === The per-frame consumer set ===
+
+/** One data occurrence's state on a frame: the consumer set last handed
+ *  to the mount, and the mount's rebind callback (`ctx.onRebind`). */
+interface Occurrence {
+  consumers: any[] | undefined;
+  rebind: ((consumers: any[]) => void) | undefined;
+}
+// Per frame: occurrence -> state. Weak, so a frame that goes takes its
+// occurrences with it; `unmount` drops an occurrence the stream dropped.
+const byFrame = new WeakMap<object, Map<string, Occurrence>>();
+function occurrencesOf(frame: object): Map<string, Occurrence> {
+  let slots = byFrame.get(frame);
+  if (!slots) byFrame.set(frame, (slots = new Map()));
+  return slots;
+}
+
+/**
+ * The consumer set the slot sync found for a MOUNTED data occurrence — at
+ * the mount (the set the fill was handed) and on every re-sync. A changed
+ * set (a morph replaced one of its elements, a response added or dropped a
+ * bound position) rebinds in place through the mount's rebinder: the fill's
+ * computation stays, the binding gets the new set.
+ */
+export function sync(frame: object, occurrence: string, consumers: any[]): void {
+  const slots = occurrencesOf(frame);
+  const entry = slots.get(occurrence);
+  // The mount: the invocation registered its rebinder first (`rebinder`),
+  // and the set it was handed is recorded without a rebind — the fill's
+  // signal already holds it.
+  if (!entry) slots.set(occurrence, { consumers, rebind: undefined });
+  else if (!entry.consumers) entry.consumers = consumers;
+  else if (!consumersEqual(entry.consumers, consumers)) {
+    entry.consumers = consumers;
+    entry.rebind && entry.rebind(consumers);
+  }
+}
+
+/** The mount's rebind callback (`ctx.onRebind`), registered during the
+ *  invocation — before `sync` records the mount's set. */
+export function rebinder(frame: object, occurrence: string, fn: (consumers: any[]) => void): void {
+  const slots = occurrencesOf(frame);
+  const entry = slots.get(occurrence);
+  if (entry) entry.rebind = fn;
+  else slots.set(occurrence, { consumers: undefined, rebind: fn });
+}
+
+/** The occurrence is gone (unmounted, or re-invoked: the new invocation
+ *  registers its own rebinder). */
+export function unmount(frame: object, occurrence: string): void {
+  byFrame.get(frame)?.delete(occurrence);
+}
+
+// === The morph's owned-position arms ===
+
+/** The positions of an incoming element a client fill writes (see
+ *  `owned`). */
+interface Owned {
+  attrs: Set<string>;
+  class: string[] | null;
+  style: string[] | null;
+}
+
+// Binding-slot ownership (principles §9.2.3). The INCOMING element's `_s:*`
+// markers say which of its positions a client fill writes: `_s:hidden` owns
+// the `hidden` attribute; `_s:class="occ:k=done"` owns the class name
+// `done` and `_s:class="occ:k"` the whole `class` string (likewise `style`
+// and its properties); `_s:on:*` / `_s:ref` are not attributes and need no
+// guard. A position the client owns is left alone by the morph: not
+// removed, not set. `class`/`style` are shared attributes — the server's
+// classes and the fill's toggled names live in one string — so when a fill
+// owns NAMES within them the morph applies the server's value and re-imposes
+// the owned names' live state on top. The markers themselves are ordinary
+// attributes and morph like any other, which is what lets the slot sync
+// see a consumer change.
+export function owned(el: Element): Owned | null {
+  const attrs = el.attributes;
+  let out: Owned | null = null;
+  for (let i = 0; i < attrs.length; i++) {
+    const name = attrs[i].name;
+    if (!name.startsWith(SLOT_MARKER)) continue;
+    const pos = name.slice(SLOT_MARKER.length);
+    if (pos === "ref" || pos.startsWith("on:")) continue;
+    out || (out = { attrs: new Set(), class: null, style: null });
+    if (pos !== "class" && pos !== "style") {
+      out.attrs.add(pos);
+      continue;
+    }
+    for (const entry of attrs[i].value.split(",")) {
+      const eq = entry.indexOf("=");
+      if (eq === -1) {
+        out.attrs.add(pos); // a whole-value read owns the attribute
+        continue;
+      }
+      (out[pos] || (out[pos] = [])).push(decodeURIComponent(entry.slice(eq + 1)));
+    }
+  }
+  return out;
+}
+
+/** Set `class` to the server's value with the fill-owned class names' live
+ *  state preserved. Returns whether the attribute changed. */
+function morphOwnedClass(oldEl: Element, value: string, names: string[]): boolean {
+  const list = oldEl.classList;
+  const set = new Set(value ? value.split(/\s+/) : []);
+  set.delete("");
+  for (const name of names) list.contains(name) ? set.add(name) : set.delete(name);
+  const next = [...set].join(" ");
+  if (next === (oldEl.getAttribute("class") || "")) return false;
+  next ? oldEl.setAttribute("class", next) : oldEl.removeAttribute("class");
+  return true;
+}
+
+/** Set `style` to the server's value with the fill-owned properties' live
+ *  values preserved. Returns whether the attribute changed. */
+function morphOwnedStyle(oldEl: HTMLElement, value: string, names: string[]): boolean {
+  const style = oldEl.style;
+  const saved = names.map(name => [
+    name,
+    style.getPropertyValue(name),
+    style.getPropertyPriority(name)
+  ]);
+  const before = oldEl.getAttribute("style");
+  value ? oldEl.setAttribute("style", value) : oldEl.removeAttribute("style");
+  for (const [name, v, priority] of saved) {
+    v ? style.setProperty(name, v, priority) : style.removeProperty(name);
+  }
+  return oldEl.getAttribute("style") !== before;
+}
+
+/**
+ * Apply the server's value for `name` (null: absent) to an element with
+ * binding-slot positions: a client-owned attribute is left alone; owned
+ * `class`/`style` NAMES are re-imposed over the server's string. Returns
+ * whether the attribute changed, or undefined when the position is not
+ * owned and the caller writes it. (The eager wrapper answers `undefined`
+ * itself for a null `owned`; the arms call here with one.)
+ */
+export function apply(
+  oldEl: Element,
+  name: string,
+  value: string,
+  owned: Owned
+): boolean | undefined {
+  if (owned.attrs.has(name)) return false;
+  if ((name === "class" || name === "style") && owned[name] !== null) {
+    return name === "class"
+      ? morphOwnedClass(oldEl, value, owned.class!)
+      : morphOwnedStyle(oldEl as HTMLElement, value, owned.style!);
+  }
+  return undefined;
+}
+
+// === The binding ===
+
+interface ElementState {
+  /** `assign`'s diff state: the props last written to the element. */
+  prev: Record<string, any>;
+  /** Bound handler props (`onclick`): the key and the value read at bind. */
+  handlers: Record<string, { key: string; value: any }>;
+  /** The ref dispatcher for the element's current ref keys, and those keys. */
+  ref: ((el: Element) => void) | undefined;
+  refId: string;
+}
+
+/**
+ * The occurrence holding each handler prop of an element. A rebind can hand
+ * an element from one occurrence to another (a positional id now names
+ * another row's data), and a delegated handler is one slot on the element:
+ * the outgoing occurrence's release must not clear what the incoming one set.
+ */
+const handlerOwners = new WeakMap<Element, Record<string, object>>();
+
+/**
+ * Bind a binding-slot occurrence (principles §9.2.3). The fill runs ONCE,
+ * untracked, under the occurrence's owner — a component body: a top-level
+ * read is a one-time read (dev names it through `untrack`'s label), and state
+ * created in the body lives as long as the occurrence. Its object's value
+ * positions are written by one render effect over every consuming element,
+ * diffed per position by `assign`, so a getter's change re-reads the
+ * occurrence and touches only what moved. Handlers and refs are read once
+ * when an element binds and handed to `assign`, which binds them as client
+ * JSX does (delegation, tuples). A consumer change (`ctx.onRebind`: the morph
+ * replaced an element, a response bound a new position) rebinds without
+ * re-running the fill. The client entry's `slotsFor` dispatches here under
+ * the occurrence's owner (client.ts).
+ */
+export function bind(
+  fill: (args: any) => any,
+  args: any,
+  ctx: any,
+  label: string | undefined
+): void {
+  const [consumers, setConsumers] = createSignal<any[]>(ctx.positions);
+  ctx.onRebind(setConsumers);
+  const raw = untrack(() => fill(args), label);
+  // Content where data was expected: a DOM node is an object, so it is
+  // named here rather than read as one (its properties are the DOM's); an
+  // async value has no properties to bind until it settles.
+  const node = typeof Node === "function" && raw instanceof Node;
+  const pending = isAsyncValue(raw);
+  if (IS_DEV && (raw == null || typeof raw !== "object" || Array.isArray(raw) || node || pending)) {
+    const shape = shapeOf(raw);
+    slotShapeFinding(
+      { reason: "fill-shape", occurrence: ctx.key, shape },
+      `[BINDING_SLOT_POSITION] The fill for \`${ctx.key}\` returned ${shape}; server markup reads ` +
+        `its properties at bound positions, so it must return an object (\`{ done, onToggle, … }\`). ` +
+        `Nothing binds.`
+    );
+  }
+  const out = raw == null || typeof raw !== "object" || node || pending ? {} : raw;
+  const token = {};
+  const state = new WeakMap<Element, ElementState>();
+  // The elements written last time: one that drops out of the consumer
+  // list on a rebind (its markers gone, the element kept by the morph) is
+  // released so its handlers unbind.
+  let bound = new Set<Element>();
+  createRenderEffect(
+    () => consumers().map(valuesFor),
+    writes => {
+      const next = new Set<Element>();
+      for (const { element, positions, values, texts } of writes) {
+        next.add(element);
+        write(element, positions, values);
+        for (const [start, v, key] of texts) writeText(start, v, key);
+      }
+      for (const element of bound) if (!next.has(element)) release(element);
+      bound = next;
+    }
+  );
+  // The occurrence's end (a later response dropped it, a positional id now
+  // names another row's data) unbinds what it bound: the element may outlive
+  // the occurrence (a morph keeps un-keyed elements) and another occurrence
+  // may bind it next, so a handler left behind fires a disposed fill's.
+  onCleanup(() => {
+    for (const element of bound) release(element);
+  });
+  // Value positions are READ in the compute phase: a getter read here
+  // tracks, so the occurrence re-writes when its sources move. Text
+  // positions are values too, collected apart: they are nodes, not props.
+  function valuesFor({ element, positions }: { element: Element; positions: any[] }) {
+    const props: Record<string, any> = {};
+    const texts: [Comment, unknown, string][] = [];
+    let classNames: Record<string, boolean> | null = null;
+    let styleProps: Record<string, any> | null = null;
+    for (const { pos, key, name, start } of positions) {
+      if (pos === "ref" || pos.startsWith("on:")) continue;
+      if (pos === "text") texts.push([start, out[key], key]);
+      else if (pos === "class" || pos === "style") {
+        if (name === undefined) props[pos] = out[key];
+        else if (pos === "class") (classNames || (classNames = {}))[name] = !!out[key];
+        else (styleProps || (styleProps = {}))[name] = out[key];
+      } else props[pos] = out[key];
+    }
+    if (classNames !== null && !("class" in props)) props.class = classNames;
+    if (styleProps !== null && !("style" in props)) props.style = styleProps;
+    return { element, positions, values: props, texts };
+  }
+  function write(element: Element, positions: any[], props: Record<string, any>) {
+    let st = state.get(element);
+    if (!st) state.set(element, (st = { prev: {}, handlers: {}, ref: undefined, refId: "" }));
+    // Handler positions: the marker's event name (`onClick` compiled to
+    // `click`) as the prop `assign` binds. The prop must be `on` + an
+    // uppercase letter (`onClick`) — a lowercase `onclick` is an attribute
+    // to `assign`. The server merges duplicate handlers last-wins, so a
+    // position names one key; given more, the last. Several keys at a ref
+    // position all fire, in marker order.
+    const handlers: Record<string, string> = {};
+    const refKeys: string[] = [];
+    for (const { pos, key } of positions) {
+      if (pos === "ref") refKeys.push(key);
+      else if (pos.startsWith("on:")) handlers["on" + pos[3].toUpperCase() + pos.slice(4)] = key;
+    }
+    let owners = handlerOwners.get(element);
+    if (!owners) handlerOwners.set(element, (owners = {}));
+    let events = false;
+    for (const prop in handlers) {
+      events = true;
+      const key = handlers[prop];
+      let h = st.handlers[prop];
+      if (h === undefined || h.key !== key)
+        st.handlers[prop] = h = { key, value: untrack(() => out[key]) };
+      props[prop] = h.value;
+      owners[prop] = token;
+    }
+    // A handler the server released (or this occurrence let go of) is
+    // unbound through `assign`'s diff — unless another occurrence has taken
+    // the element's handler since, which is then not ours to clear.
+    const clearing: Record<string, true> = {};
+    for (const prop in st.handlers) {
+      if (prop in handlers) continue;
+      delete st.handlers[prop];
+      if (owners[prop] === token) {
+        delete owners[prop];
+        clearing[prop] = true;
+      }
+    }
+    if (refKeys.length) {
+      // One stable ref per key set: `assign` fires a ref when its value
+      // changes; a rebind that changes the bound keys fires it once.
+      const id = refKeys.join(",");
+      if (st.refId !== id) {
+        const refs = refKeys.map(k => untrack(() => out[k]));
+        st.refId = id;
+        st.ref = (el: Element) => {
+          for (const r of refs) typeof r === "function" && r(el);
+        };
+      }
+      props.ref = st.ref;
+    }
+    // A value position the server RELEASED (a rebind whose incoming markup
+    // no longer marks it) is the server's again, and the morph already
+    // wrote the server's value there. Drop it from the diff state so
+    // `assign` does not null the attribute the morph just applied. The ref
+    // is the client's alone: it stays in `prev` and clears through the diff.
+    for (const k in st.prev) {
+      if (k in props || k === "ref" || k in clearing) continue;
+      delete st.prev[k];
+    }
+    assign(element, props, true, st.prev);
+    // Option (a) of the replay-window ruling (frames-rulings 3.1, C6): an
+    // event-slot consumer carries its own `_hk` (the server stamps one on
+    // an element with an `_s:on:*` position — ssrClaim, server.ts), so the
+    // hydration bootstrap queued its events while the element was not
+    // completed — the page root's pass never completes it (frame interiors
+    // are not its to claim). Its handlers are bound now: complete it and
+    // replay the queue (`runHydrationEvents` drains what is completed, in
+    // order). Once per element; a page that never hydrated has no set.
+    if (events && sharedConfig.completed && !sharedConfig.completed.has(element)) {
+      sharedConfig.completed.add(element);
+      runHydrationEvents();
+    }
+  }
+  function release(element: Element) {
+    if (!state.has(element)) return;
+    write(element, [], {});
+    state.delete(element);
+  }
+  // A text position renders as a client insert renders a primitive: a
+  // string or number as text, nullish and booleans as nothing. Anything
+  // else is content, which belongs in a template slot.
+  function writeText(start: Comment, v: unknown, key: string) {
+    let s = "";
+    if (typeof v === "string" || typeof v === "number") s = "" + v;
+    else if (IS_DEV && v != null && typeof v !== "boolean") {
+      const shape = shapeOf(v);
+      slotShapeFinding(
+        { reason: "text-shape", occurrence: ctx.key, key, shape },
+        `[BINDING_SLOT_POSITION] \`${key}\` of \`${ctx.key}\` is placed as text, but the fill ` +
+          `returned ${shape} for it. A text position renders a string or number; markup belongs ` +
+          `in a template slot. The text is cleared.`
+      );
+    }
+    const n = start.nextSibling;
+    if (n && n.nodeType === 3) {
+      if ((n as Text).data !== s) (n as Text).data = s;
+    } else if (s) start.after(s);
+  }
+}
diff --git a/packages/web/frames/src/client.ts b/packages/web/frames/src/client.ts
index d39a3614e..bdcfa6b51 100644
--- a/packages/web/frames/src/client.ts
+++ b/packages/web/frames/src/client.ts
@@ -21,9 +21,7 @@ import {
   createOwner,
   createRenderEffect,
   createSignal,
-  DEV,
   getOwner,
-  OBSERVE,
   onCleanup,
   runWithOwner,
   untrack
@@ -33,9 +31,21 @@ import type { Element as SolidElement } from "solid-js";
 // already uses — importing it from the runtime source instead bundles a second
 // copy of `insert` and the reconcile/render machinery it drags in (~4kb the app
 // already has). Kept external in rollup.config.js for the same reason the
-// server-functions/client import below is.
-import { insert, assign } from "@solidjs/web";
-import { createFrame, createFrameElement, createFrameHost, FRAME_ID_ATTR } from "./frame-client.js";
+// server-functions/client import below is. (`assign` — a binding slot's
+// position writer — is the bind tier's import, not this entry's.)
+import { insert } from "@solidjs/web";
+import {
+  createFrame,
+  createFrameElement,
+  createFrameHost,
+  FRAME_ID_ATTR,
+  isAsyncValue,
+  prepareTier,
+  slotShapeFinding,
+  tierLoaders,
+  tierLoads,
+  type TierModule
+} from "./frame-client.js";
 import {
   COMPONENT_BINDING,
   callFor,
@@ -44,22 +54,72 @@ import {
   stagedContent,
   type ServerComponentHandlerOptions
 } from "./frame-transport.js";
+import { createLoadingBoundary, sharedConfig } from "solid-js/internal";
+
 // The container tier (DR-2 case 3): server projections cross the border as
 // TRACES (snapshot + patch batches) and materialize back into live local
-// projections. The materializer is solid's (it owns the patch protocol);
-// this entry installs it and wires the host's literal-arg reviver (document
-// face). The seroval plugin itself needs no wiring — it rides the codec's
-// default plugin set, in the lazy codec chunk. These named imports pull
-// only the eager core (hooks + revive walk + the WeakSet probe); the
-// plugin object tree-shakes away.
-import {
-  isMaterializedContainer,
-  reviveContainerTraces,
-  setContainerTraceMaterializer
-} from "./frame-container-plugin.js";
-import { createLoadingBoundary, materializeContainerTrace, sharedConfig } from "solid-js/internal";
-
-setContainerTraceMaterializer(materializeContainerTrace);
+// projections. The materializer is solid's (it owns the patch protocol) and
+// it is the store engine's one edge into a server-component page — so the
+// whole client half is a TIER (frames savings pass §3 row C3), the chunk
+// `@solidjs/web/frames/trace` (trace-tier.ts: solid's materializer + the
+// plugin's revive walk, memo and marker test), loaded through the tier
+// mechanism: the server announces `trace` where it serializes a trace, and
+// a marker met in an adopt-time record's args while the tier is absent
+// holds the occurrence and starts the load (frame-client.ts, `needsTrace`).
+// This entry imports NOTHING of the plugin's client half; it keeps the
+// loader entry and reads the container probe off the plugin's registered
+// state object (the protocol endpoint every copy shares — undefined until
+// some copy loaded, and no container can exist before one did). The tier's
+// install wires the shared host's `revive` (getFrameHost). The seroval
+// plugin itself needs no wiring — it rides the codec's default plugin set,
+// in the lazy codec chunk.
+const TRACE_STATE = Symbol.for("solid.container-trace-state");
+tierLoaders.trace = () => import("@solidjs/web/frames/trace");
+// The regions tier (frames savings pass §3 row C4): nested server-content
+// regions — `{$frame}` slot args resolved to region elements with frames
+// bound over them — as the chunk `@solidjs/web/frames/regions`
+// (regions-tier.ts). The server announces `regions` where it mints one; a
+// record naming a region met while the tier is absent waits for it
+// (frame-client.ts, `needsRegions`). This entry keeps the document face's
+// `sc:region:` drain (below): an occluded region's html lands in the
+// store regardless, and the frame the tier binds on install seeds from it.
+tierLoaders.regions = () => import("@solidjs/web/frames/regions");
+// The assets tier (frames savings pass §3 row C5): the head mirror a
+// segment's `seg:<k>:assets` record drives — the stylesheet gate, module
+// and typed preloads, inline styles — as the chunk `@solidjs/web/frames/
+// assets` (assets-tier.ts), loaded through the tier mechanism: the server
+// announces `assets` wherever it emits an assets chunk, and a record met
+// while the tier is absent starts the load from the readiness check. A
+// segment with stylesheets or inline styles is NOT READY until the tier is
+// resident, and one with stylesheets not until they have settled (the
+// reveal-readiness term in frame-client.ts's #segmentReady): the server's
+// fallback stays on screen, no segment reveals unstyled. The module's
+// exports are the dispatch (`gate`, `apply`); no install.
+tierLoaders.assets = () => import("@solidjs/web/frames/assets");
+// The bind tier (frames savings pass §3 row C6): binding-slot positions
+// (principles §9.2.3) — the `_s:*` marker parsers, consumer discovery, the
+// morph's owned-position arms, the per-frame consumer set and the fill's
+// binding (`assign` over every consuming element) — as the chunk
+// `@solidjs/web/frames/bind` (bind-tier.ts). The server announces `bind`
+// wherever a slot is read as data (the slot proxy's `needs("bind")`); a
+// marker met in a frame's content while the tier is absent is noted by
+// the sync's walk and the frame holds on the note, its load started by
+// the readiness check (frame-client.ts, `#syncSlots`). The module's
+// exports are the dispatch; no install.
+tierLoaders.bind = () => import("@solidjs/web/frames/bind");
+// The live wire tier (frames savings pass §3 row C2): what a `live()`
+// loop's connection needs of the frames transport — the per-address
+// connection (join / open / supersede), the SSE reader selection and the
+// connection's lifetime told to the loop, the mount's have-list ledger and
+// the resume request — as the chunk `@solidjs/web/frames/wire`
+// (wire-tier.ts). Preload-at-call: `live()` fires the handler's `onLive`
+// hook at the call, before its first fetch, and the hook is
+// `prepareTier("wire")`; the handler's live arm awaits the same load before
+// the body is read, so a live connection without the tier cannot happen.
+// The server announces `wire` too (`X-Frame-Tiers` on a live response,
+// `sc:tiers` on a document carrying a live source). The module's exports
+// are the dispatch (`connect`, `cancel`, `resume`, `have`); no install.
+tierLoaders.wire = () => import("@solidjs/web/frames/wire");
 
 // Build-time literal (see diagnostics.ts): dev-only guidance folds out of prod.
 const IS_DEV = "_SOLID_DEV_" as unknown as boolean;
@@ -75,16 +135,6 @@ const IS_DEV = "_SOLID_DEV_" as unknown as boolean;
 // (externalizeSharedTransport), so the codec/flight config its defaults
 // read is this instance by construction.
 import { configureServerFunctionsClient } from "@solidjs/web/server-functions/client";
-// The server-function registry's two seams, read through their registered
-// symbols rather than imported (the pattern the frame runtime uses for
-// every cross-bundle brand — `CLAIM_SEAM`, `COMPONENT_BINDING`): the
-// late-bound RPC slot (registry.ts `provideServerFunctionRPC` — filled by
-// the time any server function has been referenced, so by the time a
-// response could have erred) and the declaration-metadata brand. Importing
-// either from an entry would retain a registry copy in whichever bundle
-// does not already carry one.
-const SERVER_FUNCTION_RPC = Symbol.for("solid.ServerFunctionRPC");
-const SERVER_FUNCTION_METADATA = Symbol.for("solid.ServerFunctionMetadata");
 // The seroval codec is the frames client's heaviest dependency (~6 kB gz
 // with the web plugin set) and the common frames traffic never needs it:
 // HTML chunks, scalar slot args and document records (the hydration
@@ -100,10 +150,20 @@ export {
   createFrameElement,
   FRAME_APPLIED_EVENT
 } from "./frame-client.js";
+// The shape a tier loader resolves (`InstallOptions.tiers`); type-only.
+export type { TierModule } from "./frame-client.js";
+// The bind tier's import of this entry (bind-tier.ts): one copy of the
+// async-value probe, and the edge that keeps the chunk attached to the
+// entry's graph in an app's bundler.
+/** @internal */
+export { isAsyncValue } from "./frame-client.js";
+// `FRAME_HAVE_HEADER` / `FRAME_HAVE_BUDGET` are the SERVER entry's
+// (`@solidjs/web/frames/server`): the client sends the have-list itself
+// (`resume`, through the handler) and no consumer of this entry reads the
+// header's name — an exported constant costs a consumer that keeps the whole
+// module its bytes, so the pair left this list (frames residue pass).
 export {
   FRAME_STREAM_HEADER,
-  FRAME_HAVE_HEADER,
-  FRAME_HAVE_BUDGET,
   applyFrameResponse,
   isFrameStreamResponse,
   createServerComponentHandler
@@ -143,10 +203,14 @@ export function asyncArg<T>(value: PromiseLike<T> | AsyncIterable<T>): T {
 // their own host.
 //
 // Tables materialize lazily, at first use once the codec module is
-// resident — `prepareData` guarantees that before any `data` chunk
-// delivers. A `resolve` ahead of the codec (a record's `$ref` sighted
-// before its data) answers undefined — "not delivered" — and the host hands
-// the fill a pending read the data chunk settles (see `createFrameHost`).
+// resident — `prepareData` guarantees that before any chunk that reads
+// data delivers (a `data` chunk; a `slot` chunk whose args carry a `$ref`).
+// A `resolve` of a key the response has not delivered yet is the table's
+// own pending read (the key lives there, so the wait does), settled by the
+// key's `data` chunk through `apply` and rejected when the response ends
+// (`closeData` → `table.close`, see `createFrameHost`); a version the
+// address has moved past takes its table — and its unanswered reads — with
+// it.
 let sharedHost: any;
 let codec: any;
 let codecLoading: Promise<unknown> | undefined;
@@ -235,7 +299,7 @@ function followAddress(host: any, frame: { rebind(address: string): void }, bind
  * threw — this one — and an errored landing is not a landing for a fresh
  * consumer: the re-read is a promise for the NEXT flight (`host.landing`),
  * and the flight is opened here (`reask`: the call behind the address,
- * re-invoked — `dynamic`'s factory is hoisted and never re-runs for a
+ * made again — `dynamic`'s factory is hoisted and never re-runs for a
  * `reset`, so the mount asks for itself). A re-ask whose call fails on the
  * wire (no response to land) rejects the node with that failure.
  *
@@ -268,16 +332,30 @@ function landing<T>(host: any, address: string, value: T, failed: () => unknown)
     if (!wait) return value;
     // An errored address with no flight open (a flight's `start` clears
     // the mounts' error): this read is the re-ask.
-    const asked = error !== undefined && reask ? reask(address) : undefined;
+    const asked = error !== undefined ? reask(address) : undefined;
     return (asked ? asked.then(() => wait) : wait).then(() => value);
   });
 }
 
-// The re-ask (see `landing`): installed with the handler, it re-invokes the
-// call behind an address and resolves when the call's response has been
-// handled (the flight is open and will land through the host). Undefined
-// until `installServerComponents` ran.
-let reask: ((address: string) => Promise<unknown> | undefined) | undefined;
+/**
+ * The re-ask (see `landing`): the call behind the address, as the transport
+ * recorded it (`callFor`), made again through the call's own `retry` — the
+ * server-function client hands its response handler the call it dispatched
+ * (or answered locally) as a thunk: the same reference, arguments, declared
+ * shape and per-call options, so a `GET`-declared read stays a GET by
+ * construction. Resolves when the call's response has been handled: the
+ * flight is open and lands through the host. `undefined` for an address no
+ * call is recorded for.
+ */
+function reask(address: string): Promise<unknown> | undefined {
+  const call = callFor(address);
+  if (IS_DEV && !call)
+    console.error(
+      `Server component boundary "${address}" errored, but no call is recorded for it; ` +
+        `reset() cannot re-ask the server. (The address was written by hand, not by a call.)`
+    );
+  return call && call.retry();
+}
 
 /**
  * A mount's error tick for `landing`: the read, and the frame `onApply`
@@ -301,29 +379,21 @@ export function getFrameHost() {
       applyData: (c: any, current?: number) => tableFor(c.id, c.version, current)?.apply(c),
       resolve: (ref: any, id: string, version: number, current?: number) =>
         tableFor(id, version, current)?.resolve(ref),
-      // Document-face container traces ride slot records as inline literals
-      // (never `{$ref}`s); this revives them into live stores at arg-read.
-      revive: reviveContainerTraces
+      // The response's table alone — never minted for a response that
+      // carried no data, never a superseded version's.
+      closeData: (id: string, version: number, error?: unknown) =>
+        tables.get(id)?.get(version)?.close(error)
+      // No `revive` here: document-face container traces ride slot records
+      // as inline literals (never `{$ref}`s) and are revived into live
+      // stores at arg-read by the traces tier, whose install sets this
+      // host's `revive` (trace-tier.ts). Until then no record that carries
+      // one mounts (the frame holds it on the tier), so nothing reads a
+      // marker inert.
     });
   }
   return sharedHost;
 }
 
-/** Resolve Solid JSX slot content (thunks, arrays, primitives) to nodes. */
-function normalizeSlotContent(value: any): Node | Node[] {
-  while (typeof value === "function") value = value();
-  if (Array.isArray(value)) {
-    const out: Node[] = [];
-    for (const v of value) {
-      const n = normalizeSlotContent(v);
-      Array.isArray(n) ? out.push(...n) : out.push(n);
-    }
-    return out;
-  }
-  if (value == null || typeof value === "boolean") return document.createTextNode("");
-  return value instanceof Node ? value : document.createTextNode(String(value));
-}
-
 /**
  * The stable component minted once per boundary. Every mount creates its own
  * frame instance under the boundary id (mounting the same server component
@@ -355,8 +425,19 @@ type ClaimScope = { registry?: Map<string, object>; gather?: (key: string) => vo
  * chain, finds its pending `<key>_fr` registration, and resumes into the
  * swapped content instead of re-rendering over a fragment nobody owns.
  * Plain render on a page that never hydrated (CSR boot, post-load streams).
+ *
+ * `bound`: the second window of one fill — the `insert` of what the first
+ * evaluated. It claims under the same prefix but gathers nothing: the
+ * first window's gather is still in the registry, and gathering again
+ * would put the keys the evaluation already claimed back as unclaimed.
  */
-function claimRender(prefix: string, existing: Node[], render: () => any, scope?: ClaimScope) {
+function claimRender(
+  prefix: string,
+  existing: Node[],
+  render: () => any,
+  scope?: ClaimScope,
+  bound?: boolean
+) {
   const sc: any = sharedConfig;
   // No window, or no registry gathered yet (no `hydrate()` pass has run):
   // nothing to claim against — render fresh over the markup.
@@ -365,7 +446,9 @@ function claimRender(prefix: string, existing: Node[], render: () => any, scope?
   sc.claimRoots = existing;
   try {
     // The claim owner too: the window claims this fill's subtree only.
-    return runWithOwner(createOwner({ id: prefix }), () => sc.hydrateWindow(prefix, render, scope));
+    return runWithOwner(createOwner({ id: prefix }), () =>
+      sc.hydrateWindow(bound ? undefined : prefix, render, scope)
+    );
   } finally {
     sc.claimRoots = prevRoots;
   }
@@ -390,19 +473,6 @@ function liveSlotProps(initial: Record<string, any>, ctx: any) {
   return slotArgsProxy(args);
 }
 
-/**
- * Whether a slot arg value is an async value passed whole (a promise or an
- * async iterable) — DR-2's value tier. The server never resolves these to
- * dead values; the client suspends at the consumption read.
- */
-function isAsyncValue(v: any): boolean {
-  return (
-    v !== null &&
-    typeof v === "object" &&
-    (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function")
-  );
-}
-
 /**
  * Whether two values of one slot arg are the same value — the per-prop
  * memo's equality, and so the whole dedupe of a re-sent record (a record
@@ -490,7 +560,10 @@ function slotArgsProxy(args: () => Record<string, any>) {
           // `.then` probe would detonate a pending one (property reads
           // throw not-ready), so it is classified before the probe and
           // held BOXED (see `Boxed`). Mirrors the server sink's
-          // classification order.
+          // classification order. The probe is the plugin's WeakSet of
+          // materialized values, read off its registered state (see
+          // TRACE_STATE): trap-safe, and absent until a copy of the plugin
+          // loaded — before which no container can exist.
           //
           // SUPERSEDES: every re-shipped record re-runs this memo while the
           // arg is still pending, abandoning the flight in the air — by
@@ -501,7 +574,8 @@ function slotArgsProxy(args: () => Record<string, any>) {
             createMemo(
               () => {
                 const raw = (args() as any)[key];
-                if (isMaterializedContainer(raw)) return new Boxed(raw);
+                if ((globalThis as any)[TRACE_STATE]?.materializedValues.has(raw))
+                  return new Boxed(raw);
                 if (raw != null && typeof raw.then === "function") {
                   if (raw.s === 1) return raw.v;
                   if (raw.s === 2) throw raw.v;
@@ -526,252 +600,21 @@ function slotArgsProxy(args: () => Record<string, any>) {
   );
 }
 
-interface ElementState {
-  /** `assign`'s diff state: the props last written to the element. */
-  prev: Record<string, any>;
-  /** Bound handler props (`onclick`): the key and the value read at bind. */
-  handlers: Record<string, { key: string; value: any }>;
-  /** The ref dispatcher for the element's current ref keys, and those keys. */
-  ref: ((el: Element) => void) | undefined;
-  refId: string;
-}
-
-/**
- * The occurrence holding each handler prop of an element. A rebind can hand
- * an element from one occurrence to another (a positional id now names
- * another row's data), and a delegated handler is one slot on the element:
- * the outgoing occurrence's release must not clear what the incoming one set.
- */
-const handlerOwners = new WeakMap<Element, Record<string, object>>();
-
-/**
- * Bind a binding-slot occurrence (principles §9.2.3). The fill runs ONCE,
- * untracked, under the occurrence's owner — a component body: a top-level
- * read is a one-time read (dev names it through `untrack`'s label), and state
- * created in the body lives as long as the occurrence. Its object's value
- * positions are written by one render effect over every consuming element,
- * diffed per position by `assign`, so a getter's change re-reads the
- * occurrence and touches only what moved. Handlers and refs are read once
- * when an element binds and handed to `assign`, which binds them as client
- * JSX does (delegation, tuples). A consumer change (`ctx.onRebind`: the morph
- * replaced an element, a response bound a new position) rebinds without
- * re-running the fill.
- */
-function bindDataOccurrence(
-  fill: (args: any) => any,
-  args: any,
-  ctx: any,
-  label: string | undefined
-) {
-  const [consumers, setConsumers] = createSignal<any[]>(ctx.positions);
-  ctx.onRebind(setConsumers);
-  const raw = untrack(() => fill(args), label);
-  // Content where data was expected: a DOM node is an object, so it is
-  // named here rather than read as one (its properties are the DOM's); an
-  // async value has no properties to bind until it settles.
-  const node = typeof Node === "function" && raw instanceof Node;
-  const pending = isAsyncValue(raw);
-  if (IS_DEV && (raw == null || typeof raw !== "object" || Array.isArray(raw) || node || pending)) {
-    const shape = shapeOf(raw);
-    slotShapeFinding(
-      { reason: "fill-shape", occurrence: ctx.key, shape },
-      `[BINDING_SLOT_POSITION] The fill for \`${ctx.key}\` returned ${shape}; server markup reads ` +
-        `its properties at bound positions, so it must return an object (\`{ done, onToggle, … }\`). ` +
-        `Nothing binds.`
-    );
-  }
-  const out = raw == null || typeof raw !== "object" || node || pending ? {} : raw;
-  const token = {};
-  const state = new WeakMap<Element, ElementState>();
-  // The elements written last time: one that drops out of the consumer
-  // list on a rebind (its markers gone, the element kept by the morph) is
-  // released so its handlers unbind.
-  let bound = new Set<Element>();
-  createRenderEffect(
-    () => consumers().map(valuesFor),
-    writes => {
-      const next = new Set<Element>();
-      for (const { element, positions, values, texts } of writes) {
-        next.add(element);
-        write(element, positions, values);
-        for (const [start, v, key] of texts) writeText(start, v, key);
-      }
-      for (const element of bound) if (!next.has(element)) release(element);
-      bound = next;
-    }
-  );
-  // The occurrence's end (a later response dropped it, a positional id now
-  // names another row's data) unbinds what it bound: the element may outlive
-  // the occurrence (a morph keeps un-keyed elements) and another occurrence
-  // may bind it next, so a handler left behind fires a disposed fill's.
-  onCleanup(() => {
-    for (const element of bound) release(element);
-  });
-  // Value positions are READ in the compute phase: a getter read here
-  // tracks, so the occurrence re-writes when its sources move. Text
-  // positions are values too, collected apart: they are nodes, not props.
-  function valuesFor({ element, positions }: { element: Element; positions: any[] }) {
-    const props: Record<string, any> = {};
-    const texts: [Comment, unknown, string][] = [];
-    let classNames: Record<string, boolean> | null = null;
-    let styleProps: Record<string, any> | null = null;
-    for (const { pos, key, name, start } of positions) {
-      if (pos === "ref" || pos.startsWith("on:")) continue;
-      if (pos === "text") texts.push([start, out[key], key]);
-      else if (pos === "class" || pos === "style") {
-        if (name === undefined) props[pos] = out[key];
-        else if (pos === "class") (classNames || (classNames = {}))[name] = !!out[key];
-        else (styleProps || (styleProps = {}))[name] = out[key];
-      } else props[pos] = out[key];
-    }
-    if (classNames !== null && !("class" in props)) props.class = classNames;
-    if (styleProps !== null && !("style" in props)) props.style = styleProps;
-    return { element, positions, values: props, texts };
-  }
-  function write(element: Element, positions: any[], props: Record<string, any>) {
-    let st = state.get(element);
-    if (!st) state.set(element, (st = { prev: {}, handlers: {}, ref: undefined, refId: "" }));
-    // Handler positions: the marker's event name (`onClick` compiled to
-    // `click`) as the prop `assign` binds. The prop must be `on` + an
-    // uppercase letter (`onClick`) — a lowercase `onclick` is an attribute
-    // to `assign`. The server merges duplicate handlers last-wins, so a
-    // position names one key; given more, the last. Several keys at a ref
-    // position all fire, in marker order.
-    const handlers: Record<string, string> = {};
-    const refKeys: string[] = [];
-    for (const { pos, key } of positions) {
-      if (pos === "ref") refKeys.push(key);
-      else if (pos.startsWith("on:")) handlers["on" + pos[3].toUpperCase() + pos.slice(4)] = key;
-    }
-    let owners = handlerOwners.get(element);
-    if (!owners) handlerOwners.set(element, (owners = {}));
-    for (const prop in handlers) {
-      const key = handlers[prop];
-      let h = st.handlers[prop];
-      if (h === undefined || h.key !== key)
-        st.handlers[prop] = h = { key, value: untrack(() => out[key]) };
-      props[prop] = h.value;
-      owners[prop] = token;
-    }
-    // A handler the server released (or this occurrence let go of) is
-    // unbound through `assign`'s diff — unless another occurrence has taken
-    // the element's handler since, which is then not ours to clear.
-    const clearing: Record<string, true> = {};
-    for (const prop in st.handlers) {
-      if (prop in handlers) continue;
-      delete st.handlers[prop];
-      if (owners[prop] === token) {
-        delete owners[prop];
-        clearing[prop] = true;
-      }
-    }
-    if (refKeys.length) {
-      // One stable ref per key set: `assign` fires a ref when its value
-      // changes; a rebind that changes the bound keys fires it once.
-      const id = refKeys.join(",");
-      if (st.refId !== id) {
-        const refs = refKeys.map(k => untrack(() => out[k]));
-        st.refId = id;
-        st.ref = (el: Element) => {
-          for (const r of refs) typeof r === "function" && r(el);
-        };
-      }
-      props.ref = st.ref;
-    }
-    // A value position the server RELEASED (a rebind whose incoming markup
-    // no longer marks it) is the server's again, and the morph already
-    // wrote the server's value there. Drop it from the diff state so
-    // `assign` does not null the attribute the morph just applied. The ref
-    // is the client's alone: it stays in `prev` and clears through the diff.
-    for (const k in st.prev) {
-      if (k in props || k === "ref" || k in clearing) continue;
-      delete st.prev[k];
-    }
-    assign(element, props, true, st.prev);
-  }
-  function release(element: Element) {
-    if (!state.has(element)) return;
-    write(element, [], {});
-    state.delete(element);
-  }
-  // A text position renders as a client insert renders a primitive: a
-  // string or number as text, nullish and booleans as nothing. Anything
-  // else is content, which belongs in a template slot.
-  function writeText(start: Comment, v: unknown, key: string) {
-    let s = "";
-    if (typeof v === "string" || typeof v === "number") s = "" + v;
-    else if (IS_DEV && v != null && typeof v !== "boolean") {
-      const shape = shapeOf(v);
-      slotShapeFinding(
-        { reason: "text-shape", occurrence: ctx.key, key, shape },
-        `[BINDING_SLOT_POSITION] \`${key}\` of \`${ctx.key}\` is placed as text, but the fill ` +
-          `returned ${shape} for it. A text position renders a string or number; markup belongs ` +
-          `in a template slot. The text is cleared.`
-      );
-    }
-    const n = start.nextSibling;
-    if (n && n.nodeType === 3) {
-      if ((n as Text).data !== s) (n as Text).data = s;
-    } else if (s) start.after(s);
-  }
-}
-
-/** A value's shape, as the binding-slot shape findings name it. */
-function shapeOf(v: unknown): string {
-  return v === null
-    ? "null"
-    : typeof Node === "function" && v instanceof Node
-      ? "a DOM node"
-      : Array.isArray(v)
-        ? "an array"
-        : isAsyncValue(v)
-          ? "an async value"
-          : typeof v;
-}
-
-/**
- * Dev finding (`BINDING_SLOT_POSITION`): the client side of a binding slot
- * has the wrong shape — the fill's return is not an object or the prop is
- * not a function (`fill-shape`), or a text position's value is not a
- * primitive (`text-shape`). Through the diagnostics channel, so an
- * observer captures it beside the server's findings.
- */
-function slotShapeFinding(data: Record<string, string>, message: string) {
-  DEV!.report(
-    OBSERVE!.diagnostics.emit(
-      { code: "BINDING_SLOT_POSITION", kind: "render", severity: "warn", message, data },
-      null
-    )
-  );
-}
-
-/** Whether a resolved slot value is reactive at the top level. */
-function isReactiveContent(value: any): boolean {
-  if (typeof value === "function") return true;
-  if (Array.isArray(value)) {
-    for (const v of value) if (isReactiveContent(v)) return true;
-  }
-  return false;
-}
-
 /**
  * The slot fills of a boundary. `scope` (adopted boundaries): the
  * registry/gather pair the boundary adopted under, for its occurrences'
  * claims — see `claimRender`.
  */
 function slotsFor(props: Record<string, any>, scope?: ClaimScope) {
-  // Live range bindings, one per occurrence. A re-call replaces its
-  // occurrence's binding (the frame only runs slot cleanups at unmount, not
-  // between re-calls), so dispose the outgoing one before the incoming
-  // invocation takes either path — a static re-call after a reactive one must
-  // not leave a binding fighting the frame for the range.
-  const bindings = new Map<string, { dispose(): void }>();
   // Each fill invocation's reactive scope, one per occurrence. The fill
   // renders under a PER-OCCURRENCE owner (a child of the ambient scope, so
   // context flows) whose disposal rides the frame's occurrence-level
   // cleanup: a fill's `onCleanup` and effects live and die with the
   // occurrence — a later response dropping it disposes right there — not
   // with the covering boundary, which outlives every occurrence it covers.
+  // The range binding (the `insert` below) is the same scope: it lives
+  // under the fill's owner where there is one, under an owner of its own
+  // otherwise, so one map disposes the previous invocation whole.
   const fillScopes = new Map<string, { dispose(): void }>();
   return new Proxy(
     {},
@@ -780,14 +623,11 @@ function slotsFor(props: Record<string, any>, scope?: ClaimScope) {
         if (typeof prop !== "string" || !(prop in props)) return undefined;
         return (slotProps: any, ctx: any) => {
           const key = ctx && ctx.key;
-          const prev = key !== undefined && bindings.get(key);
-          if (prev) {
-            bindings.delete(key);
-            prev.dispose();
-          }
-          // A re-call replaces the invocation wholesale (same contract as
-          // the binding above): the outgoing fill's scope disposes before
-          // the incoming one renders.
+          // A re-call replaces the invocation wholesale (the frame only
+          // runs slot cleanups at unmount, not between re-calls): the
+          // outgoing fill's scope — its binding included — disposes before
+          // the incoming one renders, so two bindings never fight for the
+          // range.
           const prevFill = key !== undefined && fillScopes.get(key);
           if (prevFill) {
             fillScopes.delete(key);
@@ -797,8 +637,9 @@ function slotsFor(props: Record<string, any>, scope?: ClaimScope) {
           // elements reading its properties at bound positions. Always under
           // a per-occurrence owner: the binding must die with the occurrence
           // (a later response dropping it, or every consumer replaced by
-          // the morph), and there are no placed nodes for the frame's zombie
-          // heuristic to misread.
+          // the morph). The binding itself is the BIND TIER's
+          // (`bind`, bind-tier.ts) — resident by construction: positions
+          // exist only once the tier parsed the markers.
           if (ctx && ctx.positions) {
             const fill = props[prop];
             if (typeof fill !== "function") {
@@ -823,7 +664,7 @@ function slotsFor(props: Record<string, any>, scope?: ClaimScope) {
               const args = ctx.onUpdate
                 ? liveSlotProps(slotProps, ctx)
                 : slotArgsProxy(() => slotProps);
-              bindDataOccurrence(
+              tierLoads.bind.r.bind(
                 fill,
                 args,
                 ctx,
@@ -832,6 +673,12 @@ function slotsFor(props: Record<string, any>, scope?: ClaimScope) {
             });
             return undefined;
           }
+          // A range occurrence without its end marker has no anchor to bind
+          // before (the document is corrupted — `FRAME_MARKER_CORRUPTED`,
+          // reported at discovery): the range is left as the server
+          // rendered it.
+          const range = ctx && ctx.range;
+          if (!range) return undefined;
           // Stream-mounted fills (no ambient owner at invocation — the frame
           // called from a chunk microtask) render under a PER-OCCURRENCE
           // owner whose disposal rides the frame's occurrence-level cleanup:
@@ -842,13 +689,11 @@ function slotsFor(props: Record<string, any>, scope?: ClaimScope) {
           // Live-render invocations (a reveal boundary's content render, the
           // t=0 adoption sync) are deliberately NOT scoped this way: the
           // ambient owner — the reconstructed segment boundary's content
-          // computation — already owns the fill with the right lifetime, and
-          // handing it to frame cleanups instead is wrong there: the frame's
-          // zombie heuristic reads "mounted nodes without a parent" as a
-          // destroyed mount, but a pending fill's nodes are legitimately
-          // detached while its covering boundary shows the fallback — the
-          // cleanup would dispose the live pending effect and release the
-          // boundary over a hole.
+          // computation — already owns the fill with the right lifetime (a
+          // pending fill's nodes are legitimately detached while its
+          // covering boundary shows the fallback; the boundary, not a frame
+          // cleanup, decides when that render is done with). Their range
+          // binding gets an owner of its own below.
           const fillOwner = streamInvoke ? createOwner() : null;
           if (fillOwner && key !== undefined && ctx) {
             fillScopes.set(key, fillOwner);
@@ -857,20 +702,6 @@ function slotsFor(props: Record<string, any>, scope?: ClaimScope) {
               fillOwner.dispose();
             });
           }
-          // A render whose output is already inside the range (hydration
-          // claims: the nodes ARE the server-rendered DOM) is a CLAIM —
-          // return undefined per the frame contract so nothing moves.
-          const settle = (out: Node | Node[]) => {
-            const existing: Node[] = (ctx && ctx.existing) || [];
-            if (existing.length) {
-              const list = Array.isArray(out) ? out : [out];
-              const inPlace = list.every(n =>
-                existing.some(e => e === n || (e.nodeType === 1 && (e as Element).contains(n)))
-              );
-              if (inPlace) return undefined;
-            }
-            return out;
-          };
           // The prop is read INSIDE the claim scope: compiled component props
           // are getters, so JSX evaluates lazily at access — deferring the
           // access into the scoped owner is what makes plain JSX (no thunks)
@@ -930,61 +761,58 @@ function slotsFor(props: Record<string, any>, scope?: ClaimScope) {
             : adopted
               ? claimRender(prefix, ctx.existing, evaluate, scope)
               : evaluate();
-          // Static content (the common case: render props returning component
-          // roots, plain JSX with no top-level control flow): today's
-          // zero-cost path — claim in place or hand the frame the nodes. No
-          // effect is created and hydration stays a no-op.
-          if (!isReactiveContent(value)) {
-            return settle(normalizeSlotContent(value));
-          }
-          // Reactive content (a boundary accessor, route children): snapshot-
-          // ting it would freeze ONE state of it into the range, so own the
-          // range instead — bind the value before the range's end marker with
-          // insert() (the same primitive compiled JSX uses for `{expr}`
-          // positions) and return undefined so the frame leaves the interior
-          // alone. `existing` seeds insert's tracked array: an accessor that
-          // yields the claimed nodes reconciles to a zero-mutation no-op, one
-          // that yields new content swaps it in place.
+          // Every fill is one `insert` before the range's end marker — the
+          // primitive compiled JSX uses for `{expr}` positions — so the
+          // fill's output has the core's lifecycle, not a frame-side copy of
+          // it: a static value (the common case — a component root, plain
+          // JSX) is placed once with no effect created; a reactive one (a
+          // boundary accessor, route children) binds the range and follows
+          // (a snapshot would freeze ONE state of it); an adopted fill
+          // claims through `insertExpression`'s claim pass — nothing moves,
+          // and a render whose nodes never entered the DOM is the core's
+          // hydration mismatch (the server's nodes stay, hydration reports
+          // them unclaimed; C1) — disposal is the owner's. `existing` seeds
+          // insert's tracked array: output that IS the claimed nodes is a
+          // zero-mutation no-op, a stream re-call reconciles its new output
+          // against the previous one.
           //
-          // The claim scope wraps the insert CALL, not the accessor: the
-          // binding's first evaluation is insert's own render effect computing
-          // synchronously, so it still creates under the producer's hydration
-          // keys — boundary-deferred children (route content behind
-          // <Loading>) create on that read — while the reads it makes belong
-          // to the effect and stay tracked. Claiming inside the accessor
-          // instead put that first read inside runWithOwner's UNTRACKED window
-          // (it clears `tracking` along with the owner). Whenever the value it
-          // returned was not itself an accessor for insert to re-read — a
-          // <Loading> answering a still-pending streamed fragment returns its
-          // fallback NODES — the effect ended up with no dependency at all and
-          // the range went permanently inert: the boundary's own resume still
-          // claimed the swapped-in server markup, so the region looked right,
-          // but nothing downstream (a route change out of it) ever re-rendered
-          // it again.
-          if (ctx && ctx.range) {
-            const source = value;
-            const owner = createOwner();
-            bindings.set(key, owner);
+          // The claim scope wraps the insert CALL, not the accessor: a
+          // reactive value's first evaluation is insert's own render effect
+          // computing synchronously, so it still creates under the
+          // producer's hydration keys — boundary-deferred children (route
+          // content behind <Loading>) create on that read — while the reads
+          // it makes belong to the effect and stay tracked. Claiming inside
+          // the accessor instead put that first read inside runWithOwner's
+          // UNTRACKED window (it clears `tracking` along with the owner).
+          // Whenever the value it returned was not itself an accessor for
+          // insert to re-read — a <Loading> answering a still-pending
+          // streamed fragment returns its fallback NODES — the effect ended
+          // up with no dependency at all and the range went permanently
+          // inert: the boundary's own resume still claimed the swapped-in
+          // server markup, so the region looked right, but nothing
+          // downstream (a route change out of it) ever re-rendered it again.
+          //
+          // The binding's owner: the fill's own (a stream-mounted fill,
+          // already in `fillScopes` with its cleanup), else one minted here
+          // and registered the same way — TRANSPARENT, so a fill mounting
+          // inside the hydrate pass consumes no id from the adopting
+          // component's counter (a keyed sibling after the frame keys the
+          // same whether a fill mounted at t=0 or after a hold; the claim
+          // window below has its own id).
+          const owner = fillOwner || createOwner({ transparent: true });
+          if (!fillOwner) {
+            fillScopes.set(key, owner);
             ctx.onCleanup(() => {
-              if (bindings.get(key) === owner) bindings.delete(key);
+              if (fillScopes.get(key) === owner) fillScopes.delete(key);
               owner.dispose();
             });
-            const end = ctx.range.end;
-            const bind = () =>
-              insert(
-                end.parentNode as any,
-                () => (typeof source === "function" ? source() : source),
-                end,
-                [...ctx.existing]
-              );
-            runWithOwner(owner, () =>
-              adopted ? claimRender(prefix, ctx.existing, bind, scope) : bind()
-            );
-            return undefined;
           }
-          // No range handle (a consumer-constructed frame without markers):
-          // static placement is the only option — degrade to the snapshot.
-          return settle(normalizeSlotContent(value));
+          const end = range.end;
+          const bind = () => insert(end.parentNode as any, value, end, [...ctx.existing]);
+          runWithOwner(owner, () =>
+            adopted ? claimRender(prefix, ctx.existing, bind, scope, true) : bind()
+          );
+          return undefined;
         };
       }
     }
@@ -1353,21 +1181,6 @@ function documentBoundary(
   return boundaryComponent(host, id)(props, binding);
 }
 
-/**
- * The address a document boundary's content is keyed under: the call's
- * address as the hydration references recorded it (`_$SC.a`, address -> id).
- * A mount without a live binding (a direct placeholder render at t=0) reads
- * it from those records; an argless call's address IS the function id, so
- * the common shell case needs no record at all.
- */
-function documentAddress(id: string) {
-  const records = (globalThis as any)._$SC?.a;
-  if (records) {
-    for (const address in records) if (records[address] === id) return address;
-  }
-  return id;
-}
-
 function adoptBoundary(
   host: any,
   id: string,
@@ -1379,8 +1192,13 @@ function adoptBoundary(
   // Content is keyed by the CALL's address (the identity split): the frame
   // binds the address's resident store, while `id` — the function id, the
   // document's wire name — stays the key records and region ids on the page
-  // are written under.
-  const address = binding ? contentAddress(binding()) : documentAddress(id);
+  // are written under. The address comes with the binding — every reference
+  // the document serializes resolves to the call's binding, and a `dynamic`
+  // mount is called with the live accessor. A mount with no binding (the
+  // per-function placeholder rendered directly, `_$SC.r(id)` — a page with
+  // no transport) binds the function id: an argless call's address IS its
+  // id, and no refetch reaches a page without a transport.
+  const address = binding ? contentAddress(binding()) : id;
   // Occlusion records (case 3, document face): content a client wrapper
   // never rendered during SSR shipped ONCE as hydration data instead of
   // markup. Apply the records BEFORE binding the frame — the host buffers
@@ -1630,6 +1448,25 @@ function adoptBoundary(
   return el as unknown as SolidElement;
 }
 
+/**
+ * Options for `installServerComponents`.
+ * @experimental
+ */
+export interface InstallOptions {
+  /**
+   * Frames-client tiers by name → loader. A tier's module's exports are its
+   * appliers (the runtime dispatches to them once resident) and its
+   * optional `install()` is called once the import resolves; every live
+   * frame is then flushed so what the tier makes applicable applies (a held
+   * occurrence mounts, a style-gated segment requests its sheets). A name
+   * with no loader is resident (eager); `trace` (`@solidjs/web/frames/trace`),
+   * `regions` (`@solidjs/web/frames/regions`) and `assets`
+   * (`@solidjs/web/frames/assets`) have built-in loaders that an entry here
+   * replaces. See `installServerComponents`.
+   */
+  tiers?: Record<string, () => Promise<TierModule>>;
+}
+
 /**
  * Installs the server-component transport policy on the server-function
  * client — the identity split (DR-1): CONTENT is keyed by the call's
@@ -1645,13 +1482,30 @@ function adoptBoundary(
  * Call once in the client entry (an explicit call — the package is
  * `sideEffects: false`, so a bare import would be tree-shaken away);
  * call again to rebind to a custom host.
+ *
+ * `options.tiers` maps a frames-client tier's name to its loader (`() =>
+ * import(...)`, the module whose exports are the tier's appliers, with an
+ * optional `install()`): the client resolves tier chunks itself, so the
+ * server announces NAMES only (`_$HY.r["sc:tiers"]`, `X-Frame-Tiers`) and
+ * the loads start here from the document's record — the `modulepreload`
+ * the document may also carry made the fetch warm. The built-in table
+ * carries `trace` (the container tier's client half,
+ * `@solidjs/web/frames/trace`), `regions` (nested server-content regions,
+ * `@solidjs/web/frames/regions`) and `assets` (the head mirror and the
+ * stylesheet gate, `@solidjs/web/frames/assets`); a loader given here for
+ * a name replaces the built-in one (tests gate a tier's load this way).
  * @experimental
  */
-export function installServerComponents(host: any = getFrameHost()) {
+export function installServerComponents(host: any = getFrameHost(), options?: InstallOptions) {
+  const g = globalThis as any;
+  // The tier seam (frames savings pass §2): the loaders, then the tiers
+  // the document announced with its first server component's records —
+  // their imports start now, ahead of the adopt-time syncs that need them.
+  Object.assign(tierLoaders, options?.tiers);
+  g._$HY?.r?.["sc:tiers"]?.forEach(prepareTier);
   // Upgrade the document shell's placeholder bootstrap (if present): the
   // hydration data scripts resolved server-component references to stable
   // per-id placeholders; installing `impl` makes them mount-adopting.
-  const g = globalThis as any;
   if (!g._$SC) {
     // Mirror of the document bootstrap (frame-sink's
     // SERVER_COMPONENT_BOOTSTRAP_EXPR), for a page whose data scripts carried
@@ -1723,29 +1577,5 @@ export function installServerComponents(host: any = getFrameHost()) {
   const records = g._$SC.a || (g._$SC.a = {});
   for (const address in records) showing(address, records[address]);
   g._$SC.reg = showing;
-  // The re-ask (see `landing`): the call behind the address, as the
-  // handler recorded it, made again — through the same declaration shape
-  // it was made with (a `GET`-declared read stays a GET; declared metadata
-  // rides along), with no per-call options (those were the original
-  // caller's; this call is the boundary's own). The callable is minted
-  // through the late-bound RPC seam, never by importing the transport:
-  // the seam is filled by the time any response has been handled. Its
-  // response is handled like any other and lands through the host.
-  reask = address => {
-    const call = callFor(address);
-    const rpc = g[SERVER_FUNCTION_RPC];
-    if (!call || !rpc) {
-      if (IS_DEV)
-        console.error(
-          `Server component boundary "${address}" errored, but no call is recorded for it; ` +
-            `reset() cannot re-ask the server. (The address was written by hand, not by a call.)`
-        );
-      return undefined;
-    }
-    const meta: any = call.meta || {};
-    const ref = rpc.createServerReference(call.id);
-    Object.assign(ref[SERVER_FUNCTION_METADATA], meta);
-    return (meta.method === "GET" ? rpc.GET(ref) : ref)(...call.args);
-  };
   configureServerFunctionsClient({ responseHandler: handler });
 }
diff --git a/packages/web/frames/src/frame-client.ts b/packages/web/frames/src/frame-client.ts
index 9b8541e0b..603451499 100644
--- a/packages/web/frames/src/frame-client.ts
+++ b/packages/web/frames/src/frame-client.ts
@@ -23,10 +23,11 @@
 import { DEV, OBSERVE } from "solid-js";
 
 /**
- * One transport chunk of a frame stream, addressed by frame `id`.
+ * One transport chunk of a frame stream, addressed by frame `id`. Any
+ * chunk may carry `tiers` (see `TierAnnouncement`).
  * @experimental
  */
-export type FrameChunk =
+export type FrameChunk = (
   | { type: "start"; id: string; version: number }
   | {
       type: "html";
@@ -124,7 +125,25 @@ export type FrameChunk =
        */
       bound?: "yields" | "time";
     }
-  | { type: "error"; id: string; version: number; key?: string; error: unknown };
+  | { type: "error"; id: string; version: number; key?: string; error: unknown }
+) &
+  TierAnnouncement;
+
+/**
+ * The in-band tier announcement (frames savings pass §2; additive — RFC 11
+ * addendum): the frames-client tiers the render first needed since the
+ * last chunk left — `"bind"`, `"regions"`, `"assets"`, `"trace"`,
+ * `"wire"` — on whichever chunk leaves next. The response head carries the
+ * tiers minted before it (`X-Frame-Tiers`); a tier minted later rides
+ * here. The client starts each named tier's load before applying the
+ * chunk; a `data` chunk additionally AWAITS them (its node tree needs the
+ * tier to decode). Absent on every chunk of a response that minted nothing
+ * after its head, and ignored by a client that predates it.
+ * @experimental
+ */
+export interface TierAnnouncement {
+  tiers?: string[];
+}
 
 /**
  * One store write applied to a frame: `r` maps record keys to values
@@ -175,17 +194,17 @@ export interface SlotContext {
   /**
    * The range's current interior — server-rendered client content on an
    * adopted document-SSR boot, or the previous output on a re-call. A
-   * framework binding hydrates onto it and returns `undefined` to claim it
-   * in place (zero DOM mutation).
+   * framework binding hydrates onto it (a claim: zero DOM mutation) or
+   * replaces it.
    */
   existing: ChildNode[];
   /**
-   * The range's own marker comments, when the occurrence has a placed range.
-   * A framework binding whose slot content is reactive at the top level (a
-   * boundary accessor, changing route children) owns the interior instead of
-   * returning nodes: bind before `end` with the framework's insert primitive
-   * and return `undefined` — the frame leaves the range alone (server morphs
-   * already protect slot ranges).
+   * The range's own marker comments, when the occurrence has a placed range
+   * — the anchor the fill owns its interior through: bind or place the
+   * output before `end` (over `existing`) with the framework's insert
+   * primitive. The frame never touches a range's interior itself (server
+   * morphs protect slot ranges). Absent for a binding-slot occurrence
+   * (`positions`) and for a range whose end marker is missing.
    */
   range?: { start: Comment; end: Comment };
 }
@@ -194,11 +213,13 @@ export interface SlotContext {
  * Client content for a server-declared slot. Direct-insert occurrences
  * call it with empty props; render-prop occurrences pass the occurrence's
  * resolved args (primitives literal, `{$ref}` data resolved through the
- * host, `{$frame}` regions as marker-range fragments). Return nodes to fill
- * the range, or `undefined` to claim `ctx.existing` untouched.
+ * host, `{$frame}` regions as frame elements). The fill owns its range: it
+ * places or binds its output before `ctx.range.end`, over `ctx.existing`
+ * (claimed in place on hydration), and disposes it through `ctx.onCleanup`.
+ * The return value is not read.
  * @experimental
  */
-export type Slot = (props: Record<string, unknown>, ctx: SlotContext) => Node | Node[] | undefined;
+export type Slot = (props: Record<string, unknown>, ctx: SlotContext) => void;
 
 /** @experimental */
 export interface Frame {
@@ -219,16 +240,6 @@ export interface Frame {
    * boundary id.
    */
   rebind(id: string): void;
-  /**
-   * The frame's have-list (RFC 11 §9.5): the server-minted digests of
-   * what this frame currently SHOWS — the root skeleton under `""`, each
-   * live hole and attr hole by ledger key, each revealed fragment by name.
-   * Kept at apply time, never derived from the DOM. `undefined` when the
-   * content's provenance carried no digests (a document-adopted interior
-   * with no seed, a re-materialized capture): a resume then takes the full
-   * snapshot.
-   */
-  have?(): Record<string, string> | undefined;
   /**
    * Push a staged response's slot args into the live occurrences they
    * address, ahead of the records' real apply (see `FrameHost.preview`).
@@ -287,8 +298,12 @@ export interface FrameHost {
    */
   landing(id: string): Promise<void> | undefined;
   serialize(value: unknown): { $ref: string };
-  /** See FrameHostOptions.revive. */
-  revive?(value: unknown): unknown;
+  /**
+   * See FrameHostOptions.revive. Assignable after creation: the frames
+   * client's traces tier installs the container-trace reviver on the
+   * shared host when its chunk loads (`@solidjs/web/frames/trace`).
+   */
+  revive?(value: unknown, claiming?: boolean): unknown;
 }
 
 /**
@@ -301,13 +316,17 @@ export interface FrameHostOptions {
    * Called at a `slot` chunk's write with the chunk's frame id and version
    * — the RESPONSE the record belongs to (data tables are response-scoped;
    * one response is one version of one id), so the integration answers from
-   * that response's table and never a later one's. `undefined` means the
-   * key has not been delivered: the host then hands the fill a pending read
-   * that the key's `data` chunk settles and the stream's `complete` or
-   * `error` rejects (frames-rulings 1.3; the L1 rule — a value that never
-   * comes is an error, not a silence). `current` is the version the id's
-   * store is at — every version below it is superseded, and an integration
-   * keeping a table per response may drop theirs.
+   * that response's table and never a later one's. Answers the key's value,
+   * or — for a key the response has not delivered yet — the table's own
+   * PENDING READ: a promise marked `s = 0`, carrying `c` (the callbacks run
+   * when it settles), that the key's `data` chunk settles (stamped `s`/`v`
+   * as it does) and `closeData` rejects (frames-rulings 1.3; the L1 rule —
+   * a value that never comes is an error, not a silence). The host counts
+   * a record's pending reads so a fresh mount waits for them
+   * (`record.pending`) and re-applies the record when the last settles.
+   * `current` is the version the id's store is at — every version below it
+   * is superseded, and an integration keeping a table per response may
+   * drop theirs.
    */
   resolve?(ref: { $ref: string }, frameId: string, version: number, current?: number): unknown;
   /** Test/host-side counterpart of `resolve`. */
@@ -318,11 +337,21 @@ export interface FrameHostOptions {
    * per response keys on `chunk.version` (see `resolve` for `current`).
    */
   applyData?(chunk: Extract<FrameChunk, { type: "data" }>, current?: number): void;
+  /**
+   * The response (one version of one id) has ended — its `complete`, or
+   * its `error` with no key — and a key it never delivered never comes:
+   * the integration closes that response's table so every pending read of
+   * it rejects (`table.close(error)`, with the response's error record when
+   * it ended by one). Called after the end chunk's own apply, so the frame
+   * has the response's last word first.
+   */
+  closeData?(frameId: string, version: number, error?: unknown): void;
   /**
    * A lazily-loaded deserializer's load, awaited by the transport before it
-   * delivers a `data` chunk — `applyData`/`resolve` can assume the codec is
-   * resident once data has arrived. Keeps codec weight out of the eager
-   * client graph for responses that never carry serialized data.
+   * delivers a `data` chunk or a `slot` chunk whose args carry a `{$ref}` —
+   * `applyData`/`resolve` can assume the codec is resident when a chunk
+   * that reads data arrives. Keeps codec weight out of the eager client
+   * graph for responses that never carry serialized data.
    */
   prepareData?(): Promise<unknown>;
   /**
@@ -332,8 +361,12 @@ export interface FrameHostOptions {
    * revived value as the markup was rendered from it. Document-face
    * container traces ride this way — inline in the record, revived by the
    * integration (`reviveContainerTraces`) into live local containers.
+   * `claiming` marks the args of an adopt-time mount — the occurrence is
+   * about to hydrate server markup rendered from these values (the
+   * materializer parks a trace's backlog beyond the snapshot the markup
+   * shows until hydration ends — frames-rulings 3.6 (iii)).
    */
-  revive?(value: unknown): unknown;
+  revive?(value: unknown, claiming?: boolean): unknown;
 }
 
 /**
@@ -364,21 +397,23 @@ export interface FrameOptions {
    */
   ownerScope?<T>(fn: () => T): T;
   /**
-   * Boundary-driven segment reveal. When present, `#revealSegment` hands the
-   * placeholder seam to this hook instead of swapping imperatively: the binding
-   * reconstructs a client `<Loading>` there — `fallback` is the placeholder's
-   * own template content (shown while holding), `content()` materializes the
-   * segment and renders its client fills INSIDE the boundary so their readiness
-   * gates the reveal — and inserts it before `before`. An unboundaried async
-   * fill suspends up to that boundary and is covered instead of orphaned; one
-   * boundary per revealed segment, i.e. per author-placed `<Loading>`. Omit it
-   * for the framework-agnostic imperative swap (no reactive reveal).
+   * Boundary-driven segment reveal. `#revealSegment` hands the placeholder
+   * seam to this hook: the binding reconstructs a client `<Loading>` there —
+   * `fallback` is the placeholder's own template content (shown while
+   * holding), `content()` materializes the segment and renders its client
+   * fills INSIDE the boundary so their readiness gates the reveal — and
+   * inserts it before `before`. An unboundaried async fill suspends up to
+   * that boundary and is covered instead of orphaned; one boundary per
+   * revealed segment, i.e. per author-placed `<Loading>`. Omitted, the
+   * default seam inserts `content()` before `before` at once and removes
+   * `before` (the framework-agnostic swap: no boundary, no reactive reveal).
    */
   reveal?(seam: { before: Node; fallback: Node[]; content: () => Node | DocumentFragment }): void;
   /**
    * Adopt path only. Called when a sync leaves an adopted occurrence
-   * waiting for its args record while none was before; returns the release,
-   * called when a sync leaves none waiting or the frame disposes. The
+   * waiting — for its args record, for a read of it to settle, or for the
+   * tier its mount needs to load — while none was before; returns the
+   * release, called when a sync leaves none waiting or the frame disposes. The
    * integration registers the hold with whatever counts its page as not
    * yet settled (hydration-done counts it as a pending boundary —
    * frames-rulings 3.1): a claim the frame has not made yet is page work
@@ -397,7 +432,8 @@ export interface FrameOptions {
  * replay, so application is prerequisite-driven and order-independent by
  * construction:
  *
- *   - root HTML apply into a boundary (element or comment-marker range)
+ *   - root HTML apply into a boundary ELEMENT (the frame's range is the
+ *     element's children — `createFrame` / `createFrameElement`)
  *   - version as a stale-guard only ("policy A": a newer version morphs in
  *     place; client slots/regions and their state survive — teardown is
  *     dispose(), never a version bump)
@@ -406,7 +442,9 @@ export interface FrameOptions {
  *     slot ranges and fragment placeholders
  *   - the slot model: direct-insert and render-function slots as one callback
  *     primitive, iteration by occurrence id, re-call on args change, slot
- *     resolution threaded down through nested frames
+ *     resolution threaded down through nested frames; the fill OWNS its
+ *     range (it places or binds its output before the range's end marker —
+ *     the frame discovers ranges and invokes, it never writes an interior)
  *
  * Adaptations from the spike:
  *   - Fragment placeholders use the document marker vocabulary emitted by
@@ -489,96 +527,81 @@ const slotEnd = id => `slot:${id}:end`;
 // element beside that element's attribute positions (`{ pos: "text", key,
 // start }`); the fill writes the one text node between the markers, and the
 // morph keeps a pair it meets again (see `reconcileChildren`).
-const SLOT_MARKER = "_s:";
-const SLOT_TEXT = SLOT_MARKER + "t=";
+//
+// Everything that READS a marker — the entry parser, the consumer
+// registration (`positions` / `text`), the owned-position arms of the
+// morph (`owned` / `apply`), the per-frame consumer set and rebinder
+// (`sync` / `rebinder` / `unmount`) and the fill's binding (`bind`) — is
+// the BIND TIER's (`@solidjs/web/frames/bind`, bind-tier.ts; frames savings
+// pass §3 row C6), reached through its resident stamp (`tierLoads.bind.r`).
+// The eager client keeps the constants, one test — whether a node carries
+// a marker at all (`hasSlotMarker`, `isTextStart`) — and the morph's
+// text-pair arm (a position's text survives a morph by not being
+// reconciled; see `reconcileChildren`). The sync's walk NOTES a marker met
+// while the tier is absent (`found.b`) and the frame holds on the note —
+// the tier's load started by the readiness check, the install's flush
+// re-walking with the tier in place.
+/** @internal (the bind tier's own copy — see bind-tier.ts) */
+export const SLOT_MARKER = "_s:";
+/** @internal (the bind tier's own copy — see bind-tier.ts) */
+export const SLOT_TEXT = SLOT_MARKER + "t=";
 const SLOT_TEXT_END = "/" + SLOT_MARKER + "t";
 
 const isTextStart = n => n.nodeType === COMMENT_NODE && n.data.startsWith(SLOT_TEXT);
 
-/**
- * One marker entry, `<occurrence>:<key>[=<name>]`, as `[occurrence,
- * { pos, key, name }]`, or null. Keys and names are percent-encoded on the
- * wire (they are client-controlled strings landing in a `,`/`:`/`=`-delimited
- * grammar) and decoded here.
- */
-function slotEntry(entry, pos) {
-  const colon = entry.indexOf(":");
-  if (colon < 1) return null;
-  const eq = entry.indexOf("=", colon);
-  return [
-    entry.slice(0, colon),
-    {
-      pos,
-      key: decodeURIComponent(eq === -1 ? entry.slice(colon + 1) : entry.slice(colon + 1, eq)),
-      name: eq === -1 ? undefined : decodeURIComponent(entry.slice(eq + 1))
-    }
-  ];
+/** Whether an element carries any `_s:*` marker (the detection alone; the
+ *  tier parses it). */
+function hasSlotMarker(el) {
+  const attrs = el.attributes;
+  for (let i = 0; i < attrs.length; i++) if (attrs[i].name.startsWith(SLOT_MARKER)) return true;
+  return false;
 }
 
 /**
- * Register a text start marker's position on its parent element's consumer
- * entry for the occurrence — the one its attribute markers opened, if any,
- * so an element is one consumer however its positions are spelled.
+ * Whether a slot arg value is an async value passed whole (a promise or an
+ * async iterable) — DR-2's value tier. The server never resolves these to
+ * dead values; the client suspends at the consumption read.
+ * @internal (the client entry's and the bind tier's — each its own copy)
  */
-function textPosition(start, elements) {
-  const parsed = slotEntry(start.data.slice(SLOT_TEXT.length), "text");
-  const consumers = parsed && consumersOf(elements, parsed[0]);
-  if (!consumers) return;
-  const element = start.parentNode;
-  let consumer;
-  for (let i = consumers.length; i-- && !consumer; )
-    if (consumers[i].element === element) consumer = consumers[i];
-  consumer || consumers.push((consumer = { element, positions: [] }));
-  parsed[1].start = start;
-  consumer.positions.push(parsed[1]);
-}
-
-/** An occurrence's consumer list, created on first use; null when a slot
- *  range claimed the id (the dev range check reports it). */
-function consumersOf(elements, occurrence) {
-  let consumers = elements.get(occurrence);
-  if (consumers === undefined) elements.set(occurrence, (consumers = []));
-  return Array.isArray(consumers) ? consumers : null;
+export function isAsyncValue(v: any): boolean {
+  return (
+    v !== null &&
+    typeof v === "object" &&
+    (typeof v.then === "function" || typeof v[Symbol.asyncIterator] === "function")
+  );
 }
 
 /**
- * Parse one element's `_s:*` markers into positions grouped by occurrence:
- * `{ [occurrence]: [{ pos, key, name }] }`, or null. `pos` is the marker's
- * position as written (`class`, `hidden`, `on:click`, `ref`), `name` the
- * class name / style property for a member position.
+ * A value's shape, as the binding-slot shape findings name it.
+ * @internal (dev only; the client entry's and the bind tier's)
  */
-function slotPositions(el) {
-  const attrs = el.attributes;
-  let out = null;
-  for (let i = 0; i < attrs.length; i++) {
-    const attr = attrs[i];
-    if (!attr.name.startsWith(SLOT_MARKER)) continue;
-    const pos = attr.name.slice(SLOT_MARKER.length);
-    for (const entry of attr.value.split(",")) {
-      const parsed = slotEntry(entry, pos);
-      if (!parsed) continue;
-      out || (out = Object.create(null));
-      (out[parsed[0]] || (out[parsed[0]] = [])).push(parsed[1]);
-    }
-  }
-  return out;
+export function shapeOf(v: unknown): string {
+  return v === null
+    ? "null"
+    : typeof Node === "function" && v instanceof Node
+      ? "a DOM node"
+      : Array.isArray(v)
+        ? "an array"
+        : isAsyncValue(v)
+          ? "an async value"
+          : typeof v;
 }
 
-/** Whether a data occurrence's consumer set changed (elements or positions). */
-function consumersEqual(a, b) {
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    const x = a[i];
-    const y = b[i];
-    if (x.element !== y.element || x.positions.length !== y.positions.length) return false;
-    for (let j = 0; j < x.positions.length; j++) {
-      const p = x.positions[j];
-      const q = y.positions[j];
-      if (p.pos !== q.pos || p.key !== q.key || p.name !== q.name || p.start !== q.start)
-        return false;
-    }
-  }
-  return true;
+/**
+ * Dev finding (`BINDING_SLOT_POSITION`): the client side of a binding slot
+ * has the wrong shape — the fill's return is not an object or the prop is
+ * not a function (`fill-shape`), or a text position's value is not a
+ * primitive (`text-shape`). Through the diagnostics channel, so an
+ * observer captures it beside the server's findings.
+ * @internal (dev only; the client entry's and the bind tier's)
+ */
+export function slotShapeFinding(data: Record<string, string>, message: string) {
+  DEV!.report(
+    OBSERVE!.diagnostics.emit(
+      { code: "BINDING_SLOT_POSITION", kind: "render", severity: "warn", message, data },
+      null
+    )
+  );
 } /**
  * Maps a wire chunk onto resident-store record writes. `data` chunks map to
  * no records — they are response-scoped and the host applies them through
@@ -687,19 +710,22 @@ export function createFrameHost(options?: FrameHostOptions): FrameHost;
  *
  * @param {{
  *   serialize?: (value: unknown) => { $ref: string },
- *   resolve?: (ref: { $ref: string }, frameId: string, version: number) => unknown,
- *   applyData?: (chunk: object) => void,
+ *   resolve?: (ref: { $ref: string }, frameId: string, version: number, current?: number) => unknown,
+ *   applyData?: (chunk: object, current?: number) => void,
+ *   closeData?: (frameId: string, version: number, error?: unknown) => void,
  *   prepareData?: () => Promise<unknown>,
- *   revive?: (value: unknown) => unknown
+ *   revive?: (value: unknown, claiming?: boolean) => unknown
  * }} [options]
- *   `serialize`/`resolve` back slot data refs (response-scoped table);
+ *   `serialize`/`resolve` back slot data refs (response-scoped table — a
+ *   key not delivered yet answers with the table's pending read);
  *   `applyData` receives each `data` chunk whole — keyed codec records
  *   ({ key, node, initial }, apply via createJSONDataTable) or eval-style
- *   `payload` scripts, depending on the producer's serializer. A host whose
- *   deserializer loads lazily exposes the load as `prepareData`: the
- *   transport awaits it before delivering a `data` chunk, so `applyData`
- *   can assume the codec is resident once data has arrived (a `resolve`
- *   ahead of it answers `undefined`, and the host waits — see below).
+ *   `payload` scripts, depending on the producer's serializer; `closeData`
+ *   is told a response ended, so its table rejects what it never
+ *   delivered. A host whose deserializer loads lazily exposes the load as
+ *   `prepareData`: the transport awaits it before delivering a chunk that
+ *   reads data (a `data` chunk, a `slot` chunk carrying a `{$ref}`), so
+ *   `applyData` / `resolve` can assume the codec is resident.
  */
 export function createFrameHost(options = {}) {
   // One logical stream may feed several mounted boundaries (the same server
@@ -744,20 +770,24 @@ export function createFrameHost(options = {}) {
   // for the chunk's response (`options.resolve(ref, id, version)`), so the
   // record the store holds — and every mount reads — carries values, never
   // refs, and a later response's data can answer none of them. A key the
-  // response has not delivered yet resolves to a pending read (`waits`,
-  // per store) stamped like a serialized promise once it settles (`s`/`v`,
-  // the marks a fill's prop read adopts synchronously): its `data` chunk
-  // settles it, the stream's `complete` or `error` rejects it (L1 — a value
-  // that never comes surfaces where it is read, instead of leaving the
-  // record silently unapplied), and a bump drops the superseded response's
-  // waits unanswered (their readers re-derive from the new response's
-  // record; nothing is left to tell). A record counts its unsettled reads
-  // (`pending`): a mounted occurrence takes the read as it is — its prop
-  // pends and holds the value it shows (A17) — while a FRESH mount waits for
-  // the record to settle (the frame's `#syncSlots`), so the frame's shell
-  // shows at its landing with the range as the server left it, and the
-  // mount's covering boundary pends on the landing alone (A0, corollary 4);
-  // the settle re-applies the record and the mount runs with values.
+  // response has not delivered yet resolves to the TABLE's pending read — a
+  // promise the table owns (marked `s = 0`; the key lives there, so the
+  // wait does too), stamped like a serialized promise once it settles
+  // (`s`/`v`, the marks a fill's prop read adopts synchronously): the key's
+  // `data` chunk settles it through the table's own `apply`, and the
+  // response's end closes the table (`closeData`) so every read it never
+  // answered rejects (L1 — a value that never comes surfaces where it is
+  // read, instead of leaving the record silently unapplied); a bump drops
+  // the superseded response's table with its reads unanswered (their
+  // readers re-derive from the new response's record; nothing is left to
+  // tell). What the host keeps is the COUNT: a record counts its unsettled
+  // reads (`pending`) — a mounted occurrence takes the read as it is (its
+  // prop pends and holds the value it shows, A17), while a FRESH mount
+  // waits for the record to settle (the frame's `#syncSlots`), so the
+  // frame's shell shows at its landing with the range as the server left
+  // it, and the mount's covering boundary pends on the landing alone (A0,
+  // corollary 4); the last read to settle re-applies the record and the
+  // mount runs with values.
   const stores = new Map();
   const storeFor = id => {
     let store = stores.get(id);
@@ -768,6 +798,11 @@ export function createFrameHost(options = {}) {
   // while the address's first response is in flight, with its resolver.
   const landings = new Map();
   const lands = records => "" in records || ":error" in records || ":complete" in records;
+  // One write's fan-out: every frame mounted under the id applies it.
+  const applyTo = (id, version, r) => {
+    const set = frames.get(id);
+    if (set) for (const frame of set) frame.apply({ version, r });
+  };
   // Mirrors FrameImpl.apply's version policy (policy A): stale writes drop,
   // a newer version replaces the records wholesale, the same version
   // accumulates.
@@ -776,7 +811,6 @@ export function createFrameHost(options = {}) {
     if (store.version === undefined || version > store.version) {
       store.version = version;
       store.records = {};
-      store.waits = undefined;
     }
     // Root assets reuse one key for the shell and late chunks. Accumulate
     // their arrays so frames registered later receive the full snapshot.
@@ -794,66 +828,53 @@ export function createFrameHost(options = {}) {
     }
     return true;
   };
-  /** The pending read for an undelivered key of a response (its version),
-   *  on behalf of `record` (stored under `recordKey`). Keyed by version and
-   *  key: ids restart per response, and a staged refetch's preview resolves
-   *  through the shown response's store. */
-  const pendingRef = (store, version, key, recordKey, record) => {
-    const waits = (store.waits ??= new Map());
-    key = version + "\0" + key;
-    let w = waits.get(key);
-    if (!w) {
-      waits.set(key, (w = { records: [] }));
-      w.p = new Promise((r, j) => ((w.r = r), (w.j = j)));
-      // Owned here: a read nobody makes (the occurrence never mounted) must
-      // not surface the rejection as unhandled; a fill's read attaches its
-      // own handlers.
-      w.p.then(undefined, () => {});
-    }
-    w.records.push(recordKey, record);
-    record.pending = (record.pending || 0) + 1;
-    return w.p;
-  };
-  /** Settle a wait (`s` 1 fulfilled / 2 rejected, as the hydration
-   *  serializer stamps a promise) and re-apply every record it was the last
-   *  unsettled read of, so a mount that waited runs with values. */
-  const settleWait = (id, store, w, s, value) => {
-    w.p.s = s;
-    w.p.v = value;
-    s === 1 ? w.r(value) : w.j(value);
-    const set = frames.get(id);
-    for (let i = 0; i < w.records.length; i += 2) {
-      const record = w.records[i + 1];
-      if (--record.pending || !set) continue;
-      for (const frame of set)
-        frame.apply({ version: store.version, r: { [w.records[i]]: record } });
-    }
-  };
   /**
    * Settle the record's `{$ref}` args into client values through the
-   * response's table (or a pending read). The record notes what it found
-   * so the frames never probe a value again (a decoded value may be a live
-   * container, whose property reads throw not-ready while pending):
-   * `decoded` names the args that came through the table — the frame
-   * passes those through untouched — and `regions` the `{$frame}` args
-   * (arg name -> the region's wire id), which are addressing, not data. A
-   * literal stays as written: it is revived at the mount (`revive`), where
-   * a claim can read it as the markup was rendered from it.
+   * response's table (or its pending read for a key not delivered yet).
+   * The record notes what it found so the frames never probe a value again
+   * (a decoded value may be a live container, whose property reads throw
+   * not-ready while pending): `decoded` names the args that came through
+   * the table — the frame passes those through untouched — and `regions`
+   * the `{$frame}` args (arg name -> the region's wire id), which are
+   * addressing, not data. A literal stays as written: it is revived at the
+   * mount (`revive`), where a claim can read it as the markup was rendered
+   * from it.
+   *
+   * A pending read (the table's promise, marked `s = 0` — a delivered value
+   * that is itself a promise, an async arg passed whole, carries no mark
+   * and is taken as the value it is) is counted on the record (`pending`),
+   * and the last of them to settle — the key delivered, or the response
+   * closed — re-applies the record to the frames (`settle`, pushed on the
+   * read's `c` and run by the table in the `apply` / `close` that settles
+   * it — not the promise's `then`, which a delivered promise value would
+   * defer to ITS settle), so a fresh mount that waited for it runs with
+   * values (or throws the rejection where it reads, L1). Re-applied only
+   * if the record is still the one the store holds: a bump replaced it
+   * (the read belongs to a superseded response), a re-sent record under
+   * the same version superseded it, or it was a staged refetch's PREVIEW
+   * (never the store's — the commit's own write re-settles it).
    */
   const settleArgs = (store, recordKey, record, chunk) => {
     const args = record.args;
     const out = {};
     let regions, decoded;
+    const settle = () => {
+      if (!--record.pending && store.records[recordKey] === record)
+        applyTo(chunk.id, store.version, { [recordKey]: record });
+    };
     for (const key in args) {
       const value = args[key];
       if (value && typeof value.$ref === "string") {
-        const resolved =
-          options.resolve && options.resolve(value, chunk.id, chunk.version, store.version);
-        out[key] =
-          resolved === undefined
-            ? pendingRef(store, chunk.version, value.$ref, recordKey, record)
-            : resolved;
+        const resolved = (out[key] =
+          options.resolve && options.resolve(value, chunk.id, chunk.version, store.version));
         (decoded ??= {})[key] = true;
+        // `instanceof` before the mark: a decoded value may be a live
+        // container, whose property reads throw not-ready while pending —
+        // `instanceof` is a prototype walk, no property read.
+        if (resolved instanceof Promise && resolved.s === 0) {
+          record.pending = (record.pending || 0) + 1;
+          resolved.c.push(settle);
+        }
       } else {
         if (value && typeof value.$frame === "string") (regions ??= {})[key] = value.$frame;
         out[key] = value;
@@ -927,7 +948,8 @@ export function createFrameHost(options = {}) {
       // now the current response's (the transport restamps every chunk
       // with its response's version; the integration rotates the table at
       // the header and creates it at first use, so the first use must be
-      // the current response's).
+      // the current response's). A record waiting on the chunk's key is
+      // answered by the table's own apply (see `settleArgs`).
       if (chunk.type === "data") {
         const store = stores.get(chunk.id);
         const current = store && store.version;
@@ -935,15 +957,6 @@ export function createFrameHost(options = {}) {
         // with none, guards nothing.)
         if (store && chunk.version < current) return;
         options.applyData && options.applyData(chunk, current);
-        // The key a record of this response is waiting on: answered now,
-        // from the table the chunk just landed in.
-        const key = chunk.version + "\0" + chunk.key;
-        const w = chunk.initial && store && store.waits && store.waits.get(key);
-        if (w) {
-          store.waits.delete(key);
-          const value = options.resolve({ $ref: chunk.key }, chunk.id, chunk.version, current);
-          settleWait(chunk.id, store, w, 1, value);
-        }
         return;
       }
       // Write through to the resident store first: the store version-guards
@@ -996,21 +1009,14 @@ export function createFrameHost(options = {}) {
           ":error" in records ? landed.j(records[":error"]) : landed.r();
         }
       }
-      const set = frames.get(chunk.id);
-      if (set) {
-        for (const frame of set) frame.apply({ version: chunk.version, r });
-      }
+      applyTo(chunk.id, chunk.version, r);
       // The response's end: a key it never delivered never comes, and every
-      // read waiting on one fails where it is read (L1) — a mount that
-      // waited for the record runs now and its read throws. After the end
-      // chunk's own apply, so the frame has the response's last word first.
-      if (store.waits && (":complete" in records || ":error" in records)) {
-        const error =
-          records[":error"] || new Error("Frame stream ended without delivering a {$ref}.");
-        const waits = store.waits;
-        store.waits = undefined;
-        for (const w of waits.values()) settleWait(chunk.id, store, w, 2, error);
-      }
+      // read waiting on one fails where it is read (L1) — the integration
+      // closes the response's table, a mount that waited for the record
+      // runs and its read throws. After the end chunk's own apply, so the
+      // frame has the response's last word first.
+      if (":complete" in records || ":error" in records)
+        options.closeData && options.closeData(chunk.id, chunk.version, records[":error"]);
     },
     landing(id) {
       const store = stores.get(id);
@@ -1035,10 +1041,10 @@ export function createFrameHost(options = {}) {
       if (!set) return;
       const records = chunkToRecords(chunk);
       const key = `slot:${chunk.key}`;
-      // Through the STAGED response's table (its version's), with the
-      // shown response's store as the wait's home — the version in the
-      // key tells them apart; a wait a bump drops is re-minted by the
-      // committed write's own settle.
+      // Through the STAGED response's table (its version's): a key it has
+      // not delivered is that table's pending read — never the shown
+      // response's — and this record is never the store's, so its settle
+      // re-applies nothing; the committed write's own settle does.
       settleArgs(storeFor(chunk.id), key, records[key], chunk);
       for (const frame of set) frame.preview && frame.preview(records);
     },
@@ -1067,16 +1073,149 @@ export function createFrameHost(options = {}) {
  */
 export const FRAME_APPLIED_EVENT = "frame:applied";
 
+// === Tiers (frames savings pass §2: the server-announced tier mechanism) ===
+//
+// A TIER is a named slice of the frames client's capability that may live
+// in its own chunk and load on demand: `bind` (binding-slot positions),
+// `regions` (nested server-content regions), `assets`, `trace` (container
+// traces), `wire` (the live loop). The server knows at render time which
+// of them a response or a document needs — it mints the feature — and
+// ANNOUNCES the names (`X-Frame-Tiers` on a stream, `_$HY.r["sc:tiers"]`
+// plus `modulepreload` links on a document, `chunk.tiers` in-band), so the
+// client starts the import in parallel with the content instead of at the
+// first use. The announcement is a warm start, never a dependency: a
+// readiness check that finds a tier absent starts the load itself and
+// holds, so an un-announced response converges to the same DOM.
+//
+// `tierLoaders` is the seam a tier plugs into: `name -> () => import(...)`,
+// the module whose exports are the tier's APPLIERS — the functions this
+// runtime dispatches to once the module is resident (off the load's `r`
+// stamp, see `tierLoads`) — and whose optional `install()` writes whatever
+// state lives elsewhere (the traces tier sets the shared host's `revive`
+// and the plugin's materializer). The built-in table (the frames client
+// entry, client.ts) carries the tiers that have been cut — `trace`, the
+// container tier's client half (plan step C3); `regions`, nested
+// server-content regions (C4); `assets`, the head mirror and the
+// stylesheet gate (C5); `bind`, binding-slot positions (C6) — and
+// `installServerComponents({ tiers })` adds or replaces entries; a name
+// with no loader is eager and resident by definition (`wire` today).
+/**
+ * A frames-client tier's module, as its loader resolves it: its exports are
+ * the tier's appliers — the functions the runtime dispatches to once the
+ * module is resident (the regions tier's `resolve` / `bind` / …, the assets
+ * tier's `gate` / `apply`) — and the optional `install()` runs once at the
+ * load, for state that lives outside the runtime's dispatch (the traces
+ * tier sets the shared host's `revive`). The index signature is what lets a
+ * module with no `install` — a module whose exports are all appliers — be
+ * one (TypeScript's weak-type rule would otherwise reject it).
+ * @experimental
+ */
+export interface TierModule {
+  install?(): void;
+  [applier: string]: unknown;
+}
+export const tierLoaders: Record<string, () => Promise<TierModule>> = {};
+// `name -> the load`, a promise stamped `r` with the MODULE once it has
+// installed (truthy = resident): the dispatch table. A frame reaches a
+// tier's appliers through the stamp — `tierLoads.regions?.r.bind(...)`,
+// `tierReady("assets").gate(...)` — with no registration step; absent until
+// the load installs, so every read is conditional on residency — and the
+// readiness checks (`tierReady`) guarantee a record that NEEDS a tier never
+// reaches an applier before it is here. One per name for the page's
+// lifetime: tiers never uninstall. Exported for the tier specs alone (a
+// test re-arms a tier's hold by deleting its load; the dist's entry never
+// re-exports it).
+/** @internal */
+export const tierLoads: Record<string, Promise<void> & { r?: any }> = {};
+// Every live frame, so an install can wake them all: a frame whose sync
+// held an occurrence on the tier re-syncs and mounts it; the rest see a
+// no-op flush.
+const liveFrames = new Set();
+
+/**
+ * Start (or join) a tier's load. Idempotent per name; a name with no loader
+ * is resident already and resolves at once. Resolves once the module has
+ * installed and every live frame has been flushed.
+ * @internal The frames client's own seam (the announcement reads call it).
+ */
+export function prepareTier(name: string): Promise<void> & { r?: any };
+
+export function prepareTier(name) {
+  let load = tierLoads[name];
+  if (!load) {
+    const loader = tierLoaders[name];
+    tierLoads[name] = load = loader
+      ? loader().then(module => {
+          // The install: the module is the resident stamp (its exports are
+          // the tier's appliers — the dispatch for a tier that has them), its
+          // `install` hook writes any state that lives elsewhere, then one
+          // flush per live frame — the write is empty, so a frame re-walks
+          // what it holds and applies what the tier now makes applicable
+          // (the held occurrence mounts and its hold releases; a buffered
+          // record applies; a style-gated segment's sheets are requested). A
+          // frame with no version yet keeps none.
+          load.r = module;
+          module.install?.();
+          for (const frame of liveFrames) frame.apply({ version: frame.version, r: {} });
+        })
+      : Promise.resolve();
+  }
+  return load;
+}
+
+/**
+ * Whether a tier's code is resident — eager (no loader: `true`), or
+ * installed (its module). A tier that is neither has its load started here
+ * (the un-announced fallback: detection at the readiness check), and the
+ * caller holds. A tier dispatched off the stamp (`assets`) needs its loader
+ * wired — the client entry does; a spec driving this module directly wires
+ * and warms it (see frames-assets-client.spec).
+ */
+const tierReady = name => !tierLoaders[name] || prepareTier(name).r;
+
+// The regions tier's reason to wait (frames savings pass §1, "regions"; §3
+// row C4): a record naming a `{$frame}` region — the host noted the args
+// that are addressing (`record.regions`, see `settleArgs`) — while the
+// tier that resolves it to a region element and binds a frame over it is
+// absent. One test, on the note the host already made (no arg walk). A
+// fresh mount waits in the held set (adopt path: the hold registers under
+// frames-rulings 3.1, the server interior stays on screen); a MOUNTED
+// occurrence's new record stays pending in the store — the live binding
+// keeps showing the previous args — until the install's flush re-syncs.
+// Either way the check starts the load (`tierReady`): the un-announced
+// fallback.
+const needsRegions = record => record.regions && !tierReady("regions");
+
+// The traces tier's reason to hold (frames savings pass §1, "traces"): a
+// container-trace marker — `{ $tr, $ta }`, the eval face's literal for a
+// trace (frame-container-plugin.js) — somewhere in a record's args while
+// the tier that materializes it is absent. The marker can sit at any depth
+// of an argument (`{ filters: { user: proj } }` is one arg), so the test is
+// a walk; it runs ONLY while the tier is not resident — once it is, a
+// decoded arg may already be a live container, whose property traps throw
+// not-ready on a pending one, and nothing can be a marker any more (the
+// codec materializes at decode, the revive walk at the mount). Before the
+// tier is resident no live container can exist (only the tier's install
+// makes one), so the walk is trap-safe. A record whose literal args carry
+// a marker found while the tier is absent starts the load (`tierReady`)
+// and holds the occurrence: its server interior stays on screen, the
+// frame's hold registers (3.1), the install's flush mounts it.
+const carriesTrace = value =>
+  value != null &&
+  typeof value === "object" &&
+  (value.$tr != null || Object.values(value).some(carriesTrace));
+const needsTrace = args => !tierLoads.trace?.r && carriesTrace(args) && !tierReady("trace");
+
 class FrameImpl {
-  // A frame renders either into an element (element boundary: #start/#end
-  // null) or between two comment markers within some parent (range boundary).
-  // The parent of a range boundary is derived live from the start marker, so
-  // the range can be moved (e.g. re-placed by a client re-call) without
-  // rebinding.
+  // A frame renders INTO an element: the boundary / region element is the
+  // range (its children are the content), so it moves with the element and
+  // needs no markers of its own.
   #element;
-  #start;
-  #end;
   #options;
+  // The frame this one is a region OF (`options.parent`, set by the regions
+  // tier at bind): slot callbacks, records and record removal thread up
+  // this link (`#resolveSlot` …). (`#parent` is the DOM parent, below.)
+  #outer;
   #version;
   #store = Object.create(null);
   // The applied state is keyed by RECORD identity (frames-rulings 2.1,
@@ -1097,35 +1236,38 @@ class FrameImpl {
   // to say (frames-rulings 2.4: its placeholder is gone once it swapped),
   // so no second ledger of revealed names exists beside this.
   #appliedHoles = new Map();
-  // The have-list (RFC 11 §9.5): what this mount currently shows, by the
-  // server's own digests. Reset by a root apply (the root IS the content;
-  // its `holes` seed the entries inside), extended by each reveal, kept
-  // current by each hole/attr apply. Applied-state, so it tracks the DOM
-  // without reading it — a fragment received but not yet revealed is not
-  // in it, and a resume whose connection dies in between still asks for
-  // the reveal. `undefined` until a digest-carrying root applies.
-  #have;
+  // The have-list (RFC 11 §9.5) — what this mount currently shows, by the
+  // server's own digests — is the live wire tier's ledger (wire-tier.ts,
+  // `have` / `haveOf`): this frame hands it every applied content record
+  // through `#recordHave` and keeps nothing itself.
   #slots;
   #mountedSlots = new Set();
   #slotCleanups = new Map();
   #slotArgs = new Map();
   #slotUpdaters = new Map();
-  #slotRegions = new Map();
-  #slotNodes = new Map();
-  // Data occurrences (§9.2.3): the consumer set last handed to the mount,
-  // and the mount's rebind callback (`ctx.onRebind`) for when it changes.
-  #slotConsumers = new Map();
-  #slotRebinders = new Map();
-  #processedAssets = new WeakSet();
+  // No region state here: a frame's nested server-content regions — the
+  // `{$frame}` args' elements and the frames bound over them — are the
+  // REGIONS TIER's (`@solidjs/web/frames/regions`, plan C4), kept by that
+  // module per frame and reached through its resident stamp
+  // (`tierLoads.regions.r`).
+  // Nor data-occurrence state (§9.2.3): the consumer set last handed to a
+  // mount and the mount's rebind callback (`ctx.onRebind`) are the BIND
+  // TIER's (`@solidjs/web/frames/bind`, plan C6), kept by that module per
+  // frame (`sync` / `rebinder` / `unmount` off `tierLoads.bind.r`).
+  // Nor the mounts' output: the fill owns its range (it places or binds
+  // before the end marker through `ctx.range`), and nothing reads the
+  // nodes back — "mounted" is `#mountedSlots`, not a check on them.
   // The release of the frame's hold with the integration while a sync
   // leaves an occurrence waiting to mount (see #syncSlots' end).
   #hold;
+  // Adopt path: the record an unmounted occurrence was first HELD with (for
+  // its tier, for its record's reads — see #syncSlots). The adopted range's
+  // server interior was rendered from that record; should the store move on
+  // while it waits (a refetch, a rebind), the mount still claims with it
+  // and the current record applies as the args change it is
+  // (frames-rulings 3.6: a claim reads what the markup was rendered from).
+  #heldRecords = new Map();
   #disposed = false;
-  // Stable identity so a pending stylesheet holds at most one waiter per
-  // frame across repeated readiness checks.
-  #styleFlush = () => {
-    if (!this.#disposed) this.#flush();
-  };
 
   // Element-claim sweep for one materialized/morph-touched subtree, run
   // under `ownerScope` when the creator provided one — claim consumers
@@ -1147,12 +1289,13 @@ class FrameImpl {
     return scope ? scope(fn) : fn();
   }
 
-  constructor(element, start, end, options = {}) {
+  constructor(element, options = {}) {
     this.#element = element;
-    this.#start = start;
-    this.#end = end;
     this.#options = options;
     this.#slots = options.slots;
+    this.#outer = options.parent;
+    // Enumerable for a tier's install (see `prepareTier`), until disposal.
+    liveFrames.add(this);
     // Adopt: the boundary already holds server-rendered content, so the first
     // root apply morphs against it rather than materializing from scratch.
     // That content never ran compiled creation code, so sweep its claimable
@@ -1177,15 +1320,10 @@ class FrameImpl {
     if (options.adopt && this.#version === undefined) this.#syncSlots();
   }
 
-  /** The node content lives in (element itself, or the range markers' parent). */
-  #parent() {
-    return this.#element ?? this.#start.parentNode;
-  }
-
   /** Server content landed: caller hook + the bubbling document notification. */
   #applied(version, reason) {
     this.#options.onApply?.({ version, reason });
-    const parent = this.#parent();
+    const parent = this.#element;
     // Construct from the element's own realm — a cross-realm CustomEvent
     // (e.g. Node's global against a JSDOM document) is rejected by dispatch.
     const Ev = parent && (parent.ownerDocument || parent).defaultView?.CustomEvent;
@@ -1199,11 +1337,6 @@ class FrameImpl {
     }
   }
 
-  /** First content node (or `#end`/null when empty). */
-  #firstContent() {
-    return this.#start ? this.#start.nextSibling : this.#parent().firstChild;
-  }
-
   get version() {
     return this.#version;
   }
@@ -1278,43 +1411,37 @@ class FrameImpl {
   preview(records, inherited?) {
     const adopted = new Set<string>();
     if (this.#disposed) return adopted;
+    const R = tierLoads.regions?.r;
     for (const key in records) {
       const record = records[key];
       if (!record || record.kind !== "slot" || !key.startsWith("slot:")) continue;
       if (inherited && key in this.#store) continue;
       const occurrence = key.slice(5);
       const update = this.#mountedSlots.has(occurrence) && this.#slotUpdaters.get(occurrence);
-      if (!update || this.#regionsChange(occurrence, record)) continue;
+      // A record that adds a region to the occurrence or renames one of its
+      // regions is not previewed (its chunks ride the new name, so the
+      // rename lands with them at the commit) — the regions tier reads its
+      // cache for that; with the tier absent no region can exist yet, so
+      // any region the record names is an addition.
+      if (!update || (R ? R.changed(this, occurrence, record) : record.regions)) continue;
       this.#slotArgs.set(occurrence, record);
       adopted.add(key);
       update(this.#resolveArgs(occurrence, record));
     }
-    for (const regions of this.#slotRegions.values())
-      for (const entry of regions.values())
-        if (entry.frame) for (const key of entry.frame.preview(records, true)) adopted.add(key);
+    if (R)
+      for (const frame of R.frames(this))
+        for (const key of frame.preview(records, true)) adopted.add(key);
     if (!inherited) for (const key of adopted) this.#store[key] = records[key];
     return adopted;
   }
 
-  /** Whether the record adds a region to the occurrence or renames one of
-   *  its regions (its chunks ride the new name, so the rename lands with
-   *  them). Read off the host's note of the record's `{$frame}` args. */
-  #regionsChange(occurrence, record) {
-    const regions = this.#slotRegions.get(occurrence);
-    for (const key in record.regions) {
-      const entry = regions && regions.get(key);
-      if (!(entry && entry.childId === record.regions[key])) return true;
-    }
-    return false;
-  }
-
   /**
    * The applied state is one version's (frames-rulings 2.1): the version
    * bump and the rebind replace it wholesale — the store (every record of
    * the previous response), the root the morph applied (so a byte-identical
    * root under the new version applies as the new version's — 2.2), the
    * error it notified, the applied map (segments revealed, fallbacks shown,
-   * holes), the assets. Nothing applied under the previous version is
+   * holes, asset records). Nothing applied under the previous version is
    * consulted under the next; the DOM keeps showing what it showed until
    * the new version's writes morph it.
    */
@@ -1322,7 +1449,6 @@ class FrameImpl {
     this.#store = Object.create(null);
     this.#appliedRoot = this.#appliedError = undefined;
     this.#appliedHoles.clear();
-    this.#processedAssets = new WeakSet();
   }
 
   #flush() {
@@ -1335,7 +1461,7 @@ class FrameImpl {
       this.#applyRoot(root.value);
       this.#appliedRoot = root;
       // The root resets the ledger: everything shown is now this root.
-      this.#have = root.digest === undefined ? undefined : { "": root.digest, ...root.holes };
+      this.#recordHave("", root);
       this.#applied(version, reason);
     }
 
@@ -1350,6 +1476,26 @@ class FrameImpl {
       this.#applied(version, "error");
     }
 
+    // Asset records (`seg:<k>:assets`, the root's `seg::assets`): module
+    // and typed preloads, inline styles — through the ASSETS TIER
+    // (`@solidjs/web/frames/assets`, plan step C5), once per record identity
+    // per mount (the applied map — root asset records reuse one key, so the
+    // record is the unit; a fresh mount seeding from a warm store replays
+    // them). Before the segments, so a segment's inline styles precede its
+    // content in the head as the document face orders them. Stylesheets
+    // are the reveal gate's (#segmentReady), never applied here. A record
+    // met while the tier is absent starts its load (`tierReady`) and stays
+    // pending — the install's flush applies it; the walk stops there (the
+    // rest wait on the same load).
+    for (const key in this.#store) {
+      const record = this.#store[key];
+      if (!key.endsWith(":assets") || !record || this.#appliedHoles.get(key) === record) continue;
+      const tier = tierReady("assets");
+      if (!tier) break;
+      this.#appliedHoles.set(key, record);
+      tier.apply(record);
+    }
+
     // Segments: every content record the store holds whose placeholder is
     // in the frame's range reveals; a revealed segment's own range is
     // applied as it is revealed (nested segments included — see
@@ -1394,28 +1540,20 @@ class FrameImpl {
     }
     if (morphed) this.#applied(version, "morph");
 
-    // Root asset records reuse a store key, so consume them by identity.
-    // Styles remain owned by the reveal gate.
-    for (const key in this.#store) {
-      const record = this.#store[key];
-      if (!key.endsWith(":assets") || !record || this.#processedAssets.has(record)) {
-        continue;
-      }
-      this.#processedAssets.add(record);
-      if (record.modules) {
-        for (const href of record.modules) ensureModulePreload(href);
-      }
-      if (record.preloads) {
-        for (const entry of record.preloads) ensurePreload(entry);
-      }
-    }
-
     this.#syncSlots();
   }
 
-  /** Resolve a slot callback by prop: this frame's slots, then ancestors'. */
+  /**
+   * Resolve a slot callback by prop: this frame's slots, then ancestors'.
+   * A nested region frame carries its parent (`options.parent`, set by the
+   * regions tier when it binds the region — frame-internal, not a public
+   * option), and the three thread-ups below walk that link: private
+   * access across instances of this class, so the chain costs no closure
+   * per region. (`#outer && #outer.#x()`, not `parent?.#x()` — TypeScript
+   * rejects a private name in an optional chain, TS18030.)
+   */
   #resolveSlot(prop) {
-    return this.#slots?.[prop] ?? this.#options.resolveSlot?.(prop);
+    return this.#slots?.[prop] ?? (this.#outer && this.#outer.#resolveSlot(prop));
   }
 
   /**
@@ -1428,7 +1566,7 @@ class FrameImpl {
   #resolveSlotRecord(occurrence) {
     const record = this.#store[`slot:${occurrence}`];
     if (record !== undefined) return record;
-    return this.#options.resolveSlotRecord?.(occurrence);
+    return this.#outer && this.#outer.#resolveSlotRecord(occurrence);
   }
 
   /**
@@ -1450,7 +1588,7 @@ class FrameImpl {
     const key = `slot:${occurrence}`;
     if (key in this.#store) {
       if (!this.#mountedSlots.has(occurrence)) delete this.#store[key];
-    } else this.#options.removeSlotRecord?.(occurrence);
+    } else this.#outer && this.#outer.#removeSlotRecord(occurrence);
   }
 
   // `root`, when given, scopes discovery to a detached fragment instead of the
@@ -1460,7 +1598,7 @@ class FrameImpl {
   // skipped by the next full sync; the unmount sweep is full-frame-only (a
   // scoped fill only ADDS occurrences, never removes the frame's others).
   #syncSlots(root) {
-    if (!this.#slots && !this.#options.resolveSlot) return;
+    if (!this.#slots && !this.#outer) return;
 
     // Range-driven discovery: find every server-owned slot occurrence in this
     // frame's content. An occurrence id is the marker key (e.g. "children" or
@@ -1473,13 +1611,21 @@ class FrameImpl {
     // loop below treats them as occurrences whose mount binds those
     // positions rather than filling a range (no interior, no regions, never
     // replaced), and whose consumer set may change without a re-call.
-    const found = new Map();
+    const found: Map<any, any> & { b?: boolean } = new Map();
     if (root) collectSlots(root.firstChild, null, found, found);
     else this.#collectSlots(found, found);
     // Whether this sync leaves an occurrence WAITING to mount — for its
     // record, for a `{$ref}`'s data: a claim the frame owes the page and has
     // not made yet (see the hold at the end).
     let waiting = false;
+    // The regions and bind tiers' appliers, if resident (an install cannot
+    // land mid-sync: it is a load's continuation). Absent, nothing in this
+    // sync can need them — a record naming a region waits (`needsRegions`);
+    // a marker met with the bind tier absent is a NOTE on the found map
+    // (`found.b`, no consumer entry — see `collectSlots`) and the sync
+    // holds on it below, so `B` is resident wherever `consumers` exist.
+    const R = tierLoads.regions?.r;
+    const B = tierLoads.bind?.r;
 
     for (const [occurrence, start] of found) {
       const callback = this.#resolveSlot(propOf(occurrence));
@@ -1493,22 +1639,11 @@ class FrameImpl {
         continue;
       }
       const record = this.#resolveSlotRecord(occurrence);
-      // A mount whose output the morph destroyed (its range was recreated
-      // inside a different server parent — ranges only relocate among
-      // siblings) is a zombie: remount fresh so content stays correct, even
-      // though state can't survive a destroyed node.
-      const prev = this.#slotNodes.get(occurrence);
-      const prevFirst = Array.isArray(prev) ? prev[0] : prev;
-      let mounted = this.#mountedSlots.has(occurrence);
-      // A data occurrence is never a zombie: its nodes are the server's
-      // consumers, not the fill's output — a replaced element is a consumer
-      // change (rebind, below), and an occurrence no element reads any more
-      // is simply not found (unmounted at the end).
-      if (!consumers && mounted && prevFirst && !prevFirst.parentNode) {
-        this.#mountedSlots.delete(occurrence);
-        this.#runSlotCleanups(occurrence);
-        mounted = false;
-      }
+      // A mounted occurrence is one this frame invoked and has not unmounted;
+      // the morph never destroys a mount's output (identity-first matching
+      // relocates a range among siblings and recreates nothing — DR-5), so
+      // "mounted" is the set, not a check on the nodes.
+      const mounted = this.#mountedSlots.has(occurrence);
       // The occurrence's name decides its class: the producer mints every
       // CALLED occurrence as `prop#n` and emits its record at the call,
       // ahead of the markup that reads it; a bare occurrence (the prop
@@ -1542,29 +1677,67 @@ class FrameImpl {
         continue;
       }
       // A record's args are client values by the time it is here: the host
-      // settled its `{$ref}`s at the write — a delivered value, or a pending
-      // read its `data` chunk settles (`record.pending` counts those still
-      // open). A MOUNTED occurrence takes the read as it is: its prop pends
-      // and holds what it shows until the value lands (DR-2's value tier,
-      // the path a promise passed whole takes). A fresh mount waits for the
-      // record to settle — the host re-applies it then — so the frame's
+      // settled its `{$ref}`s at the write — a delivered value, or the
+      // table's pending read its `data` chunk settles (`record.pending`
+      // counts those still open). A MOUNTED occurrence takes the read as it
+      // is: its prop pends and holds what it shows until the value lands
+      // (DR-2's value tier, the path a promise passed whole takes). A fresh
+      // mount waits for the record to settle — the host re-applies it then
+      // — so the frame's
       // shell shows at its landing with the range as the server left it,
       // instead of a fill whose first read pends into the mount's covering
       // boundary (which would hold the frame's own address follow behind
       // the fallback). A read the response never answers settles rejected
       // at its end: the mount runs then and the read throws (L1).
-      if (!mounted && record && record.pending) {
+      //
+      // A fresh mount also waits for the TIER its occurrence needs (frames
+      // savings pass §2 — the server-announced tier mechanism): a called
+      // occurrence whose record names a region needs `regions`
+      // (`needsRegions` — the host's note of the `{$frame}` args), one
+      // whose literal args carry a container-trace marker needs `trace`
+      // (`needsTrace` — the marker walk, run only while that tier is
+      // absent). Resident tiers cost one test; an absent one has its load
+      // started by the check (`tierReady`) and the occurrence stays as the
+      // server left it — its interior on screen — until the install's
+      // flush re-syncs. (A data occurrence's own tier, `bind`, is waited
+      // for at the walk: absent, no consumer entry reaches this loop — see
+      // the note after it.) On the adopt path this wait is one more reason
+      // in the frame's registered hold (3.1): hydration-done waits. The
+      // hold does NOT keep the delegated-event replay window open for the
+      // page's elements — replay is keyed on each `_hk` element's
+      // completion, which the root pass grants long before the hold lifts;
+      // an event-slot consumer's window is its own `_hk` stamp, completed
+      // by the bind tier at the bind (see bind-tier.ts).
+      if (
+        !mounted &&
+        record &&
+        (record.pending || needsRegions(record) || needsTrace(record.args))
+      ) {
         waiting = true;
+        // Remember what the adopted interior was rendered from. A hold is
+        // the t=0 mount deferred: when it lifts, the mount must do what t=0
+        // would have — claim with THIS record — even if a later write has
+        // since replaced it in the store (the mount below falls through to
+        // the args-change path for the replacement). A claim with the
+        // replacement's args instead would trust markup rendered from the
+        // old ones and leave every differing text hole stale: a claim pass
+        // never rewrites text (frames-rulings 3.6).
+        // A data occurrence mounts with the CURRENT record instead: its
+        // positions are written whole at the bind (the fill's object over
+        // the server's values — never claimed), so the latest args are the
+        // right ones and the held/current two-step would write twice.
+        if (this.#options.adopt && !consumers)
+          this.#heldRecords.has(occurrence) || this.#heldRecords.set(occurrence, record);
         continue;
       }
       if (!mounted) {
         // Direct-insert occurrences have no `slot:<id>` record and mount with
         // empty props; render-function occurrences mount with resolved props.
-        // Mounting replaces the range interior: on a fresh stream it is
-        // empty, but an adopted document-SSR range already holds the
-        // server-rendered client content — a callback that returns nodes
-        // replaces it (client render), one that returns undefined claims it
-        // in place (hydration attach; the DOM is untouched).
+        // The fill owns the range interior (`ctx.range`, `ctx.existing`): on
+        // a fresh stream it is empty, but an adopted document-SSR range
+        // already holds the server-rendered client content — the fill
+        // claims it in place (hydration attach; the DOM is untouched) or
+        // replaces it (client render).
         // In an adopt frame, a MOUNT is the hydration attach — whether the
         // constructor sync or a registration-flush drain (t=0 records
         // buffered before adoption) triggered it. ctx.adopted lets
@@ -1574,54 +1747,52 @@ class FrameImpl {
         // stream introduces mount with EMPTY interiors (the producer ships
         // bare marker pairs), so consumers' existing-content gate already
         // excludes them from claiming.
-        // Discover the interior's region elements BEFORE invoking, on the
-        // adopt path — claim wiring, not identity recovery (A5): the t=0
-        // record names every region arg by `{$frame}` address; discovery's
-        // job is locating the already-rendered ELEMENTS those addresses
-        // resolve to, so #resolveArgs hands the wrapper the adopted node
-        // instead of minting an empty one. A fresh mount has no interior
-        // regions yet; discovery is a no-op then, and #resolveArgs creates
-        // its entries during the invoke instead.
-        if (this.#options.adopt) this.#discoverRegions(occurrence, start);
-        const nodes = this.#invokeSlot(occurrence, callback, record, start, this.#options.adopt);
-        // A data occurrence's nodes are its consuming elements (so the
-        // zombie check above sees a morph that replaced them all); its mount
-        // never returns nodes to place.
-        if (consumers) {
-          this.#slotNodes.set(
-            occurrence,
-            consumers.map(c => c.element)
-          );
-          this.#slotConsumers.set(occurrence, consumers);
-        } else {
-          if (nodes) this.#replaceRange(occurrence, start, nodes);
-          this.#slotNodes.set(occurrence, nodes);
-        }
+        // Regions (the regions tier, through #resolveArgs): on the adopt
+        // path the record's `{$frame}` args resolve to the region ELEMENTS
+        // already rendered in the interior — the tier discovers them before
+        // the fill runs, claim wiring, not identity recovery (A5) — so the
+        // wrapper is handed the adopted node instead of an empty one; a
+        // fresh mount has no interior regions yet and the tier mints its
+        // elements during the invoke.
+        // A held occurrence mounts with the record it was held on (see the
+        // hold above); a current record that differs applies right after,
+        // through the mounted path below.
+        const held = this.#heldRecords.get(occurrence);
+        this.#heldRecords.delete(occurrence);
+        const mountRecord = held || record;
+        this.#invokeSlot(occurrence, callback, mountRecord, start, this.#options.adopt);
+        // A data occurrence's consumer set is handed to the tier (`sync`),
+        // which keeps it per frame for the rebind below.
+        if (consumers) B.sync(this, occurrence, consumers);
         this.#mountedSlots.add(occurrence);
-        // Re-scan after invoke: a fresh mount's regions come from
-        // #resolveArgs during the invoke, and the callback's output may have
-        // introduced more. A claim on the adopt path (nodes === null) left
-        // the interior untouched, so the pre-invoke discovery already saw
-        // everything — skip the repeat walk (it is per-occurrence over a
-        // large adopted tree).
-        if (!this.#options.adopt || nodes) this.#discoverRegions(occurrence, start);
-        this.#bindRegions(occurrence);
-        continue;
+        // Bind the occurrence's regions (the tier): a frame over each region
+        // element #resolveArgs minted or — on the adopt path — discovered in
+        // the interior before the fill ran.
+        R?.bind(this, occurrence);
+        if (mountRecord === record || !record || record.kind !== "slot") continue;
       }
       // A mounted data occurrence whose CONSUMERS changed — a morph replaced
       // one of its elements, a response added or dropped a bound position
       // — rebinds in place: the fill's computation stays, the binding gets
-      // the new set. Independent of an args change, which follows below.
-      if (consumers && !consumersEqual(this.#slotConsumers.get(occurrence), consumers)) {
-        this.#slotConsumers.set(occurrence, consumers);
-        this.#slotNodes.set(
-          occurrence,
-          consumers.map(c => c.element)
-        );
-        const rebind = this.#slotRebinders.get(occurrence);
-        if (rebind) rebind(consumers);
-      }
+      // the new set. The tier compares against the set it keeps and calls
+      // the mount's rebinder. Independent of an args change, which follows.
+      if (consumers) B.sync(this, occurrence, consumers);
       if (record !== this.#slotArgs.get(occurrence)) {
+        // A new record that names a region while the regions tier is absent
+        // (a refetch adding a `{$frame}` arg to a mounted occurrence — the
+        // response announced the tier, its load is in flight) is NOT taken:
+        // it stays pending in the store, the live binding keeps the args it
+        // shows, and the install's flush re-syncs to here with the tier in
+        // place. The check starts the load when nothing announced it. (A
+        // mounted occurrence reaching here has a record: a called one
+        // without left above, a bare one's is `undefined` on both sides.)
+        // The same wait for the TRACES tier: a new record whose literal
+        // args carry a `{ $tr }` marker while that tier is absent — a live
+        // slot op minting the page's first trace after the shell, a refetch
+        // adding a projection arg — would otherwise be pushed into the live
+        // binding raw (the marker read as the value). `needsTrace` guards
+        // the fresh mount above; this is its update-site twin.
+        if (needsRegions(record) || needsTrace(record.args)) continue;
         // A re-sent record, live binding (the mount registered
         // ctx.onUpdate): push the re-resolved props into the LIVE
         // occurrence instead of re-calling — the consumer's reactive props
@@ -1641,26 +1812,28 @@ class FrameImpl {
           const props = this.#resolveArgs(occurrence, record);
           this.#slotArgs.set(occurrence, record);
           update(props);
-          this.#bindRegions(occurrence);
+          R?.bind(this, occurrence);
           continue;
         }
         // Args changed (incl. late args): re-call this occurrence only,
-        // reusing its cached server-content regions. Same contract: an
-        // undefined return keeps the current interior.
-        const nodes = this.#invokeSlot(occurrence, callback, record, start);
-        if (consumers)
-          this.#slotNodes.set(
-            occurrence,
-            consumers.map(c => c.element)
-          );
-        else {
-          if (nodes) this.#replaceRange(occurrence, start, nodes);
-          this.#slotNodes.set(occurrence, nodes);
-        }
-        this.#bindRegions(occurrence);
+        // reusing its cached server-content regions; the fill replaces its
+        // previous output (`ctx.existing`) over the same range.
+        this.#invokeSlot(occurrence, callback, record, start);
+        R?.bind(this, occurrence);
       }
     }
 
+    // The bind tier's wait (frames savings pass §1, "bind"; §3 row C6): the
+    // walk met a `_s:*` marker — an element's or a text position's — while
+    // the tier that parses it is absent, and noted it (`found.b`) without
+    // registering an occurrence. The data occurrences stay as the server
+    // left them — positions at the server's values, handlers inert, their
+    // events queued behind each consumer's own `_hk` stamp — and the frame
+    // waits: the check starts the load (the un-announced fallback;
+    // announced, it is already in flight), the install's flush re-syncs
+    // with the tier in place and the loop above mounts them.
+    if (found.b && !tierReady("bind")) waiting = true;
+
     // Unmount occurrences whose range has disappeared from the server content
     // — full-frame syncs only; a scoped fragment fill never removes siblings.
     if (!root) {
@@ -1669,10 +1842,11 @@ class FrameImpl {
       }
       // The frame's hold (frames-rulings 3.2): ONE registration with the
       // integration while a sync leaves an occurrence waiting to mount —
-      // for its record, or for the record's reads to settle — released by
-      // the first sync that leaves none, or by disposal. The waits are
-      // bounded as a `<Loading>` resume's is: the record by its declared
-      // value settling, the read by the stream's `complete`/`:error`.
+      // for its record, for the record's reads to settle, or for its tier
+      // — released by the first sync that leaves none, or by disposal. The
+      // waits are bounded as a `<Loading>` resume's is: the record by its
+      // declared value settling, the read by the stream's
+      // `complete`/`:error`, the tier by its load settling.
       if (waiting && !this.#hold) this.#hold = this.#options.hold?.();
       else if (!waiting && this.#hold) this.#releaseHold();
     }
@@ -1688,21 +1862,19 @@ class FrameImpl {
    * Invoke a slot occurrence's callback with resolved props. `ctx.existing`
    * carries the range's current interior (server-rendered client content on
    * an adopted document-SSR boot; the previous output on a re-call) so a
-   * framework binding can hydrate onto it. Returns the nodes to place, or
-   * null when the callback returned undefined — "I claimed the existing DOM,
-   * leave the range alone".
+   * framework binding can hydrate onto it, `ctx.range` the markers it
+   * places or binds its output within. The frame never writes an interior.
    */
   #invokeSlot(occurrence, callback, record, start, adopted) {
     // A (re-)call replaces the occurrence's binding wholesale: drop the old
     // binding's updater so a stream args-change can't push props into a
     // disposed instance. The new invocation re-registers if it wants updates.
     this.#slotUpdaters.delete(occurrence);
-    this.#slotRebinders.delete(occurrence);
     const cleanups = this.#slotCleanups.get(occurrence) ?? [];
     // One walk yields both the interior and the end marker. The end marker is
-    // part of the consumer contract (ctx.range): a framework binding that owns
-    // the range reactively (top-level dynamic slot content) needs an anchor to
-    // insert before — the markers are the only stable nodes in the range.
+    // the consumer contract (ctx.range): the fill owns the range and needs
+    // an anchor to insert before — the markers are the only stable nodes in
+    // the range.
     let existing = [];
     let end = null;
     // A data occurrence's node is its consumer list: no interior to collect,
@@ -1736,63 +1908,57 @@ class FrameImpl {
       // change. Registration is per-invocation; a real re-call clears it.
       onUpdate: fn => this.#slotUpdaters.set(occurrence, fn),
       existing,
-      // The range's own markers, when it has them: consumers that bind the
-      // interior reactively insert before `end` and return undefined — the
-      // frame then never touches the interior (morphs protect slot ranges).
+      // The range's own markers, when it has them: the fill places or binds
+      // its output before `end` — the frame never touches the interior
+      // (morphs protect slot ranges).
       range: end ? { start, end } : undefined,
       // Binding slot (§9.2.3): the positions of server markup that read this
       // occurrence — `[{ element, positions: [{ pos, key, name }] }]` in
-      // document order. The consumer runs the fill, writes each position
-      // from its returned object, and returns undefined (there is nothing
-      // to place). `onRebind` receives the new set when consumers change
+      // document order. The consumer runs the fill and writes each position
+      // from its returned object (there is nothing to place). `onRebind`
+      // receives the new set when consumers change
       // (a morph replaced an element; a response bound a new position)
-      // without the args changing — the fill's computation survives.
+      // without the args changing — the fill's computation survives. The
+      // rebinder is kept by the bind tier (resident: positions exist only
+      // once it is), beside the consumer set it compares.
       positions,
-      onRebind: positions ? fn => this.#slotRebinders.set(occurrence, fn) : undefined
+      onRebind: positions ? fn => tierLoads.bind.r.rebinder(this, occurrence, fn) : undefined
     };
     // One record shape (A5): the t=0 record carries used regions as
     // `{$frame}` refs like any stream record would, and #resolveArgs
-    // resolves them to the elements #discoverRegions seeded from the
-    // adopted interior — the wrapper's own reactivity OWNS the
-    // already-rendered element from the first render (a client-only
-    // toggle can hide/show it at t=0, no re-arming stream needed).
-    const props = record && record.kind === "slot" ? this.#resolveArgs(occurrence, record) : {};
+    // resolves them to the elements the regions tier discovers in the
+    // adopted interior (`start`, on the adopt path) — the wrapper's own
+    // reactivity OWNS the already-rendered element from the first render
+    // (a client-only toggle can hide/show it at t=0, no re-arming stream
+    // needed). `adopted` doubles as the claiming hint: this mount is about
+    // to hydrate server markup rendered from these args (see #resolveArgs).
+    const props =
+      record && record.kind === "slot" ? this.#resolveArgs(occurrence, record, adopted, start) : {};
     // Run under the boundary's owner (when the creator provided one): slot
     // content reads the mount point's context (routers, stores) and bounds
     // its lifetime there. The t=0 adopt sync happens to run inside the
     // adopting render, but stream-driven mounts and re-calls arrive from
     // microtasks with no owner of their own — without the scope, a render
     // prop touching context works on boot and throws on the first refresh.
-    const content = this.#scoped(() => callback(props, ctx));
+    this.#scoped(() => callback(props, ctx));
     this.#slotArgs.set(occurrence, record);
     if (cleanups.length) this.#slotCleanups.set(occurrence, cleanups);
-    if (content == null) return null;
-    return Array.isArray(content) ? content : [content];
-  }
-
-  /** Replace the nodes between a slot range's start marker and its end marker. */
-  #replaceRange(key, start, nodes) {
-    const parent = start.parentNode;
-    const end = eachInRange(start, key, n => parent.removeChild(n));
-    for (const node of nodes) parent.insertBefore(node, end);
   }
 
   #unmountSlot(key) {
     this.#mountedSlots.delete(key);
-    this.#slotNodes.delete(key);
-    this.#slotConsumers.delete(key);
     // Long-session hygiene: an occurrence gone from the stream releases its
     // record and caches — keyed churn must not accumulate forever.
     this.#slotArgs.delete(key);
     this.#slotUpdaters.delete(key);
-    this.#slotRebinders.delete(key);
+    this.#heldRecords.delete(key);
     this.#removeSlotRecord(key);
     this.#runSlotCleanups(key);
-    const regions = this.#slotRegions.get(key);
-    if (regions) {
-      disposeRegions(regions);
-      this.#slotRegions.delete(key);
-    }
+    // The occurrence's regions (the tier's): their frames dispose, the
+    // entries go. Nothing to do while the tier is absent — no region was
+    // ever bound. Likewise its consumer set and rebinder (the bind tier's).
+    tierLoads.regions?.r?.unmount(this, key);
+    tierLoads.bind?.r?.unmount(this, key);
   }
 
   #runSlotCleanups(key) {
@@ -1802,10 +1968,15 @@ class FrameImpl {
     for (const fn of cleanups) fn();
   }
 
-  #regionsFor(slotKey) {
-    let regions = this.#slotRegions.get(slotKey);
-    if (!regions) this.#slotRegions.set(slotKey, (regions = new Map()));
-    return regions;
+  /**
+   * The frame's options, for the regions tier: a nested region frame
+   * inherits the host, the owner scope and the claim scope of the frame it
+   * is bound under (`regions-tier.ts`, `bind`). Not on the `Frame`
+   * interface.
+   * @internal
+   */
+  get options() {
+    return this.#options;
   }
 
   /**
@@ -1817,119 +1988,42 @@ class FrameImpl {
    *  - frame ref `{$frame}` (named in `record.regions`) -> a nested
    *    reconciled region delivered as a frame ELEMENT the wrapper places,
    *    **cached per slot** so a re-call reuses the same element and its
-   *    bound frame.
+   *    bound frame — the REGIONS TIER's work (`regions-tier.ts`, `resolve`;
+   *    this runs only with the tier resident: a record naming a region
+   *    waits for it, `needsRegions`). On the adopt path (`claiming`, with
+   *    the range's `start`) the tier first discovers the region elements
+   *    already rendered in the interior, so the wrapper is handed those.
    *  - a literal -> through the host's `revive` (document-face container
    *    traces arrive as inline markers), HERE rather than at the write: an
    *    adopted occurrence's claim must read the container as the markup
    *    was rendered from it, and the materializer keys that on the claim
-   *    (frames-rulings 3.6 (iii)).
-   *
-   * Regions cache by ARG NAME, not wire id: `(occurrence, arg)` IS the
-   * region's identity, while its `$frame` childId is a per-stream wire name
-   * — different producers prefix it differently (the document and direct
-   * responses render under the function id, a single-flight region under
-   * the call's address). A re-sent ref whose only change is the wire name
-   * keeps the region — same element, same live interior — and the bound
-   * frame REBINDS to the new name so the incoming stream's chunks reach it.
+   *    (frames-rulings 3.6 (iii)) — `claiming` is that hint, true for the
+   *    adopt-time mount (`#invokeSlot`'s `adopted`), threaded to `revive`.
    */
-  #resolveArgs(slotKey, record) {
+  #resolveArgs(slotKey, record, claiming, start) {
     const { args, regions, decoded } = record;
     const revive = this.#options.host && this.#options.host.revive;
     const props = {};
     for (const key in args) {
       if (regions && key in regions) continue;
       const value = args[key];
-      props[key] = revive && !(decoded && key in decoded) ? revive(value) : value;
-    }
-    if (regions) {
-      const cache = this.#regionsFor(slotKey);
-      for (const key in regions) {
-        // A nested server-content region: a single frame ELEMENT the wrapper
-        // places. On re-call the wrapper re-places the SAME element (the
-        // platform moves the subtree as one node — no marker range to walk,
-        // no fragment refill), and the bound frame's parent follows live.
-        const childId = regions[key];
-        let entry = cache.get(key);
-        if (!entry) {
-          cache.set(
-            key,
-            (entry = { childId, element: makeFrameElement(childId), frame: undefined })
-          );
-        } else if (entry.childId !== childId) renameRegion(entry, childId);
-        props[key] = entry.element;
-      }
+      props[key] = revive && !(decoded && key in decoded) ? revive(value, claiming) : value;
     }
+    if (regions) tierLoads.regions.r.resolve(this, slotKey, regions, props, claiming && start);
     return props;
   }
 
-  /**
-   * Element discovery for the adopt path — claim wiring only (A5): the t=0
-   * record names every region arg by `{$frame}` address, and this walk
-   * locates the already-rendered ELEMENTS those addresses resolve to,
-   * seeding entries (marked `adopt`) so `#resolveArgs` reuses the adopted
-   * node instead of minting an empty one. Seed from the OUTERMOST region
-   * elements in the interior (a region's own deeper regions belong to its
-   * occurrences and are discovered recursively when those claim);
-   * `#bindRegions` then constructs adopting frames over them, which run
-   * their own slot sync — this is what wires nested occurrences at boot.
-   */
-  #discoverRegions(slotKey, start) {
-    // A data occurrence has no interior (its args are data; a region arg
-    // has nowhere to render at an attribute position).
-    if (!start || Array.isArray(start)) return;
-    const regions = this.#regionsFor(slotKey);
-    eachInRange(start, slotKey, n => collectRegionElements(n, regions));
-  }
-
-  #bindRegions(slotKey) {
-    const regions = this.#slotRegions.get(slotKey);
-    if (!regions) return;
-    for (const entry of regions.values()) {
-      if (!entry.frame) {
-        // Bind eagerly — the region ELEMENT always exists (unlike the old
-        // marker range, which needed placement in a fragment/DOM to count).
-        // This is what makes an OCCLUDED region work: its element is created
-        // when args resolve but the wrapper doesn't place it until (e.g.)
-        // expand, so it must bind and fill (from buffered/streamed chunks)
-        // off-DOM, then reveal in place when the wrapper finally inserts the
-        // single node. Host buffering flushes any queued childId chunks. The
-        // region inherits this frame's slot resolution, so client slots
-        // revealed in its streamed content are filled by the same callbacks
-        // the client threaded down — no global registry.
-        entry.frame = new FrameImpl(entry.element, null, null, {
-          id: entry.childId,
-          host: this.#options.host,
-          // Regions discovered from adopted document elements already hold
-          // their server-rendered content (adopt); streamed regions start
-          // empty. Claim scoping threads the root boundary's id down.
-          adopt: entry.adopt,
-          claimScope: this.#options.claimScope ?? this.#options.id,
-          // Element-claim sweeps in the region bind cleanup to the same
-          // boundary owner as the root's.
-          ownerScope: this.#options.ownerScope,
-          resolveSlot: prop => this.#resolveSlot(prop),
-          resolveSlotRecord: occurrence => this.#resolveSlotRecord(occurrence),
-          removeSlotRecord: occurrence => this.#removeSlotRecord(occurrence)
-        });
-      }
-    }
-  }
-
   /** Collect this frame's own top-level slot ranges (bounded to its content),
    *  and — for the slot sync — its binding-slot elements into the same map. */
   #collectSlots(found, elements) {
-    collectSlots(this.#firstContent(), this.#end, found, elements);
+    collectSlots(this.#element.firstChild, null, found, elements);
   }
 
-  /** Find a fragment placeholder `<template id="pl-NAME">` bounded to this
-   *  frame's content, or null. */
   /** The `pl-<name>` template in `root` (a segment's content being
-   *  revealed) or, without one, in the frame's range; null when absent —
+   *  revealed) or, without one, in the frame's content; null when absent —
    *  not in the range yet, or already swapped out. */
   #findPlaceholder(name, root) {
-    return root
-      ? findPlaceholder(root.firstChild, null, placeholderId(name))
-      : findPlaceholder(this.#firstContent(), this.#end, placeholderId(name));
+    return findPlaceholder((root || this.#element).firstChild, null, placeholderId(name));
   }
 
   /**
@@ -1940,7 +2034,7 @@ class FrameImpl {
    * re-materialize from. Null when there is nothing to capture.
    */
   contentHTML() {
-    if (this.#disposed || !this.#element || !this.#hasContent) return null;
+    if (this.#disposed || !this.#hasContent) return null;
     return this.#element.innerHTML;
   }
 
@@ -1988,22 +2082,16 @@ class FrameImpl {
     if (host) host.register(id, this);
   }
 
-  /** The have-list of what this mount shows (see the `Frame` interface). */
-  have() {
-    return this.#have;
-  }
-
   /**
-   * Ledger upkeep for an applied content record: the entry under `key`
-   * takes the record's digest and the map of holes inside it. A record
-   * without a digest (an older producer) leaves the entry as it was.
-   * Without a ledger (no digest-carrying root applied) there is nothing to
-   * keep — the next resume is a full snapshot either way.
+   * Ledger upkeep for an applied content record — the live wire tier's
+   * (`have`: `""` is the root and resets the ledger; any other key takes
+   * the record's digest and the holes inside it). The writers stay here,
+   * at apply time, because the ledger is what the mount SHOWS; a record
+   * applied while the tier is absent is not kept — the next resume is a
+   * full snapshot then (the degraded case, wire-tier.ts).
    */
   #recordHave(key, record) {
-    if (!this.#have || !record || record.digest === undefined) return;
-    this.#have[key] = record.digest;
-    if (record.holes) Object.assign(this.#have, record.holes);
+    tierLoads.wire?.r?.have(this, key, record);
   }
 
   dispose() {
@@ -2014,26 +2102,27 @@ class FrameImpl {
     const { host, id } = this.#options;
     if (host && id !== undefined) host.unregister(id, this);
     this.#disposed = true;
+    liveFrames.delete(this);
     this.#releaseHold();
     for (const key of [...this.#slotCleanups.keys()]) this.#runSlotCleanups(key);
     // Release this frame's occurrences' records from the store that owns them
     // (an ancestor's, for a region frame's nested occurrences) so a torn-down
     // region leaves nothing stale to dedupe a later re-navigation against.
     for (const key of this.#mountedSlots) this.#removeSlotRecord(key);
-    for (const regions of this.#slotRegions.values()) disposeRegions(regions);
-    this.#slotRegions.clear();
+    // Every region bound under this frame disposes with it (the tier's).
+    tierLoads.regions?.r?.unmount(this);
     this.#mountedSlots.clear();
   }
 
   #applyRoot(html) {
     const fragment = parseFragment(html);
-    const parent = this.#parent();
+    const parent = this.#element;
     if (!this.#hasContent) {
-      this.#clearContent();
+      parent.textContent = "";
       // Claim before insertion empties the fragment — matching compiled
       // output, which claims at creation, pre-insert.
       this.#claimTree(fragment);
-      parent.insertBefore(fragment, this.#end);
+      parent.appendChild(fragment);
       this.#hasContent = true;
     } else {
       // #claimTree self-gates on registered nav-claim handlers, so it
@@ -2054,7 +2143,7 @@ class FrameImpl {
       // never orphaned by position. Entries left over are occurrences the
       // new content dropped: detached, exactly what removal meant.
       const grafts = [];
-      reconcileChildren(parent, fragment, this.#start, this.#end, claim, ranges, grafts);
+      reconcileChildren(parent, fragment, null, null, claim, ranges, grafts);
       if (ranges.size) for (const root of grafts) flushGrafts(root, ranges);
     }
   }
@@ -2072,8 +2161,8 @@ class FrameImpl {
   #applyHole(marker, html) {
     if (!this.#hasContent) return false;
     const open = findLiveTarget(
-      this.#firstContent(),
-      this.#end,
+      this.#element.firstChild,
+      null,
       n => n.nodeType === COMMENT_NODE && n.data === marker
     );
     if (!open) return false;
@@ -2109,8 +2198,8 @@ class FrameImpl {
   #applyAttrs(addr, text, removed) {
     if (!this.#hasContent) return false;
     const el = findLiveTarget(
-      this.#firstContent(),
-      this.#end,
+      this.#element.firstChild,
+      null,
       n => n.nodeType === ELEMENT_NODE && n.getAttribute("data-lha") === addr
     );
     if (!el) return false;
@@ -2145,18 +2234,9 @@ class FrameImpl {
     return true;
   }
 
-  /** Remove the frame's current content (bounded to its range). */
-  #clearContent() {
-    removeUntil(this.#parent(), this.#firstContent(), this.#end);
-  }
-
   /** Sweep-claim the frame's existing content (the adoption path). */
   #claimContent() {
-    let n = this.#firstContent();
-    while (n && n !== this.#end) {
-      this.#claimTree(n);
-      n = n.nextSibling;
-    }
+    for (let n = this.#element.firstChild; n; n = n.nextSibling) this.#claimTree(n);
   }
 
   /**
@@ -2203,16 +2283,30 @@ class FrameImpl {
     // Reveal gate must be present and truthy.
     if (!this.#store[`seg:${name}:reveal`]) return false;
     // Style gate: the segment's streamed stylesheets must be loaded before it
-    // shows (the $dfs/$dfc analogue). ensureStylesheet inserts pending links
-    // immediately — even when other prerequisites are missing — so loading
-    // overlaps with the rest of the stream; #styleFlush re-runs this frame
-    // when one settles. Inline styles never gate (they apply on insertion).
+    // shows (the $dfs/$dfc analogue), and the code that loads them is the
+    // ASSETS TIER — so the term is two-fold (frames savings pass §1,
+    // "assets": the reveal-readiness term): the segment is not ready while
+    // the tier is not resident (`tierReady` starts its load if nothing
+    // announced it; the server's fallback stays on screen; the install's
+    // flush re-evaluates), and once it is, not until every named sheet has
+    // settled — the tier's `gate` inserts pending links immediately, even
+    // when other prerequisites are missing, so loading overlaps the rest of
+    // the stream, and re-flushes this frame when one settles. The reveal is
+    // at max(tier load, stylesheet load); no segment reveals unstyled. A
+    // segment whose record carries INLINE styles holds the same way while
+    // the tier is absent — its `<style>` lands in the assets walk, which the
+    // tier performs, so revealing before the install would be the unstyled
+    // window the term exists to prevent; once the tier is resident inline
+    // styles never gate (the walk applied them at the record's arrival, in
+    // the same flush, ahead of the segments). A segment with neither never
+    // consults the tier: modules and preloads do not gate.
     const assets = this.#store[`seg:${name}:assets`];
-    if (assets && assets.styles) {
-      let ready = true;
-      for (const entry of assets.styles) ready = ensureStylesheet(entry, this.#styleFlush) && ready;
-      if (!ready) return false;
-    }
+    if (
+      assets &&
+      (assets.styles || assets.inlineStyles) &&
+      !tierReady("assets")?.gate(assets.styles || [], this)
+    )
+      return false;
     // Structural prerequisite: the placeholder must exist in the range.
     return !!this.#findPlaceholder(name, root);
   }
@@ -2225,66 +2319,61 @@ class FrameImpl {
   #revealSegment(name, root) {
     const tpl = this.#findPlaceholder(name, root);
     if (!tpl) return;
-    // Inline styles ride the segment's assets record and apply just before
-    // its content shows (document order: <style> precedes the template).
-    const assets = this.#store[`seg:${name}:assets`];
-    if (assets && assets.inlineStyles) applyInlineStyles(assets.inlineStyles);
+    // The segment's inline styles rode its assets record and landed in the
+    // head at the record's arrival (the assets walk in #flush, ahead of the
+    // segments), so they precede the content as the document face orders
+    // them; with the assets tier absent then, the segment held (#segmentReady)
+    // and they land at the install's flush, still ahead of this reveal.
     const content = this.#store[`seg:${name}`];
     const closing = rangeClose(tpl, placeholderId(name));
-    if ("_SOLID_DEV_" && !closing) {
-      console.error(
-        `Frame fragment placeholder "${name}" is missing its closing comment ` +
-          `(<!--${placeholderId(name)}-->); revealed content will be appended at the end of ` +
-          `its parent instead of in place. Likely an HTML-rewriting layer stripped the ` +
-          `comment, or invalid nesting split the placeholder range.`,
-        tpl
-      );
-    }
-    const parent = tpl.parentNode;
-    // Clear the current range interior (a materialized fallback, if #showFallback
-    // ran) — both paths below re-own this position.
-    removeUntil(parent, tpl.nextSibling, closing);
-
-    if (this.#options.reveal) {
-      // Boundary-driven reveal (the ratified "per-`<Loading>`" model): the
-      // server `<Loading>` boundary's footprint on the client is this exact
-      // placeholder seam, so the binding reconstructs a client boundary here —
-      // fallback = the placeholder's own template content, children = the
-      // segment content plus its client fills, rendered INSIDE the boundary so
-      // their readiness gates it. An unboundaried async fill suspends up to
-      // THIS boundary and is covered, not orphaned; a fill with its own
-      // boundary contains itself. Cost is one boundary per revealed segment —
-      // and segments are `<Loading>` boundaries (few, author-placed), so this
-      // is React's granularity, not a per-chunk tax. `closing` stays as the
-      // boundary's insertion anchor; only the template is removed. The
-      // content is applied as it is revealed (2.3): its fills mount and its
-      // nested segments reveal INSIDE the still-detached fragment, so a
-      // placeholder the boundary commits later (a pending fill holds it)
-      // is already swapped when it lands.
-      const fallbackFrag = tpl.content.cloneNode(true);
-      this.#claimTree(fallbackFrag);
-      this.#options.reveal({
-        before: closing,
-        fallback: [...fallbackFrag.childNodes],
-        content: () => {
-          const materialized = this.#materialize(content);
-          this.#syncSlots(materialized);
-          this.#claimTree(materialized);
-          this.#revealSegments(materialized);
-          return materialized;
-        }
-      });
-      tpl.remove();
-      this.#recordHave(name, content);
+    // A placeholder without its closing comment is not a range: nothing
+    // reveals into it (as #showFallback materializes nothing there).
+    if (!closing) {
+      if ("_SOLID_DEV_")
+        console.error(
+          `Frame fragment placeholder "${name}" is missing its closing comment ` +
+            `(<!--${placeholderId(name)}-->); the segment is not revealed. Likely an ` +
+            `HTML-rewriting layer stripped the comment, or invalid nesting split the ` +
+            `placeholder range.`,
+          tpl
+        );
       return;
     }
-
-    const materialized = this.#materialize(content);
-    this.#claimTree(materialized);
-    this.#revealSegments(materialized);
-    parent.insertBefore(materialized, closing);
+    // Clear the current range interior (a materialized fallback, if #showFallback
+    // ran) — the seam re-owns this position.
+    removeUntil(tpl.parentNode, tpl.nextSibling, closing);
+
+    // Boundary-driven reveal (the ratified "per-`<Loading>`" model): the
+    // server `<Loading>` boundary's footprint on the client is this exact
+    // placeholder seam, so the binding reconstructs a client boundary here —
+    // fallback = the placeholder's own template content, children = the
+    // segment content plus its client fills, rendered INSIDE the boundary so
+    // their readiness gates it. An unboundaried async fill suspends up to
+    // THIS boundary and is covered, not orphaned; a fill with its own
+    // boundary contains itself. Cost is one boundary per revealed segment —
+    // and segments are `<Loading>` boundaries (few, author-placed), so this
+    // is React's granularity, not a per-chunk tax. `closing` stays as the
+    // boundary's insertion anchor; only the template is removed. The
+    // content is applied as it is revealed (2.3): its fills mount and its
+    // nested segments reveal INSIDE the still-detached fragment, so a
+    // placeholder the boundary commits later (a pending fill holds it)
+    // is already swapped when it lands. A frame created without the hook
+    // reveals through the default seam — the same content, inserted at
+    // once (no boundary).
+    const fallbackFrag = tpl.content.cloneNode(true);
+    this.#claimTree(fallbackFrag);
+    (this.#options.reveal || revealAtOnce)({
+      before: closing,
+      fallback: [...fallbackFrag.childNodes],
+      content: () => {
+        const materialized = this.#materialize(content);
+        this.#syncSlots(materialized);
+        this.#claimTree(materialized);
+        this.#revealSegments(materialized);
+        return materialized;
+      }
+    });
     tpl.remove();
-    closing && closing.remove();
     this.#recordHave(name, content);
   }
 
@@ -2321,7 +2410,7 @@ class FrameImpl {
 export function createFrame(boundary: Element, options?: FrameOptions): Frame;
 
 export function createFrame(boundary, options) {
-  return new FrameImpl(boundary, null, null, options);
+  return new FrameImpl(boundary, options);
 }
 
 // The boundary/region element vocabulary — the DOM contract the producer
@@ -2372,7 +2461,7 @@ export function createFrameElement(options: FrameOptions): {
  */
 export function createFrameElement(options) {
   const el = makeFrameElement(options.id);
-  const frame = new FrameImpl(el, null, null, options);
+  const frame = new FrameImpl(el, options);
   return {
     element: el,
     frame,
@@ -2390,16 +2479,22 @@ export function createFrameElement(options) {
  * defined: an undefined custom element is inert HTMLUnknownElement, and
  * `display:contents` makes it generate no box, so its children lay out in the
  * frame's parent.
+ *
+ * Exported (with `isFrameElement` and `eachInRange`) for the regions tier
+ * (`regions-tier.ts`), which bundles its own copy of these pure helpers;
+ * the eager entry re-exports none of them.
+ * @internal
  */
-function makeFrameElement(id) {
+export function makeFrameElement(id) {
   const el = document.createElement(FRAME_TAG);
   el.style.display = "contents";
   if (id !== undefined) el.setAttribute(FRAME_ID_ATTR, id);
   return el;
 }
 
-/** Whether `node` is a frame boundary/region element (carries our id attr). */
-function isFrameElement(node) {
+/** Whether `node` is a frame boundary/region element (carries our id attr).
+ *  @internal */
+export function isFrameElement(node) {
   return node.nodeType === ELEMENT_NODE && node.hasAttribute(FRAME_ID_ATTR);
 }
 
@@ -2421,9 +2516,14 @@ function isCalled(occurrence) {
   return occurrence.indexOf("#") !== -1;
 }
 
-/** Dispose every bound frame in a slot's region-entry map. */
-function disposeRegions(regions) {
-  for (const { frame } of regions.values()) frame?.dispose();
+/**
+ * The default reveal seam (`FrameOptions.reveal` omitted): the segment's
+ * content inserted before the closing comment at once, the comment removed
+ * — the framework-agnostic swap, no boundary.
+ */
+function revealAtOnce(seam) {
+  seam.before.parentNode.insertBefore(seam.content(), seam.before);
+  seam.before.remove();
 }
 
 /** Remove siblings from `n` (inclusive) up to `stop` (exclusive). */
@@ -2442,120 +2542,6 @@ function parseFragment(html) {
   return template.content;
 }
 
-// ---- Style loading (reveal gating) ------------------------------------
-//
-// Minimal, import-free mirror of the client asset registry's conventions
-// (client.js acquireAsset): data-asset ids for inline styles, attribute-
-// compared lookup instead of selector interpolation, adopt elements already
-// in the document. The Solid binding can swap in the ref-counted
-// registry later; the gate only needs "are this segment's stylesheets loaded,
-// and call me back when they settle".
-
-// Mirrors head.ts without importing it into the standalone frame client.
-const PRELOAD_QUALIFIERS = ["as", "crossorigin", "type", "media", "imagesrcset", "imagesizes"];
-
-// Mirrors head.ts's qualifierValue — keep them in step. `as` folds ASCII
-// case; an empty source set or size reads as absent (registration never
-// emits one); `crossorigin` is three states, not a string range, so `""`, a
-// bare attribute and `anonymous` are one request. Frame `attrs` are already
-// canonical strings, but the document may carry any spelling.
-function qualifierValue(name, value) {
-  if (value == null) return null;
-  if (name === "imagesrcset" || name === "imagesizes") return value === "" ? null : value;
-  if (name === "as") return value.replace(/[A-Z]/g, c => String.fromCharCode(c.charCodeAt(0) + 32));
-  if (name !== "crossorigin") return value;
-  return value.length === 15 && value.toLowerCase() === "use-credentials"
-    ? "use-credentials"
-    : "anonymous";
-}
-
-/** Attribute-compared head lookup so href/id values never need escaping. */
-function findHeadElement(selector, attr, value, qualifiers) {
-  candidate: for (const node of document.head.querySelectorAll(selector)) {
-    if (node.getAttribute(attr) !== value) continue;
-    if (!qualifiers) return node;
-    for (let i = 0; i < PRELOAD_QUALIFIERS.length; i++) {
-      const name = PRELOAD_QUALIFIERS[i];
-      if (
-        qualifierValue(name, node.getAttribute(name)) !==
-        qualifierValue(name, qualifiers[name] ?? null)
-      )
-        continue candidate;
-    }
-    return node;
-  }
-  return null;
-}
-
-/** Ensure one typed preload exists, preserving request-qualifying attributes. */
-function ensurePreload(entry) {
-  const attrs = entry.attrs;
-  const href = entry.href;
-  if (findHeadElement('link[rel="preload"]', "href", href || null, attrs)) return;
-  const link = document.createElement("link");
-  link.rel = "preload";
-  for (const name in attrs) link.setAttribute(name, attrs[name]);
-  if (href) link.setAttribute("href", href);
-  document.head.appendChild(link);
-}
-
-/**
- * Ensure a stylesheet link exists and report whether it has settled. A link
- * this loader created tracks waiters until load/error (error unblocks too —
- * same policy as the document runtime's $dfc gate); a link that was
- * already in the document counts as settled. `entry` is a url string or an
- * attributed record `{ href, attrs }` (fetch-metadata attributes carried by
- * useHead stylesheets).
- */
-function ensureStylesheet(entry, onSettle) {
-  const href = typeof entry === "string" ? entry : entry.href;
-  let link = findHeadElement('link[rel="stylesheet"]', "href", href);
-  if (!link) {
-    link = document.createElement("link");
-    link.rel = "stylesheet";
-    if (typeof entry !== "string" && entry.attrs) {
-      for (const name in entry.attrs) link.setAttribute(name, entry.attrs[name]);
-    }
-    link.href = href;
-    const waiters = new Set();
-    link._$frWaiters = waiters;
-    const settle = () => {
-      link._$frWaiters = null;
-      for (const fn of waiters) fn();
-    };
-    link.addEventListener("load", settle);
-    link.addEventListener("error", settle);
-    document.head.appendChild(link);
-  }
-  const waiters = link._$frWaiters;
-  if (waiters == null) return true; // settled, or document-owned
-  waiters.add(onSettle);
-  return false;
-}
-
-/** Ensure a modulepreload link exists for `href` (deduped, adopt existing). */
-function ensureModulePreload(href) {
-  if (findHeadElement('link[rel="modulepreload"]', "href", href)) return;
-  const link = document.createElement("link");
-  link.rel = "modulepreload";
-  link.href = href;
-  document.head.appendChild(link);
-}
-
-/** Insert inline-style entries into the head, deduped by data-asset id. */
-function applyInlineStyles(inlineStyles) {
-  for (const entry of inlineStyles) {
-    if (findHeadElement("style[data-asset]", "data-asset", entry.id)) continue;
-    const el = document.createElement("style");
-    el.setAttribute("data-asset", entry.id);
-    if (entry.attrs) {
-      for (const name in entry.attrs) el.setAttribute(name, entry.attrs[name]);
-    }
-    el.textContent = entry.content || "";
-    document.head.appendChild(el);
-  }
-}
-
 /** Whether `node` is the `<template id="pl-KEY">` placeholder start marker. */
 function isPlaceholderStart(node, id) {
   return node.tagName === "TEMPLATE" && node.id === id;
@@ -2624,26 +2610,25 @@ function collectSlots(n, end, out, elements) {
       n = afterRange(n, id);
       continue;
     }
+    // Binding-slot markers (`_s:*`), when the caller wants them — the slot
+    // sync does; the morph's range index does not (an element is reconciled
+    // as an element, not relocated as a protected range). The BIND TIER
+    // parses them: a text position's start marker joins its parent
+    // element's consumer entry (`text`); an element's positions join its
+    // occurrence's consumer list, in document order (`positions`). With
+    // the tier absent, the walk only NOTES that a marker was met
+    // (`elements.b`) — the sync holds on the note and the install's flush
+    // re-walks. A text pair's interior (one text node, the end marker) and
+    // the element's interior are walked like any server content: they may
+    // hold further occurrences of either kind.
     if (elements !== undefined && isTextStart(n)) {
-      textPosition(n, elements);
-      n = afterText(n);
-      continue;
+      const B = tierLoads.bind?.r;
+      B ? B.text(n, elements) : (elements.b = true);
     }
     if (n.nodeType === ELEMENT_NODE && !isFrameElement(n)) {
-      // Data occurrences (`_s:*` markers), when the caller wants them — the
-      // slot sync does; the morph's range index does not (an element is
-      // reconciled as an element, not relocated as a protected range). The
-      // element's positions join its occurrence's consumer list, in document
-      // order. The element's interior is still walked: it is server content
-      // and may hold further occurrences of either kind.
       if (elements !== undefined && n.hasAttributes()) {
-        const byOccurrence = slotPositions(n);
-        if (byOccurrence !== null) {
-          for (const occurrence in byOccurrence) {
-            const consumers = consumersOf(elements, occurrence);
-            if (consumers) consumers.push({ element: n, positions: byOccurrence[occurrence] });
-          }
-        }
+        const B = tierLoads.bind?.r;
+        B ? B.positions(n, elements) : hasSlotMarker(n) && (elements.b = true);
       }
       collectSlots(n.firstChild, null, out, elements);
     }
@@ -2651,56 +2636,14 @@ function collectSlots(n, end, out, elements) {
   }
 }
 
-/**
- * Collect the OUTERMOST frame region elements in `node`'s subtree into
- * `regions` (keyed by arg name — the childId's final segment, always the
- * dot-free arg identifier — seeded for adoption). A region is opaque — its
- * own deeper regions belong to its occurrences, discovered when they claim —
- * so the walk stops descending at each region element. Client wrapper
- * elements around a region are descended through.
- */
-function collectRegionElements(node, regions) {
-  if (node.nodeType !== ELEMENT_NODE) return;
-  if (isFrameElement(node)) {
-    const childId = node.getAttribute(FRAME_ID_ATTR);
-    // Region ids are dotted (`<producer frame>.<occurrence>.<arg>`); bare ids
-    // belong to nested document BOUNDARIES, which own their interiors (the
-    // walk stops at every frame element, so a nested boundary's own regions
-    // are never reachable from here). The producer prefix is wire-relative —
-    // a mount registered under a call ADDRESS still adopts markup produced
-    // under the function id — so region membership is structural
-    // (outermost-in-this-interior), not prefix-matched.
-    if (childId && childId.includes(".")) {
-      const argKey = childId.slice(childId.lastIndexOf(".") + 1);
-      if (!regions.has(argKey)) {
-        regions.set(argKey, { childId, element: node, frame: undefined, adopt: true });
-      }
-    }
-    return;
-  }
-  for (let c = node.firstChild; c; c = c.nextSibling) collectRegionElements(c, regions);
-}
-
-/**
- * Point a cached region entry at a new wire name: the identity (occurrence,
- * arg) and the live element/interior stay, while the bound frame re-registers
- * under the id the incoming stream addresses its content by. An entry not
- * bound yet (discovery just seeded it) only updates its element's id — the
- * eager bind that follows registers under the new name.
- */
-function renameRegion(entry, childId) {
-  entry.childId = childId;
-  if (entry.frame) entry.frame.rebind(childId);
-  else entry.element.setAttribute(FRAME_ID_ATTR, childId);
-}
-
 /**
  * Walk a slot range's interior — every node between `start` and the range's
  * end marker — calling `cb` on each. The next sibling is captured before the
  * callback runs, so callbacks may detach the node. Returns the end marker
  * (null if the range is truncated).
+ * @internal (exported for the regions tier — see `makeFrameElement`)
  */
-function eachInRange(start, key, cb) {
+export function eachInRange(start, key, cb) {
   const end = slotEnd(key);
   let n = start.nextSibling;
   while (n && !(n.nodeType === COMMENT_NODE && n.data === end)) {
@@ -2786,61 +2729,17 @@ function preservesOpen(el) {
 // the owned names' live state on top. The markers themselves are ordinary
 // attributes and morph like any other, which is what lets the slot sync
 // see a consumer change.
-function ownedPositions(el) {
-  const attrs = el.attributes;
-  let out = null;
-  for (let i = 0; i < attrs.length; i++) {
-    const name = attrs[i].name;
-    if (!name.startsWith(SLOT_MARKER)) continue;
-    const pos = name.slice(SLOT_MARKER.length);
-    if (pos === "ref" || pos.startsWith("on:")) continue;
-    out || (out = { attrs: new Set(), class: null, style: null });
-    if (pos !== "class" && pos !== "style") {
-      out.attrs.add(pos);
-      continue;
-    }
-    for (const entry of attrs[i].value.split(",")) {
-      const eq = entry.indexOf("=");
-      if (eq === -1) {
-        out.attrs.add(pos); // a whole-value read owns the attribute
-        continue;
-      }
-      (out[pos] || (out[pos] = [])).push(decodeURIComponent(entry.slice(eq + 1)));
-    }
-  }
-  return out;
-}
-
-/** Set `class` to the server's value with the fill-owned class names' live
- *  state preserved. Returns whether the attribute changed. */
-function morphOwnedClass(oldEl, value, names) {
-  const list = oldEl.classList;
-  const set = new Set(value ? value.split(/\s+/) : []);
-  set.delete("");
-  for (const name of names) list.contains(name) ? set.add(name) : set.delete(name);
-  const next = [...set].join(" ");
-  if (next === (oldEl.getAttribute("class") || "")) return false;
-  next ? oldEl.setAttribute("class", next) : oldEl.removeAttribute("class");
-  return true;
-}
-
-/** Set `style` to the server's value with the fill-owned properties' live
- *  values preserved. Returns whether the attribute changed. */
-function morphOwnedStyle(oldEl, value, names) {
-  const style = oldEl.style;
-  const saved = names.map(name => [
-    name,
-    style.getPropertyValue(name),
-    style.getPropertyPriority(name)
-  ]);
-  const before = oldEl.getAttribute("style");
-  value ? oldEl.setAttribute("style", value) : oldEl.removeAttribute("style");
-  for (const [name, v, priority] of saved) {
-    v ? style.setProperty(name, v, priority) : style.removeProperty(name);
-  }
-  return oldEl.getAttribute("style") !== before;
-}
-
+//
+// The parse and the re-imposition are the BIND TIER's (`owned` / `apply`,
+// bind-tier.ts): while it is absent nothing is bound, so nothing is the
+// client's and the morph writes the server's values whole — `null` here,
+// the "no owned positions" answer the arms already take.
+/** The incoming element's owned positions, or null (none, or the tier
+ *  absent). */
+const ownedPositions = el => {
+  const B = tierLoads.bind?.r;
+  return B ? B.owned(el) : null;
+};
 /**
  * Apply the server's value for `name` (null: absent) to an element with
  * binding-slot positions: a client-owned attribute is left alone; owned
@@ -2848,16 +2747,8 @@ function morphOwnedStyle(oldEl, value, names) {
  * whether the attribute changed, or undefined when the position is not
  * owned and the caller writes it.
  */
-function applyOwned(oldEl, name, value, owned) {
-  if (owned === null) return undefined;
-  if (owned.attrs.has(name)) return false;
-  if ((name === "class" || name === "style") && owned[name] !== null) {
-    return name === "class"
-      ? morphOwnedClass(oldEl, value, owned.class)
-      : morphOwnedStyle(oldEl, value, owned.style);
-  }
-  return undefined;
-}
+const applyOwned = (oldEl, name, value, owned) =>
+  owned === null ? undefined : tierLoads.bind.r.apply(oldEl, name, value, owned);
 
 function morphAttributes(oldEl, newEl, claim) {
   let reclaim = false;
@@ -3123,10 +3014,14 @@ function reconcileChildren(
       old.nodeType === COMMENT_NODE &&
       old.data === newChild.data
     ) {
-      // The same text position: its interior is the client's (the incoming
-      // one is empty on the stream face) — keep it and skip both ranges.
-      // Any other case reconciles as ordinary nodes; the consumer change
-      // that follows rebinds the owner, which writes the new range.
+      // The same binding-slot text position: its interior is the client's
+      // (the incoming one is empty on the stream face) — keep it and skip
+      // both ranges. Any other case reconciles as ordinary nodes; the
+      // consumer change that follows rebinds the owner, which writes the
+      // new range. Eager, not the bind tier's: reconciled as ordinary nodes
+      // the pair's text would be dropped and its unchanged position would
+      // not rebind (same start marker), and a dispatch point here costs
+      // what the arm does (measured, C6).
       oldChild = afterText(old);
       newChild = afterText(newChild);
       continue;
diff --git a/packages/web/frames/src/frame-container-plugin.ts b/packages/web/frames/src/frame-container-plugin.ts
index 6d284c614..ef48e6194 100644
--- a/packages/web/frames/src/frame-container-plugin.ts
+++ b/packages/web/frames/src/frame-container-plugin.ts
@@ -46,19 +46,22 @@ export interface ContainerTraceMarker {
 // for integrations to wire, and its weight stays in the lazy codec graph.
 
 // Hook state is shared ACROSS MODULE COPIES, like the TRACE symbol below:
-// integration bundles carry this module once per entry (the frames client
+// integration bundles carry this module once per entry (the frames client's
+// TRACES TIER chunk — `@solidjs/web/frames/trace`, loaded on demand —
 // installs the materializer on its copy; the LAZY CODEC chunk's copy is the
 // one whose plugin deserializes stream data), and module-local state would
 // leave the codec copy hookless — deserialize falls back to the inert
 // marker, the arg reads as a plain object, and the meter just renders
 // nothing (chat example, 2026-08-10). One registered global carries the
 // hooks and the materialization memo, so every copy is the same protocol
-// endpoint.
+// endpoint. The EAGER frames client carries no copy at all: it reads the
+// container probe (`materializedValues`) off this object by its registered
+// symbol, and nothing else of the client half until the tier installs.
 /**
  * @type {{
  *   resolveTrace?: (value: unknown) => ({ subscribe(): AsyncIterable<any>, array: boolean } | undefined),
  *   shareIterable?: (source: AsyncIterable<any>) => AsyncIterable<any>,
- *   materializeTrace?: (marker: { $tr: any, $ta?: number }) => unknown,
+ *   materializeTrace?: (marker: { $tr: any, $ta?: number }, claiming?: boolean) => unknown,
  *   streamOf?: (iterable: AsyncIterable<any>) => any,
  *   materialized: WeakMap<object, unknown>,
  *   materializedValues: WeakSet<object>
@@ -92,9 +95,16 @@ export function setAsyncIterableSharer(
 export function setAsyncIterableSharer(fn) {
   state.shareIterable = fn;
 } /** Client half: install the reactive core's trace materializer. */
-export function setContainerTraceMaterializer(fn: (marker: ContainerTraceMarker) => unknown): void;
+export function setContainerTraceMaterializer(
+  fn: (marker: ContainerTraceMarker, claiming?: boolean) => unknown
+): void;
 
-/** Client half: install the reactive core's trace materializer. */
+/**
+ * Client half: install the reactive core's trace materializer. Installed by
+ * the frames client's traces tier (`@solidjs/web/frames/trace`) when it
+ * loads — never at the eager client's module load. `claiming` is the
+ * revival site's hint (see reviveContainerTraces).
+ */
 export function setContainerTraceMaterializer(fn) {
   state.materializeTrace = fn;
 }
@@ -219,10 +229,10 @@ function isShareableIterable(value) {
 // across independent revival sites (an eval-face marker read by two
 // occurrences, a codec node re-resolved per record — possibly by DIFFERENT
 // copies of this module).
-function materialize(marker) {
+function materialize(marker, claiming) {
   let value = state.materialized.get(marker.$tr);
   if (value === undefined) {
-    value = state.materializeTrace(marker);
+    value = state.materializeTrace(marker, claiming);
     state.materialized.set(marker.$tr, value);
     if (value !== null && typeof value === "object") state.materializedValues.add(value);
   }
@@ -259,23 +269,29 @@ export function isContainerTraceMarker(value) {
   const tr = value.$tr;
   return tr.__SEROVAL_STREAM__ === true || typeof tr[Symbol.asyncIterator] === "function";
 } /** Deep-revive trace markers inside a decoded value (document-face slot args). */
-export function reviveContainerTraces(value: unknown): unknown;
+export function reviveContainerTraces(value: unknown, claiming?: boolean): unknown;
 
 /**
  * Deep-revive trace markers inside a decoded value (document-face slot args
  * arrive as literals, and a container can sit at ANY depth of an argument —
  * `{ filters: { user: proj } }` is one arg). In-place: args records are
  * per-record decoded copies. No-op until the materializer is installed.
+ * The traces tier installs this as the shared frame host's `revive`, so it
+ * runs at the mount's arg-read (`FrameHostOptions.revive`). `claiming`: the
+ * value's reader is about to hydrate server markup rendered from it (a
+ * frame's adopt-time mount) — the materializer parks a trace's backlog
+ * beyond the snapshot the markup shows until hydration ends
+ * (frames-rulings 3.6 (iii)).
  */
-export function reviveContainerTraces(value) {
+export function reviveContainerTraces(value, claiming) {
   if (!state.materializeTrace || value == null || typeof value !== "object") return value;
-  if (isContainerTraceMarker(value)) return materialize(value);
+  if (isContainerTraceMarker(value)) return materialize(value, claiming);
   // Plain containers only — anything exotic was either produced by the
   // codec plugin (already materialized) or is an app value not ours to walk.
   if (Array.isArray(value)) {
-    for (let i = 0; i < value.length; i++) value[i] = reviveContainerTraces(value[i]);
+    for (let i = 0; i < value.length; i++) value[i] = reviveContainerTraces(value[i], claiming);
   } else if (Object.getPrototypeOf(value) === Object.prototype) {
-    for (const key of Object.keys(value)) value[key] = reviveContainerTraces(value[key]);
+    for (const key of Object.keys(value)) value[key] = reviveContainerTraces(value[key], claiming);
   }
   return value;
 }
@@ -334,10 +350,13 @@ export const ContainerTracePlugin = {
   deserialize(node, ctx) {
     const iterable = ctx.deserialize(node.i);
     const marker = { $tr: iterable, $ta: node.a };
-    // Codec face: the decode runs where the reactive core is resident (the
-    // frames client installs the materializer at module load, before any
-    // response can decode), so the value leaves the table already live. The
-    // marker fallback keeps a hookless decode inert instead of broken.
+    // Codec face: the decode runs where the materializer is resident — the
+    // `data` chunk that carries this node announces the traces tier
+    // (`chunk.tiers`, frame-sink.ts), and the transport awaits the tier's
+    // install before it lets the chunk decode — so the value leaves the
+    // table already live. A fresh value, never a claim's: no `claiming`.
+    // The marker fallback keeps a hookless decode (an un-announced chunk
+    // from a producer that predates the tier) inert instead of broken.
     return state.materializeTrace ? materialize(marker) : marker;
   }
 };
diff --git a/packages/web/frames/src/frame-sink.ts b/packages/web/frames/src/frame-sink.ts
index 1bb3af1c5..781b9c59a 100644
--- a/packages/web/frames/src/frame-sink.ts
+++ b/packages/web/frames/src/frame-sink.ts
@@ -219,6 +219,7 @@ import { observeFrame } from "../../src/server-observe.js";
 import {
   FRAME_HAVE_HEADER,
   FRAME_STREAM_HEADER,
+  FRAME_TIERS_HEADER,
   decodeHaveList,
   SERVER_COMPONENT,
   SERVER_COMPONENT_ADDRESS,
@@ -387,11 +388,35 @@ function withHoles(chunk, holes) {
  */
 export function createFrameSink(write, frame, have, hooks) {
   const { id, version } = frame;
-  // Every emission passes here, so a sweep knows whether it produced one.
+  // The tiers this render has minted (frames savings pass §2, the
+  // server-announced tier mechanism): the frames-client capabilities the
+  // response needs, learned where the sink mints each feature — a nested
+  // region (`regions`), an assets chunk (`assets`), a binding-slot position
+  // read (`bind`), a container trace in an arg (`trace`), a `live` response
+  // (`wire`). `announce()` hands the set to the response head
+  // (`X-Frame-Tiers`); a name minted since the last chunk left rides
+  // IN-BAND on the next one (`chunk.tiers`) — so a tier the head could not
+  // know (a later segment's) is still announced ahead of, or with, the
+  // chunk that needs it. Both are warm starts for the client's loads; its
+  // readiness checks detect and hold regardless.
+  const tiers = new Set();
+  let staged = [];
+  // Every emission passes here, so a sweep knows whether it produced one,
+  // and a staged tier announcement leaves with the next chunk.
   const emit = chunk => {
     if (swept) swept.emitted = true;
+    if (staged.length) {
+      chunk.tiers = staged;
+      staged = [];
+    }
     write(chunk);
   };
+  const needs = name => {
+    if (!tiers.has(name)) {
+      tiers.add(name);
+      staged.push(name);
+    }
+  };
   // Conditional emission (Stage 8 B4, RFC 11 §9.5 Server face 2). `have`
   // is the client's ledger for this address; `conditional` arms once the
   // shell decides the client's structure stands (skeleton digests equal)
@@ -552,6 +577,7 @@ export function createFrameSink(write, frame, have, hooks) {
             chunk.preloads.push(wirePreload(entry));
           }
         }
+        needs("assets");
         emit(chunk);
       }
       emit(withHoles({ type: "html", id, version, html, digest }, holeDigests(html, attrText)));
@@ -633,6 +659,7 @@ export function createFrameSink(write, frame, have, hooks) {
         if (inline.length) {
           chunk.inlineStyles = inline.map(e => ({ id: e.id, content: e.content, attrs: e.attrs }));
         }
+        needs("assets");
         emit(chunk);
       }
       emit(
@@ -692,8 +719,10 @@ export function createFrameSink(write, frame, have, hooks) {
       // style links on the fragment path. Emitting them here too would
       // duplicate, mis-keyed to the root.
       if (type === "module") {
+        needs("assets");
         emit({ type: "assets", id, version, key: "", modules: [value] });
       } else if (type === "preload") {
+        needs("assets");
         emit({ type: "assets", id, version, key: "", preloads: [wirePreload(value)] });
       }
     },
@@ -728,7 +757,9 @@ export function createFrameSink(write, frame, have, hooks) {
     // A nested server-content region (a `{$frame}` slot arg): its html is a
     // chunk addressed to the CHILD frame id — the consumer binds a nested
     // frame to the arg's marker range and the host routes/buffers by id.
+    // The first region minted is the `regions` tier announced.
     region(childId, html) {
+      needs("regions");
       emit({ type: "html", id: childId, version, html });
     },
     // A live-hole re-emission (Stage 3): the hole's re-resolved HTML, keyed
@@ -785,6 +816,23 @@ export function createFrameSink(write, frame, have, hooks) {
     /** The current commit epoch (see the ledger comment above). */
     get epoch() {
       return epoch;
+    },
+    // ---- tiers (see `tiers` above) ----
+    /**
+     * This render needs the named frames-client tier: announced on the
+     * response head if it has not left, in-band on the next chunk if it
+     * has. Called where the sink mints the tier's feature; idempotent.
+     */
+    needs,
+    /**
+     * The tiers minted so far, for the response head — every one the sync
+     * render pass produced, the stream face's `X-Frame-Tiers`. Names it
+     * returns need no in-band announcement; what is minted later rides the
+     * next chunk.
+     */
+    announce() {
+      staged = [];
+      return [...tiers];
     }
   };
 } /**
@@ -901,6 +949,11 @@ const DEFAULT_MAX_DURATION_MS = 30_000;
 // The abort reason a response's own `cancel` tears its render down with:
 // the reader left, so the stream must not dress the end as a bound.
 const DISCONNECTED = Symbol("solid.frames.disconnected");
+// A pipe writable's hook for the tiers the sync render pass minted (see
+// `createFrameSink`'s `announce`): `serverComponentResponse` writes them
+// into the response head, which it builds right after the pass. Module-
+// private — the `pipe` writable's public shape is `write`/`end`.
+const ANNOUNCE = Symbol("solid.frames.announce");
 
 function frameStream(makeCode, options) {
   const { id = "", version = 1 } = options.frame || {};
@@ -985,6 +1038,9 @@ function frameStream(makeCode, options) {
           }
         : undefined
     );
+    // A `live` response is the wire tier's: the standing connection the
+    // client holds after this answer is that tier's code.
+    if (options.live) sink.needs("wire");
     w.write({ type: "start", id, version });
     // A caller already gone has nobody to render for.
     if (upstream && upstream.aborted) return finish();
@@ -1026,6 +1082,10 @@ function frameStream(makeCode, options) {
       observation && observation.settle("error", err);
       finish();
     }
+    // The sync render pass is over: the tiers it minted are what the
+    // response head can carry (the shell's own flush, and everything after
+    // it, is asynchronous — those mints ride in-band).
+    if (w[ANNOUNCE]) w[ANNOUNCE](sink.announce());
   }
   return {
     pipe: stream,
@@ -1095,13 +1155,18 @@ function isRangeKey(key) {
   const c = key.charCodeAt(0);
   return c === 36 /* $ */ || (c >= 48 && c <= 57) /* index */ || RANGE_KEYS.has(key);
 }
-function slotProxy(range, occurrence, face, content, onData) {
+// `needs(tier)` is the face's tier announcement (createFrameSink's `needs`
+// on a stream, `documentNeeds` on a document): a property read is a
+// binding-slot position minted, and the `bind` tier announced with it.
+function slotProxy(range, occurrence, face, content, onData, needs) {
   return new Proxy(range, {
     get(target, key, receiver) {
       if (typeof key !== "string" || isRangeKey(key)) return Reflect.get(target, key, receiver);
       // The first property read fixes the proxy's face as DATA (see
       // repeatKey): a placed range never gets here.
       if (onData) onData = void onData();
+      // A read off markup binds nothing (a dev finding at the position).
+      if (face !== SLOT_FACE_MARKUP) needs("bind");
       return slotValue(occurrence, key, content ? content[key] : undefined, face);
     }
   });
@@ -1117,8 +1182,8 @@ function slotProxy(range, occurrence, face, content, onData) {
  * client an object where it expects the value (`{ k, v, f }` — and on the
  * document face `v` is the t=0 value, which hydration then contradicts).
  */
-function argBorderForm(value, key, occurrence) {
-  return toBorderForm(withoutStandIns(value, key, occurrence), true);
+function argBorderForm(value, key, occurrence, needs) {
+  return toBorderForm(withoutStandIns(value, key, occurrence, needs), true);
 }
 
 /**
@@ -1130,12 +1195,18 @@ function argBorderForm(value, key, occurrence) {
  * objects alone; anything exotic is the app's and is not read. Both faces
  * take the same arg: the document face's t=0 fill reads what hydration
  * will (see createDocumentSlotProps), the records carry it.
+ *
+ * A container met here (at any depth) is a trace the serializer will
+ * stamp: the `trace` tier announced (`needs`, the face's).
  */
-function withoutStandIns(value, key, occurrence) {
+function withoutStandIns(value, key, occurrence, needs) {
   return rewriteTree(
     value,
     (v, path) => {
-      if (isContainerTraced(v)) return v;
+      if (isContainerTraced(v)) {
+        needs("trace");
+        return v;
+      }
       if (Object.getPrototypeOf(v) === Object.prototype && isSlotValue(v)) {
         if ("_SOLID_DEV_") standInArgFinding(v, key, occurrence, path);
         return undefined;
@@ -1469,7 +1540,14 @@ export function createDocumentSlotProps(clientProps, frameId) {
     r.$occurrence = occurrence;
     const face = slotFace(r, content);
     r.$face = face;
-    return slotProxy(r, occurrence, face, face === SLOT_FACE_DATA ? content : undefined);
+    return slotProxy(
+      r,
+      occurrence,
+      face,
+      face === SLOT_FACE_DATA ? content : undefined,
+      undefined,
+      documentNeeds
+    );
   };
   // Client content renders under a per-occurrence hydration-key OWNER
   // scope, so the adopting client re-renders each slot under the SAME
@@ -1655,12 +1733,17 @@ export function createDocumentSlotProps(clientProps, frameId) {
                 // itself: settled reads pass through; a pending read throws
                 // not-ready into the hole machinery — a per-arg suspend, the
                 // value tier's own behavior. The record ships the proxy, which
-                // the serializer's trace plugin carries as snapshot + patches.
+                // the serializer's trace plugin carries as snapshot + patches
+                // — the `trace` tier, announced.
+                documentNeeds("trace");
                 resolved[key] = value;
               } else if (isServerContent(value)) {
                 const childId = `${frameId}.${occurrence}.${key}`;
                 const region = { key, childId, value, used: false, locked: false };
                 regions.push(region);
+                // Used or occluded, the record names it `{$frame}`: the
+                // `regions` tier, announced.
+                documentNeeds("regions");
                 resolved[key] = () => {
                   // Streaming occlusion lock: the usage flip below runs at the
                   // wrapper's SYNCHRONOUS return, but a wrapper that places this
@@ -1714,7 +1797,7 @@ export function createDocumentSlotProps(clientProps, frameId) {
                 // `undefined` in the record (argBorderForm), so the t=0 fill
                 // takes the same value — the one-record shape holds for the
                 // args the fill saw, not only the ones it shipped.
-                resolved[key] = vals[key] = withoutStandIns(value, key, occurrence);
+                resolved[key] = vals[key] = withoutStandIns(value, key, occurrence, documentNeeds);
               }
             }
             const out = suppressedFill(() =>
@@ -1747,7 +1830,7 @@ export function createDocumentSlotProps(clientProps, frameId) {
                 if (!isContainerTraced(value) && isServerContent(value)) continue;
                 // Containers (at any depth) ride the record as trace envelopes;
                 // everything else passes through by reference.
-                args[key] = argBorderForm(value, key, occurrence);
+                args[key] = argBorderForm(value, key, occurrence, documentNeeds);
               }
               // A CLONE settles the declaration (or IS the record, on a sync
               // render); `args` stays canonical for the ledger below —
@@ -1790,7 +1873,7 @@ export function createDocumentSlotProps(clientProps, frameId) {
                     evals[key],
                     states[key],
                     value => {
-                      args[key] = argBorderForm(value, key, occurrence);
+                      args[key] = argBorderForm(value, key, occurrence, documentNeeds);
                       liveArgs.slot(frameId, occurrence, { ...args });
                     }
                   );
@@ -1875,6 +1958,43 @@ const FRAME_ELEMENT_CLOSE = `</${FRAME_TAG}>`;
  * never saw the first) rides `ctx.live`, the shared slot the root context
  * creates and every derived context inherits by reference.
  */
+/**
+ * The document face's tier announcement (frames savings pass §2): the
+ * `sc:tiers` hydration record — the names of the frames-client tiers the
+ * document's server components have minted, `_$HY.r["sc:tiers"] =
+ * ["bind", …]` — and, when the integration gave the tier's chunk URL
+ * (`frameTransformDirectResult`'s `tierUrls`), a `modulepreload` for it in
+ * the head. The client's `installServerComponents` reads the record and
+ * starts each import; the preload made it warm.
+ *
+ * The record is RE-WRITTEN at each new mint with the cumulative list:
+ * written once at the first mint, a later component's tier (or one inside
+ * a boundary that resumes before the shell) would be missing from it,
+ * and the hydration serializer parses a value when it is written. Every
+ * write before the shell flush lands in the shell's data script (the last
+ * assignment wins — the complete set); one after it is a later script,
+ * which the client may or may not have run by install — the adopt-time
+ * sync's own detection covers that (the hold). The link goes through the
+ * render's asset registry (`registerAsset("module")`: joins the shell head
+ * before the flush, writes into the stream after; identity-deduped).
+ *
+ * Carrier: `ctx.live`, the one slot the streaming root context shares by
+ * reference with every component's context copy (see
+ * `armDocumentLiveHoles`). A sync render (`renderToString`) has no shared
+ * slot and no later script — it announces nothing; the client detects.
+ */
+function documentNeeds(name) {
+  const ctx = sharedConfig.context;
+  const live = ctx && ctx.live;
+  if (!live || !ctx.serialize) return;
+  const tiers = live.tiers || (live.tiers = []);
+  if (tiers.includes(name)) return;
+  tiers.push(name);
+  ctx.serialize("sc:tiers", tiers.slice());
+  const url = live.tierUrls && live.tierUrls[name];
+  if (url && ctx.registerAsset) ctx.registerAsset("module", url);
+}
+
 function armDocumentLiveHoles(ctx) {
   if (!ctx || ctx.liveHoles !== undefined) return;
   const live = ctx.live;
@@ -2025,7 +2145,21 @@ function armDocumentLiveHoles(ctx) {
  */
 export function frameTransformDirectResult<T>(
   value: T,
-  options: { id: string; args?: unknown[] }
+  options: {
+    id: string;
+    args?: unknown[];
+    /**
+     * The client chunk URL of each frames-client tier, by tier name (the
+     * integration's, from its manifest — the server does not know the
+     * client's chunks). Given, the document emits a `modulepreload` for a
+     * tier when a server component first mints its feature, beside the
+     * `sc:tiers` record it writes either way; absent, the record alone
+     * announces the name and the client's `installServerComponents` starts
+     * the import from it. Document-wide: the first call's map is the
+     * render's.
+     */
+    tierUrls?: Record<string, string>;
+  }
 ): T;
 
 /**
@@ -2036,7 +2170,7 @@ export function frameTransformDirectResult<T>(
  * ELEMENT around it, document-mode slot props inside. HTTP calls are
  * untouched (`frameTransformResult` owns that leg).
  */
-export function frameTransformDirectResult(value, { id, args }) {
+export function frameTransformDirectResult(value, { id, args, tierUrls }) {
   if (typeof value !== "function") return value;
   const component = value;
   const wrapped = props => [
@@ -2048,6 +2182,10 @@ export function frameTransformDirectResult(value, { id, args }) {
     serverOwned(() => {
       const page = sharedConfig.context;
       armDocumentLiveHoles(page);
+      // The tier chunk URLs, for the document's `modulepreload` links (see
+      // documentNeeds) — on the shared slot, so every component's mint
+      // reads them.
+      if (tierUrls && page && page.live && !page.live.tierUrls) page.live.tierUrls = tierUrls;
       // Handler positions: arm the compiled `ssrClaim` guard — and the
       // spread walk's slot probes — for this subtree, on a render context
       // DERIVED from the page's (prototype: every shared field and method
@@ -2071,8 +2209,11 @@ export function frameTransformDirectResult(value, { id, args }) {
         // every async source inside takes its first value and closes — the
         // document completes, and the standing render is the client's
         // connection after hydration (RFC 11 §9.5, Server face 3). Read at
-        // render, not at wrap: the brand arrives from `live`, outside.
-        return serverComponentScope(() => component(slotProps), !!wrapped[LIVE_SOURCE]);
+        // render, not at wrap: the brand arrives from `live`, outside. That
+        // connection is the wire tier's — announced with the document.
+        const live = !!wrapped[LIVE_SOURCE];
+        if (live) documentNeeds("wire");
+        return serverComponentScope(() => component(slotProps), live);
       } finally {
         sharedConfig.context = page;
       }
@@ -2311,6 +2452,9 @@ export function createSlotProps(sink, frame) {
   const getters = new Map();
   // Repeated calls are one occurrence within a render (see repeatKey).
   const repeats = new Map();
+  // The tier announcement (createFrameSink's `needs`); a composed sink
+  // without one announces nothing — the client detects and holds.
+  const needs = sink.needs || (() => {});
   return new Proxy(Object.create(null), {
     // Every key virtually exists — a prop is a *position* the client may
     // fill, and the server cannot know which ones the client supplied. This
@@ -2332,7 +2476,7 @@ export function createSlotProps(sink, frame) {
       if (!fn) {
         fn = (...callArgs) => {
           if (callArgs.length === 0 || callArgs[0] === undefined) {
-            return slotProxy(slotRange(prop), prop, SLOT_FACE_STREAM, undefined);
+            return slotProxy(slotRange(prop), prop, SLOT_FACE_STREAM, undefined, undefined, needs);
           }
           const rk = repeatKey(prop, callArgs[0]);
           const repeat = rk !== undefined && repeats.get(rk);
@@ -2480,8 +2624,11 @@ export function createSlotProps(sink, frame) {
               } else {
                 const ref = `arg:${occurrence}:${key}`;
                 // Containers (at any depth) swap for their trace envelopes
-                // before the value meets seroval — see toBorderForm.
-                ctx.serialize(ref, argBorderForm(value, key, occurrence));
+                // before the value meets seroval — see toBorderForm. A
+                // container announces the `trace` tier (`sink.needs`)
+                // before the serializer emits the record's data chunk, so
+                // the announcement rides that very chunk.
+                ctx.serialize(ref, argBorderForm(value, key, occurrence, needs));
                 args[key] = { $ref: ref };
                 if (evaluate && !state) state = { settled: true, last: value };
               }
@@ -2511,7 +2658,7 @@ export function createSlotProps(sink, frame) {
               } else {
                 const ref = `arg:${occurrence}:${key}@${sink.nextArgRef(ledgerKey)}`;
                 sink.mintRef(ref);
-                ctx.serialize(ref, argBorderForm(value, key, occurrence));
+                ctx.serialize(ref, argBorderForm(value, key, occurrence, needs));
                 args[key] = { $ref: ref };
               }
               sink.slot(occurrence, { ...args });
@@ -2526,7 +2673,8 @@ export function createSlotProps(sink, frame) {
             occurrence,
             SLOT_FACE_STREAM,
             undefined,
-            rk === undefined || keyed ? undefined : () => repeats.has(rk) || repeats.set(rk, out)
+            rk === undefined || keyed ? undefined : () => repeats.has(rk) || repeats.set(rk, out),
+            needs
           );
           if (keyed) repeats.set(rk, out);
           return out;
@@ -2654,7 +2802,16 @@ export function serverComponentResponse(component, options = {}, init = {}) {
             closed = true;
           }
         },
-        end
+        end,
+        // The tiers the sync render pass minted, into the response head
+        // (`X-Frame-Tiers`; frames savings pass §2). `start` runs
+        // synchronously inside the `ReadableStream` constructor, so this
+        // fires before the `Response` below is built — the head carries
+        // what the render knew at its first flush; anything later rides
+        // in-band on a chunk. Omitted when the pass minted nothing.
+        [ANNOUNCE](tiers) {
+          if (tiers.length) headers.set(FRAME_TIERS_HEADER, tiers.join(","));
+        }
       });
     },
     cancel() {
diff --git a/packages/web/frames/src/frame-transport.ts b/packages/web/frames/src/frame-transport.ts
index ecb223c7f..5b33ab7ea 100644
--- a/packages/web/frames/src/frame-transport.ts
+++ b/packages/web/frames/src/frame-transport.ts
@@ -20,8 +20,7 @@ import {
   deserializeStream,
   frameAddress,
   getServerFunctionsCodec,
-  hasFlightMetadata,
-  isEventStream
+  hasFlightMetadata
 } from "../../server-functions/src/shared.js";
 import { observeFrameApply } from "../../src/observe.js";
 
@@ -33,7 +32,7 @@ const IS_OBSERVE = "_SOLID_OBSERVE_" as unknown as boolean;
 // experimental preview, excluded from the 2.0 stability guarantee: API
 // shapes and the wire format may change between prereleases (RFC 11).
 // Every export in this module is @experimental.
-import { FrameChunk, FrameHost } from "./frame-client.js";
+import { FrameChunk, FrameHost, prepareTier, tierLoads } from "./frame-client.js";
 
 import { JSONCodecOptions } from "../../serialization/src/serializer-decode.js";
 
@@ -113,6 +112,20 @@ export interface ServerComponentHandlerOptions<C = unknown> {
  */
 export const FRAME_STREAM_HEADER = "X-Frame-Stream";
 
+/**
+ * The tiers a frame stream needs (frames savings pass §2, the
+ * server-announced tier mechanism): the names, comma-separated, of the
+ * frames-client tiers the render had minted when the response head left
+ * — `bind,regions,assets,trace,wire` — so the client starts their loads
+ * before it reads the body. Omitted when nothing was minted. A tier first
+ * needed after the head rides in-band instead: `tiers` on the next chunk
+ * (`FrameChunk.tiers`). Additive wire: an old client ignores both; a new
+ * client without them falls back to detection at the readiness check and
+ * holds (frames-rulings 3.1) — the same DOM, later.
+ * @experimental
+ */
+export const FRAME_TIERS_HEADER = "X-Frame-Tiers";
+
 /**
  * The resume request's have-list (RFC 11 §9.5, Resume request): the
  * digests the client holds for the address it is reconnecting — the root
@@ -131,24 +144,9 @@ export const FRAME_HAVE_HEADER = "X-Frame-Have";
 /** The have-list's size ceiling in encoded bytes (see FRAME_HAVE_HEADER). */
 export const FRAME_HAVE_BUDGET = 4096;
 
-/**
- * Encodes a have-list for the header: `key=digest` pairs, comma-joined
- * (keys never contain either separator; the root's key is empty).
- * `undefined` when the list is empty or over budget.
- * @internal
- */
-export function encodeHaveList(have: Record<string, string>): string | undefined;
-
-export function encodeHaveList(have) {
-  let out = "";
-  for (const key in have) {
-    const digest = have[key];
-    if (typeof digest !== "string") continue;
-    out += (out ? "," : "") + key + "=" + digest;
-    if (out.length > FRAME_HAVE_BUDGET) return undefined;
-  }
-  return out || undefined;
-}
+// The encoder (`encodeHaveList`) is the live wire tier's (wire-tier.ts): the
+// client sends the have-list only from a `live` reconnect, which runs
+// through the tier. The decoder below is the server's.
 
 /**
  * Decodes a have-list header value; `undefined` for an absent/empty one.
@@ -247,17 +245,20 @@ async function observedApplyFrameResponse(response, host, options = {}) {
  */
 function applyFrames(response, host, options = {}, observation) {
   const rootId = response.headers.get(FRAME_STREAM_HEADER) ?? "";
+  // The announced tiers (see FRAME_TIERS_HEADER): their loads start here,
+  // before the body is read, so a tier downloads in parallel with the
+  // stream and is resident by the time a frame's sync needs it. Idempotent
+  // and a no-op for a tier with no loader (eager).
+  response.headers.get(FRAME_TIERS_HEADER)?.split(",").forEach(prepareTier);
   const as = options.as;
   const version = options.version;
   const perFrame = typeof version === "function" ? new Map() : null;
-  // A `live` loop's call (the slot it threads through its invoke options —
-  // see LIVE_WIRE): the body is read through the loop's own reader when it
-  // is framed as an event stream, and the connection's end is reported to
-  // the loop instead of being judged here.
-  const wire = options[LIVE_WIRE];
-  const connection = wire && wire.connection;
-  const reader =
-    wire && isEventStream(response) ? wire.open(response.body) : new ChunkReader(response.body);
+  // A `live` loop's call runs through the live wire tier (wire-tier.ts,
+  // `connect`), which hands its own reader in under the loop's slot
+  // (LIVE_WIRE): the loop's event-stream reader when the body is framed as
+  // one, and the connection's end is judged THERE — by what the body left
+  // open, told to the loop — never here.
+  const reader = options[LIVE_WIRE] || new ChunkReader(response.body);
   // The frames this response has begun (`start`) and not yet ended —
   // `complete` is the bounded signal (a frame the server declared done), an
   // unkeyed `error` the failing kind of it. A body that ends with any still
@@ -267,24 +268,6 @@ function applyFrames(response, host, options = {}, observation) {
   // ids as applied (remapped, per-frame versioned), so an error record
   // written for one lands in its store.
   const open = new Map();
-  // Supersession (§9.5, Client face 4): the handler cancels this connection
-  // when a newer response writes the address — the read ends as a death
-  // carrying the reason, and the loop reconnects from it.
-  let cancelled;
-  let resolveEnd;
-  if (connection) {
-    connection.ended = new Promise(resolve => (resolveEnd = resolve));
-    connection.cancel = reason => {
-      if (cancelled !== undefined) return;
-      cancelled = reason;
-      // The reader owns the body's lock; cancelling through it ends the
-      // drain as a clean body end (the death is in `open`, not the error).
-      try {
-        const r = reader.cancel && reader.cancel(reason);
-        if (r && typeof r.then === "function") r.then(undefined, () => {});
-      } catch {}
-    };
-  }
   const errorRecord = (id, error) => ({
     type: "error",
     id,
@@ -311,36 +294,48 @@ function applyFrames(response, host, options = {}, observation) {
         // The observe tier's chunk census (see `observedApplyFrameResponse`);
         // folds with the literal.
         if (IS_OBSERVE && observation) observation.chunk(chunk, wireId);
-        // Codec-free until a `data` chunk actually arrives: a host whose
-        // deserializer loads lazily (`prepareData`) gets awaited here, and
-        // because the loop is sequential every later chunk — the records
-        // referencing this data included — queues behind the load. Chunk
+        // In-band tier announcement (`chunk.tiers`, see FRAME_TIERS_HEADER):
+        // a tier the render first needed after the head left names itself
+        // on the next chunk out; its load starts here. A `data` chunk that
+        // carries the name is one whose node tree NEEDS the tier to decode
+        // (the serializer minted the feature on this very record — a
+        // container trace's plugin node materializes into a live container
+        // only with the tier resident), so it awaits the load, as it awaits
+        // the codec below.
+        const needs = chunk.tiers?.map(prepareTier) || [];
+        // Codec-free until a chunk that READS data actually arrives: a host
+        // whose deserializer loads lazily (`prepareData`) gets awaited here,
+        // and because the loop is sequential every later chunk — the
+        // records referencing this data included — queues behind the load.
+        // A `slot` chunk whose args carry a `{$ref}` reads data too (its
+        // refs settle at the write, through its response's table — a key
+        // not delivered yet is the TABLE's pending read, so the table must
+        // exist); the producer emits the data ahead of the record that
+        // names it, so on its wire this await is already answered. Chunk
         // ORDER is the only contract downstream (network jitter already
         // stretches time between chunks), so nothing else observes the wait.
-        if (chunk.type === "data" && host.prepareData) await host.prepareData();
+        if (
+          chunk.type === "data" ||
+          (chunk.type === "slot" && Object.values(chunk.args).some(v => v && v.$ref))
+        )
+          await Promise.all([host.prepareData?.(), ...needs]);
         host.apply(chunk);
       }
       result = await reader.next();
     }
   };
-  // How the body ended, judged by what it left open. A live loop is TOLD
-  // (the connection's lifetime signal — death or completion — and the sweep
-  // it may run over the open frames if the iteration ends for good by
-  // error; `close` leaves them as they stand, since a superseding
-  // reconnect re-renders them). Without a loop, an open frame's death is an
-  // ERROR on the frame — a bounded server component the server never
+  // How the body ended, judged by what it left open: an open frame's death
+  // is an ERROR on the frame — a bounded server component the server never
   // declared complete was cut off mid-render, and nothing resumes it
   // (undeclared death, D1): the record surfaces through `frame.error`, and
-  // the content already applied stays.
+  // the content already applied stays. (A live loop's verdict is the wire
+  // tier's: its host swallows this sweep once the body has drained and
+  // tells the loop instead — death or completion, with the sweep the loop
+  // may run if the iteration ends for good by error.)
   const end = error => {
-    const dead = error || cancelled || new Error("Frame stream ended before the frame completed.");
-    const sweep = () => {
-      for (const id of open.keys()) host.apply(errorRecord(id, dead));
-    };
-    if (connection) {
-      connection.done = true;
-      resolveEnd({ open: open.size, error: dead, sweep, close: () => {} });
-    } else if (error === undefined) sweep();
+    if (error === undefined)
+      for (const id of open.keys())
+        host.apply(errorRecord(id, new Error("Frame stream ended before the frame completed.")));
   };
   return drain().then(
     () => {
@@ -425,26 +420,29 @@ export const stagedContent: {
 // seam never needs a global.
 let resolveServerComponent;
 
-// The call behind an address, as the transport saw it — `{ id, meta, args }`
-// — recorded when a response for it is handled (or the document answered
-// it). An address is a one-way hash of the call, so this is the only way
-// back from "this address errored" to "ask the server again": a frame's
-// `:error` is its one async value rejecting (frames-rulings 3.3), and the
-// enclosing `<Errored>`'s `reset` re-reads the landing — an errored landing
-// is not a landing for a fresh consumer, so the re-read is a new flight for
-// the same address, re-invoked from this record (`client.ts`, `reask`).
-// Same module-state pattern as `resolveServerComponent`; one entry per
-// address, the newest call wins (same call, same hash).
+// The call behind an address, as the transport saw it — `{ id, meta, args,
+// retry }` — recorded when a response for it is handled (or the document
+// answered it). An address is a one-way hash of the call, so this is the
+// only way back from "this address errored" to "ask the server again": a
+// frame's `:error` is its one async value rejecting (frames-rulings 3.3),
+// and the enclosing `<Errored>`'s `reset` re-reads the landing — an errored
+// landing is not a landing for a fresh consumer, so the re-read is a new
+// flight for the same address, made again through the call's own `retry`
+// (the server-function client's thunk for the dispatch it made — see
+// `client.ts`, `reask`). Same module-state pattern as
+// `resolveServerComponent`; one entry per address, the newest call wins
+// (same call, same hash).
 const calls = new Map();
 
 /**
- * The call recorded for an address (`{ id, meta, args }`), or `undefined`
- * for an address no response or document answer named.
+ * The call recorded for an address — `{ id, meta, args, retry }`, `retry`
+ * the thunk that makes the same call again — or `undefined` for an address
+ * no response or document answer named.
  * @internal
  */
 export function callFor(
   address: string
-): { id: string; meta: unknown; args: unknown[] } | undefined;
+): { id: string; meta: unknown; args: unknown[]; retry(): Promise<unknown> } | undefined;
 
 export function callFor(address) {
   return calls.get(address);
@@ -596,18 +594,42 @@ export function flightCodec(codec) {
  * @experimental
  */
 export function createServerComponentHandler<C>(options: ServerComponentHandlerOptions<C>): {
-  intercept?(info: { id: string; meta: unknown; args: unknown[] }): unknown;
+  /**
+   * `retry` (the server-function client's thunk for the call it is
+   * answering or dispatched, declared shape included) is recorded behind
+   * the call's address for the re-ask (`callFor`, frames-rulings 3.3).
+   */
+  intercept?(info: {
+    id: string;
+    meta: unknown;
+    args: unknown[];
+    retry?(): Promise<unknown>;
+  }): unknown;
   handle(
     response: Response,
-    ctx: { id: string; meta: unknown; args: unknown[]; context: unknown }
+    ctx: {
+      id: string;
+      meta: unknown;
+      args: unknown[];
+      context: unknown;
+      retry?(): Promise<unknown>;
+    }
   ): unknown;
+  /**
+   * A `live()` call was made (before its first fetch): starts the live wire
+   * tier's load (`prepareTier("wire")`), so the import races only the
+   * request — preload-at-call.
+   */
+  onLive(): void;
   /**
    * What a `live` (re)connect of the call resumes from (RFC 11 §9.5,
    * Resume request): the address's version ordinal as the position
    * (`Last-Event-ID`) and, when a mount shows the address with a ledger,
    * its have-list under `FRAME_HAVE_HEADER` — omitted over budget, so the
    * render is a full snapshot then. `undefined` when nothing here has
-   * shown the call.
+   * shown the call — or while the live wire tier, which keeps the ledger
+   * and answers this, is not resident yet (a first connect over content a
+   * plain call applied: a full snapshot, the degraded case accepted).
    */
   resume(info: {
     id: string;
@@ -618,10 +640,8 @@ export function createServerComponentHandler<C>(options: ServerComponentHandlerO
    * Declares that the document is showing a call: hydration-data references
    * carry their call's address (`_$SC.r(id, address)`) but never travel
    * through the transport, so the integration forwards those records here.
-   * Mints the call's binding (a post-load refetch then resolves a value
-   * whose component matches what the document mounted) and brands the
-   * per-function component so cache-seeded readers deliver instead of
-   * remounting when their site later switches calls.
+   * Mints the call's binding, so a post-load refetch resolves a value
+   * whose component matches what the document mounted.
    */
   showing(address: string, functionId: string): void;
 };
@@ -768,13 +788,6 @@ export function createServerComponentHandler({ host, component, intercept }) {
   // party that observes ordering across transports (a getter refetch, a
   // mutation's regions, a preload), so stale-guarding is per-address here.
   const versions = new Map();
-  // The live connection per address — the `live` loop's call whose body is
-  // currently streaming into the store (its lifetime slot, see LIVE_WIRE).
-  // One per address: content is keyed by call, so two live readers of one
-  // call share one connection (the second joins the first's lifetime below)
-  // — otherwise each would supersede the other's stream and the two loops
-  // would cycle for as long as both were mounted.
-  const connections = new Map();
   const bump = address => {
     const version = (versions.get(address) || 0) + 1;
     versions.set(address, version);
@@ -783,24 +796,13 @@ export function createServerComponentHandler({ host, component, intercept }) {
     staged.delete(address);
     // Supersession is a death (§9.5, Client face 4): a newer version from
     // another response — a getter refetch, a preload, a mutation's region —
-    // makes the open connection's later chunks inert under the stale-guard,
-    // so it is cancelled and the loop reconnects from the death. Run for
-    // every bump, the loop's own reconnect included (whose predecessor has
-    // already ended and left the slot).
-    const connection = connections.get(address);
-    if (connection) {
-      connections.delete(address);
-      connection.cancel(new Error("Superseded by a newer response for the address."));
-    }
+    // makes an open live connection's later chunks inert under the
+    // stale-guard, so it is cancelled and the loop reconnects from the
+    // death. The connections are the live wire tier's (wire-tier.ts): a
+    // page with the tier absent has none to cancel.
+    tierLoads.wire?.r?.cancel(host, address);
     return version;
   };
-  /** Register a live connection under its address until its body ends. */
-  const hold = (address, connection) => {
-    connections.set(address, connection);
-    connection.ended.then(() => {
-      if (connections.get(address) === connection) connections.delete(address);
-    });
-  };
   /**
    * An unstaged response has begun for an address — at its header, before
    * its body is read. The address's store moves to the response's version
@@ -835,19 +837,17 @@ export function createServerComponentHandler({ host, component, intercept }) {
           return hit.then(landed => (landed ? binding() : undefined));
         return binding();
       }),
+    // Preload-at-call (plan §1, the wire row): `live()` fires this at the
+    // call, before its first fetch, so the tier's import races only the
+    // request; `handle`'s live arm awaits the same load.
+    onLive() {
+      prepareTier("wire");
+    },
+    // The resume request is the tier's (`resume`: the ordinal, the mount's
+    // have-list). Before the tier is resident nothing here has shown a live
+    // call — the ledger is kept there — so the loop's own cursor stands.
     resume(info) {
-      const address = frameAddress(info.id, info.args);
-      const version = versions.get(address);
-      // The ledger is the MOUNT's (it tracks what the DOM shows); the first
-      // mount under the address speaks for all — they show the same store.
-      const frame = host.get(address);
-      const have = frame && frame.have ? frame.have() : undefined;
-      if (version === undefined && !have) return undefined;
-      const encoded = have && encodeHaveList(have);
-      return {
-        position: String(version || 0),
-        headers: encoded ? { [FRAME_HAVE_HEADER]: encoded } : undefined
-      };
+      return tierLoads.wire?.r?.resume(host, info, versions);
     },
     handle(response, ctx) {
       if (!isFrameStreamResponse(response)) return undefined;
@@ -863,43 +863,20 @@ export function createServerComponentHandler({ host, component, intercept }) {
       if (response.headers.has(SINGLE_FLIGHT_HEADER)) {
         return applyFlightResponse(response, address, binding);
       }
-      // A `live` loop's call: the binding resolves it now, and the
-      // response's lifetime — its end and how it ended — reaches the loop
-      // through its wire slot (§9.5, Client face 2), so frames CONSUME the
-      // loop rather than mirror it: death → the loop's backoff and
-      // re-invoke, which resolves this same binding again (stable per
-      // address, so an equals-gated reader keeps its instance); completion
-      // → the loop completes.
+      // A `live` loop's call (its wire slot rides on the ctx, see
+      // LIVE_WIRE) is the live wire tier's (wire-tier.ts, `connect`): the
+      // binding resolves it, and the response's lifetime reaches the loop
+      // through the slot (§9.5, Client face 2). The arm AWAITS the tier —
+      // `live()` started the load at the call (`onLive`), so the import
+      // raced only the request and is usually here; the body is not read
+      // before it is, so a live connection without the tier cannot happen.
+      // `connection.ended` is set inside `connect`, before the promise this
+      // returns resolves — the loop reads it after awaiting the call.
       const wire = ctx[LIVE_WIRE];
-      const connection = wire && wire.connection;
-      if (connection) {
-        // A live connection already streams this address: join its
-        // lifetime instead of opening a second stream into the same store
-        // (see `connections`). This response is ended here — the server
-        // tears its render down on the cancel — and the joining loop sees
-        // the shared connection's death when it comes, reconnecting like
-        // the loop that owns it (one of the two wins the next slot; the
-        // other joins again).
-        const current = connections.get(address);
-        if (current && !current.done) {
-          connection.ended = current.ended;
-          const body = response.body;
-          if (body) body.cancel().catch(() => {});
-          return binding;
-        }
-        const version = bump(address);
-        begin(address, version);
-        // The end is judged by the loop from `connection.ended` (set
-        // synchronously by applyFrames); a rejected read is a death it
-        // already sees, not an error record — the loop decides what the
-        // open frames become (a sweep when it ends by error, nothing when
-        // it reconnects).
-        applyFrameResponse(response, host, { as: address, version, [LIVE_WIRE]: wire }).catch(
-          () => {}
+      if (wire)
+        return prepareTier("wire").then(() =>
+          tierLoads.wire.r.connect(response, wire, address, binding, host, bump, begin)
         );
-        hold(address, connection);
-        return binding;
-      }
       // The call behind the address, for a re-ask (see `calls`): a plain
       // response's — a `live` loop owns its own reconnects.
       calls.set(address, ctx);
@@ -941,21 +918,12 @@ export function createServerComponentHandler({ host, component, intercept }) {
      * through this seam instead — the t=0 reference carries it (see
      * ServerComponentPlugin.serialize). Minting the binding here keeps a
      * post-load refetch of the same call resolving a value whose component
-     * matches what the document mounted; branding the document's per-
-     * function placeholder (the cache-seeded value readers hold at t=0)
-     * lets an equals-gated reader deliver instead of remounting when its
-     * site later switches calls.
+     * matches what the document mounted. (The reference the reader holds
+     * at t=0 is the bootstrap's BINDING for the address — branded there —
+     * never the bare per-function placeholder, so nothing brands it here.)
      */
     showing(address, functionId) {
       bindingFor(address, functionId);
-      const comp = componentFor(functionId);
-      if (
-        comp &&
-        (typeof comp === "function" || typeof comp === "object") &&
-        !comp[COMPONENT_BINDING]
-      ) {
-        comp[COMPONENT_BINDING] = { component: comp, address };
-      }
     }
   };
 
diff --git a/packages/web/frames/src/regions-tier.ts b/packages/web/frames/src/regions-tier.ts
new file mode 100644
index 000000000..6d40f4fc6
--- /dev/null
+++ b/packages/web/frames/src/regions-tier.ts
@@ -0,0 +1,271 @@
+/**
+ * `@solidjs/web/frames/regions` — the frames client's REGIONS tier (frames
+ * savings pass §3 row C4): nested server-content regions, loaded on demand
+ * through the tier mechanism (`prepareTier("regions")`, frame-client.ts).
+ *
+ * A region is server content passed as a PROP to a client fill (`{$frame}`
+ * in the occurrence's record, the arg's wire id): a `<solid-frame>` region
+ * ELEMENT the wrapper places like any node — the platform moves the subtree
+ * as one — with a frame bound over it that the host routes the region's
+ * chunks to, so the region fills and morphs wherever (and whether) the
+ * wrapper placed it. Occluded regions (not placed yet — behind an expand)
+ * bind and fill off-DOM, then reveal in place when the wrapper inserts the
+ * single node. On the document face a used region's content is already in
+ * the adopted interior, and the record's `{$frame}` resolves to THAT
+ * element (claim wiring, not identity recovery — A5).
+ *
+ * What rides in this chunk, and so leaves the eager frames client: the
+ * per-frame region cache (arg name -> entry), element discovery in an
+ * adopted interior, the `{$frame}` arm of the frame's arg resolution
+ * (mint / reuse / rename), binding a frame over each region element with
+ * the parent's slot resolution threaded down, and disposal. The eager
+ * client keeps one test — a record naming a region while this tier is
+ * absent WAITS (`needsRegions`: a fresh mount in the held set, the frame's
+ * hold registered under frames-rulings 3.1 on the adopt path; a mounted
+ * occurrence's new record pending in the store) — and the document face's
+ * `sc:region:` drain, which lands an occluded region's html in the host
+ * store regardless (the frame this tier binds seeds from it on install).
+ *
+ * The module's exports ARE its appliers: `prepareTier` records the module
+ * in the runtime's dispatch table (`tierModules.regions`) and the frame
+ * calls `resolve` / `bind` / `unmount` / `changed` / `frames` through it;
+ * no `install()` is needed — nothing of this tier lives outside the
+ * runtime's dispatch. After the install, one flush per live frame re-syncs
+ * what the tier made applicable: a held occurrence mounts with its region
+ * element, a pending record applies.
+ *
+ * The server announces this tier where it mints a region (`sink.needs
+ * ("regions")` in `region()`, the document face's `documentNeeds("regions")`
+ * where a slot arg is server content — frame-sink.ts), so the load is a
+ * warm start; an un-announced record starts it from the readiness check
+ * and waits (the same DOM, later).
+ *
+ * Region identity and wire names: the cache keys by ARG NAME, because
+ * `(occurrence, arg)` IS the region's identity while its `$frame` childId
+ * is a per-stream wire name — producers prefix it differently (the
+ * document and direct responses render under the function id, a
+ * single-flight region under the call's address). A re-sent ref whose only
+ * change is the wire name keeps the region — same element, same live
+ * interior — and the bound frame REBINDS to the new name so the incoming
+ * stream's chunks reach it (`rename`). This is the compensation
+ * server-components-principles.md §4 row 19 names; it deletes when regions
+ * become store substructure keyed `(parent address, occurrence, arg)` (§5.3,
+ * the SC audit's S7) and the wire id normalizes at the store boundary — not
+ * here, where a direct response and a flight refresh of the same boundary
+ * still address one region by two names.
+ * @experimental
+ */
+// The eager frames client — the SHARED instance the app runs (external in the
+// dist build: rollup.config.js's externalizeFramesClient resolves this to
+// `@solidjs/web/frames`; a bundled copy would mint frames nobody routes to).
+// `createFrame` is how the tier binds a frame over a region element: the
+// runtime's own class, registered with the parent's host.
+import { createFrame } from "./client.js";
+// Pure DOM helpers, bundled into this chunk as their own copy (no module
+// state, no instance to keep in agreement — frame-client is importless by
+// design).
+import { eachInRange, isFrameElement, makeFrameElement, FRAME_ID_ATTR } from "./frame-client.js";
+
+/** One region of an occurrence: its wire id, its element, the frame bound
+ *  over it once `bind` ran, and whether the element was adopted from the
+ *  document (its content is already there). */
+interface RegionEntry {
+  childId: string;
+  element: Element;
+  frame: any;
+  adopt?: boolean;
+}
+type Regions = Map<string, RegionEntry>;
+
+// Per frame: occurrence -> (arg name -> entry). Weak, so a frame that goes
+// away takes its cache with it even if `unmount` never ran for it.
+const byFrame = new WeakMap<object, Map<string, Regions>>();
+
+const regionsFor = (frame: any, occurrence: string): Regions => {
+  let slots = byFrame.get(frame);
+  if (!slots) byFrame.set(frame, (slots = new Map()));
+  let regions = slots.get(occurrence);
+  if (!regions) slots.set(occurrence, (regions = new Map()));
+  return regions;
+};
+
+/**
+ * Collect the OUTERMOST frame region elements in `node`'s subtree into
+ * `regions` (keyed by arg name — the childId's final segment, always the
+ * dot-free arg identifier — seeded for adoption). A region is opaque — its
+ * own deeper regions belong to its occurrences, discovered when they claim —
+ * so the walk stops descending at each region element. Client wrapper
+ * elements around a region are descended through.
+ */
+function collectRegionElements(node: Node, regions: Regions): void {
+  if (node.nodeType !== 1) return;
+  if (isFrameElement(node)) {
+    const childId = (node as Element).getAttribute(FRAME_ID_ATTR);
+    // Region ids are dotted (`<producer frame>.<occurrence>.<arg>`); bare ids
+    // belong to nested document BOUNDARIES, which own their interiors (the
+    // walk stops at every frame element, so a nested boundary's own regions
+    // are never reachable from here). The producer prefix is wire-relative —
+    // a mount registered under a call ADDRESS still adopts markup produced
+    // under the function id — so region membership is structural
+    // (outermost-in-this-interior), not prefix-matched.
+    if (childId && childId.includes(".")) {
+      const argKey = childId.slice(childId.lastIndexOf(".") + 1);
+      if (!regions.has(argKey))
+        regions.set(argKey, { childId, element: node as Element, frame: undefined, adopt: true });
+    }
+    return;
+  }
+  for (let c = node.firstChild; c; c = c.nextSibling) collectRegionElements(c, regions);
+}
+
+/**
+ * Element discovery for the adopt path — claim wiring only (A5): the t=0
+ * record names every region arg by `{$frame}` address, and this walk
+ * locates the already-rendered ELEMENTS those addresses resolve to,
+ * seeding entries (marked `adopt`) so `resolve` reuses the adopted node
+ * instead of minting an empty one. Seed from the OUTERMOST region elements
+ * in the interior (a region's own deeper regions belong to its
+ * occurrences and are discovered recursively when those claim); `bind`
+ * then constructs adopting frames over them, which run their own slot
+ * sync — this is what wires nested occurrences at boot. A data occurrence
+ * (`start` is its consumer list) has no interior: its args are data, and a
+ * region arg has nowhere to render at an attribute position.
+ */
+function discover(frame: any, occurrence: string, start: unknown): void {
+  if (!start || Array.isArray(start)) return;
+  const regions = regionsFor(frame, occurrence);
+  eachInRange(start, occurrence, (n: Node) => collectRegionElements(n, regions));
+}
+
+/**
+ * Point a cached region entry at a new wire name: the identity (occurrence,
+ * arg) and the live element/interior stay, while the bound frame re-registers
+ * under the id the incoming stream addresses its content by. An entry not
+ * bound yet (discovery just seeded it) only updates its element's id — the
+ * eager bind that follows registers under the new name.
+ */
+function rename(entry: RegionEntry, childId: string): void {
+  entry.childId = childId;
+  if (entry.frame) entry.frame.rebind(childId);
+  else entry.element.setAttribute(FRAME_ID_ATTR, childId);
+}
+
+/**
+ * The `{$frame}` arm of a frame's arg resolution: for each region arg of
+ * the record (`regions`: arg name -> wire id), the region ELEMENT the
+ * wrapper places goes into `props` — cached per occurrence, so a re-call
+ * re-places the SAME element (no marker range to walk, no fragment refill)
+ * and the bound frame's parent follows live. `start` is given on the
+ * adopt-time mount (the frame's `claiming`): the interior's region elements
+ * are discovered first, so the record's addresses resolve to them.
+ */
+export function resolve(
+  frame: any,
+  occurrence: string,
+  regions: Record<string, string>,
+  props: Record<string, unknown>,
+  start?: unknown
+): void {
+  if (start) discover(frame, occurrence, start);
+  const cache = regionsFor(frame, occurrence);
+  for (const key in regions) {
+    const childId = regions[key];
+    let entry = cache.get(key);
+    if (!entry)
+      cache.set(key, (entry = { childId, element: makeFrameElement(childId), frame: undefined }));
+    else if (entry.childId !== childId) rename(entry, childId);
+    props[key] = entry.element;
+  }
+}
+
+/**
+ * Bind a frame over each of the occurrence's region elements that has none
+ * yet — those `resolve` minted during the invoke or, on the adopt path,
+ * discovered in the interior before the fill ran (the fill owns its range
+ * through the framework's insert; the frame never reads its output back).
+ * Bind eagerly — the region ELEMENT always exists (unlike a marker range,
+ * which needs placement to count).
+ * This is what makes an OCCLUDED region work: its element is created when
+ * args resolve but the wrapper doesn't place it until (e.g.) expand, so it
+ * must bind and fill (from buffered/streamed chunks) off-DOM, then reveal
+ * in place when the wrapper finally inserts the single node. Host
+ * buffering flushes any queued childId chunks. The region inherits this
+ * frame's slot resolution (`parent`), so client slots revealed in its
+ * streamed content are filled by the same callbacks the client threaded
+ * down — no global registry.
+ */
+export function bind(frame: any, occurrence: string): void {
+  const regions = byFrame.get(frame)?.get(occurrence);
+  if (!regions) return;
+  const o = frame.options;
+  for (const entry of regions.values()) {
+    if (!entry.frame) {
+      entry.frame = createFrame(entry.element, {
+        id: entry.childId,
+        host: o.host,
+        // Regions discovered from adopted document elements already hold
+        // their server-rendered content (adopt); streamed regions start
+        // empty. Claim scoping threads the root boundary's id down.
+        adopt: entry.adopt,
+        claimScope: o.claimScope ?? o.id,
+        // Element-claim sweeps in the region bind cleanup to the same
+        // boundary owner as the root's.
+        ownerScope: o.ownerScope,
+        parent: frame
+      } as any);
+    }
+  }
+}
+
+/**
+ * Dispose the frames bound over an occurrence's regions and forget them;
+ * without an occurrence, every region of the frame (the frame is being
+ * disposed).
+ */
+export function unmount(frame: any, occurrence?: string): void {
+  const slots = byFrame.get(frame);
+  if (!slots) return;
+  const dispose = (regions: Regions) => {
+    for (const { frame: bound } of regions.values()) bound?.dispose();
+  };
+  if (occurrence === undefined) {
+    for (const regions of slots.values()) dispose(regions);
+    byFrame.delete(frame);
+  } else {
+    const regions = slots.get(occurrence);
+    if (regions) {
+      dispose(regions);
+      slots.delete(occurrence);
+    }
+  }
+}
+
+/**
+ * For the staged preview (`Frame.preview`): whether the record adds a
+ * region to the occurrence or renames one of its regions — its chunks ride
+ * the new name, so the rename must land with them at the commit, not in
+ * the preview. Read off the host's note of the record's `{$frame}` args.
+ */
+export function changed(
+  frame: any,
+  occurrence: string,
+  record: { regions?: Record<string, string> }
+): boolean {
+  const regions = byFrame.get(frame)?.get(occurrence);
+  for (const key in record.regions) {
+    const entry = regions && regions.get(key);
+    if (!(entry && entry.childId === record.regions[key])) return true;
+  }
+  return false;
+}
+
+/** The frames bound over the frame's regions (the staged preview recurses
+ *  into them). */
+export function frames(frame: any): any[] {
+  const out: any[] = [];
+  const slots = byFrame.get(frame);
+  if (slots)
+    for (const regions of slots.values())
+      for (const { frame: bound } of regions.values()) if (bound) out.push(bound);
+  return out;
+}
diff --git a/packages/web/frames/src/server.ts b/packages/web/frames/src/server.ts
index 5d24b1879..57fcf08ce 100644
--- a/packages/web/frames/src/server.ts
+++ b/packages/web/frames/src/server.ts
@@ -155,5 +155,8 @@ export {
   FRAME_STREAM_HEADER,
   FRAME_HAVE_HEADER,
   FRAME_HAVE_BUDGET,
+  // The tier announcement's header name (frames savings pass §2). The client
+  // entry reads it but does not re-export it (its one use inlines).
+  FRAME_TIERS_HEADER,
   isFrameStreamResponse
 } from "./frame-transport.js";
diff --git a/packages/web/frames/src/trace-tier.ts b/packages/web/frames/src/trace-tier.ts
new file mode 100644
index 000000000..554dee178
--- /dev/null
+++ b/packages/web/frames/src/trace-tier.ts
@@ -0,0 +1,51 @@
+/**
+ * `@solidjs/web/frames/trace` — the frames client's TRACES tier (frames
+ * savings pass §3 row C3): the container tier's client half, loaded on
+ * demand through the tier mechanism (`prepareTier("trace")`, frame-client.ts).
+ *
+ * What rides in this chunk, and so leaves the eager frames client: solid's
+ * container-trace materializer (`solid-js/internal/container-trace` — the
+ * store engine's one edge into a server-component page, ~8 KB brotli with
+ * the projection/reconcile machinery it builds on) and the plugin's client
+ * half that reaches it (`frame-container-plugin.js`: the shared hook state,
+ * the materialization memo, the marker test, the deep arg-revive walk, the
+ * container probe). The eager client keeps only the trigger: the loader
+ * entry (`tierLoaders.trace`), the held-set predicate (a `{ $tr }` marker in
+ * an adopt-time record's args while this tier is absent — the occurrence is
+ * HELD, its server interior on screen, the frame's hold registered under
+ * frames-rulings 3.1), and the container probe through the plugin's
+ * registered state object.
+ *
+ * `install()` is the tier's one export, called once by `prepareTier` when
+ * the import resolves — before the install's flush re-syncs every live
+ * frame, so a held occurrence mounts with the materializer in place:
+ *   - the materializer goes onto the plugin's shared state
+ *     (`setContainerTraceMaterializer`), where the lazy codec's own copy of
+ *     the plugin reads it at decode (a `data` chunk that carries a trace
+ *     awaits this tier through its `tiers` announcement, so the decode
+ *     finds it installed);
+ *   - the shared host's `revive` becomes the deep arg-revive walk
+ *     (`reviveContainerTraces`): document-face markers in a record's
+ *     literal args materialize at the mount's arg-read, with the mount's
+ *     `claiming` hint — an adopt-time mount's trace parks its backlog
+ *     beyond the snapshot until hydration ends (frames-rulings 3.6 (iii)).
+ *
+ * The server announces this tier where it serializes a trace (`sink.needs
+ * ("trace")`: `X-Frame-Tiers` / `chunk.tiers` on a stream, `_$HY.r["sc:
+ * tiers"]` + a `modulepreload` on a document — frame-sink.ts), so the load
+ * is a warm start; an un-announced marker starts it from the readiness
+ * check and holds (the same DOM, later).
+ * @experimental
+ */
+import { materializeContainerTrace } from "solid-js/internal/container-trace";
+// The eager frames client — the SHARED instance the app runs (external in the
+// dist build: rollup.config.js's externalizeFramesClient resolves this to
+// `@solidjs/web/frames`; a bundled copy would wire a host nobody mounts in).
+import { getFrameHost } from "./client.js";
+import { reviveContainerTraces, setContainerTraceMaterializer } from "./frame-container-plugin.js";
+
+/** Install the traces tier into the frames client (called by `prepareTier`). */
+export function install(): void {
+  setContainerTraceMaterializer(materializeContainerTrace);
+  getFrameHost().revive = reviveContainerTraces;
+}
diff --git a/packages/web/frames/src/wire-tier.ts b/packages/web/frames/src/wire-tier.ts
new file mode 100644
index 000000000..293e417e5
--- /dev/null
+++ b/packages/web/frames/src/wire-tier.ts
@@ -0,0 +1,341 @@
+/**
+ * `@solidjs/web/frames/wire` — the frames client's LIVE WIRE tier (frames
+ * savings pass §3 row C2, E.a2): what a `live()` loop's connection needs of
+ * the frames transport, loaded on demand through the tier mechanism
+ * (`prepareTier("wire")`, frame-client.ts).
+ *
+ * A live server component streams into its address's store for as long as
+ * the loop holds the connection: the body is read through the loop's own
+ * event-stream reader, the connection's end — death or completion, judged
+ * by the frames the body left open — is told to the loop through its wire
+ * slot (`LIVE_WIRE`, RFC 11 §9.5 Client face 2), a newer response for the
+ * address cancels the open connection (supersession, Client face 4), two
+ * loops on one call share one connection, and a reconnect names what the
+ * page shows — the address's version ordinal as `Last-Event-ID` and the
+ * mount's have-list of server digests as `X-Frame-Have` (§9.5 Resume
+ * request) — so the server answers conditionally.
+ *
+ * What rides in this chunk, and so leaves the eager frames client: the
+ * per-host connection map (`connect` joins or opens; `cancel` supersedes),
+ * the SSE reader selection and the connection's lifetime (`ended` /
+ * `cancel` / `done`, the open-frame count the end is judged by, the sweep
+ * the loop may run), the have-list ledger per mount (`have` keeps it off
+ * the frame's applied content records, `haveOf` reads it) and the resume
+ * request (`resume` + `encodeHaveList`). The eager client keeps the
+ * dispatch alone: `handle`'s `LIVE_WIRE` arm awaits the load and hands
+ * over, `bump` asks the resident module to cancel, the frame's
+ * `#recordHave` hands each applied record to `have`, and `resume` answers
+ * through the resident module or not at all.
+ *
+ * Preload-at-call (plan §1, the wire row): `live()`'s decorator fires the
+ * handler's `onLive` hook at the call — before its first fetch — and the
+ * frames handler's hook is `prepareTier("wire")`, so the import races only
+ * the request; `handle`'s arm awaits the same promise before the body is
+ * read, so a live connection without this chunk is impossible by
+ * construction (no buffer, no hold). The server announces the tier too
+ * (`X-Frame-Tiers: wire` on a live response, `sc:tiers` on a document
+ * carrying a live source), a warm start for a page that connects before
+ * any `live()` call runs.
+ *
+ * The degraded case, accepted: content applied to a mount BEFORE this
+ * chunk was resident (a plain call's response, a document-adopted
+ * interior) kept no ledger — `have` was not here to keep it — so a live
+ * connect over that mount resumes from the version ordinal with no
+ * have-list and the server answers with a full snapshot (today's
+ * post-adoption connect already does). Degraded, not wrong; the live
+ * response's own root resets the ledger with the tier resident.
+ * @experimental
+ */
+// The eager frames client — the SHARED instance the app runs (external in the
+// dist build: rollup.config.js's externalizeFramesClient resolves this to
+// `@solidjs/web/frames`; `applyFrameResponse` must be the one the handler's
+// own host routes through).
+import { applyFrameResponse } from "./client.js";
+// The transport's have-list header name and budget — two literals, bundled
+// (the client entry stops exporting them: frames residue pass, residue 1).
+import { FRAME_HAVE_BUDGET, FRAME_HAVE_HEADER } from "./frame-transport.js";
+// The server-function wire layer — the SHARED built instance (external:
+// rollup.config.js's externalizeSharedTransport resolves this to
+// `@solidjs/web/server-functions/client`).
+import {
+  ChunkReader,
+  LIVE_WIRE,
+  frameAddress,
+  isEventStream
+} from "../../server-functions/src/shared.js";
+
+import type { FrameHost, FrameHostOptions } from "./frame-client.js";
+
+/**
+ * The host the handler hands over: the frame host, carrying the lazily
+ * loaded deserializer's load (`prepareData`) the transport awaits before a
+ * chunk that reads data — forwarded unchanged to the connection's proxy.
+ */
+type Host = FrameHost & Pick<FrameHostOptions, "prepareData">;
+
+/** A live loop's wire slot (see `LIVE_WIRE` in server-functions/shared.ts). */
+interface WireSlot {
+  connection: Connection;
+  open(body: ReadableStream<Uint8Array> | null): {
+    next(): Promise<IteratorResult<string>>;
+    cancel?(reason?: unknown): unknown;
+  };
+}
+
+/** The connection slot the loop renews per connect (`wire.connection`). */
+interface Connection {
+  ended?: Promise<ConnectionEnd>;
+  cancel?(reason: Error): void;
+  done?: boolean;
+}
+
+/** How a connection ended, as the loop reads it off `connection.ended`. */
+interface ConnectionEnd {
+  open: number;
+  error: Error;
+  sweep(): void;
+  close(): void;
+}
+
+// One live connection per address per host (the handler's `connections`):
+// content is keyed by call, so two live readers of one call share one
+// connection — the second joins the first's lifetime — otherwise each would
+// supersede the other's stream and the two loops would cycle for as long as
+// both were mounted.
+const connections = new WeakMap<object, Map<string, Connection>>();
+const connectionsOf = (host: object) => {
+  let map = connections.get(host);
+  if (!map) connections.set(host, (map = new Map()));
+  return map;
+};
+
+// The have-list ledger, per MOUNT (RFC 11 §9.5): what the mount shows, by
+// the server's own digests — reset by a root apply (the root IS the
+// content; its `holes` seed the entries inside), extended by each reveal,
+// kept current by each hole/attr apply. Applied-state, so it tracks the DOM
+// without reading it — a fragment received but not yet revealed is not in
+// it, and a resume whose connection dies in between still asks for the
+// reveal. Absent until a digest-carrying root applies with this tier
+// resident. Written through the frame's `#recordHave`; read by `resume`.
+const ledgers = new WeakMap<object, Record<string, string> | undefined>();
+
+/**
+ * Ledger upkeep for an applied content record (the frame's `#recordHave`
+ * hands every one here): `""` is the root and RESETS the ledger to the
+ * root's digest and hole map; any other key takes the record's digest and
+ * the map of holes inside it. A record without a digest (an older
+ * producer) leaves the entry as it was. Without a ledger (no digest-
+ * carrying root applied) there is nothing to keep — the next resume is a
+ * full snapshot either way.
+ * @internal
+ */
+export function have(
+  frame: object,
+  key: string,
+  record: { digest?: string; holes?: Record<string, string> }
+): void {
+  if (key === "") {
+    ledgers.set(
+      frame,
+      record.digest === undefined ? undefined : { "": record.digest, ...record.holes }
+    );
+    return;
+  }
+  const ledger = ledgers.get(frame);
+  if (!ledger || !record || record.digest === undefined) return;
+  ledger[key] = record.digest;
+  if (record.holes) Object.assign(ledger, record.holes);
+}
+
+/**
+ * The have-list of what a mount shows — the server-minted digests of the
+ * root skeleton under `""`, each live hole and attr hole by ledger key,
+ * each revealed fragment by name. `undefined` when the content's provenance
+ * carried no digests, or applied before this tier was resident (a
+ * document-adopted interior, a plain call's response): a resume then takes
+ * the full snapshot.
+ * @internal
+ */
+export function haveOf(frame: object): Record<string, string> | undefined {
+  return ledgers.get(frame);
+}
+
+/**
+ * Encodes a have-list for the header: `key=digest` pairs, comma-joined
+ * (keys never contain either separator; the root's key is empty).
+ * `undefined` when the list is empty or over budget.
+ * @internal
+ */
+export function encodeHaveList(have: Record<string, string>): string | undefined {
+  let out = "";
+  for (const key in have) {
+    const digest = have[key];
+    if (typeof digest !== "string") continue;
+    out += (out ? "," : "") + key + "=" + digest;
+    if (out.length > FRAME_HAVE_BUDGET) return undefined;
+  }
+  return out || undefined;
+}
+
+/**
+ * What a `live` (re)connect of a call resumes from (the handler's
+ * `resume`): the address's version ordinal as the position and, when a
+ * mount shows the address with a ledger, its have-list under
+ * `FRAME_HAVE_HEADER` — omitted over budget, so the render is a full
+ * snapshot then. `undefined` when nothing here has shown the call. The
+ * ledger is the MOUNT's (it tracks what the DOM shows); the first mount
+ * under the address speaks for all — they show the same store.
+ * @internal
+ */
+export function resume(
+  host: FrameHost,
+  info: { id: string; args: unknown[] },
+  versions: Map<string, number>
+): { position: string; headers?: Record<string, string> } | undefined {
+  const address = frameAddress(info.id, info.args);
+  const version = versions.get(address);
+  const frame = host.get(address);
+  const list = frame && ledgers.get(frame);
+  if (version === undefined && !list) return undefined;
+  const encoded = list && encodeHaveList(list);
+  return {
+    position: String(version || 0),
+    headers: encoded ? { [FRAME_HAVE_HEADER]: encoded } : undefined
+  };
+}
+
+/**
+ * Supersession (§9.5, Client face 4): a newer version for the address from
+ * another response — a getter refetch, a preload, a mutation's region —
+ * makes the open connection's later chunks inert under the stale-guard, so
+ * it is cancelled and the loop reconnects from the death. The handler's
+ * `bump` calls this for every bump, the loop's own reconnect included
+ * (whose predecessor has already ended and left the slot).
+ * @internal
+ */
+export function cancel(host: object, address: string): void {
+  const map = connections.get(host);
+  const connection = map && map.get(address);
+  if (connection) {
+    map.delete(address);
+    connection.cancel!(new Error("Superseded by a newer response for the address."));
+  }
+}
+
+/**
+ * The live arm of the handler's `handle` (§9.5, Client face 2): the binding
+ * resolves the call now, and the response's lifetime — its end and how it
+ * ended — reaches the loop through its wire slot, so frames CONSUME the
+ * loop rather than mirror it: death → the loop's backoff and re-invoke,
+ * which resolves this same binding again (stable per address, so an
+ * equals-gated reader keeps its instance); completion → the loop
+ * completes.
+ *
+ * A live connection already streaming this address is JOINED: this
+ * response is ended here (the server tears its render down on the
+ * cancel) and the joining loop sees the shared connection's death when it
+ * comes, reconnecting like the loop that owns it (one of the two wins the
+ * next slot; the other joins again). Otherwise the response OPENS the
+ * address's connection: `bump` versions it and `begin` moves the store to
+ * the version at the header; the body is read through the loop's reader
+ * when it is framed as an event stream (`ChunkReader` otherwise), handed to
+ * the transport under the wire slot; and the end is judged HERE by what the
+ * body left open — `complete` is the bounded signal, an unkeyed `error` the
+ * failing kind of it; a body that ends with any still open is a DEATH, never
+ * a completion (§9.5, Wire) — and told to the loop with the sweep it may run
+ * over the open frames if the iteration ends for good by error (`close`
+ * leaves them as they stand: a superseding reconnect re-renders them). The
+ * transport's own end-of-body sweep (an error record per open frame, the
+ * no-loop verdict) is swallowed: the loop decides. A rejected read is a
+ * death the loop already sees, not an error record.
+ * @internal
+ */
+export function connect(
+  response: Response,
+  wire: WireSlot,
+  address: string,
+  binding: unknown,
+  host: Host,
+  bump: (address: string) => number,
+  begin: (address: string, version: number) => void
+): unknown {
+  const connection = wire.connection;
+  const map = connectionsOf(host);
+  const current = map.get(address);
+  if (current && !current.done) {
+    connection.ended = current.ended;
+    const body = response.body;
+    if (body) body.cancel().catch(() => {});
+    return binding;
+  }
+  const version = bump(address);
+  begin(address, version);
+  const inner = isEventStream(response) ? wire.open(response.body) : new ChunkReader(response.body);
+  // The body has drained: the transport's sweep follows at once and is not
+  // this connection's verdict (below).
+  let drained = false;
+  let cancelled: Error | undefined;
+  const reader = {
+    next: () =>
+      inner.next().then(result => {
+        if (result.done) drained = true;
+        return result;
+      })
+  };
+  // The frames this connection has begun (`start`) and not yet ended, as
+  // applied (remapped, versioned) — the count the end is judged by. A nested
+  // region's chunks ride inside its parent's start/complete and are not
+  // counted apart.
+  const open = new Map<string, number>();
+  const target = {
+    prepareData: host.prepareData,
+    apply(chunk: any) {
+      if (drained) return;
+      if (chunk.type === "start") open.set(chunk.id, chunk.version);
+      else if (chunk.type === "complete" || (chunk.type === "error" && !chunk.key))
+        open.delete(chunk.id);
+      host.apply(chunk);
+    }
+  };
+  let resolveEnd!: (end: ConnectionEnd) => void;
+  connection.ended = new Promise(resolve => (resolveEnd = resolve));
+  connection.cancel = reason => {
+    if (cancelled !== undefined) return;
+    cancelled = reason;
+    // The reader owns the body's lock; cancelling through it ends the drain
+    // as a clean body end (the death is in `open`, not the error).
+    try {
+      const r = inner.cancel && inner.cancel(reason);
+      if (r && typeof (r as any).then === "function")
+        (r as Promise<unknown>).then(undefined, () => {});
+    } catch {}
+  };
+  const end = (error?: Error) => {
+    const dead = error || cancelled || new Error("Frame stream ended before the frame completed.");
+    connection.done = true;
+    resolveEnd({
+      open: open.size,
+      error: dead,
+      sweep: () => {
+        for (const [id, version] of open)
+          host.apply({
+            type: "error",
+            id,
+            version,
+            error: { message: String(dead && dead.message) }
+          });
+      },
+      close: () => {}
+    });
+  };
+  applyFrameResponse(
+    response,
+    target as any,
+    { as: address, version, [LIVE_WIRE]: reader } as any
+  ).then(() => end(), end);
+  map.set(address, connection);
+  connection.ended.then(() => {
+    if (map.get(address) === connection) map.delete(address);
+  });
+  return binding;
+}
diff --git a/packages/web/package.json b/packages/web/package.json
index cdadf2670..73df21c46 100644
--- a/packages/web/package.json
+++ b/packages/web/package.json
@@ -333,6 +333,30 @@
       "types": "./types/frames/client.d.ts",
       "default": "./frames/dist/client.js"
     },
+    "./frames/trace": {
+      "types": "./types/frames/trace-tier.d.ts",
+      "default": "./frames/dist/trace.js"
+    },
+    "./frames/regions": {
+      "types": "./types/frames/regions-tier.d.ts",
+      "default": "./frames/dist/regions.js"
+    },
+    "./frames/assets": {
+      "types": "./types/frames/assets-tier.d.ts",
+      "default": "./frames/dist/assets.js"
+    },
+    "./frames/bind": {
+      "development": {
+        "types": "./types/frames/bind-tier.d.ts",
+        "default": "./frames/dist/bind.dev.js"
+      },
+      "types": "./types/frames/bind-tier.d.ts",
+      "default": "./frames/dist/bind.js"
+    },
+    "./frames/wire": {
+      "types": "./types/frames/wire-tier.d.ts",
+      "default": "./frames/dist/wire.js"
+    },
     "./types/*": "./types/*"
   },
   "scripts": {
diff --git a/packages/web/rollup.config.js b/packages/web/rollup.config.js
index 9886f8441..570dfe872 100644
--- a/packages/web/rollup.config.js
+++ b/packages/web/rollup.config.js
@@ -80,7 +80,10 @@ const replaceDev = isDev => replaceFlags(isDev, isDev);
 const externalizeSharedTransport = {
   name: "externalize-shared-transport",
   resolveId(source, importer) {
-    if (!importer || !/[\\/]frame-transport\.(js|ts)$/.test(importer)) return null;
+    // The live wire tier (wire-tier.ts) imports the same wire layer: the
+    // loop's `LIVE_WIRE` slot is a process-local symbol, so the tier must
+    // read the one instance the loop wrote.
+    if (!importer || !/[\\/](frame-transport|wire-tier)\.(js|ts)$/.test(importer)) return null;
     if (source === "../../server-functions/src/shared.js" || source === "../../src/response.js") {
       return { id: "@solidjs/web/server-functions/client", external: true };
     }
@@ -106,6 +109,29 @@ const externalizeSharedClient = {
   }
 };
 
+// The frames TIER entries (`frames/src/trace-tier.ts` →
+// `@solidjs/web/frames/trace`, `frames/src/regions-tier.ts` →
+// `@solidjs/web/frames/regions`; loaded by the frames client through
+// `prepareTier(name)`) wire themselves into the eager frames client: the
+// traces tier sets the shared host's `revive` (`getFrameHost()`) at install,
+// the regions tier binds frames (`createFrame`) the parent frame's host
+// routes to. That must be the SAME frames client instance the app mounted
+// its boundaries through, so a tier's import of the client entry resolves
+// to the external package specifier, never to a bundled private copy (whose
+// `getFrameHost()` would mint a host nothing reads, whose `createFrame`
+// would mint frames nothing routes to). Same instance-identity reasoning as
+// externalizeSharedClient above. A tier's imports of frame-client.js's pure
+// helpers stay bundled (its own copy — the module is importless and keeps
+// no state those helpers read).
+const externalizeFramesClient = {
+  name: "externalize-frames-client",
+  resolveId(source, importer) {
+    if (!importer || !/[\\/](trace|regions|bind|wire)-tier\.(js|ts)$/.test(importer)) return null;
+    if (source === "./client.js") return { id: "@solidjs/web/frames", external: true };
+    return null;
+  }
+};
+
 // The frames SERVER entry's counterpart of externalizeSharedTransport. The
 // frame sink and transport lean on three server-side modules that carry
 // module state the rest of the app writes through the PUBLIC entries:
@@ -374,7 +400,30 @@ export default [
       "@solidjs/web/server-functions/client",
       // Lazily imported (`prepareData`): the codec loads only when a `data`
       // chunk actually arrives, so the frames client ships seroval-free.
-      "@solidjs/web/serialization/decode"
+      "@solidjs/web/serialization/decode",
+      // Lazily imported (`tierLoaders.trace`, through `prepareTier`): the
+      // traces tier — solid's container-trace materializer (the store
+      // engine's one edge into a server-component page) and the plugin's
+      // client half — loads behind the server's announcement or the first
+      // adopt-time record whose args carry a trace. Its own entry below.
+      "@solidjs/web/frames/trace",
+      // Lazily imported (`tierLoaders.regions`): the regions tier — nested
+      // server-content regions (`{$frame}` args) — loads behind the
+      // server's announcement or the first record naming a region. Its own
+      // entry below.
+      "@solidjs/web/frames/regions",
+      // Lazily imported (`tierLoaders.assets`): the assets tier — the head
+      // mirror a segment's assets record drives. Its own entry below.
+      "@solidjs/web/frames/assets",
+      // Lazily imported (`tierLoaders.bind`): the bind tier — binding-slot
+      // positions (the `_s:*` marker readers, the owned-position arms, the
+      // fill's binding over `assign`). Its own entries below.
+      "@solidjs/web/frames/bind",
+      // Lazily imported (`tierLoaders.wire`): the live wire tier — a
+      // `live()` loop's connection (join / open / supersede, the SSE
+      // reader, the lifetime told to the loop, the have-list ledger and the
+      // resume request). Its own entry below.
+      "@solidjs/web/frames/wire"
     ],
     // Prod build: strip `_SOLID_DEV_` like the main `dist/web.js` entry, so the
     // frame runtime's dev checks/warnings (marker-integrity diagnostics) do
@@ -396,7 +445,12 @@ export default [
       "seroval",
       "seroval-plugins/web",
       "@solidjs/web/server-functions/client",
-      "@solidjs/web/serialization/decode"
+      "@solidjs/web/serialization/decode",
+      "@solidjs/web/frames/trace",
+      "@solidjs/web/frames/regions",
+      "@solidjs/web/frames/assets",
+      "@solidjs/web/frames/bind",
+      "@solidjs/web/frames/wire"
     ],
     plugins: [replaceFlags(false, true), externalizeSharedTransport]
       .concat(plugins)
@@ -414,12 +468,117 @@ export default [
       "seroval",
       "seroval-plugins/web",
       "@solidjs/web/server-functions/client",
-      "@solidjs/web/serialization/decode"
+      "@solidjs/web/serialization/decode",
+      "@solidjs/web/frames/trace",
+      "@solidjs/web/frames/regions",
+      "@solidjs/web/frames/assets",
+      "@solidjs/web/frames/bind",
+      "@solidjs/web/frames/wire"
     ],
     plugins: [replaceDev(true), externalizeSharedTransport]
       .concat(plugins)
       .concat(assertFramesClientTransport)
   },
+  {
+    // The traces tier (`@solidjs/web/frames/trace`, frames/src/trace-tier.ts):
+    // the container tier's client half as a lazy chunk the frames client
+    // loads through `prepareTier("trace")`. Bundles the plugin's client half
+    // (frame-container-plugin.js: the shared hook state, the memo, the
+    // marker test, the revive walk); solid's materializer stays the external
+    // `solid-js/internal/container-trace` entry so the app's bundler can
+    // give the store engine to this chunk (bundled here it would be a second
+    // engine). The eager client entry is external by instance (see
+    // externalizeFramesClient). No `_SOLID_DEV_` gates of its own, so one
+    // build serves every condition.
+    input: "frames/src/trace-tier.ts",
+    output: { file: "frames/dist/trace.js", format: "es" },
+    external: [
+      "solid-js",
+      "solid-js/internal",
+      "solid-js/internal/container-trace",
+      "@solidjs/web"
+    ],
+    plugins: [externalizeFramesClient].concat(plugins)
+  },
+  {
+    // The regions tier (`@solidjs/web/frames/regions`, frames/src/regions-tier.ts):
+    // nested server-content regions as a lazy chunk the frames client loads
+    // through `prepareTier("regions")` — the per-frame region cache,
+    // discovery in an adopted interior, the `{$frame}` arm of arg
+    // resolution, the bind of a frame over each region element, disposal.
+    // Bundles its own copy of frame-client.js's pure DOM helpers
+    // (`eachInRange`, `makeFrameElement`, `isFrameElement`); the eager
+    // client entry is external by instance (see externalizeFramesClient) —
+    // `createFrame` must be the runtime the app's host routes to. No
+    // `_SOLID_DEV_` gates of its own, so one build serves every condition.
+    input: "frames/src/regions-tier.ts",
+    output: { file: "frames/dist/regions.js", format: "es" },
+    external: ["solid-js", "solid-js/internal", "@solidjs/web"],
+    plugins: [externalizeFramesClient].concat(plugins)
+  },
+  {
+    // The assets tier (`@solidjs/web/frames/assets`, frames/src/assets-tier.ts):
+    // the head mirror a segment's assets record drives — the stylesheet
+    // gate, module / typed preloads, inline styles — as a lazy chunk the
+    // frames client loads through `prepareTier("assets")` (plan step C5).
+    // Import-free (its one import is a type), so nothing is external and no
+    // instance seam applies: the module's exports are the dispatch the
+    // eager client calls off the resident stamp, with the frame handed in.
+    // No `_SOLID_DEV_` gates of its own, so one build serves every condition.
+    input: "frames/src/assets-tier.ts",
+    output: { file: "frames/dist/assets.js", format: "es" },
+    plugins
+  },
+  {
+    // The bind tier (`@solidjs/web/frames/bind`, frames/src/bind-tier.ts):
+    // binding-slot positions as a lazy chunk the frames client loads
+    // through `prepareTier("bind")` (plan step C6) — the `_s:*` marker
+    // readers and consumer discovery, the morph's owned-position arms, the
+    // per-frame consumer set, the fill's binding over `@solidjs/web`'s
+    // `assign` (external: it binds delegated handlers into the app's own
+    // event tables; the eager frames client no longer imports it). Bundles
+    // its own copy of frame-client.js's constants and dev shape finders;
+    // the eager client entry is external by instance (externalizeFramesClient
+    // — `isAsyncValue`, and the edge that keeps an app's bundler attaching
+    // the chunk to the entry's graph instead of splitting the shared
+    // runtime out; see bind-tier.ts). Unlike the other tiers it carries
+    // `_SOLID_DEV_` gates of its own (the fill-shape and
+    // text-shape findings), so it builds twice like the client entry: this
+    // prod chunk strips them, the dev chunk below (the `development` export
+    // condition) keeps them. (`_SOLID_OBSERVE_` is not read here, so the
+    // prod chunk serves the `observe` condition too.)
+    input: "frames/src/bind-tier.ts",
+    output: { file: "frames/dist/bind.js", format: "es" },
+    external: ["solid-js", "solid-js/internal", "@solidjs/web"],
+    plugins: [replaceDev(false), externalizeFramesClient].concat(plugins)
+  },
+  {
+    input: "frames/src/bind-tier.ts",
+    output: { file: "frames/dist/bind.dev.js", format: "es" },
+    external: ["solid-js", "solid-js/internal", "@solidjs/web"],
+    plugins: [replaceDev(true), externalizeFramesClient].concat(plugins)
+  },
+  {
+    // The live wire tier (`@solidjs/web/frames/wire`, frames/src/wire-tier.ts):
+    // what a `live()` loop's connection needs of the frames transport — the
+    // per-address connection (join / open / supersede), the SSE reader
+    // selection and the connection's lifetime told to the loop, the
+    // mount's have-list ledger and the resume request — as a lazy chunk the
+    // frames client loads through `prepareTier("wire")` (plan step C2;
+    // preload-at-call from `live()`'s `onLive` hook). The eager client
+    // entry is external by instance (externalizeFramesClient —
+    // `applyFrameResponse` must be the runtime the handler's host routes
+    // through), and so is the server-function wire layer
+    // (externalizeSharedTransport — the loop's `LIVE_WIRE` slot, the
+    // `ChunkReader`, `frameAddress`, `isEventStream`; one instance). Its
+    // two literals from frame-transport.ts (the have-list header name and
+    // budget) bundle as its own copy. No `_SOLID_DEV_` gates of its own, so
+    // one build serves every condition.
+    input: "frames/src/wire-tier.ts",
+    output: { file: "frames/dist/wire.js", format: "es" },
+    external: ["solid-js", "solid-js/internal", "@solidjs/web"],
+    plugins: [externalizeFramesClient, externalizeSharedTransport].concat(plugins)
+  },
   {
     // Prod build, like the main server entry above: the sink's own
     // `_SOLID_DEV_` gates (and the bundled observe emitters') must strip —
diff --git a/packages/web/serialization/src/serializer-decode.ts b/packages/web/serialization/src/serializer-decode.ts
index 34e0644d1..97b310013 100644
--- a/packages/web/serialization/src/serializer-decode.ts
+++ b/packages/web/serialization/src/serializer-decode.ts
@@ -170,8 +170,17 @@ export interface JSONCodecOptions {
 /**
  * A resident, response-scoped decode table over the keyed JSON codec: apply
  * each frame `data` chunk with `apply`, resolve `{ $ref }` slot args with
- * `resolve`. The frames client host wires one per response
- * (`applyData: c => table.apply(c)`).
+ * `resolve`, and `close` it when the response ends. The frames client host
+ * wires one per response (`applyData: c => table.apply(c)`,
+ * `closeData: (…) => table.close(error)`).
+ *
+ * A `{ $ref }` to a key no `apply` has delivered yet is a PENDING READ the
+ * table owns (`@internal` behaviour — the frames client is its consumer): a
+ * promise marked `s = 0`, settled by the key's `apply` and rejected by
+ * `close` — the response ended without delivering the key, so a value that
+ * never comes is an error where it is read, not a silence. Stamped `s`/`v`
+ * as it settles (`1` fulfilled, `2` rejected — the hydration serializer's
+ * marks, which a reader adopts synchronously).
  *
  * Integration-facing; may change (see the entry banner). This serialization
  * entry is the single home of the data table — the frames client consumes
@@ -179,7 +188,20 @@ export interface JSONCodecOptions {
  */
 export interface JSONDataTable {
   apply(chunk: { key?: string; node?: unknown; initial?: boolean }): void;
+  /**
+   * The value under `ref`, or the table's pending read of it: a promise
+   * marked `s = 0` carrying `c`, the callbacks the table runs in the
+   * `apply` / `close` that settles it — the key delivered (whatever its
+   * value's shape: a delivered promise is adopted by the read, the
+   * callbacks do not wait for it) or the table closed.
+   */
   resolve<T = unknown>(ref: { $ref: string }): T;
+  /**
+   * The response has ended: every pending read of a key it never
+   * delivered rejects — with `error` (the response's own) when given, with
+   * an `Error` naming the key otherwise. Idempotent.
+   */
+  close(error?: unknown): void;
 }
 
 // Container traces cross as RAW seroval streams so their buffered snapshot
@@ -478,20 +500,73 @@ export function createJSONDataTable(options?: JSONCodecOptions): JSONDataTable;
  * nodes patch pending values (promise/stream resolutions) through the shared
  * deserializer refs. `resolve` reads a `{ $ref }` back out — the record ids
  * double as the reference namespace.
+ *
+ * A key the table does not hold yet answers with a PENDING READ the table
+ * owns: one promise per undelivered key (a second reader of the key gets
+ * the same one), marked `s = 0` so a consumer can tell it from a delivered
+ * value that happens to be a promise (an async arg passed whole), settled
+ * by the key's own `apply` and rejected by `close` — the response ended and
+ * the key never came (frames-rulings L1). It is stamped `s`/`v` as it
+ * settles, the marks the hydration serializer puts on a settled promise, so
+ * a reader that must stay synchronous (a fill's prop read at a t=0 claim)
+ * adopts the value without a pending beat. Owned here (`then(undefined,
+ * noop)`): a read nobody makes — the occurrence never mounted — must not
+ * surface its rejection as unhandled; a reader attaches its own handlers.
+ * The table does not know what a key is FOR: who waits on a read and what
+ * runs when it settles is the consumer's — the read carries `c`, the
+ * callbacks the table runs in the `apply` / `close` that settles it (the
+ * frames host counts a record's reads and re-applies it when the last one
+ * lands). Callbacks, not the promise's own `then`: a delivered value may
+ * itself be a promise (an async arg passed whole), which the read ADOPTS —
+ * its `then` would fire at the inner value, while the consumer must learn
+ * of the DELIVERY (a fresh mount runs then, and the fill's own boundary
+ * holds the inner wait — DR-2's value tier).
  */
 export function createJSONDataTable(options) {
   const deserialize = createJSONDeserializer(options);
   const table = new Map();
+  // key -> { p, r, j }: the pending read for an undelivered key (`p.c` its
+  // settle callbacks).
+  const waits = new Map();
+  const settle = (w, s, value) => {
+    const p = w.p;
+    p.s = s;
+    p.v = value;
+    s === 1 ? w.r(value) : w.j(value);
+    for (const c of p.c) c();
+  };
   return {
     apply(record) {
       const value = deserialize(record.node);
-      if (record.initial) table.set(record.key, value);
+      if (record.initial) {
+        table.set(record.key, value);
+        const w = waits.get(record.key);
+        if (w) {
+          waits.delete(record.key);
+          settle(w, 1, value);
+        }
+      }
     },
     get(key) {
       return table.get(key);
     },
     resolve(ref) {
-      return table.get(ref.$ref);
+      const key = ref.$ref;
+      if (table.has(key)) return table.get(key);
+      let w = waits.get(key);
+      if (!w) {
+        waits.set(key, (w = {}));
+        const p = (w.p = new Promise((r, j) => ((w.r = r), (w.j = j))));
+        p.s = 0;
+        p.c = [];
+        p.then(undefined, () => {});
+      }
+      return w.p;
+    },
+    close(error) {
+      for (const [key, w] of waits)
+        settle(w, 2, error || new Error(`Stream ended without delivering {$ref: "${key}"}`));
+      waits.clear();
     }
   };
 }
diff --git a/packages/web/server-functions/src/client.ts b/packages/web/server-functions/src/client.ts
index 158ab973d..dbfda6c8e 100644
--- a/packages/web/server-functions/src/client.ts
+++ b/packages/web/server-functions/src/client.ts
@@ -239,10 +239,34 @@ export interface ServerFunctionsClientConfig {
    */
   responseHandler?: {
     capture?(info: { id: string; meta: unknown }): unknown;
+    /**
+     * `ctx.retry` makes the same call again — the reference, arguments,
+     * declared shape and per-call options as dispatched (a `GET`-declared
+     * read stays a GET; a caller-supplied `signal` still owns the wire) —
+     * for a handler re-asking on its own account (a frames boundary's
+     * `reset`, frames-rulings 3.3).
+     */
     handle(
       response: Response,
-      ctx: { id: string; meta: unknown; args: unknown[]; context: unknown }
+      ctx: {
+        id: string;
+        meta: unknown;
+        args: unknown[];
+        context: unknown;
+        retry(): Promise<unknown>;
+      }
     ): unknown;
+    /**
+     * Answer a call before any request is made (t = 0 local answers — see
+     * `createServerComponentHandler`). `info.retry` is the call as it would
+     * go to the wire, for a handler that answers now and re-asks later.
+     */
+    intercept?(info: {
+      id: string;
+      meta: unknown;
+      args: unknown[];
+      retry(): Promise<unknown>;
+    }): unknown;
     /**
      * What a `live` (re)connect of the call resumes from, when the handler
      * shows it: `position` becomes the request's `Last-Event-ID`, `headers`
@@ -254,6 +278,13 @@ export interface ServerFunctionsClientConfig {
       meta: unknown;
       args: unknown[];
     }): { position?: string; headers?: Record<string, string> } | undefined;
+    /**
+     * A `live()` call was made — fired at the call, before its first fetch,
+     * so a handler that serves live calls through code it loads on demand
+     * (the frames client's live wire tier) can start the load against the
+     * request's own latency. Per call, not per connect.
+     */
+    onLive?(): void;
   };
   /**
    * Encoder for argument lists JSON can't carry faithfully. JSON-safe args
@@ -454,12 +485,7 @@ let rpcProvided = false;
 function provideRPC() {
   if (rpcProvided) return;
   rpcProvided = true;
-  // `createServerReference` rides the seam on the client half only: an
-  // integration holding a function's ID (the frames client re-asking an
-  // errored server component — frames-rulings 3.3) mints the callable
-  // through here instead of importing the transport into its eager graph.
-  // The server half has no wire to re-ask on.
-  provideServerFunctionRPC({ GET, decodeResponse, createServerReference });
+  provideServerFunctionRPC({ GET, decodeResponse });
 }
 
 // A reconstructed callable's base is a rendered PLAIN-HTTP address
@@ -764,6 +790,12 @@ async function dispatchServerFunction(base, id, options, args, meta, callArgs =
   // sync up to its first await), so ambient call context is still live.
   const handler = config.responseHandler;
   const context = handler && handler.capture ? handler.capture({ id, meta }) : undefined;
+  // The call as made, for the handler's `ctx.retry` (see
+  // `ServerFunctionsClientConfig.responseHandler`): the options as the
+  // caller sent them — before this dispatch's own controller is spliced in
+  // below, so the re-ask mints a controller of its own; a caller-supplied
+  // signal rides along, as it owns the wire (below).
+  const sent = options;
 
   // The call owns an AbortController so a streaming result can be ENDED, not
   // just abandoned: `iterator.return()` on the received iterable aborts the
@@ -786,7 +818,13 @@ async function dispatchServerFunction(base, id, options, args, meta, callArgs =
   // LIVE_WIRE) so the handler can read the body through the loop's reader
   // and hang the connection's end on the slot as the decoder would.
   if (handler) {
-    const ctx = { id, meta, args: callArgs, context };
+    const ctx = {
+      id,
+      meta,
+      args: callArgs,
+      context,
+      retry: () => fetchServerFunction(base, id, sent, args, meta, callArgs)
+    };
     if (options[LIVE_WIRE]) ctx[LIVE_WIRE] = options[LIVE_WIRE];
     const handled = handler.handle(response, ctx);
     if (handled !== undefined) return handled;
@@ -1002,7 +1040,9 @@ export function createServerReference(id, name, base) {
       );
     const handler = config.responseHandler;
     if (handler && handler.intercept && !adoptedCall(invokeOptions)) {
-      const hit = handler.intercept({ id, meta: metadata, args });
+      // `retry`: the call as it would go to the wire, for a handler that
+      // answers it now and re-asks later (see `ServerFunctionsClientConfig`).
+      const hit = handler.intercept({ id, meta: metadata, args, retry: send });
       if (hit !== undefined) return localOrSend(hit, send);
     }
     return send();
@@ -1100,8 +1140,9 @@ export function GET(fn) {
   const run = async (args, invokeOptions) => {
     const handler = config.responseHandler;
     if (handler && handler.intercept && !adoptedCall(invokeOptions)) {
-      const hit = handler.intercept({ id, meta: metadata, args });
-      if (hit !== undefined) return localOrSend(hit, () => send(args, invokeOptions));
+      const retry = () => send(args, invokeOptions);
+      const hit = handler.intercept({ id, meta: metadata, args, retry });
+      if (hit !== undefined) return localOrSend(hit, retry);
     }
     return send(args, invokeOptions);
   };
@@ -1311,6 +1352,10 @@ export function live(fn) {
     // any other consumer's iteration yields it first, then connects. Either
     // way the connect that follows is not answered locally again (`adopted`).
     const handler = config.responseHandler;
+    // Preload-at-call (see `responseHandler.onLive`): the handler starts
+    // whatever a live connection will need of it NOW, before this call's
+    // first fetch — the load races only the request.
+    handler && handler.onLive && handler.onLive();
     const local =
       handler && handler.intercept ? handler.intercept({ id, meta: metadata, args }) : undefined;
     const iterable = {
diff --git a/packages/web/server-functions/src/registry.ts b/packages/web/server-functions/src/registry.ts
index b9b4f3a36..7e4a8860d 100644
--- a/packages/web/server-functions/src/registry.ts
+++ b/packages/web/server-functions/src/registry.ts
@@ -263,10 +263,9 @@ export function provideServerFunctionRPC(rpc) {
  * The registered RPC surface, or undefined when no server function exists
  * in this build's graph. Integration plumbing (routers): gate every use of
  * the transport/codec behind this read instead of importing it. Both halves
- * carry `GET` and `decodeResponse`; the client half adds
- * `createServerReference(id)` — the by-id callable an integration holding
- * only a function id re-asks through (the frames client, frames-rulings
- * 3.3); the server half has no wire to re-ask on.
+ * carry `GET` and `decodeResponse`. (A handler re-asking a call it answered
+ * does so through the call's own `retry` thunk — `responseHandler` in the
+ * client config — not through this slot.)
  * @internal
  */
 export function getServerFunctionRPC() {
diff --git a/packages/web/src/index.server.ts b/packages/web/src/index.server.ts
index 27c4f7894..5fb1ba377 100644
--- a/packages/web/src/index.server.ts
+++ b/packages/web/src/index.server.ts
@@ -117,6 +117,36 @@ export function dynamic<T extends ValidComponent>(
   source: () => T | Promise<T> | null | undefined | false,
   options?: DynamicOptions
 ): Component<ComponentProps<T>> {
+  return dynamicCore(source, options, ssrTag);
+}
+
+/**
+ * The server twin of the client's `dynamicComponent`: `dynamic` for a source
+ * that only ever answers with a component, never a tag name. Same owner
+ * shape as `dynamic` on both sides (the factory / value / render memos), so
+ * hydration ids agree with the client whichever of the two mounts the same
+ * value. The client entry's JSDoc carries the cost model; here the tag arm
+ * is simply absent.
+ */
+export function dynamicComponent<C extends Component<any>>(
+  source: () => C | Promise<C> | null | undefined | false,
+  options?: DynamicOptions
+): Component<ComponentProps<C>> {
+  return dynamicCore(source, options);
+}
+
+/** `dynamic`'s string arm on the server: a tag name is one `ssrElement()`. */
+type TagArm = (tag: string, props: any) => JSX.Element;
+const ssrTag: TagArm = (tag, props) =>
+  ssrElement(tag, props, undefined, true) as unknown as JSX.Element;
+
+// The shared implementation behind `dynamic` and `dynamicComponent`; the tag
+// arm is the only thing that differs (what a string value renders as).
+function dynamicCore(
+  source: () => any,
+  options: DynamicOptions | undefined,
+  tagArm?: TagArm
+): Component<any> {
   // Static: the same owner-free path as the client — a tag is one
   // ssrElement(), a component one call — so both sides allocate the same
   // hydration keys. No memo on either level, so nothing to serialize or hold.
@@ -125,8 +155,7 @@ export function dynamic<T extends ValidComponent>(
     if (isDev && component && typeof component.then === "function")
       throw new Error("dynamic(): a static source must resolve synchronously, not to a promise");
     if (typeof component === "function") return props => (component as Function)(props);
-    if (typeof component === "string")
-      return props => ssrElement(component, props, undefined, true) as unknown as JSX.Element;
+    if (typeof component === "string" && tagArm) return props => tagArm(component, props);
     return () => undefined as unknown as JSX.Element;
   }
   // Mirrors the client exactly — three memos, the same owner shape on both
@@ -238,9 +267,9 @@ export function dynamic<T extends ValidComponent>(
         const c: unknown = value();
         if (c) {
           if (typeof c === "function") return (c as Function)(props);
-          if (typeof c === "string") {
-            return ssrElement(c, props, undefined, true) as unknown as JSX.Element;
-          }
+          // `dynamic` only: `dynamicComponent` has no tag arm, so a string
+          // renders nothing there — as it does on the client.
+          if (typeof c === "string" && tagArm) return tagArm(c, props);
         }
       },
       { sync: true } as any
diff --git a/packages/web/src/index.ts b/packages/web/src/index.ts
index 381c3e5df..8f463cfc6 100644
--- a/packages/web/src/index.ts
+++ b/packages/web/src/index.ts
@@ -332,12 +332,79 @@ export interface DynamicOptions {
  * (as a reference) or a serializable value (a tag name). A promise of a
  * client component function is a dev error on the server
  * (`DYNAMIC_ASYNC_COMPONENT`): resolve the async upstream, or use `lazy()`.
+ *
+ * Cost: because a source may answer with a tag name, one `dynamic` on a page
+ * retains the element runtime (create/claim, `spread`, the namespace tables)
+ * for everyone. A source that only ever answers with a component — a server
+ * component mount — should use `dynamicComponent`, which never does.
  */
 export function dynamic<T extends ValidComponent>(
   source: () => T | Promise<T> | AsyncIterable<T> | null | undefined | false,
   options?: DynamicOptions
 ): Component<ComponentProps<T>> {
-  if (options?.static) return staticDynamic(untrack(source));
+  return dynamicCore(source, options, staticElement);
+}
+
+/**
+ * `dynamic` for a source that only ever answers with a component — never a
+ * tag name. Same contract, same semantics, same hydration shape (the two
+ * share one implementation): a reactive, optionally async source; a stable
+ * `Component` back; `{ static: true }` and `{ deferStream: true }` as on
+ * `dynamic`. The source's type excludes strings, so a tag name is a compile
+ * error here — use `dynamic` for one.
+ *
+ * Cost model, which is the reason this exists: `dynamic` must be able to
+ * render a tag, so one `dynamic` anywhere on a page retains the element
+ * runtime — `createElement`, `spread` and the prop-collection helpers, the
+ * SVG/MathML tables — for everyone, whether or not any source ever answers
+ * with a string (a bundler cannot know what a source will resolve to).
+ * `dynamicComponent` has no tag arm and never references that runtime, so a
+ * page whose only dynamic mounts are components pays nothing for it.
+ *
+ * This is the documented way to mount a server component: a server
+ * function's answer is a component reference, and the frames transport
+ * resolves every call for the same function to the same mount identity, so
+ * a refetch or an argument change is delivered into the mounted instance
+ * rather than remounting it (see `dynamic` for the full account).
+ *
+ * @example
+ * ```tsx
+ * const Story = dynamicComponent(() => getStory(props.storyId));
+ * return <Story comment={p => <Comment cid={p.cid}>{p.children}</Comment>} />;
+ *
+ * // A client component chosen by (sync) data — the same thing `dynamic`
+ * // does, without retaining the element runtime for the page.
+ * const Page = dynamicComponent(() => (page().editable ? Editor : Viewer));
+ * ```
+ */
+export function dynamicComponent<C extends Component<any>>(
+  source: () => C | Promise<C> | AsyncIterable<C> | null | undefined | false,
+  options?: DynamicOptions
+): Component<ComponentProps<C>> {
+  return dynamicCore(source, options);
+}
+
+/**
+ * How a tag name a source resolved to becomes an element — `dynamic`'s
+ * string arm (`staticElement`: create or claim, spread, replay hydration
+ * events). The core takes it as a PARAMETER so that it never names the
+ * element runtime itself: `dynamic` passes it, `dynamicComponent` passes
+ * nothing, and a bundle whose only consumer is `dynamicComponent` sheds
+ * `staticElement` and everything under it.
+ */
+type TagArm = (tag: string, props: any) => JSX.Element;
+
+// The shared implementation behind `dynamic` and `dynamicComponent`. Every
+// line here is load-bearing for both (the pins listed in
+// documentation/plans/frames-b3-sync.md §3): the factory/value/render memo
+// shape, the FLIGHT box, kept-resolution delivery, the live address accessor.
+// The only thing the tag arm decides is what a string value renders as.
+function dynamicCore(
+  source: () => any,
+  options: DynamicOptions | undefined,
+  tagArm?: TagArm
+): Component<any> {
+  if (options?.static) return staticDynamic(untrack(source), tagArm);
   // `prev` threads into the resolution so a source switching server-component
   // calls of the same function DELIVERS instead of swapping: the memo keeps
   // its previous value (the mount below never re-renders) and the new call's
@@ -499,7 +566,10 @@ export function dynamic<T extends ValidComponent>(
         }
 
         case "string":
-          return staticElement(component, props);
+          // `dynamic` only: `dynamicComponent` has no tag arm (its source
+          // type excludes strings), so a string there renders nothing, like
+          // any other non-component value.
+          return tagArm ? tagArm(component, props) : undefined;
 
         default:
           break;
@@ -512,7 +582,7 @@ export function dynamic<T extends ValidComponent>(
 // memo, no per-instance memo — the instance IS the element or the component
 // call, owner-free like compiled JSX, so the server's static path (the same
 // rule) produces the same hydration keys.
-function staticDynamic(component: any): Component<any> {
+function staticDynamic(component: any, tagArm?: TagArm): Component<any> {
   if (isDev && component && typeof component.then === "function")
     throw new Error("dynamic(): a static source must resolve synchronously, not to a promise");
   if (typeof component === "function") {
@@ -526,7 +596,7 @@ function staticDynamic(component: any): Component<any> {
     }
     return props => untrack(() => component(props));
   }
-  if (typeof component === "string") return props => staticElement(component, props);
+  if (typeof component === "string" && tagArm) return props => tagArm(component, props);
   return () => undefined as unknown as JSX.Element;
 }
 
diff --git a/packages/web/src/server.ts b/packages/web/src/server.ts
index c42b39ae1..0679f0b33 100644
--- a/packages/web/src/server.ts
+++ b/packages/web/src/server.ts
@@ -4964,6 +4964,28 @@ function slotEntry(sv, name) {
 function slotMarker(position, entries) {
   return ` ${SLOT_MARKER}${position}="${entries}"`;
 }
+/**
+ * The replay-window stamp of an EVENT-SLOT consumer (frames savings pass
+ * C6, option (a) of the ruling): an element bound to a stand-in at a handler
+ * position (`_s:on:*`) on the DOCUMENT face carries a bare `_hk`, so the
+ * hydration bootstrap's nearest-`_hk` lookup files the element's events
+ * behind its OWN completion rather than the nearest page element's — which
+ * the page root's pass completes long before any frame tier lands, replaying
+ * the click into an element whose handler is not bound yet (lost). The bind
+ * tier completes the element at the bind and replays (bind-tier.ts). Bare
+ * (no key): the bootstrap tests presence, and no claim ever looks this
+ * element up — the ambient `_hk` sweep skips frame interiors (`data-fid`
+ * containment, client.ts `gatherHydratable`) and a prefix-scoped gather
+ * (`[_hk^="sc-…"]`, a boundary id) cannot match the empty value, so the dev
+ * completion sweep never reports it. Four bytes per element, document face
+ * only: the stream face arrives after hydration, when the bootstrap no
+ * longer queues (its `events` buffer is gone with `_$HY.done`). Server
+ * components render under NoHydration, so the element has no keyed `_hk`
+ * of its own to collide with.
+ */
+function eventSlotStamp(mode) {
+  return mode === CLAIMS_DOCUMENT ? " _hk" : "";
+}
 function propOfOccurrence(occurrence) {
   const i = occurrence.indexOf("#");
   return i === -1 ? occurrence : occurrence.slice(0, i);
@@ -5110,13 +5132,19 @@ function spreadBehaviorMarkers(behaviors, claims, mode) {
     }
   }
   let out = "";
+  let events = false;
   if (behaviors !== null) {
     for (const [pos, b] of behaviors) {
       const e = claims === undefined ? b : b.e;
-      if (e) out += slotMarker(pos === "ref" ? "ref" : "on:" + pos, e);
+      if (!e) continue;
+      if (pos === "ref") out += slotMarker("ref", e);
+      else {
+        out += slotMarker("on:" + pos, e);
+        events = true;
+      }
     }
   }
-  return out;
+  return events ? out + eventSlotStamp(mode) : out;
 }
 
 /**
@@ -5219,7 +5247,9 @@ function slotSpreadSource(tag, source) {
  * drops handler and ref expressions from plain SSR output, so this is
  * where a stand-in at one of those positions is seen. A server-local
  * function there can never run (the server has no client to run it on);
- * dev says so, inside the component barrier only.
+ * dev says so, inside the component barrier only. An element with a
+ * handler position bound is an EVENT-SLOT consumer and carries the
+ * replay-window stamp beside its markers (`eventSlotStamp`).
  */
 export function ssrClaim(map: Record<string, unknown>): string;
 
@@ -5227,11 +5257,17 @@ export function ssrClaim(map) {
   const mode = sharedConfig.context && sharedConfig.context.claims;
   if (!mode) return "";
   let out = "";
+  let events = false;
   for (const pos in map) {
     const entries = claimEntries(pos, map[pos], mode);
-    if (entries) out += slotMarker(pos === "ref" ? "ref" : "on:" + pos, entries);
+    if (!entries) continue;
+    if (pos === "ref") out += slotMarker("ref", entries);
+    else {
+      out += slotMarker("on:" + pos, entries);
+      events = true;
+    }
   }
-  return out;
+  return events ? out + eventSlotStamp(mode) : out;
 }
 
 /**
diff --git a/packages/web/test/consistency/c01-claim-once.spec.tsx b/packages/web/test/consistency/c01-claim-once.spec.tsx
index 912dac835..9997e4fd3 100644
--- a/packages/web/test/consistency/c01-claim-once.spec.tsx
+++ b/packages/web/test/consistency/c01-claim-once.spec.tsx
@@ -12,8 +12,10 @@
  *
  * Mechanism meant to carry it: frames/src/client.ts `claimRender` (the
  * range-scoped registry handed over from the root registry), `slotsFor`'s
- * `settle` (in-place output → a claim, anything else → the frame replaces),
- * frames/src/frame-client.ts `FrameImpl.#replaceRange`, client.ts
+ * `insert` of the fill's output inside the claim window (web/src/client.ts
+ * `insertExpression`'s claim pass: in-place output is a claim, a render
+ * whose nodes never entered the DOM is the core's hydration mismatch — the
+ * server's nodes stay and hydration reports them unclaimed), client.ts
  * `adoptBoundary` + `claimedBoundaries` (one adopter per element) and
  * `documentBoundary` (a second mount of a claimed id goes fresh).
  */
@@ -83,10 +85,14 @@ describe("C1 — claim once, or replace, never both, never twice", () => {
   });
 
   // Arm (b): one occurrence claims, its sibling's fill answers with FRESH
-  // nodes (built outside the claim walk). The frame must replace that range
-  // wholesale — the server node leaves the document, nothing is duplicated
-  // — while the claiming sibling is untouched.
-  test("(b) a fill returning fresh nodes replaces its range; no server node of the range is left beside the clone", async () => {
+  // nodes (built outside the claim walk). The fill is placed by `insert`
+  // (residue step 3), so this is the core's hydration mismatch and takes
+  // the core's rule: a claim pass moves nothing — the server node stays in
+  // place, the fresh render is dropped, nothing is duplicated — and
+  // hydration reports the node left unclaimed. (Before residue step 3 the
+  // frame placed the fill's output itself and replaced the range.) The
+  // claiming sibling is untouched either way.
+  test("(b) a fill returning fresh nodes at the claim is a hydration mismatch: the server node stays, nothing is duplicated, hydration reports it", async () => {
     const fid = freshFid("c1b");
     page = bootPage(
       frameHtml(
@@ -128,11 +134,12 @@ describe("C1 — claim once, or replace, never both, never twice", () => {
     const lis = [...page.container.querySelectorAll("li")];
     expect(lis.length).toBe(2);
     expect(lis[0]).toBe(serverOne);
-    expect(lis[1]).not.toBe(serverTwo);
-    expect(lis[1].className).toBe("fresh");
-    expect(serverTwo.isConnected).toBe(false);
-    expect(page.container.textContent).toBe("onefresh:two");
-    expect(page.warnings).toEqual([]);
+    expect(lis[1]).toBe(serverTwo);
+    expect(page.container.querySelector(".fresh")).toBeNull();
+    expect(page.container.textContent).toBe("onetwo");
+    expect(page.warnings.length).toBe(1);
+    expect(page.warnings[0]).toContain("unclaimed");
+    expect(page.warnings[0]).toContain(`sc-${fid}-item#1-`);
     expect(page.errors).toEqual([]);
     dispose();
   });
diff --git a/packages/web/test/consistency/c03-hydration-done-counts-holds.spec.tsx b/packages/web/test/consistency/c03-hydration-done-counts-holds.spec.tsx
index 466e86e5f..6e3418f34 100644
--- a/packages/web/test/consistency/c03-hydration-done-counts-holds.spec.tsx
+++ b/packages/web/test/consistency/c03-hydration-done-counts-holds.spec.tsx
@@ -92,11 +92,14 @@ describe("C3 — hydration-done counts every hold", () => {
 
   // Arm (b): a container-trace arg present at adoption. The record and its
   // trace snapshot are in the page when the boundary adopts; the fill reads
-  // `props.data.n` through the revived projection. On `next` the materializer
-  // is installed at module load, so the claim runs in the adopt pass and done
-  // implies claimed. (On `size/s1-lazy-store-materializer` the materializer
-  // loads lazily and `prepareArgs` HOLDS the occurrence until it lands — a
-  // hold hydration does not count; this arm is the S1 probe.)
+  // `props.data.n` through the revived projection. Since the traces tier
+  // (plan step C3) the materializer loads LAZILY (`@solidjs/web/frames/
+  // trace`, through `prepareTier("trace")`), so the adopt pass finds it
+  // absent and HOLDS the occurrence — S1's `prepareArgs` hold, re-based onto
+  // A2's registered held set: the hold is a pending boundary (3.1), so done
+  // waits for the late claim. This is S1's C3 (b) arm, green by the ruling
+  // (it was the probe that would have been red on S1 as built, where the
+  // hold registered with nothing hydration counted).
   test("(b) container-trace arg present at adoption: the occurrence has claimed by hydration end", async () => {
     const fid = freshFid("c3b");
     page = bootPage(
@@ -122,6 +125,11 @@ describe("C3 — hydration-done counts every hold", () => {
     onHydrationEnd(() => {
       invocationsAtEnd = invocations.length;
     });
+    // The adopt pass HELD the occurrence on its tier: no fill yet, the
+    // server's interior on screen, hydration not done (the hold counts).
+    expect(invocations.length).toBe(0);
+    expect(page.container.textContent).toBe("1");
+    expect(hydrationInProgress()).toBe(true);
     await quiesce();
     await quiesce();
     expect(invocations.length).toBe(1);
diff --git a/packages/web/test/consistency/c11-trace-equals-oracle.spec.tsx b/packages/web/test/consistency/c11-trace-equals-oracle.spec.tsx
index 098344099..9a2e205ad 100644
--- a/packages/web/test/consistency/c11-trace-equals-oracle.spec.tsx
+++ b/packages/web/test/consistency/c11-trace-equals-oracle.spec.tsx
@@ -21,14 +21,18 @@
  * The oracle is `applyPatches` reproduced here over a plain value: the wire
  * shape is a tuple per patch — `[path, value]` sets, `[path]` deletes
  * (`splice(i, 1)` on arrays), `[path, value, 1]` inserts (`splice(i, 0, v)`).
- * The materializer under test is whichever the branch ships: resident at
- * module load on `next`, loaded lazily behind `host.prepareArgs` on
- * `size/s1-lazy-store-materializer` — `readyMaterializer` covers both.
+ * The materializer is the frames client's traces tier (`@solidjs/web/frames/
+ * trace`, loaded through `prepareTier("trace")` — plan step C3); these cells
+ * run with it RESIDENT (`readyMaterializer` warms it as the production host
+ * has it once that load has settled). The load itself, and the hold while
+ * it pends, are `tier-trace-hold.spec` and the `container-trace-hold-*`
+ * specs under test/hydration.
  */
 import { afterEach, describe, expect, test } from "vitest";
 import { createRoot, flush, NotReadyError } from "solid-js";
 import { hydrate } from "@solidjs/web";
-import { getFrameHost, installServerComponents } from "../../frames/src/client.js";
+import { installServerComponents } from "../../frames/src/client.js";
+import { prepareTier } from "../../frames/src/frame-client.js";
 import {
   isMaterializedContainer,
   reviveContainerTraces
@@ -84,11 +88,10 @@ function read(store: any): unknown {
   }
 }
 
-/** The branch's materializer, resident. */
+/** The traces tier, resident (the production load, settled). */
 async function readyMaterializer() {
   installServerComponents();
-  const host: any = getFrameHost();
-  await host.prepareArgs?.({ probe: traceMarker().marker });
+  await prepareTier("trace");
 }
 
 /** A small deterministic PRNG (mulberry32) for the partition arm. */
diff --git a/packages/web/test/consistency/c15-staging-atomic.spec.tsx b/packages/web/test/consistency/c15-staging-atomic.spec.tsx
index eb2bc9d6e..4d62b6d3c 100644
--- a/packages/web/test/consistency/c15-staging-atomic.spec.tsx
+++ b/packages/web/test/consistency/c15-staging-atomic.spec.tsx
@@ -278,6 +278,45 @@ describe("C15 — a staged refetch lands at the commit, whole", () => {
     expect(watch.frames).toEqual(["a0|v1|one", "a2|v3|three"]);
   });
 
+  // Arm (e) — the gap #3844 named, pinned by name. A refetch resolving to
+  // the address the mount SHOWS is a write only the content token carries
+  // (`dynamic` delivers a kept resolution only when its address differs, so
+  // the bare address would be a `setAddress` no-op and nothing of the
+  // frame's graph would run in the transaction); and the fill's derivation
+  // must read the NEW arg in the pass that delivers it — not at the commit,
+  // one flush behind an optimistic intent it dissolves (principles §9.2.2,
+  // `frames-optimistic-hold`). So, with the body complete and the sibling
+  // still held: the fill HAS derived "two" (the staged read happened in the
+  // transaction's pass) while nothing shows, applies or versions it; the
+  // release lands the whole in one frame. Any carrier of the staging —
+  // the push (`preview`) or a pull — must keep both halves.
+  test("(e) the gap (#3844): a same-address refetch enters the transaction — the fill derives the new arg in its pass, the DOM holds, the commit lands whole", async () => {
+    const s = setup("c15e");
+    await showV1(s);
+    action(function* () {
+      s.setTick(1);
+    })();
+    await pump(3);
+    expect(s.calls.length).toBe(2);
+    for (const c of response(s.id, 2, "v2", "two")) s.v2.send(c);
+    s.v2.close();
+    await pump(3);
+    // The fill's derivation ran with the new arg in the transaction's pass…
+    expect(s.seen).toEqual(["one", "two"]);
+    // …while nothing of v2 is shown, applied, or versioned.
+    expect(s.view()).toBe("a0|v1|one");
+    expect(s.applied).toEqual([]);
+    expect(s.host.get(s.id)?.version).toBe(1);
+    s.sibling.release();
+    await pump(3);
+    s.sample();
+    expect(s.view()).toBe("a1|v2|two");
+    expect(torn(s.frames)).toEqual([]);
+    expect(s.frames).toEqual(["a0|v1|one", "a1|v2|two"]);
+    // Read exactly once, in the pass — never again at the commit.
+    expect(s.seen).toEqual(["one", "two"]);
+  });
+
   // Control: a refetch that moves NO sibling (a different signal re-asks
   // the call). The staged content lands when the staged call settles — at
   // body end — whole: root and fill in one frame.
diff --git a/packages/web/test/consistency/c16-reference-identity.spec.tsx b/packages/web/test/consistency/c16-reference-identity.spec.tsx
index 2e18e99bf..adc7821de 100644
--- a/packages/web/test/consistency/c16-reference-identity.spec.tsx
+++ b/packages/web/test/consistency/c16-reference-identity.spec.tsx
@@ -26,8 +26,8 @@
  * plain roots (a fill's claim is C1/C10's business).
  */
 import { afterEach, describe, expect, test, vi } from "vitest";
-import { createMemo, createRoot, createSignal, Loading } from "solid-js";
-import { dynamic, hydrate } from "@solidjs/web";
+import { createMemo, createRoot, createSignal, Loading, type Component } from "solid-js";
+import { dynamic, dynamicComponent, hydrate } from "@solidjs/web";
 import { installServerComponents } from "../../frames/src/client.js";
 import {
   COMPONENT_BINDING,
@@ -106,13 +106,23 @@ afterEach(async () => {
   document.body.innerHTML = "";
 });
 
+// Both entry points: `dynamic` and its component-only sibling
+// `dynamicComponent` share one implementation (`bindingOf`, `sameInstance`,
+// the delivery into mounted sites included); the sibling is the documented
+// server-component mount, so the rule is pinned on it by name.
+type Dyn = (source: () => any) => Component<any>;
+const VIA: ReadonlyArray<[string, Dyn]> = [
+  ["dynamic", dynamic],
+  ["dynamicComponent", dynamicComponent]
+];
+
 /**
  * A site over `source`. The document face hydrates INTO `container` (the
  * shell is the bare `<solid-frame>`); the dom face mounts a fresh root under
  * a `<Loading>`, appended to `container`.
  */
-function mountSite(source: () => unknown, container: Element, face: "document" | "dom") {
-  const Site = dynamic(() => source() as any);
+function mountSite(dyn: Dyn, source: () => unknown, container: Element, face: "document" | "dom") {
+  const Site = dyn(() => source() as any);
   let div: Element = container;
   if (face === "document") {
     disposers.push(
@@ -147,7 +157,7 @@ function mountSite(source: () => unknown, container: Element, face: "document" |
   };
 }
 
-describe("C16 — one component identity per function", () => {
+describe.each(VIA)("C16 — one component identity per function — via %s", (_via, dyn) => {
   // Arms (a), (b), (d) on one document page: the hydration reference
   // (`_$SC.r(fid, A)`) mounts first and adopts the SSR'd element; then a
   // refetch of A (staged — the site shows A), a switch to B, a re-call of A.
@@ -175,7 +185,7 @@ describe("C16 — one component identity per function", () => {
       resolutions.push(Promise.resolve(call));
       return call;
     };
-    const site = mountSite(source, page.container, "document");
+    const site = mountSite(dyn, source, page.container, "document");
     await quiesce();
     await quiesce();
     const el = site.frame()!;
@@ -259,7 +269,7 @@ describe("C16 — one component identity per function", () => {
       })
     );
     const list = createRoot(() => createMemo(() => (cache().list ?? getX()) as any));
-    const site = mountSite(() => list(), document.body, "dom");
+    const site = mountSite(dyn, () => list(), document.body, "dom");
     await pump();
     for (const c of chunks(fid, 1, "v1")) held[0].send(c);
     held[0].close();
diff --git a/packages/web/test/consistency/c17-gate-bound-address.spec.tsx b/packages/web/test/consistency/c17-gate-bound-address.spec.tsx
index 2c6690bf0..6a8c2d118 100644
--- a/packages/web/test/consistency/c17-gate-bound-address.spec.tsx
+++ b/packages/web/test/consistency/c17-gate-bound-address.spec.tsx
@@ -22,8 +22,8 @@
  * every distinct text the site showed is recorded (`watchFrames`).
  */
 import { afterEach, describe, expect, test, vi } from "vitest";
-import { createRoot, createSignal, Errored, Loading } from "solid-js";
-import { dynamic } from "@solidjs/web";
+import { createRoot, createSignal, Errored, Loading, type Component } from "solid-js";
+import { dynamic, dynamicComponent } from "@solidjs/web";
 import { installServerComponents } from "../../frames/src/client.js";
 import { createServerReference } from "../../server-functions/src/client.js";
 import { freshFid, heldStream, makeHost, pump, stubHeldFetch, watchFrames } from "./support.js";
@@ -52,9 +52,19 @@ afterEach(() => {
 // nearest client `<Errored>` as any rejected `createAsync` does — without
 // one, the core halts the reactive system. Its fallback is an `<em>`, so
 // `pending` (the `<span>` fallback) still reads the <Loading> alone.
-function mountSite(getX: (...args: any[]) => unknown) {
+// Both entry points: `dynamic` and its component-only sibling
+// `dynamicComponent` share one implementation (the address accessor the gate
+// is bound through included); the sibling is the documented server-component
+// mount, so the rule is pinned on it by name.
+type Dyn = (source: () => any) => Component<any>;
+const VIA: ReadonlyArray<[string, Dyn]> = [
+  ["dynamic", dynamic],
+  ["dynamicComponent", dynamicComponent]
+];
+
+function mountSite(dyn: Dyn, getX: (...args: any[]) => unknown) {
   const [n, setN] = createSignal(1);
-  const Site = dynamic(() => getX(n()) as any);
+  const Site = dyn(() => getX(n()) as any);
   let div!: HTMLDivElement;
   const dispose = createRoot(d => {
     <div ref={div}>
@@ -75,7 +85,7 @@ function mountSite(getX: (...args: any[]) => unknown) {
   return { div, frames: watch.frames, pending, h1, error, setN };
 }
 
-describe("C17 — the shell gate answers only to the bound address", () => {
+describe.each(VIA)("C17 — the shell gate answers only to the bound address (%s)", (_, dyn) => {
   // Arm (a): A's stream is held open after its header (the mount pends on
   // A's landing, the fallback shows); the site switches to B (B's header
   // resolved and the switch delivered — the second request is out); then
@@ -100,7 +110,7 @@ describe("C17 — the shell gate answers only to the bound address", () => {
     installServerComponents(makeHost().host);
     const { held, calls } = stubHeldFetch([WIRE, WIRE]);
     const [a, b] = held;
-    const site = mountSite(getX);
+    const site = mountSite(dyn, getX);
     await pump();
     a.send(start);
     await pump(1);
@@ -149,7 +159,7 @@ describe("C17 — the shell gate answers only to the bound address", () => {
     installServerComponents(makeHost().host);
     const { held } = stubHeldFetch([WIRE, WIRE]);
     const [a, b] = held;
-    const site = mountSite(getX);
+    const site = mountSite(dyn, getX);
     await pump();
     a.send(start);
     await pump(1);
@@ -198,7 +208,7 @@ describe("C17 — the shell gate answers only to the bound address", () => {
       await bHeader;
       return b.response;
     });
-    const site = mountSite(getX);
+    const site = mountSite(dyn, getX);
     await pump();
     a.send(start);
     await pump(1);
@@ -238,7 +248,7 @@ describe("C17 — the shell gate answers only to the bound address", () => {
     installServerComponents(makeHost().host);
     const { held } = stubHeldFetch([WIRE, WIRE]);
     const [a, b] = held;
-    const site = mountSite(getX);
+    const site = mountSite(dyn, getX);
     await pump();
     a.send(start);
     await pump(1);
@@ -268,7 +278,7 @@ describe("C17 — the shell gate answers only to the bound address", () => {
     installServerComponents(makeHost().host);
     const { held } = stubHeldFetch([WIRE]);
     const [a] = held;
-    const site = mountSite(getX);
+    const site = mountSite(dyn, getX);
     await pump();
     a.send(start);
     await pump(1);
diff --git a/packages/web/test/consistency/c19-claim-reads-snapshot.spec.tsx b/packages/web/test/consistency/c19-claim-reads-snapshot.spec.tsx
index 431f865d4..a03b0c2f5 100644
--- a/packages/web/test/consistency/c19-claim-reads-snapshot.spec.tsx
+++ b/packages/web/test/consistency/c19-claim-reads-snapshot.spec.tsx
@@ -21,10 +21,20 @@
  *
  * Release order pinned (3.2, "ordering to pin with it"): the claim, then
  * the frame's hold release, then done, then the backlog.
+ *
+ * The materializer is the frames client's traces tier (plan step C3), loaded
+ * through `prepareTier("trace")`; these cells run with it RESIDENT (warmed
+ * once below, as the production host has it once that load has settled), so
+ * the t=0 claim is synchronous. The park is keyed on the claim since C3
+ * (`revive(value, claiming)`): a fresh mount pays no beat — pinned in
+ * solid's `container-trace.spec`; the late claim UNDER THE TIER'S OWN HOLD
+ * is `container-trace-hold-snapshot.spec` (test/hydration).
  */
-import { afterEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeAll, describe, expect, test, vi } from "vitest";
 import { createSignal, flush, untrack } from "solid-js";
 import { hydrate } from "@solidjs/web";
+import { prepareTier } from "../../frames/src/frame-client.js";
+import "../../frames/src/client.js";
 import {
   bootPage,
   fillHtml,
@@ -45,6 +55,8 @@ afterEach(async () => {
   await page?.cleanup();
   page = undefined;
 });
+// The traces tier, resident before any page boots (see the module doc).
+beforeAll(() => prepareTier("trace"));
 
 /** A trace the server rendered at `n = snapshot` and then moved past. */
 function movedTrace(snapshot: number, ...patches: number[]) {
diff --git a/packages/web/test/consistency/harness/run.tsx b/packages/web/test/consistency/harness/run.tsx
index ba036149b..2a5fa9c83 100644
--- a/packages/web/test/consistency/harness/run.tsx
+++ b/packages/web/test/consistency/harness/run.tsx
@@ -11,7 +11,8 @@
 import { vi } from "vitest";
 import { createSignal, flush, untrack } from "solid-js";
 import { hydrate } from "@solidjs/web";
-import { getFrameHost, installServerComponents } from "../../../frames/src/client.js";
+import { installServerComponents } from "../../../frames/src/client.js";
+import { prepareTier } from "../../../frames/src/frame-client.js";
 import {
   bootPage,
   fillHtml,
@@ -50,17 +51,18 @@ let runCounter = 0;
 let holeCounter = 0;
 
 /**
- * On a branch whose materializer loads lazily, warm it once so trace args
- * read synchronously at claim (the pins do the same; see C11's
- * `readyMaterializer`). A no-op where the materializer is resident.
+ * The materializer is the frames client's traces tier, loaded on demand
+ * (`prepareTier("trace")`, plan step C3); warm it once so trace args read
+ * synchronously at claim (the pins do the same; see C11's
+ * `readyMaterializer`). The load and the hold while it pends have their own
+ * pins (`tier-trace-hold.spec`, the `container-trace-hold-*` specs).
  */
 let materializerReady: Promise<void> | undefined;
 async function readyMaterializer() {
   if (!materializerReady) {
     materializerReady = (async () => {
       installServerComponents();
-      const host: any = getFrameHost();
-      await host.prepareArgs?.({ probe: traceMarker().marker });
+      await prepareTier("trace");
       delete (globalThis as any)._$SC;
     })();
   }
diff --git a/packages/web/test/consistency/sref-table-pending-read.spec.tsx b/packages/web/test/consistency/sref-table-pending-read.spec.tsx
new file mode 100644
index 000000000..777e8665b
--- /dev/null
+++ b/packages/web/test/consistency/sref-table-pending-read.spec.tsx
@@ -0,0 +1,231 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * S-ref — the pending read is the decode table's (frames residue step 4).
+ *
+ * "A `{$ref}` to a key the response has not delivered yet is answered by
+ * that response's table with a promise the table owns; the key's `data`
+ * chunk settles it; the response's end rejects every read the response
+ * never answered (L1 — a value that never comes is an error where it is
+ * read, not a silence)."
+ *
+ * Mechanism: serialization/src/serializer-decode.ts `createJSONDataTable`
+ * — `resolve` of a missing key mints one pending read per key (a promise
+ * marked `s = 0`), `apply` of the key settles it (stamped `s = 1` / `v`),
+ * `close(error)` rejects what is still pending (`s = 2`); frames/src
+ * `createFrameHost.settleArgs` counts a record's pending reads
+ * (`record.pending`) and re-applies the record when the last settles; the
+ * host tells the integration a response ended (`closeData`), and the
+ * shared host (frames/src/client.ts) closes that response's table. C5 / C6
+ * pin which response's data answers a read; this file pins the read's own
+ * lifecycle — at the table (a) and through the production shared host (b,
+ * c), where no earlier pin reached the rejection.
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createMemo, createRoot, Errored, Loading } from "solid-js";
+import { dynamic } from "@solidjs/web";
+import { getFrameHost, installServerComponents } from "../../frames/src/client.js";
+import { createJSONDataTable } from "../../serialization/src/serializer.js";
+import { createServerReference } from "../../server-functions/src/client.js";
+import { createDataSource, freshFid, pump, stubHeldFetch } from "./support.js";
+
+const WIRE = "srv";
+const ARTICLE = `<article><ul><!--slot:comment#0:start--><!--slot:comment#0:end--></ul></article>`;
+const start = { type: "start", id: WIRE, version: 1 };
+const slot = (ref: string) => ({
+  type: "slot",
+  id: WIRE,
+  version: 1,
+  key: "comment#0",
+  args: { text: { $ref: ref } }
+});
+const html = { type: "html", id: WIRE, version: 1, html: ARTICLE };
+const complete = { type: "complete", id: WIRE, version: 1 };
+
+const disposers: (() => void)[] = [];
+afterEach(() => {
+  for (const d of disposers.splice(0)) d();
+  vi.unstubAllGlobals();
+  delete (globalThis as any)._$SC;
+  document.body.innerHTML = "";
+});
+
+async function sharedHost() {
+  installServerComponents();
+  const host = getFrameHost();
+  await host.prepareData({ type: "data", id: "", version: 0, node: null } as any);
+  return host;
+}
+
+/**
+ * A site under a `<Loading>` and an `<Errored>`: the fill records every
+ * value its prop read yields; a read that throws reaches the `<em>`.
+ */
+function mountSite(call: Promise<unknown>) {
+  const Site = dynamic(() => call as any);
+  const seen: string[] = [];
+  let div!: HTMLDivElement;
+  const dispose = createRoot(d => {
+    <div ref={div}>
+      <Errored fallback={err => <em>{String((err() as any)?.message)}</em>}>
+        <Loading fallback={<span>…</span>}>
+          <Site
+            comment={(p: any) => {
+              createMemo(() => seen.push(p.text));
+              return <li>{p.text}</li>;
+            }}
+          />
+        </Loading>
+      </Errored>
+    </div>;
+    document.body.appendChild(div);
+    return d;
+  });
+  disposers.push(dispose);
+  return {
+    div,
+    seen,
+    li: () => div.querySelector("li")?.textContent,
+    error: () => div.querySelector("em")?.textContent
+  };
+}
+
+describe("S-ref — the pending read is the table's", () => {
+  // Arm (a): the table alone. A missing key answers with ONE pending read
+  // (a second reader gets the same promise), marked `s = 0` so a consumer
+  // tells it from a delivered value that is itself a promise; the key's
+  // `apply` settles it, stamped `s = 1` / `v` (a synchronous reader adopts
+  // the value), and runs the read's `c` callbacks IN that apply — even
+  // when the delivered value is a pending promise the read adopts (the
+  // consumer learns of the delivery, not of the inner value); `close()`
+  // rejects what is still pending with an error naming the key,
+  // `close(error)` with the response's own; a second close is a no-op; a
+  // key delivered after a close is a value again.
+  test("(a) the table: resolve of a missing key is a marked pending read; apply settles it stamped and runs its callbacks; close rejects the rest", async () => {
+    const table = createJSONDataTable();
+    const source = createDataSource();
+    const read = table.resolve<any>({ $ref: "1" });
+    expect(read).toBeInstanceOf(Promise);
+    expect(read.s).toBe(0);
+    expect(read.c).toEqual([]);
+    expect(table.resolve({ $ref: "1" })).toBe(read);
+    const other = table.resolve<any>({ $ref: "2" });
+    expect(other).not.toBe(read);
+    const settled: string[] = [];
+    read.c.push(() => settled.push("1"));
+    other.c.push(() => settled.push("2"));
+    for (const c of source.chunks(WIRE, 1, { "1": "one" })) table.apply(c);
+    expect(read.s).toBe(1);
+    expect(read.v).toBe("one");
+    expect(settled).toEqual(["1"]);
+    await expect(read).resolves.toBe("one");
+    expect(table.resolve({ $ref: "1" })).toBe("one");
+    expect(other.s).toBe(0);
+    table.close();
+    expect(other.s).toBe(2);
+    expect(other.v).toBeInstanceOf(Error);
+    expect(other.v.message).toContain('{$ref: "2"}');
+    expect(settled).toEqual(["1", "2"]);
+    await expect(other).rejects.toBe(other.v);
+    // A key whose value is a PENDING promise: the read is settled — stamped
+    // `s = 1`, `v` the promise, callbacks run — at delivery, while the read
+    // itself (adopting the value) stays pending until the value does.
+    let resolveInner!: (v: string) => void;
+    const inner = new Promise<string>(r => (resolveInner = r));
+    const asyncRead = table.resolve<any>({ $ref: "p" });
+    let delivered = 0;
+    asyncRead.c.push(() => delivered++);
+    const patches: any[] = [];
+    for (const c of createDataSource().chunks(WIRE, 1, { p: inner }, c => patches.push(c)))
+      table.apply(c);
+    expect(delivered).toBe(1);
+    expect(asyncRead.s).toBe(1);
+    expect(asyncRead.v).toBeInstanceOf(Promise);
+    let outer: string | undefined;
+    asyncRead.then((v: string) => (outer = v));
+    await Promise.resolve();
+    expect(outer).toBeUndefined();
+    resolveInner("late");
+    await new Promise(r => setTimeout(r));
+    for (const c of patches.splice(0)) table.apply(c);
+    await expect(asyncRead).resolves.toBe("late");
+    // Idempotent; a read minted after the close is a fresh pending one.
+    table.close();
+    const late = table.resolve<any>({ $ref: "3" });
+    expect(late.s).toBe(0);
+    const reason = new Error("the response's own");
+    table.close(reason);
+    expect(late.s).toBe(2);
+    expect(late.v).toBe(reason);
+    await expect(late).rejects.toBe(reason);
+  });
+
+  // Arm (b): L1 through the production shared host. The record names a key
+  // the response never delivers; the html mounts the occurrence, which
+  // WAITS (a fresh mount pends on `record.pending`, not into its covering
+  // boundary — the frame's shell shows with the range as the server left
+  // it); the stream completes. The response's table closes, the read
+  // rejects, the mount runs and its read throws: the nearest client
+  // `<Errored>` shows the error, which names the key. Nothing fabricated
+  // ever reached the fill.
+  test("(b) a {$ref} the response never delivers rejects at complete: the fill's read throws to <Errored>, naming the key", async () => {
+    const fid = freshFid("sref-b");
+    const getX = createServerReference(fid);
+    await sharedHost();
+    const { held } = stubHeldFetch([WIRE]);
+    const [v1] = held;
+    const p1 = getX(1);
+    await p1;
+    v1.send(start);
+    v1.send(slot("1"));
+    v1.send(html);
+    await pump(1);
+    const site = mountSite(p1);
+    await pump();
+    // The shell landed; the occurrence waits on its read — no fallback, no
+    // value, no error.
+    expect(site.div.querySelector("article")).not.toBeNull();
+    expect(site.div.querySelector("span")).toBeNull();
+    expect(site.seen).toEqual([]);
+    expect(site.li()).toBeUndefined();
+    expect(site.error()).toBeUndefined();
+    v1.send(complete);
+    v1.close();
+    await pump();
+    expect(site.seen).toEqual([]);
+    expect(site.li()).toBeUndefined();
+    expect(site.error()).toContain('{$ref: "1"}');
+  });
+
+  // Arm (c) (control): the same shape with the data arriving between the
+  // record and the end — the read settles through the table's own apply,
+  // the mount runs with the value, and the close at `complete` has nothing
+  // left to reject.
+  test("(c) control: the key delivered before complete settles the read; the mount runs with the value and nothing rejects", async () => {
+    const fid = freshFid("sref-c");
+    const getX = createServerReference(fid);
+    await sharedHost();
+    const { held } = stubHeldFetch([WIRE]);
+    const [v1] = held;
+    const p1 = getX(1);
+    await p1;
+    v1.send(start);
+    v1.send(slot("1"));
+    v1.send(html);
+    await pump(1);
+    const site = mountSite(p1);
+    await pump();
+    expect(site.seen).toEqual([]);
+    for (const c of createDataSource().chunks(WIRE, 1, { "1": "one" })) v1.send(c);
+    await pump();
+    expect(site.seen).toEqual(["one"]);
+    expect(site.li()).toBe("one");
+    v1.send(complete);
+    v1.close();
+    await pump();
+    expect(site.seen).toEqual(["one"]);
+    expect(site.li()).toBe("one");
+    expect(site.error()).toBeUndefined();
+  });
+});
diff --git a/packages/web/test/consistency/support.ts b/packages/web/test/consistency/support.ts
index d6ee7efa8..6e7916ddd 100644
--- a/packages/web/test/consistency/support.ts
+++ b/packages/web/test/consistency/support.ts
@@ -332,7 +332,16 @@ export interface Page {
  * shell parses. `fetch` is stubbed to THROW unless the test re-stubs it —
  * the document face must never request what the page carries.
  */
-export function bootPage(shellHtml: string, options: { hostOptions?: Record<string, any> } = {}) {
+export function bootPage(
+  shellHtml: string,
+  options: {
+    hostOptions?: Record<string, any>;
+    /** Tier loaders for `installServerComponents({ tiers })` (frames savings pass §2). */
+    tiers?: Record<string, () => Promise<{ install?(): void }>>;
+    /** `_$HY.r` records present before the frames client installs (the shell's data script). */
+    records?: Record<string, unknown>;
+  } = {}
+) {
   installDocumentRuntime();
   const hy: any = { events: [], completed: new WeakSet(), r: {}, fe() {} };
   (globalThis as any)._$HY = hy;
@@ -357,6 +366,7 @@ export function bootPage(shellHtml: string, options: { hostOptions?: Record<stri
     }
   });
   enableHydration();
+  Object.assign(hy.r, options.records);
   // The PRODUCTION host by default (`getFrameHost()`: per-response data
   // tables, the lazy codec, the container-trace hooks — on S1 also the lazy
   // materializer's `prepareData`/`prepareArgs` seams). A document page never
@@ -365,6 +375,7 @@ export function bootPage(shellHtml: string, options: { hostOptions?: Record<stri
   // a CUSTOM host (`hostOptions`), which is the only time it is wired.
   const table = createJSONDataTable();
   let host: any;
+  const install = options.tiers ? { tiers: options.tiers } : undefined;
   if (options.hostOptions) {
     host = createFrameHost({
       applyData: (c: any) => table.apply(c),
@@ -372,9 +383,9 @@ export function bootPage(shellHtml: string, options: { hostOptions?: Record<stri
       revive: reviveContainerTraces,
       ...options.hostOptions
     });
-    installServerComponents(host);
+    installServerComponents(host, install);
   } else {
-    installServerComponents();
+    installServerComponents(undefined, install);
     host = getFrameHost();
   }
   const warnings: string[] = [];
diff --git a/packages/web/test/consistency/tier-assets-ready.spec.tsx b/packages/web/test/consistency/tier-assets-ready.spec.tsx
new file mode 100644
index 000000000..63109f0f5
--- /dev/null
+++ b/packages/web/test/consistency/tier-assets-ready.spec.tsx
@@ -0,0 +1,557 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * The assets tier's timing pin — the FOUC guard (frames savings pass §1,
+ * row "assets"; §3 row C5; §6 decision 2, ruled: tiered WITH the
+ * reveal-readiness term). The race: a `reveal` for a segment whose
+ * `seg:<k>:assets` record names stylesheets arrives before
+ * `@solidjs/web/frames/assets` (the stylesheet gate, the head mirror) has
+ * loaded. Lost, the segment would reveal unstyled and the sheet land after
+ * — a flash of unstyled content on every cold load of a style-gated
+ * fragment. The bound: ANNOUNCE + the READINESS TERM.
+ *
+ *  - `#segmentReady`: a segment whose assets record names styles while the
+ *    tier is not resident is NOT READY. The server's `<Loading>` fallback —
+ *    what the placeholder carries — stays on screen; the readiness check
+ *    starts the load if nothing announced it. The install's flush
+ *    re-evaluates: the tier's gate requests the sheets, and the reveal is
+ *    at max(tier load, stylesheet load). No frame between the fallback and
+ *    the styled content.
+ *  - A segment whose record carries INLINE styles holds the same way while
+ *    the tier is absent: its `<style>` is the tier's to land (the assets
+ *    walk), so revealing before the install would be the very unstyled
+ *    window. The install's flush lands the style and reveals the segment,
+ *    in that order. Once the tier is resident inline styles never gate: the
+ *    style lands at the record's arrival and the segment reveals in the
+ *    same flush, style first.
+ *  - A segment with neither never waits on the tier: it reveals with the
+ *    tier absent, and a stream with no asset records never loads it.
+ *    Modules and typed preloads are not reveal-gating: they buffer in the
+ *    store and apply at the install's flush.
+ *  - Announced: `X-Frame-Tiers: assets` starts the import before the body
+ *    is read; `tiers: ["assets"]` in-band (the sink stamps the first assets
+ *    chunk after the head) at the chunk; `_$HY.r["sc:tiers"]` at
+ *    `installServerComponents`.
+ *
+ * Stream face only: the document face's style gate is the core's `$dfs`.
+ * A tier, once resident, stays so for the worker: each test gates the load
+ * itself (`installServerComponents({ tiers })` replaces the built-in
+ * loader) and drops it between tests (`tierLoads`, the runtime's test seam).
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createRoot, Loading } from "solid-js";
+import { dynamic } from "@solidjs/web";
+import { applyFrameResponse, installServerComponents } from "../../frames/src/client.js";
+import { createFrame, prepareTier, tierLoads } from "../../frames/src/frame-client.js";
+import { createServerReference } from "../../server-functions/src/client.js";
+import { createChunk } from "../../server-functions/src/shared.js";
+import {
+  bootPage,
+  frameHtml,
+  freshFid,
+  makeHost,
+  pump,
+  quiesce,
+  watchFrames,
+  type Page
+} from "./support.js";
+
+/** The assets tier's load, gated by the test; `release()` installs the real module. */
+function gatedAssets() {
+  delete (tierLoads as any).assets;
+  let resolve!: (m: any) => void;
+  const loader = vi.fn(() => new Promise<any>(r => (resolve = r)));
+  return {
+    tiers: { assets: loader },
+    loader,
+    release: async () => resolve(await import("../../frames/src/assets-tier.js"))
+  };
+}
+const resident = () => !!(tierLoads as any).assets?.r;
+
+/** A held frame-stream Response with the given extra headers. */
+function heldResponse(id: string, headers: Record<string, string> = {}) {
+  let controller!: ReadableStreamDefaultController<Uint8Array>;
+  const body = new ReadableStream<Uint8Array>({
+    start(c) {
+      controller = c;
+    }
+  });
+  return {
+    response: new Response(body, { headers: { "X-Frame-Stream": id, ...headers } }),
+    send: (chunk: any) => controller.enqueue(createChunk(JSON.stringify(chunk))),
+    close: () => controller.close()
+  };
+}
+
+/** The shell: a pending placeholder per key, the server `<Loading>` fallback in each template. */
+const shell = (...keys: string[]) =>
+  `<article>${keys
+    .map(
+      k =>
+        `<template id="pl-${k}"><span class="fallback">${k}-loading</span></template><!--pl-${k}-->`
+    )
+    .join("")}</article>`;
+
+const links = () => [...document.head.querySelectorAll<HTMLLinkElement>("link")];
+const styles = () => [...document.head.querySelectorAll<HTMLStyleElement>("style[data-asset]")];
+const load = (href: string) =>
+  document.head.querySelector(`link[href="${href}"]`)!.dispatchEvent(new Event("load"));
+
+/**
+ * One observer over the head and a boundary: the order its records come in
+ * is the order of the mutations across both. `order()` is the index of the
+ * first head mutation and of the one that inserted the node with `text`.
+ */
+function observeOrder(boundary: Element) {
+  const records: MutationRecord[] = [];
+  const observer = new MutationObserver(rs => records.push(...rs));
+  observer.observe(document.head, { childList: true });
+  observer.observe(boundary, { childList: true, subtree: true });
+  return (text: string) => {
+    records.push(...observer.takeRecords());
+    observer.disconnect();
+    return {
+      head: records.findIndex(r => r.target === document.head),
+      content: records.findIndex(r =>
+        [...r.addedNodes].some(n => (n as Element).textContent === text)
+      )
+    };
+  };
+}
+
+let page: Page | undefined;
+const disposers: (() => void)[] = [];
+afterEach(async () => {
+  for (const d of disposers.splice(0)) d();
+  await page?.cleanup();
+  page = undefined;
+  vi.unstubAllGlobals();
+  delete (globalThis as any)._$SC;
+  document.head.replaceChildren();
+  document.body.innerHTML = "";
+});
+
+describe("the FOUC guard — a style-gated segment before the tier", () => {
+  test("announced in-band: the fallback stays on screen, no unstyled reveal; the tier's install requests the sheet; the reveal is at the sheet's load", async () => {
+    const gate = gatedAssets();
+    const WIRE = "tier-assets/fouc";
+    const fid = freshFid("tier-assets-a");
+    const getStory = createServerReference(fid);
+    const held = heldResponse(WIRE);
+    vi.stubGlobal("fetch", async () => held.response);
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    const Story = dynamic(() => getStory() as any);
+    let div!: HTMLDivElement;
+    const dispose = createRoot(d => {
+      <div ref={div}>
+        <Loading fallback={<span>outer</span>}>
+          <Story />
+        </Loading>
+      </div>;
+      document.body.appendChild(div);
+      return d;
+    });
+    disposers.push(dispose);
+    await pump();
+    // No head announcement (the sheet is a late segment's): nothing loads yet.
+    expect(gate.loader).not.toHaveBeenCalled();
+    const seen = watchFrames(div);
+    held.send({ type: "start", id: WIRE, version: 1 });
+    held.send({ type: "html", id: WIRE, version: 1, html: shell("c") });
+    // The server's `<Loading>` outcome: the fallback shows at the placeholder.
+    held.send({ type: "reveal", id: WIRE, version: 1, keys: ["c"], fallback: true });
+    // The style-gated fragment: its assets chunk is the first after the
+    // head, so it carries the announcement; then the content, then the
+    // reveal — all before the tier can have landed.
+    held.send({
+      type: "assets",
+      id: WIRE,
+      version: 1,
+      key: "c",
+      styles: ["/c.css"],
+      tiers: ["assets"]
+    });
+    held.send({
+      type: "fragment",
+      id: WIRE,
+      version: 1,
+      key: "c",
+      html: '<p class="styled">content</p>'
+    });
+    held.send({ type: "reveal", id: WIRE, version: 1, keys: ["c"], waitForStyles: true });
+    held.send({ type: "complete", id: WIRE, version: 1 });
+    held.close();
+    await pump();
+    // The announcement started the load (once); the readiness check found
+    // the tier absent and HELD: the fallback is what is on screen, the
+    // content is not, and no sheet could have been requested yet.
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(resident()).toBe(false);
+    expect(div.querySelector(".fallback")!.textContent).toBe("c-loading");
+    expect(div.querySelector(".styled")).toBeNull();
+    expect(div.querySelector("template#pl-c")).not.toBeNull();
+    expect(links()).toEqual([]);
+    // The tier lands: its install flushes the frame, the gate requests the
+    // sheet — and the segment is STILL held, on the sheet now.
+    await gate.release();
+    await pump();
+    expect(resident()).toBe(true);
+    expect(links().map(l => l.getAttribute("href"))).toEqual(["/c.css"]);
+    expect(div.querySelector(".fallback")!.textContent).toBe("c-loading");
+    expect(div.querySelector(".styled")).toBeNull();
+    // Every frame a user could have seen so far ends at the fallback; the
+    // content never showed (the "" is the shell landing before the
+    // server's fallback reveal — the range empty between two chunks).
+    expect(seen.frames).toEqual(["outer", "", "c-loading"]);
+    // The sheet loads: the reveal. max(tier, sheet) = the sheet.
+    load("/c.css");
+    await pump();
+    expect(div.querySelector("template#pl-c")).toBeNull();
+    expect(div.querySelector(".fallback")).toBeNull();
+    expect(div.querySelector(".styled")!.textContent).toBe("content");
+    // From the fallback straight to the styled content — nothing unstyled
+    // in between.
+    seen.stop();
+    expect(seen.frames.slice(2)).toEqual(["c-loading", "content"]);
+  });
+
+  test("the sheet already in the document: the reveal is at the tier's install (max(tier, sheet) = the tier)", async () => {
+    const gate = gatedAssets();
+    const doc = document.createElement("link");
+    doc.rel = "stylesheet";
+    doc.setAttribute("href", "/doc.css");
+    document.head.appendChild(doc);
+    const WIRE = "tier-assets/doc-sheet";
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    const boundary = document.createElement("div");
+    document.body.appendChild(boundary);
+    const frame = createFrame(boundary, { id: WIRE, host });
+    disposers.push(() => frame.dispose());
+    const held = heldResponse(WIRE);
+    const done = applyFrameResponse(held.response, host, { as: WIRE, version: 1 });
+    held.send({ type: "start", id: WIRE, version: 1 });
+    held.send({ type: "html", id: WIRE, version: 1, html: shell("c") });
+    held.send({ type: "reveal", id: WIRE, version: 1, keys: ["c"], fallback: true });
+    held.send({ type: "assets", id: WIRE, version: 1, key: "c", styles: ["/doc.css"] });
+    held.send({
+      type: "fragment",
+      id: WIRE,
+      version: 1,
+      key: "c",
+      html: '<p class="styled">in</p>'
+    });
+    held.send({ type: "reveal", id: WIRE, version: 1, keys: ["c"], waitForStyles: true });
+    held.send({ type: "complete", id: WIRE, version: 1 });
+    held.close();
+    await done;
+    // Un-announced: the readiness check started the load, and held.
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(boundary.querySelector(".fallback")).not.toBeNull();
+    expect(boundary.querySelector(".styled")).toBeNull();
+    await gate.release();
+    await pump();
+    // The gate found the document's link settled: revealed at the install.
+    expect(links()).toEqual([doc]);
+    expect(boundary.querySelector(".fallback")).toBeNull();
+    expect(boundary.querySelector(".styled")!.textContent).toBe("in");
+  });
+});
+
+describe("inline styles — held while the tier is absent, never gating once it is resident", () => {
+  test("tier absent: an inline-only segment holds like a style-gated one; the install lands its style, then reveals it", async () => {
+    const gate = gatedAssets();
+    const WIRE = "tier-assets/inline-held";
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    const boundary = document.createElement("div");
+    document.body.appendChild(boundary);
+    const frame = createFrame(boundary, { id: WIRE, host });
+    disposers.push(() => frame.dispose());
+    const held = heldResponse(WIRE);
+    const done = applyFrameResponse(held.response, host, { as: WIRE, version: 1 });
+    held.send({ type: "start", id: WIRE, version: 1 });
+    held.send({ type: "html", id: WIRE, version: 1, html: shell("inline") });
+    held.send({ type: "reveal", id: WIRE, version: 1, keys: ["inline"], fallback: true });
+    held.send({
+      type: "assets",
+      id: WIRE,
+      version: 1,
+      key: "inline",
+      inlineStyles: [{ id: "inline-only", content: "p{}" }]
+    });
+    held.send({ type: "fragment", id: WIRE, version: 1, key: "inline", html: "<p>inline</p>" });
+    held.send({ type: "reveal", id: WIRE, version: 1, keys: ["inline"], waitForStyles: false });
+    held.send({ type: "complete", id: WIRE, version: 1 });
+    held.close();
+    await done;
+    // Un-announced: the readiness check met the record with the tier
+    // absent — it started the load and HELD. The fallback is on screen, the
+    // content is not, and the style has not landed (it is the tier's to land).
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(resident()).toBe(false);
+    expect(boundary.querySelector(".fallback")!.textContent).toBe("inline-loading");
+    expect(boundary.querySelector("p")).toBeNull();
+    expect(styles()).toEqual([]);
+    // The install's flush: the walk lands the style, then the segment
+    // reveals — one observer over both targets sees the mutations in order.
+    const order = observeOrder(boundary);
+    await gate.release();
+    await pump();
+    expect(styles().map(s => s.getAttribute("data-asset"))).toEqual(["inline-only"]);
+    expect(boundary.querySelector(".fallback")).toBeNull();
+    expect(boundary.querySelector("p")!.textContent).toBe("inline");
+    const at = order("inline");
+    expect(at.head).toBeGreaterThanOrEqual(0);
+    expect(at.content).toBeGreaterThan(at.head);
+  });
+
+  test("tier resident: an inline-only segment reveals at the record's arrival, its style landing first in the same flush", async () => {
+    const gate = gatedAssets();
+    const WIRE = "tier-assets/inline-resident";
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    // Warm the tier ahead of the stream.
+    prepareTier("assets");
+    await gate.release();
+    await pump();
+    expect(resident()).toBe(true);
+    const boundary = document.createElement("div");
+    document.body.appendChild(boundary);
+    const frame = createFrame(boundary, { id: WIRE, host });
+    disposers.push(() => frame.dispose());
+    // The shell with the server's fallback showing.
+    frame.apply({
+      version: 1,
+      r: { "": { kind: "html", value: shell("inline") }, "seg:inline:fallback": true }
+    });
+    expect(boundary.querySelector(".fallback")!.textContent).toBe("inline-loading");
+    expect(styles()).toEqual([]);
+    // The segment's three records in ONE apply — one flush: the walk lands
+    // the style, then the reveal, with no readiness wait on the tier.
+    const order = observeOrder(boundary);
+    frame.apply({
+      version: 1,
+      r: {
+        "seg:inline:assets": { inlineStyles: [{ id: "inline-only", content: "p{}" }] },
+        "seg:inline": { kind: "html", value: "<p>inline</p>" },
+        "seg:inline:reveal": true
+      }
+    });
+    // Synchronously, before any task: asked no second time; revealed with
+    // the style, style first.
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(styles().map(s => s.getAttribute("data-asset"))).toEqual(["inline-only"]);
+    expect(boundary.querySelector(".fallback")).toBeNull();
+    expect(boundary.querySelector("p")!.textContent).toBe("inline");
+    const at = order("inline");
+    expect(at.head).toBeGreaterThanOrEqual(0);
+    expect(at.content).toBeGreaterThan(at.head);
+  });
+});
+
+describe("what never waits on the tier", () => {
+  test("a segment without stylesheets or inline styles reveals at once with the tier absent; styled and inline-only ones hold, revealing at the install (inline) and the sheet's load (styled)", async () => {
+    const gate = gatedAssets();
+    const WIRE = "tier-assets/unstyled";
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    const boundary = document.createElement("div");
+    document.body.appendChild(boundary);
+    const frame = createFrame(boundary, { id: WIRE, host });
+    disposers.push(() => frame.dispose());
+    const held = heldResponse(WIRE);
+    const done = applyFrameResponse(held.response, host, { as: WIRE, version: 1 });
+    held.send({ type: "start", id: WIRE, version: 1 });
+    held.send({ type: "html", id: WIRE, version: 1, html: shell("styled", "plain", "inline") });
+    held.send({
+      type: "reveal",
+      id: WIRE,
+      version: 1,
+      keys: ["styled", "plain", "inline"],
+      fallback: true
+    });
+    held.send({
+      type: "assets",
+      id: WIRE,
+      version: 1,
+      key: "styled",
+      styles: ["/s.css"],
+      tiers: ["assets"]
+    });
+    held.send({ type: "fragment", id: WIRE, version: 1, key: "styled", html: "<p>styled</p>" });
+    held.send({ type: "fragment", id: WIRE, version: 1, key: "plain", html: "<p>plain</p>" });
+    held.send({
+      type: "assets",
+      id: WIRE,
+      version: 1,
+      key: "inline",
+      inlineStyles: [{ id: "inline-only", content: "p{}" }]
+    });
+    held.send({ type: "fragment", id: WIRE, version: 1, key: "inline", html: "<p>inline</p>" });
+    held.send({
+      type: "reveal",
+      id: WIRE,
+      version: 1,
+      keys: ["styled", "plain", "inline"],
+      waitForStyles: true
+    });
+    held.send({ type: "complete", id: WIRE, version: 1 });
+    held.close();
+    await done;
+    expect(resident()).toBe(false);
+    const text = () => [...boundary.querySelectorAll("p")].map(p => p.textContent);
+    // The plain segment revealed (the grouped reveal's `waitForStyles` is
+    // the server's note; the client reads each segment's record); the
+    // style-gated one and the inline-only one are held on the tier — the
+    // inline style buffers, not applied, and its segment does not show.
+    expect(text()).toEqual(["plain"]);
+    expect(boundary.querySelector("template#pl-styled")).not.toBeNull();
+    expect(boundary.querySelector("template#pl-inline")).not.toBeNull();
+    expect([...boundary.querySelectorAll(".fallback")].map(f => f.textContent)).toEqual([
+      "styled-loading",
+      "inline-loading"
+    ]);
+    expect(styles()).toEqual([]);
+    await gate.release();
+    await pump();
+    // The install: the inline style lands (once) and its segment reveals;
+    // the sheet is requested and the styled segment still holds on it.
+    expect(styles().map(s => s.getAttribute("data-asset"))).toEqual(["inline-only"]);
+    expect(links().map(l => l.getAttribute("href"))).toEqual(["/s.css"]);
+    expect(text()).toEqual(["plain", "inline"]);
+    expect(boundary.querySelector(".fallback")!.textContent).toBe("styled-loading");
+    load("/s.css");
+    await pump();
+    expect(text()).toEqual(["styled", "plain", "inline"]);
+    expect(styles()).toHaveLength(1);
+  });
+
+  test("a stream with no asset records never loads the tier", async () => {
+    const gate = gatedAssets();
+    const WIRE = "tier-assets/none";
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    const boundary = document.createElement("div");
+    document.body.appendChild(boundary);
+    const frame = createFrame(boundary, { id: WIRE, host });
+    disposers.push(() => frame.dispose());
+    const held = heldResponse(WIRE);
+    const done = applyFrameResponse(held.response, host, { as: WIRE, version: 1 });
+    held.send({ type: "start", id: WIRE, version: 1 });
+    held.send({ type: "html", id: WIRE, version: 1, html: shell("c") });
+    held.send({ type: "fragment", id: WIRE, version: 1, key: "c", html: "<p>plain</p>" });
+    held.send({ type: "reveal", id: WIRE, version: 1, keys: ["c"], waitForStyles: false });
+    held.send({ type: "complete", id: WIRE, version: 1 });
+    held.close();
+    await done;
+    expect(boundary.querySelector("p")!.textContent).toBe("plain");
+    expect(gate.loader).not.toHaveBeenCalled();
+  });
+
+  test("module and typed preloads buffer until the install, then apply once", async () => {
+    const gate = gatedAssets();
+    const WIRE = "tier-assets/preloads";
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    const boundary = document.createElement("div");
+    document.body.appendChild(boundary);
+    const frame = createFrame(boundary, { id: WIRE, host });
+    disposers.push(() => frame.dispose());
+    const held = heldResponse(WIRE);
+    const done = applyFrameResponse(held.response, host, { as: WIRE, version: 1 });
+    held.send({ type: "start", id: WIRE, version: 1 });
+    // The shell's pre-flush assets, then the shell.
+    held.send({
+      type: "assets",
+      id: WIRE,
+      version: 1,
+      key: "",
+      modules: ["/entry.js"],
+      preloads: [{ href: "/font.woff2", attrs: { as: "font", crossorigin: "" } }]
+    });
+    held.send({ type: "html", id: WIRE, version: 1, html: "<p>shell</p>" });
+    // A late preload: the root's assets key again.
+    held.send({
+      type: "assets",
+      id: WIRE,
+      version: 1,
+      key: "",
+      preloads: [{ href: "/late.webp", attrs: { as: "image" } }]
+    });
+    held.send({ type: "complete", id: WIRE, version: 1 });
+    held.close();
+    await done;
+    // Un-announced: the walk met the record with the tier absent — it
+    // started the load and left the record pending. Content is unaffected.
+    expect(boundary.querySelector("p")!.textContent).toBe("shell");
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(links()).toEqual([]);
+    await gate.release();
+    await pump();
+    const hrefs = () => links().map(l => `${l.rel}:${l.getAttribute("href")}`);
+    expect(hrefs()).toEqual([
+      "modulepreload:/entry.js",
+      "preload:/font.woff2",
+      "preload:/late.webp"
+    ]);
+    // A later flush re-applies nothing (once per record identity per mount).
+    frame.apply({ version: 1, r: {} });
+    expect(hrefs()).toEqual([
+      "modulepreload:/entry.js",
+      "preload:/font.woff2",
+      "preload:/late.webp"
+    ]);
+  });
+});
+
+describe("the announcement", () => {
+  test("`X-Frame-Tiers: assets` starts the import before the body is read; the held segment reveals on the install + load", async () => {
+    const gate = gatedAssets();
+    const WIRE = "tier-assets/header";
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    const boundary = document.createElement("div");
+    document.body.appendChild(boundary);
+    const frame = createFrame(boundary, { id: WIRE, host });
+    disposers.push(() => frame.dispose());
+    const held = heldResponse(WIRE, { "X-Frame-Tiers": "assets" });
+    const done = applyFrameResponse(held.response, host, { as: WIRE, version: 1 });
+    await pump();
+    // The head announced it: started before any chunk of the body.
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    held.send({ type: "start", id: WIRE, version: 1 });
+    held.send({ type: "html", id: WIRE, version: 1, html: shell("c") });
+    held.send({ type: "assets", id: WIRE, version: 1, key: "c", styles: ["/h.css"] });
+    held.send({ type: "fragment", id: WIRE, version: 1, key: "c", html: "<p>h</p>" });
+    held.send({ type: "reveal", id: WIRE, version: 1, keys: ["c"], waitForStyles: true });
+    held.send({ type: "complete", id: WIRE, version: 1 });
+    held.close();
+    await done;
+    expect(boundary.querySelector("p")).toBeNull();
+    // Asked no second time by the readiness check.
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    await gate.release();
+    await pump();
+    load("/h.css");
+    await pump();
+    expect(boundary.querySelector("p")!.textContent).toBe("h");
+  });
+
+  test('document face: `_$HY.r["sc:tiers"]` names `assets` — the import starts at install', async () => {
+    const gate = gatedAssets();
+    const fid = freshFid("tier-assets-doc");
+    page = bootPage(frameHtml(fid, "<p>plain</p>"), {
+      tiers: gate.tiers,
+      records: { "sc:tiers": ["assets"] }
+    });
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    await gate.release();
+    await quiesce();
+    expect(resident()).toBe(true);
+    expect(page.errors).toEqual([]);
+  });
+});
diff --git a/packages/web/test/consistency/tier-bind-hold.spec.tsx b/packages/web/test/consistency/tier-bind-hold.spec.tsx
new file mode 100644
index 000000000..e3416f1a7
--- /dev/null
+++ b/packages/web/test/consistency/tier-bind-hold.spec.tsx
@@ -0,0 +1,335 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * The bind tier's timing pin (frames savings pass §1, row "bind"; §3 row
+ * C6). The race: a binding-slot consumer (`_s:*` markers, principles
+ * §9.2.3) adopted before `@solidjs/web/frames/bind` has loaded. Lost, the
+ * positions would never bind — the elements sit inert with no error. The
+ * bound: ANNOUNCE + HOLD, and for the delegated-event window, the STAMP.
+ *
+ *  - Document face, un-announced (the fallback): the adopt-time walk meets
+ *    a marker with the tier absent, starts the load and HOLDS the frame —
+ *    its server interior on screen, the frame's hold registered under
+ *    frames-rulings 3.1 (hydration-done waits). The install's flush binds
+ *    every occurrence; a data occurrence mounts with the CURRENT record
+ *    (its positions are written whole at the bind — no claim to match the
+ *    markup to), so a record that replaced the adopted one during the hold
+ *    is the one the fill sees, once.
+ *  - Document face, announced: `_$HY.r["sc:tiers"]` names `bind`;
+ *    `installServerComponents` starts the import before any boundary
+ *    adopts.
+ *  - The REPLAY WINDOW (the C6 ruling, option (a)): the 3.1 hold does NOT
+ *    keep it open — the bootstrap queues a delegated event only under an
+ *    `_hk` element that is not yet completed, and a frame interior has no
+ *    keyed elements of its own (server components render under
+ *    NoHydration). The server stamps a bare ` _hk` on every element with
+ *    an `_s:on:*` position (and only those; web/src/server.ts
+ *    `eventSlotStamp`); the tier marks it completed at the bind and drains
+ *    the queue. Both arms are pinned below: a click BEFORE `hydrate()` and
+ *    a click DURING the hold each replay into the bound handler at the
+ *    install. The mutant — the same page without the stamp — loses both,
+ *    pinned as the contrast. The two halves ship together: a stamp the
+ *    tier did not complete is worse than none — the bootstrap keeps
+ *    queueing the element's events and the delegated handler leaves a
+ *    queued event to the replay (`dedupEvent`), so even a click AFTER the
+ *    bind is lost; the first test's post-bind click pins the client half.
+ *  - The dev completion sweep: a stamped consumer is inside a frame
+ *    (`gatherHydratable` leaves frame interiors to their fills), so the
+ *    page root's sweep never lists it as unclaimed — no orphan `_hk` after
+ *    the bind.
+ *
+ * A tier, once resident, stays so for the worker: each test gates the load
+ * itself (`installServerComponents({ tiers })` replaces the built-in loader)
+ * and drops it between tests (`tierLoads`, the runtime's test seam).
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { untrack } from "solid-js";
+import { sharedConfig } from "solid-js/internal";
+import { hydrate } from "@solidjs/web";
+import { tierLoads } from "../../frames/src/frame-client.js";
+import { installBootstrapCapture } from "./generic/support.js";
+import {
+  bootPage,
+  frameHtml,
+  freshFid,
+  hydrationInProgress,
+  keyedElements,
+  onHydrationEnd,
+  quiesce,
+  type Page
+} from "./support.js";
+
+/** The bind tier's load, gated by the test; `release()` installs the real module. */
+function gatedBind() {
+  delete (tierLoads as any).bind;
+  let resolve!: (m: any) => void;
+  const loader = vi.fn(() => new Promise<any>(r => (resolve = r)));
+  return {
+    tiers: { bind: loader },
+    loader,
+    release: async () => resolve(await import("../../frames/src/bind-tier.js"))
+  };
+}
+const resident = () => !!(tierLoads as any).bind?.r;
+
+/**
+ * The document face of a row whose fill binds a class, a checkbox, a text
+ * and two handlers — as web/src/server.ts writes it (the values beside
+ * their markers; the stamp on the two event-slot consumers, `stamp` true).
+ */
+const rowHtml = (stamp: boolean) =>
+  `<ul><li class="todo" _s:class="row#1:done=completed">` +
+  `<input type="checkbox" _s:checked="row#1:done" _s:on:input="row#1:toggle"${stamp ? " _hk" : ""}>` +
+  `<!--_s:t=row#1:title-->a<!--/_s:t-->` +
+  `<button _s:on:click="row#1:remove"${stamp ? " _hk" : ""}>×</button></li></ul>`;
+
+type Row = { id: string; completed: boolean; title: string };
+
+let page: Page | undefined;
+const disposers: (() => void)[] = [];
+afterEach(async () => {
+  for (const d of disposers.splice(0)) d();
+  await page?.cleanup();
+  page = undefined;
+  vi.unstubAllGlobals();
+  delete (globalThis as any)._$SC;
+  document.body.innerHTML = "";
+});
+
+/** Boot the row page with the tier gated; wire the fill's probes. */
+function bootRow(stamp: boolean, options: { announce?: boolean } = {}) {
+  const gate = gatedBind();
+  const fid = freshFid("tier-bind");
+  page = bootPage(frameHtml(fid, rowHtml(stamp)), {
+    tiers: gate.tiers,
+    records: options.announce ? { "sc:tiers": ["bind"] } : undefined
+  });
+  disposers.push(installBootstrapCapture(document.documentElement, ["click", "input"]));
+  const button = page.container.querySelector("button")!;
+  const input = page.container.querySelector("input")!;
+  const li = page.container.querySelector("li")!;
+  const mounted: string[] = [];
+  const clicks: string[] = [];
+  const toggles: string[] = [];
+  let mountedAtEnd = -1;
+  let inProgressAtEnd: boolean | undefined;
+  const start = () => {
+    const Comp = (globalThis as any)._$SC.r(fid);
+    const dispose = hydrate(
+      () => (
+        <Comp
+          row={(p: Row) => {
+            // The mount's record, read once (a fill's own reads are
+            // getters — the strict-read diagnostic is right about a direct one).
+            mounted.push(untrack(() => p.title));
+            return {
+              get done() {
+                return p.completed;
+              },
+              get title() {
+                return p.title;
+              },
+              toggle: () => toggles.push(p.id),
+              remove: () => clicks.push(p.id)
+            };
+          }}
+        />
+      ),
+      page!.container
+    );
+    disposers.push(dispose);
+    onHydrationEnd(() => {
+      mountedAtEnd = mounted.length;
+      inProgressAtEnd = hydrationInProgress();
+    });
+  };
+  return {
+    gate,
+    fid,
+    button,
+    input,
+    li,
+    mounted,
+    clicks,
+    toggles,
+    start,
+    atEnd: () => ({ mountedAtEnd, inProgressAtEnd })
+  };
+}
+
+describe("the bind tier — document face", () => {
+  test("un-announced: a consumer in the adopted interior before the load holds the frame (interior on screen, hydration waits); the install binds every position, hydration-done follows, no orphan `_hk`", async () => {
+    const row = bootRow(true);
+    page!.slotRecord(row.fid, "row#1", { id: "1", completed: false, title: "a" });
+    // Nothing announced: no load at install.
+    expect(row.gate.loader).not.toHaveBeenCalled();
+    row.start();
+    await quiesce();
+    // The walk met the markers with the tier absent: it started the load
+    // (once) and HELD — no fill ran, the server's nodes are untouched, and
+    // hydration is not done (3.1: the hold is a pending boundary).
+    expect(row.gate.loader).toHaveBeenCalledTimes(1);
+    expect(resident()).toBe(false);
+    expect(row.mounted).toEqual([]);
+    expect(page!.container.querySelector("li")).toBe(row.li);
+    expect(row.li.className).toBe("todo");
+    expect(row.li.textContent).toBe("a×");
+    expect(hydrationInProgress()).toBe(true);
+    expect(row.atEnd().mountedAtEnd).toBe(-1);
+    expect(page!.errors).toEqual([]);
+
+    // The tier lands: its appliers register, one flush per live frame. The
+    // occurrence mounts ONCE and its positions are the client's: the
+    // handlers dispatch, the class follows the fill.
+    await row.gate.release();
+    await quiesce();
+    await quiesce();
+    expect(resident()).toBe(true);
+    expect(row.mounted).toEqual(["a"]);
+    expect(page!.container.querySelector("li")).toBe(row.li);
+    expect(row.li.textContent).toBe("a×");
+    row.button.click();
+    expect(row.clicks).toEqual(["1"]);
+    row.input.dispatchEvent(new Event("input", { bubbles: true }));
+    expect(row.toggles).toEqual(["1"]);
+    // Hydration-done came after the mount, not before.
+    expect(hydrationInProgress()).toBe(false);
+    expect(row.atEnd()).toEqual({ mountedAtEnd: 1, inProgressAtEnd: false });
+    // The stamp is on screen (both event-slot consumers, nothing else), and
+    // the page root's completion sweep listed none of it: frame interiors
+    // are the fills' to claim.
+    expect(keyedElements(page!.container)).toEqual([row.input, row.button]);
+    expect(page!.warnings.filter(w => w.includes("unclaimed"))).toEqual([]);
+    expect(page!.warnings).toEqual([]);
+    expect(page!.errors).toEqual([]);
+  });
+
+  test("replay arm (i): a click queued BEFORE `hydrate()` against a stamped consumer replays into the bound handler at the install", async () => {
+    const row = bootRow(true);
+    page!.slotRecord(row.fid, "row#1", { id: "1", completed: false, title: "a" });
+    // The user clicked while the page was still parsing: the bootstrap
+    // queued it at the element's own `_hk` (nothing above it is keyed).
+    row.button.click();
+    expect(page!.hy.events).toHaveLength(1);
+    expect(page!.hy.events[0][0]).toBe(row.button);
+    row.start();
+    await quiesce();
+    // Held; the queue still holds the click (the element is not completed;
+    // the hold keeps hydration — and so `_$HY.events` — alive).
+    expect(row.mounted).toEqual([]);
+    expect(row.clicks).toEqual([]);
+    expect(page!.hy.events).toHaveLength(1);
+    expect(hydrationInProgress()).toBe(true);
+    // The bind: the handler is on the element, the element is completed,
+    // the queue drains into it.
+    await row.gate.release();
+    await quiesce();
+    await quiesce();
+    expect(row.mounted).toEqual(["a"]);
+    expect(row.clicks).toEqual(["1"]);
+    expect(sharedConfig.completed == null || sharedConfig.completed.has(row.button)).toBe(true);
+    expect(hydrationInProgress()).toBe(false);
+    expect(page!.warnings).toEqual([]);
+    expect(page!.errors).toEqual([]);
+  });
+
+  test("replay arm (ii): a live click DURING the hold is queued and replays at the bind; the stamp on the other consumer queues its own event type too", async () => {
+    const row = bootRow(true);
+    page!.slotRecord(row.fid, "row#1", { id: "1", completed: false, title: "a" });
+    row.start();
+    await quiesce();
+    expect(row.mounted).toEqual([]);
+    expect(hydrationInProgress()).toBe(true);
+    // Mid-hold: the interior is on screen and the user acts on it. The
+    // bootstrap's capture is still live (hydration is not done), and the
+    // elements carry their own keys: queued, in order.
+    row.button.click();
+    row.input.dispatchEvent(new Event("input", { bubbles: true }));
+    expect(page!.hy.events.map((e: any) => e[0])).toEqual([row.button, row.input]);
+    expect(row.clicks).toEqual([]);
+    expect(row.toggles).toEqual([]);
+    await row.gate.release();
+    await quiesce();
+    await quiesce();
+    expect(row.mounted).toEqual(["a"]);
+    expect(row.clicks).toEqual(["1"]);
+    expect(row.toggles).toEqual(["1"]);
+    expect(page!.hy.events == null || page!.hy.events.length === 0).toBe(true);
+    expect(hydrationInProgress()).toBe(false);
+    expect(page!.errors).toEqual([]);
+  });
+
+  test("the mutant — no stamp: the same page loses both arms (nothing is queued without an `_hk` to queue under); the bind itself is unaffected", async () => {
+    const row = bootRow(false);
+    page!.slotRecord(row.fid, "row#1", { id: "1", completed: false, title: "a" });
+    row.button.click();
+    expect(page!.hy.events).toHaveLength(0);
+    row.start();
+    await quiesce();
+    expect(row.mounted).toEqual([]);
+    row.button.click();
+    expect(page!.hy.events).toHaveLength(0);
+    await row.gate.release();
+    await quiesce();
+    await quiesce();
+    expect(row.mounted).toEqual(["a"]);
+    // Both clicks are gone; a click AFTER the bind dispatches.
+    expect(row.clicks).toEqual([]);
+    row.button.click();
+    expect(row.clicks).toEqual(["1"]);
+    expect(keyedElements(page!.container)).toEqual([]);
+    expect(page!.errors).toEqual([]);
+  });
+
+  test("a record that replaced the adopted one during the hold is the one the fill sees: a data occurrence mounts ONCE, with the CURRENT record (its positions are written whole at the bind)", async () => {
+    const row = bootRow(true);
+    page!.slotRecord(row.fid, "row#1", { id: "1", completed: false, title: "a" });
+    row.start();
+    await quiesce();
+    expect(row.mounted).toEqual([]);
+    // A live slot op re-sends the occurrence's record mid-hold.
+    page!.live.push({
+      type: "slot",
+      fid: row.fid,
+      key: "row#1",
+      args: { id: "1", completed: true, title: "b" }
+    });
+    await quiesce();
+    expect(row.mounted).toEqual([]);
+    expect(row.li.className).toBe("todo");
+    await row.gate.release();
+    await quiesce();
+    await quiesce();
+    // One mount, with the replacement; the positions show it.
+    expect(row.mounted).toEqual(["b"]);
+    expect(row.li.className).toBe("todo completed");
+    expect(row.input.checked).toBe(true);
+    expect(row.li.textContent).toBe("b×");
+    expect(hydrationInProgress()).toBe(false);
+    expect(page!.errors).toEqual([]);
+  });
+
+  test('announced: `_$HY.r["sc:tiers"]` names `bind` — the import starts at install, before any boundary adopts; the held frame binds on the install', async () => {
+    const row = bootRow(true, { announce: true });
+    // Started at install (the record), ahead of the adopt-time walk.
+    expect(row.gate.loader).toHaveBeenCalledTimes(1);
+    expect(resident()).toBe(false);
+    page!.slotRecord(row.fid, "row#1", { id: "1", completed: false, title: "a" });
+    row.start();
+    await quiesce();
+    // Held on the load the announcement started; asked no second time.
+    expect(row.mounted).toEqual([]);
+    expect(row.gate.loader).toHaveBeenCalledTimes(1);
+    expect(hydrationInProgress()).toBe(true);
+    await row.gate.release();
+    await quiesce();
+    await quiesce();
+    expect(row.mounted).toEqual(["a"]);
+    row.button.click();
+    expect(row.clicks).toEqual(["1"]);
+    expect(hydrationInProgress()).toBe(false);
+    expect(page!.warnings).toEqual([]);
+    expect(page!.errors).toEqual([]);
+  });
+});
diff --git a/packages/web/test/consistency/tier-prepare.spec.tsx b/packages/web/test/consistency/tier-prepare.spec.tsx
new file mode 100644
index 000000000..629b73c19
--- /dev/null
+++ b/packages/web/test/consistency/tier-prepare.spec.tsx
@@ -0,0 +1,362 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * The server-announced tier mechanism, client half (frames savings pass
+ * §2, Phase B — the seam alone; no tier is cut, so every real name is
+ * resident and the loaders here are the test's own).
+ *
+ * - `prepareTier` is idempotent per name: one import, one promise; a name
+ *   with no loader is resident at once.
+ * - The document face: `installServerComponents` reads `_$HY.r["sc:tiers"]`
+ *   and starts each named tier's load before any adopt-time sync.
+ * - The stream face: `X-Frame-Tiers` starts the loads before the body is
+ *   read; `chunk.tiers` in-band starts them at the chunk; a `data` chunk
+ *   AWAITS the tiers it names before it decodes.
+ * - The held set is A2's registered set (frames-rulings 3.1 / 3.2): an
+ *   adopt-time occurrence whose tier is not resident is held exactly like
+ *   a recordless called occurrence — its positions stay at the server's
+ *   values, the frame's hold registers, hydration-done WAITS — and the
+ *   install's flush (one per live frame) mounts it and releases the hold.
+ *   Un-announced, the readiness check itself starts the load (detection
+ *   is the fallback): the same DOM, later.
+ * - The stream path buffers and retries: a record for an occurrence whose
+ *   tier is absent stays pending in the store until the install's flush.
+ *
+ * Module state: a tier, once installed, stays resident for the worker —
+ * so the two predicate names (`bind`, `regions`) are each held in ONE
+ * test below, before anything else in this file makes them resident;
+ * every other test uses a fresh name.
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createRoot, Loading } from "solid-js";
+import { dynamic, hydrate } from "@solidjs/web";
+import { prepareTier, tierLoaders, type TierModule } from "../../frames/src/frame-client.js";
+import { applyFrameResponse, installServerComponents } from "../../frames/src/client.js";
+import { createServerReference } from "../../server-functions/src/client.js";
+import { createChunk } from "../../server-functions/src/shared.js";
+import {
+  bootPage,
+  frameHtml,
+  freshFid,
+  hydrationInProgress,
+  makeHost,
+  onHydrationEnd,
+  pump,
+  quiesce,
+  slotRange,
+  type Page
+} from "./support.js";
+
+/** A loader the test settles: the import's promise, and the module — the
+ *  test's `install` hook over the appliers of `module` (a real tier's, when
+ *  the mount the install flushes needs them). */
+function deferredTier() {
+  let resolve!: (m: TierModule) => void;
+  const promise = new Promise<TierModule>(r => (resolve = r));
+  const install = vi.fn();
+  const loader = vi.fn(() => promise);
+  return { loader, install, resolve: (module?: object) => resolve({ ...module, install }) };
+}
+
+/** A held frame-stream Response with the given extra headers. */
+function heldResponse(id: string, headers: Record<string, string> = {}) {
+  let controller!: ReadableStreamDefaultController<Uint8Array>;
+  const body = new ReadableStream<Uint8Array>({
+    start(c) {
+      controller = c;
+    }
+  });
+  return {
+    response: new Response(body, { headers: { "X-Frame-Stream": id, ...headers } }),
+    send: (chunk: any) => controller.enqueue(createChunk(JSON.stringify(chunk))),
+    close: () => controller.close()
+  };
+}
+
+let page: Page | undefined;
+const disposers: (() => void)[] = [];
+afterEach(async () => {
+  for (const d of disposers.splice(0)) d();
+  await page?.cleanup();
+  page = undefined;
+  vi.unstubAllGlobals();
+  delete (globalThis as any)._$SC;
+  document.body.innerHTML = "";
+});
+
+describe("the held set — bind (adopt path, un-announced: detection starts the load)", () => {
+  // The ONE test for `bind` while it is not resident (see the module doc).
+  // `bind` is a REAL tier since C6 (`@solidjs/web/frames/bind`): the walk
+  // that would register the occurrences is the module's, so the deferred
+  // loader settles with the real module (the install hook is the test's
+  // own, counted the same way). The tier's own pins — the hold's shape,
+  // the delegated-event replay window — are consistency/tier-bind-hold.
+  test("an adopted data occurrence waits for its tier: positions untouched, the hold registers under 3.1, hydration-done waits; the install flushes every frame and mounts them", async () => {
+    const bind = deferredTier();
+    const fidA = freshFid("tier-bind-a");
+    const fidB = freshFid("tier-bind-b");
+    // Two boundaries, each one binding-slot occurrence with the server's
+    // t=0 value at its position.
+    const row = (fid: string) =>
+      frameHtml(fid, `<ul><li class="server" _s:class="row#0:cls">item</li></ul>`);
+    // No `sc:tiers` record — the page did not announce; the records the
+    // occurrences need are present, so only the tier holds them.
+    page = bootPage(row(fidA) + row(fidB), { tiers: { bind: bind.loader } });
+    page.slotRecord(fidA, "row#0", { id: 1 });
+    page.slotRecord(fidB, "row#0", { id: 2 });
+    // Nothing announced: no load yet.
+    expect(bind.loader).not.toHaveBeenCalled();
+    const A = (globalThis as any)._$SC.r(fidA);
+    const B = (globalThis as any)._$SC.r(fidB);
+    const runs: number[] = [];
+    let runsAtEnd = -1;
+    let inProgressAtEnd: boolean | undefined;
+    const fill = (p: any) => {
+      runs.push(p.id);
+      return { cls: `client-${p.id}` };
+    };
+    const dispose = hydrate(() => [<A row={fill} />, <B row={fill} />], page.container);
+    disposers.push(dispose);
+    onHydrationEnd(() => {
+      runsAtEnd = runs.length;
+      inProgressAtEnd = hydrationInProgress();
+    });
+    await quiesce();
+    // The adopt-time sync found the tier absent: it started the load
+    // (detection, the un-announced fallback) — once for two frames…
+    expect(bind.loader).toHaveBeenCalledTimes(1);
+    // …and HELD: the fills did not run, the positions are the server's.
+    expect(runs).toEqual([]);
+    const lis = () => [...page!.container.querySelectorAll("li")];
+    expect(lis().map(li => li.className)).toEqual(["server", "server"]);
+    // The hold is a pending boundary (3.1): hydration is not done.
+    expect(hydrationInProgress()).toBe(true);
+    expect(runsAtEnd).toBe(-1);
+    // The tier lands: its install hook runs once, then one flush per live
+    // frame — both occurrences mount (a data occurrence with the CURRENT
+    // record — here the one they were held on, nothing moved).
+    bind.resolve(await import("../../frames/src/bind-tier.js"));
+    await quiesce();
+    await quiesce();
+    expect(bind.install).toHaveBeenCalledTimes(1);
+    expect(runs.sort()).toEqual([1, 2]);
+    expect(
+      lis()
+        .map(li => li.className)
+        .sort()
+    ).toEqual(["client-1", "client-2"]);
+    // The hold released; hydration-done came after the mounts, not before.
+    expect(hydrationInProgress()).toBe(false);
+    expect(inProgressAtEnd).toBe(false);
+    expect(runsAtEnd).toBe(2);
+    expect(page.warnings.filter(w => w.includes("unclaimed"))).toEqual([]);
+    expect(page.errors).toEqual([]);
+    // Resident from here on: a later ask resolves without a second import.
+    await prepareTier("bind");
+    expect(bind.loader).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("the stream path — regions (announced on the head; the record buffers until the install)", () => {
+  // The ONE test for `regions` while it is not resident. `regions` is a REAL
+  // tier since C4 (`@solidjs/web/frames/regions`): the mount the install
+  // flushes resolves its `{$frame}` through the module's appliers, so the
+  // deferred loader settles with the real module (the install hook is the
+  // test's own, counted the same way).
+  test("`X-Frame-Tiers` starts the load before the body is read; the occurrence's record stays pending in the store until the install's flush mounts it", async () => {
+    const regions = deferredTier();
+    const WIRE = "tier/regions-wire";
+    const fid = freshFid("tier-regions");
+    const getPanel = createServerReference(fid);
+    const held = heldResponse(WIRE, { "X-Frame-Tiers": "regions" });
+    vi.stubGlobal("fetch", async () => held.response);
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: { regions: regions.loader } });
+    const Page = dynamic(() => getPanel() as any);
+    let mounts = 0;
+    let div!: HTMLDivElement;
+    const dispose = createRoot(d => {
+      <div ref={div}>
+        <Loading fallback={<span>fallback</span>}>
+          <Page
+            panel={(p: any) => {
+              mounts++;
+              return <div class="wrap">{p.body}</div>;
+            }}
+          />
+        </Loading>
+      </div>;
+      document.body.appendChild(div);
+      return d;
+    });
+    disposers.push(dispose);
+    await pump();
+    // The head announced it: the load started at the response, before
+    // any chunk of the body was read.
+    expect(regions.loader).toHaveBeenCalledTimes(1);
+    // The body: the record names a region, the shell carries its range,
+    // the region's own html follows.
+    held.send({ type: "start", id: WIRE, version: 1 });
+    held.send({
+      type: "slot",
+      id: WIRE,
+      version: 1,
+      key: "panel#0",
+      args: { body: { $frame: `${WIRE}.panel#0.body` } }
+    });
+    held.send({
+      type: "html",
+      id: WIRE,
+      version: 1,
+      html: "<article><!--slot:panel#0:start--><!--slot:panel#0:end--></article>"
+    });
+    held.send({
+      type: "html",
+      id: `${WIRE}.panel#0.body`,
+      version: 1,
+      html: "<em>server body</em>"
+    });
+    held.send({ type: "complete", id: WIRE, version: 1 });
+    held.close();
+    await pump();
+    // The shell landed (the frame has content); the occurrence did NOT
+    // mount — its tier is absent, so the record stays pending in the store.
+    expect(div.querySelector("article")).not.toBeNull();
+    expect(mounts).toBe(0);
+    expect(div.querySelector(".wrap")).toBeNull();
+    // The install (the real tier's appliers, the test's hook): one flush,
+    // the pending record applies — the occurrence mounts with the record it
+    // was held on, its region inside.
+    regions.resolve(await import("../../frames/src/regions-tier.js"));
+    await pump();
+    expect(regions.install).toHaveBeenCalledTimes(1);
+    expect(mounts).toBe(1);
+    expect(div.querySelector(".wrap em")!.textContent).toBe("server body");
+    // Idempotent: the header's ask and the sync's are one load.
+    expect(regions.loader).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("prepareTier", () => {
+  test("is idempotent per name: one import, the same promise; a name with no loader is resident at once", async () => {
+    const t = deferredTier();
+    Object.assign(tierLoaders, { "tier/idem": t.loader });
+    const p1 = prepareTier("tier/idem");
+    const p2 = prepareTier("tier/idem");
+    expect(p1).toBe(p2);
+    expect(t.loader).toHaveBeenCalledTimes(1);
+    expect((p1 as any).r).toBeUndefined();
+    t.resolve();
+    await p1;
+    expect(t.install).toHaveBeenCalledTimes(1);
+    // The resident stamp is the module itself (a tier's exports are its
+    // dispatch — the assets tier's `gate` / `apply` are read off it).
+    expect((p1 as any).r).toEqual({ install: t.install });
+    expect(prepareTier("tier/idem")).toBe(p1);
+    expect(t.loader).toHaveBeenCalledTimes(1);
+    // No loader: nothing to import, resolved.
+    const eager = prepareTier("tier/no-such-loader");
+    await eager;
+    expect(prepareTier("tier/no-such-loader")).toBe(eager);
+  });
+
+  test("a module without an `install` hook installs too (resident on load)", async () => {
+    let resolve!: (m: any) => void;
+    Object.assign(tierLoaders, { "tier/bare": () => new Promise<any>(r => (resolve = r)) });
+    const p = prepareTier("tier/bare");
+    const bare = {};
+    resolve(bare);
+    await p;
+    expect((p as any).r).toBe(bare);
+  });
+});
+
+describe('the document face — `_$HY.r["sc:tiers"]`', () => {
+  test("installServerComponents reads the record and starts each named tier's load; no record, no load", async () => {
+    const t = deferredTier();
+    const u = deferredTier();
+    const fid = freshFid("tier-record");
+    page = bootPage(frameHtml(fid, "<p>plain</p>"), {
+      tiers: { "tier/rec-a": t.loader, "tier/rec-b": u.loader, "tier/rec-c": u.loader },
+      records: { "sc:tiers": ["tier/rec-a", "tier/rec-b"] }
+    });
+    // Started at install — before any boundary adopted.
+    expect(t.loader).toHaveBeenCalledTimes(1);
+    expect(u.loader).toHaveBeenCalledTimes(1);
+    t.resolve();
+    u.resolve();
+    await quiesce();
+    expect(t.install).toHaveBeenCalledTimes(1);
+    // The record's names only: "tier/rec-c" was never asked for.
+    expect(u.install).toHaveBeenCalledTimes(1);
+  });
+
+  test("a page with no record announces nothing: no loader runs at install", async () => {
+    const t = deferredTier();
+    const fid = freshFid("tier-norecord");
+    page = bootPage(frameHtml(fid, "<p>plain</p>"), { tiers: { "tier/none": t.loader } });
+    await quiesce();
+    expect(t.loader).not.toHaveBeenCalled();
+  });
+});
+
+describe("the stream face — in-band and the codec", () => {
+  test("`chunk.tiers` starts the load at the chunk; a `data` chunk awaits the tiers it names before it decodes", async () => {
+    const t = deferredTier();
+    Object.assign(tierLoaders, { "tier/data": t.loader });
+    const applied: string[] = [];
+    const { host } = makeHost({
+      applyData: (c: any) => applied.push(c.key)
+    });
+    const WIRE = "tier/data-wire";
+    const held = heldResponse(WIRE);
+    const done = applyFrameResponse(held.response, host, { as: WIRE, version: 1 });
+    held.send({ type: "start", id: WIRE, version: 1 });
+    // A record whose node tree needs the tier: the chunk names it.
+    held.send({
+      type: "data",
+      id: WIRE,
+      version: 1,
+      key: "arg:x",
+      node: null,
+      initial: true,
+      tiers: ["tier/data"]
+    });
+    held.send({ type: "html", id: WIRE, version: 1, html: "<p>after</p>" });
+    await pump();
+    // The announcement started the load…
+    expect(t.loader).toHaveBeenCalledTimes(1);
+    // …and the data chunk is held behind it: nothing decoded, and the
+    // chunks behind it in the sequential drain wait too.
+    expect(applied).toEqual([]);
+    expect(host.get(WIRE)).toBeUndefined();
+    t.resolve();
+    await pump();
+    expect(applied).toEqual(["arg:x"]);
+    held.send({ type: "complete", id: WIRE, version: 1 });
+    held.close();
+    await done;
+  });
+
+  test("a non-data chunk's `tiers` starts the load but does not wait; a `data` chunk without `tiers` decodes at once", async () => {
+    const t = deferredTier();
+    Object.assign(tierLoaders, { "tier/nowait": t.loader });
+    const applied: string[] = [];
+    const { host } = makeHost({ applyData: (c: any) => applied.push(c.key) });
+    const WIRE = "tier/nowait-wire";
+    const held = heldResponse(WIRE);
+    const done = applyFrameResponse(held.response, host, { as: WIRE, version: 1 });
+    held.send({ type: "start", id: WIRE, version: 1 });
+    held.send({ type: "html", id: WIRE, version: 1, html: "<p>shell</p>", tiers: ["tier/nowait"] });
+    held.send({ type: "data", id: WIRE, version: 1, key: "arg:y", node: null, initial: true });
+    held.send({ type: "complete", id: WIRE, version: 1 });
+    held.close();
+    await pump();
+    expect(t.loader).toHaveBeenCalledTimes(1);
+    // Neither the html nor the data waited on the still-pending load.
+    expect(applied).toEqual(["arg:y"]);
+    await done;
+    t.resolve();
+  });
+});
diff --git a/packages/web/test/consistency/tier-regions-hold.spec.tsx b/packages/web/test/consistency/tier-regions-hold.spec.tsx
new file mode 100644
index 000000000..54d2de9e3
--- /dev/null
+++ b/packages/web/test/consistency/tier-regions-hold.spec.tsx
@@ -0,0 +1,366 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * The regions tier's timing pin (frames savings pass §1, row "regions"; §3
+ * row C4). The race: a `slot:` record naming a `{$frame}` ref — or a
+ * `data-fid` region element inside adopted content — before
+ * `@solidjs/web/frames/regions` has loaded. Lost, the fill would receive
+ * the raw `{$frame}` ref (wrong content) and an occluded region could not
+ * mount from the store. The bound: ANNOUNCE + HOLD / BUFFER.
+ *
+ *  - Document face, un-announced (the fallback): the adopt-time sync finds
+ *    the record names a region (`needsRegions`), starts the load and HOLDS
+ *    the occurrence — its server interior on screen, the region element
+ *    and its content untouched, the frame's hold registered under
+ *    frames-rulings 3.1 (hydration-done waits). It mounts with the record
+ *    it was held on; the tier discovers the adopted region element and
+ *    binds a frame over it, so the stream's chunks reach it.
+ *  - Document face, announced: `_$HY.r["sc:tiers"]` names `regions`;
+ *    `installServerComponents` starts the import before any boundary
+ *    adopts (the warm start the `modulepreload` made a cache hit).
+ *  - An occluded region's `sc:region:` record drained BEFORE the tier lands
+ *    in the host store regardless (the eager drain arm); the frame the
+ *    tier binds on install seeds from it — the region shows the record's
+ *    html once the fill places it, with nothing re-delivered.
+ *  - Stream face, a MOUNTED occurrence: a new record naming a region while
+ *    the tier is absent is not taken — the live binding keeps the args it
+ *    shows, the record stays pending in the store — and the install's
+ *    flush applies it: the region element is placed and its html lands.
+ *
+ * A tier, once resident, stays so for the worker: each test gates the load
+ * itself (`installServerComponents({ tiers })` replaces the built-in loader)
+ * and drops it between tests (`tierLoads`, the runtime's test seam).
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createRoot, Loading } from "solid-js";
+import { dynamic, hydrate } from "@solidjs/web";
+import { installServerComponents } from "../../frames/src/client.js";
+import { tierLoads } from "../../frames/src/frame-client.js";
+import { createServerReference } from "../../server-functions/src/client.js";
+import {
+  bootPage,
+  fillKey,
+  frameHtml,
+  freshFid,
+  hydrationInProgress,
+  makeHost,
+  onHydrationEnd,
+  openFrameResponse,
+  pump,
+  quiesce,
+  slotRange,
+  type Page
+} from "./support.js";
+
+/** The regions tier's load, gated by the test; `release()` installs the real module. */
+function gatedRegions() {
+  delete (tierLoads as any).regions;
+  let resolve!: (m: any) => void;
+  const loader = vi.fn(() => new Promise<any>(r => (resolve = r)));
+  return {
+    tiers: { regions: loader },
+    loader,
+    release: async () => resolve(await import("../../frames/src/regions-tier.js"))
+  };
+}
+const resident = () => !!(tierLoads as any).regions?.r;
+
+/** A used region's element as the document carries it inside a fill's output. */
+const regionHtml = (childId: string, inner: string) =>
+  `<solid-frame data-fid="${childId}" style="display:contents">${inner}</solid-frame>`;
+/** The server render of `p => <li>{p.body}</li>` with `body` a used region. */
+const regionFillHtml = (fid: string, occurrence: string, childId: string, inner: string) =>
+  `<li _hk="${fillKey(fid, occurrence)}">${regionHtml(childId, inner)}</li>`;
+
+let page: Page | undefined;
+const disposers: (() => void)[] = [];
+afterEach(async () => {
+  for (const d of disposers.splice(0)) d();
+  await page?.cleanup();
+  page = undefined;
+  vi.unstubAllGlobals();
+  delete (globalThis as any)._$SC;
+  document.body.innerHTML = "";
+});
+
+describe("the regions tier — document face", () => {
+  test("un-announced: a `{$frame}` in an adopted record before the load holds the occurrence (interior and region content on screen, hydration waits); it mounts with the held record on install, the adopted region element bound and reachable by the stream", async () => {
+    const gate = gatedRegions();
+    const fid = freshFid("tier-regions-a");
+    const childId = `${fid}.item#0.body`;
+    page = bootPage(
+      frameHtml(
+        fid,
+        `<ul>${slotRange("item#0", regionFillHtml(fid, "item#0", childId, "<em>server body</em>"))}</ul>`
+      ),
+      { tiers: gate.tiers }
+    );
+    page.slotRecord(fid, "item#0", { label: "first", body: { $frame: childId } });
+    // Nothing announced: no load at install.
+    expect(gate.loader).not.toHaveBeenCalled();
+    const Comp = (globalThis as any)._$SC.r(fid);
+    const li = page.container.querySelector("li")!;
+    const regionEl = page.container.querySelector(`solid-frame[data-fid="${childId}"]`)!;
+    const em = page.container.querySelector("em")!;
+    const mounted: string[] = [];
+    const bodies: unknown[] = [];
+    let mountedAtEnd = -1;
+    let inProgressAtEnd: boolean | undefined;
+    const dispose = hydrate(
+      () => (
+        <Comp
+          item={(p: { label: string; body: Element }) => {
+            mounted.push(p.label);
+            bodies.push(p.body);
+            return <li>{p.body}</li>;
+          }}
+        />
+      ),
+      page.container
+    );
+    disposers.push(dispose);
+    onHydrationEnd(() => {
+      mountedAtEnd = mounted.length;
+      inProgressAtEnd = hydrationInProgress();
+    });
+    await quiesce();
+    // The adopt-time sync found the record names a region with the tier
+    // absent: it started the load (once) and HELD — no fill ran, the
+    // server's nodes are untouched down to the region's content, and
+    // hydration is not done (3.1: the hold is a pending boundary).
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(resident()).toBe(false);
+    expect(mounted).toEqual([]);
+    expect(page.container.querySelector("li")).toBe(li);
+    expect(page.container.querySelector(`solid-frame[data-fid="${childId}"]`)).toBe(regionEl);
+    expect(page.container.querySelector("em")).toBe(em);
+    expect(em.textContent).toBe("server body");
+    expect(hydrationInProgress()).toBe(true);
+    expect(mountedAtEnd).toBe(-1);
+    expect(page.errors).toEqual([]);
+
+    // The tier lands: its appliers register, then one flush per live frame.
+    // The occurrence mounts ONCE, with the record it was held on; the
+    // `{$frame}` resolves to the ADOPTED region element (discovered in the
+    // interior, not minted), which the fill places back where it was.
+    await gate.release();
+    await quiesce();
+    await quiesce();
+    expect(resident()).toBe(true);
+    expect(mounted).toEqual(["first"]);
+    expect(bodies).toEqual([regionEl]);
+    expect(page.container.querySelector("li")).toBe(li);
+    expect(page.container.querySelector(`solid-frame[data-fid="${childId}"]`)).toBe(regionEl);
+    expect(em.textContent).toBe("server body");
+    // Hydration-done came after the mount, not before; nothing warned, no
+    // `TypeError` from a `{$frame}` handed to the fill raw.
+    expect(hydrationInProgress()).toBe(false);
+    expect(inProgressAtEnd).toBe(false);
+    expect(mountedAtEnd).toBe(1);
+    expect(page.warnings.filter(w => w.includes("unclaimed"))).toEqual([]);
+    expect(page.errors).toEqual([]);
+
+    // The region is a live frame now: a later chunk addressed to its wire
+    // id morphs its interior in place.
+    page.host.apply({ type: "html", id: childId, version: 1, html: "<em>streamed body</em>" });
+    await quiesce();
+    expect(page.container.querySelector(`solid-frame[data-fid="${childId}"]`)).toBe(regionEl);
+    expect(regionEl.textContent).toBe("streamed body");
+    expect(page.errors).toEqual([]);
+  });
+
+  test('announced: `_$HY.r["sc:tiers"]` names `regions` — the import starts at install, before any boundary adopts; the held occurrence mounts on the install', async () => {
+    const gate = gatedRegions();
+    const fid = freshFid("tier-regions-b");
+    const childId = `${fid}.item#0.body`;
+    page = bootPage(
+      frameHtml(
+        fid,
+        `<ul>${slotRange("item#0", regionFillHtml(fid, "item#0", childId, "<em>one</em>"))}</ul>`
+      ),
+      { tiers: gate.tiers, records: { "sc:tiers": ["regions"] } }
+    );
+    // Started at install (the record), ahead of the adopt-time sync.
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(resident()).toBe(false);
+    page.slotRecord(fid, "item#0", { body: { $frame: childId } });
+    const Comp = (globalThis as any)._$SC.r(fid);
+    let mounts = 0;
+    const dispose = hydrate(
+      () => (
+        <Comp
+          item={(p: { body: Element }) => {
+            mounts++;
+            return <li>{p.body}</li>;
+          }}
+        />
+      ),
+      page.container
+    );
+    disposers.push(dispose);
+    await quiesce();
+    // Held on the load the announcement started; asked no second time.
+    expect(mounts).toBe(0);
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(hydrationInProgress()).toBe(true);
+    await gate.release();
+    await quiesce();
+    await quiesce();
+    expect(mounts).toBe(1);
+    expect(page.container.textContent).toBe("one");
+    expect(hydrationInProgress()).toBe(false);
+    expect(page.warnings).toEqual([]);
+    expect(page.errors).toEqual([]);
+  });
+
+  test("an occluded region's `sc:region:` record drained before the tier lands in the store; the frame the tier binds on install seeds from it when the fill places the region", async () => {
+    const gate = gatedRegions();
+    const fid = freshFid("tier-regions-c");
+    const childId = `${fid}.item#0.body`;
+    // The fill's server render placed NO region (occluded — behind an
+    // expand), so the interior is the fill's shell alone and the region's
+    // html rides the `sc:region:` record.
+    page = bootPage(
+      frameHtml(
+        fid,
+        `<ul>${slotRange("item#0", `<li _hk="${fillKey(fid, "item#0")}"><button>expand</button></li>`)}</ul>`
+      ),
+      { tiers: gate.tiers }
+    );
+    page.slotRecord(fid, "item#0", { body: { $frame: childId } });
+    page.regionRecord(childId, "<p>occluded body</p>");
+    const Comp = (globalThis as any)._$SC.r(fid);
+    let region: Element | undefined;
+    let mounts = 0;
+    const dispose = hydrate(
+      () => (
+        <Comp
+          item={(p: { body: Element }) => {
+            mounts++;
+            region = p.body;
+            // Claims the shell in place; places the region later, on expand.
+            return (
+              <li>
+                <button>expand</button>
+              </li>
+            );
+          }}
+        />
+      ),
+      page.container
+    );
+    disposers.push(dispose);
+    await quiesce();
+    // Held on the tier; the drain already ran (the records are the page's).
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(mounts).toBe(0);
+    expect(hydrationInProgress()).toBe(true);
+    // The region's record is consumed from `_$HY.r` by the adopt-time
+    // drain — before the tier — and sits in the host store under the
+    // region's id; delete it from the page so nothing could re-deliver it.
+    delete page.hy.r[`sc:region:${childId}`];
+    await gate.release();
+    await quiesce();
+    await quiesce();
+    expect(mounts).toBe(1);
+    expect(hydrationInProgress()).toBe(false);
+    // The region element exists (minted by the tier: nothing to discover in
+    // the interior) and its frame — bound off-DOM — already holds the
+    // record's html from the store seed.
+    expect(region).toBeInstanceOf(Element);
+    expect(region!.getAttribute("data-fid")).toBe(childId);
+    expect(region!.isConnected).toBe(false);
+    expect(region!.textContent).toBe("occluded body");
+    // The wrapper expands: the single node goes in, content and all.
+    page.container.querySelector("li")!.appendChild(region!);
+    expect(page.container.querySelector("li")!.textContent).toBe("expandoccluded body");
+    expect(page.errors).toEqual([]);
+  });
+});
+
+describe("the regions tier — stream face, a mounted occurrence", () => {
+  test("a new record naming a region while the tier is absent is not taken: the live binding keeps its args, the record stays pending, and the install's flush applies it — the region element placed, its html landing", async () => {
+    const gate = gatedRegions();
+    const WIRE = "tier-regions/stream-wire";
+    const fid = freshFid("tier-regions-d");
+    const getPanel = createServerReference(fid);
+    const held = openFrameResponse(WIRE);
+    vi.stubGlobal("fetch", async () => held.response);
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    const Page = dynamic(() => getPanel() as any);
+    const labels: string[] = [];
+    let div!: HTMLDivElement;
+    const dispose = createRoot(d => {
+      <div ref={div}>
+        <Loading fallback={<span>fallback</span>}>
+          <Page
+            panel={(p: any) => {
+              labels.push(p.label);
+              return (
+                <div class="wrap">
+                  <b>{p.label}</b>
+                  {p.body}
+                </div>
+              );
+            }}
+          />
+        </Loading>
+      </div>;
+      document.body.appendChild(div);
+      return d;
+    });
+    disposers.push(dispose);
+    await pump();
+    // The first response: no region, the tier is not needed — the
+    // occurrence mounts and shows its label.
+    held.send({ type: "start", id: WIRE, version: 1 });
+    held.send({ type: "slot", id: WIRE, version: 1, key: "panel#0", args: { label: "plain" } });
+    held.send({
+      type: "html",
+      id: WIRE,
+      version: 1,
+      html: "<article><!--slot:panel#0:start--><!--slot:panel#0:end--></article>"
+    });
+    held.send({ type: "complete", id: WIRE, version: 1 });
+    held.close();
+    await pump();
+    expect(labels).toEqual(["plain"]);
+    expect(div.querySelector(".wrap b")!.textContent).toBe("plain");
+    expect(gate.loader).not.toHaveBeenCalled();
+
+    // A refetch (the next version) adds a `{$frame}` arg — un-announced,
+    // written to the ADDRESS the mount is bound to (the argless call's: its
+    // function id). The record is NOT taken while the tier is absent: the
+    // live binding shows the first record's label, the region's html warms
+    // its store, and the check started the load.
+    const childId = `${fid}.panel#0.body`;
+    host.apply({
+      type: "slot",
+      id: fid,
+      version: 2,
+      key: "panel#0",
+      args: { label: "with region", body: { $frame: childId } }
+    });
+    host.apply({ type: "html", id: childId, version: 1, html: "<em>region body</em>" });
+    await pump();
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(resident()).toBe(false);
+    expect(div.querySelector(".wrap b")!.textContent).toBe("plain");
+    expect(div.querySelector(".wrap solid-frame")).toBeNull();
+    expect(labels).toEqual(["plain"]);
+
+    // The install: the pending record applies into the LIVE binding (no
+    // re-call), the region element is placed and seeds from its store.
+    await gate.release();
+    await pump();
+    expect(resident()).toBe(true);
+    expect(labels).toEqual(["plain"]);
+    expect(div.querySelector(".wrap b")!.textContent).toBe("with region");
+    const region = div.querySelector(".wrap solid-frame")!;
+    expect(region).not.toBeNull();
+    expect(region.getAttribute("data-fid")).toBe(childId);
+    expect(region.textContent).toBe("region body");
+  });
+});
diff --git a/packages/web/test/consistency/tier-trace-hold.spec.tsx b/packages/web/test/consistency/tier-trace-hold.spec.tsx
new file mode 100644
index 000000000..d71953aef
--- /dev/null
+++ b/packages/web/test/consistency/tier-trace-hold.spec.tsx
@@ -0,0 +1,317 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * The traces tier's timing pin (frames savings pass §1, row "traces";
+ * §3 row C3). The race: an adopt-time record whose literal args carry a
+ * `{ $tr, $ta }` marker — or a `data` chunk whose node tree holds the trace
+ * plugin's node — before `@solidjs/web/frames/trace` (the materializer + the
+ * store engine) has loaded. Lost, the fill would run with an inert marker
+ * object (a `TypeError` or wrong content). The bound: ANNOUNCE + HOLD.
+ *
+ *  - Document face, un-announced (the fallback): the adopt-time sync finds
+ *    the marker (`needsTrace`), starts the load and HOLDS the occurrence —
+ *    its server interior on screen, the frame's hold registered under
+ *    frames-rulings 3.1 (hydration-done waits). It mounts with the record
+ *    it was held on (S1 commit 3's held-record mount, generalized): a
+ *    record that replaced it meanwhile applies as the args change it is.
+ *    No `TypeError`, nothing read inert.
+ *  - Document face, update site: a MOUNTED occurrence's new record carrying
+ *    a marker while the tier is absent (a live slot op minting the page's
+ *    first trace after the shell) stays pending in the store — the live
+ *    binding keeps the args it shows, the load starts, the install's flush
+ *    applies it as an args change. The fresh-mount hold's twin (`needsTrace`
+ *    at the update site, as `needsRegions` is for regions).
+ *  - Document face, announced: `_$HY.r["sc:tiers"]` names `trace`;
+ *    `installServerComponents` starts the import before any boundary
+ *    adopts (the warm start the `modulepreload` made a cache hit).
+ *  - Codec face: a `data` chunk that names `trace` (the sink stamps it on
+ *    the chunk carrying the node) awaits the tier before it decodes —
+ *    frames-container-lazy-codec.spec has the full arm; here the chunk's
+ *    wait alone.
+ *
+ * A tier, once resident, stays so for the worker: each test gates the load
+ * itself (`installServerComponents({ tiers })` replaces the built-in loader)
+ * and drops it between tests (`tierLoads`, the runtime's test seam).
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { hydrate } from "@solidjs/web";
+import { applyFrameResponse, installServerComponents } from "../../frames/src/client.js";
+import { tierLoads } from "../../frames/src/frame-client.js";
+import { createChunk } from "../../server-functions/src/shared.js";
+import {
+  bootPage,
+  fillHtml,
+  frameHtml,
+  freshFid,
+  hydrationInProgress,
+  makeHost,
+  onHydrationEnd,
+  pump,
+  quiesce,
+  slotRange,
+  traceMarker,
+  type Page
+} from "./support.js";
+
+/** The traces tier's load, gated by the test; `release()` installs the real module. */
+function gatedTrace() {
+  delete (tierLoads as any).trace;
+  let resolve!: (m: any) => void;
+  const loader = vi.fn(() => new Promise<any>(r => (resolve = r)));
+  return {
+    tiers: { trace: loader },
+    loader,
+    release: async () => resolve(await import("../../frames/src/trace-tier.js"))
+  };
+}
+const resident = () => !!(tierLoads as any).trace?.r;
+
+let page: Page | undefined;
+const disposers: (() => void)[] = [];
+afterEach(async () => {
+  for (const d of disposers.splice(0)) d();
+  await page?.cleanup();
+  page = undefined;
+  vi.unstubAllGlobals();
+  delete (globalThis as any)._$SC;
+  document.body.innerHTML = "";
+});
+
+describe("the traces tier — document face", () => {
+  test("un-announced: a marker in an adopted record's args before the load holds the occurrence (interior on screen, hydration waits); it mounts with the record it was held on and applies a replacement as an args change", async () => {
+    const gate = gatedTrace();
+    const fid = freshFid("tier-trace-a");
+    page = bootPage(
+      frameHtml(fid, `<ul>${slotRange("item#0", fillHtml(fid, "item#0", "2"))}</ul>`),
+      { tiers: gate.tiers }
+    );
+    const t0 = traceMarker();
+    t0.snapshot({ n: 2 });
+    page.slotRecord(fid, "item#0", { label: "first", data: t0.marker });
+    // Nothing announced: no load at install.
+    expect(gate.loader).not.toHaveBeenCalled();
+    const Comp = (globalThis as any)._$SC.r(fid);
+    const li = page.container.querySelector("li")!;
+    const mounted: string[] = [];
+    let readN: (() => number) | undefined;
+    let mountedAtEnd = -1;
+    let inProgressAtEnd: boolean | undefined;
+    const dispose = hydrate(
+      () => (
+        <Comp
+          item={(p: { label: string; data: { n: number } }) => {
+            mounted.push(p.label);
+            readN = () => p.data.n;
+            return <li>{p.data.n}</li>;
+          }}
+        />
+      ),
+      page.container
+    );
+    disposers.push(dispose);
+    onHydrationEnd(() => {
+      mountedAtEnd = mounted.length;
+      inProgressAtEnd = hydrationInProgress();
+    });
+    await quiesce();
+    // The adopt-time sync found the marker with the tier absent: it started
+    // the load (once) and HELD — no fill ran, the server's node and text are
+    // untouched, and hydration is not done (3.1: the hold is a pending
+    // boundary).
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(mounted).toEqual([]);
+    expect(page.container.querySelector("li")).toBe(li);
+    expect(li.textContent).toBe("2");
+    expect(hydrationInProgress()).toBe(true);
+    expect(mountedAtEnd).toBe(-1);
+    expect(page.errors).toEqual([]);
+
+    // Meanwhile the record is REPLACED — a refetch of the same call (the
+    // next version's write; the store is one response's). The interior on
+    // screen was rendered from the FIRST record.
+    const t1 = traceMarker();
+    t1.snapshot({ n: 7 });
+    page.host.apply({
+      type: "slot",
+      id: fid,
+      version: 1,
+      key: "item#0",
+      args: { label: "second", data: t1.marker }
+    });
+    await quiesce();
+    expect(mounted).toEqual([]);
+
+    // The tier lands: its install, then one flush per live frame. The
+    // occurrence mounts ONCE, with the record it was held on (the claim —
+    // the markup shows `2`), and the replacement applies as an args change:
+    // the live mount's props move to the second record's values.
+    await gate.release();
+    await quiesce();
+    await quiesce();
+    expect(resident()).toBe(true);
+    expect(mounted).toEqual(["first"]);
+    expect(page.container.querySelector("li")).toBe(li);
+    expect(readN!()).toBe(7);
+    expect(li.textContent).toBe("7");
+    // Hydration-done came after the mount, not before; nothing warned, no
+    // `TypeError` from a marker read inert.
+    expect(hydrationInProgress()).toBe(false);
+    expect(inProgressAtEnd).toBe(false);
+    expect(mountedAtEnd).toBe(1);
+    expect(page.warnings.filter(w => w.includes("unclaimed"))).toEqual([]);
+    expect(page.errors).toEqual([]);
+  });
+
+  test("update site: a MOUNTED occurrence's new record carrying `{ $tr }` while the tier is absent stays pending — the live binding keeps its args, the load starts, the install's flush applies it (a live slot op minting the page's first trace post-shell)", async () => {
+    const gate = gatedTrace();
+    const fid = freshFid("tier-trace-u");
+    page = bootPage(
+      frameHtml(fid, `<ul>${slotRange("item#0", fillHtml(fid, "item#0", "first"))}</ul>`),
+      { tiers: gate.tiers }
+    );
+    // The page's record carries no trace: the occurrence mounts at t=0 with
+    // the tier absent (nothing to wait for, nothing announced).
+    page.slotRecord(fid, "item#0", { label: "first" });
+    const Comp = (globalThis as any)._$SC.r(fid);
+    const li = page.container.querySelector("li")!;
+    let mounts = 0;
+    let read: (() => [string, unknown]) | undefined;
+    const dispose = hydrate(
+      () => (
+        <Comp
+          item={(p: { label: string; data?: { n: number } }) => {
+            mounts++;
+            read = () => [p.label, p.data];
+            return <li>{p.data ? p.data.n : p.label}</li>;
+          }}
+        />
+      ),
+      page.container
+    );
+    disposers.push(dispose);
+    await quiesce();
+    expect(mounts).toBe(1);
+    expect(gate.loader).not.toHaveBeenCalled();
+    expect(hydrationInProgress()).toBe(false);
+    expect(li.textContent).toBe("first");
+
+    // Post-shell, the page's FIRST trace: a live slot op re-sends the
+    // occurrence's record with a projection arg (a marker) while the tier
+    // is still absent. The record is NOT pushed into the live binding raw
+    // — it stays pending in the store; the binding keeps the args it
+    // shows; the check starts the load (nothing announced it).
+    const t = traceMarker();
+    t.snapshot({ n: 5 });
+    page.live.push({ type: "slot", fid, key: "item#0", args: { label: "second", data: t.marker } });
+    await quiesce();
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(read!()).toEqual(["first", undefined]);
+    expect(li.textContent).toBe("first");
+    expect(mounts).toBe(1);
+    expect(page.errors).toEqual([]);
+
+    // The install's flush re-syncs with the tier in place: the pending
+    // record applies as an args change into the SAME mount — the marker
+    // materialized, the projection readable.
+    await gate.release();
+    await quiesce();
+    await quiesce();
+    expect(resident()).toBe(true);
+    expect(mounts).toBe(1);
+    expect(page.container.querySelector("li")).toBe(li);
+    const [label, data] = read!();
+    expect(label).toBe("second");
+    expect((data as any).n).toBe(5);
+    expect(li.textContent).toBe("5");
+    expect(page.warnings).toEqual([]);
+    expect(page.errors).toEqual([]);
+  });
+
+  test('announced: `_$HY.r["sc:tiers"]` names `trace` — the import starts at install, before any boundary adopts; the held occurrence mounts on the install', async () => {
+    const gate = gatedTrace();
+    const fid = freshFid("tier-trace-b");
+    page = bootPage(
+      frameHtml(fid, `<ul>${slotRange("item#0", fillHtml(fid, "item#0", "1"))}</ul>`),
+      { tiers: gate.tiers, records: { "sc:tiers": ["trace"] } }
+    );
+    // Started at install (the record), ahead of the adopt-time sync.
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(resident()).toBe(false);
+    const trace = traceMarker();
+    trace.snapshot({ n: 1 });
+    page.slotRecord(fid, "item#0", { data: trace.marker });
+    const Comp = (globalThis as any)._$SC.r(fid);
+    let mounts = 0;
+    const dispose = hydrate(
+      () => (
+        <Comp
+          item={(p: { data: { n: number } }) => {
+            mounts++;
+            return <li>{p.data.n}</li>;
+          }}
+        />
+      ),
+      page.container
+    );
+    disposers.push(dispose);
+    await quiesce();
+    // Held on the load the announcement started; asked no second time.
+    expect(mounts).toBe(0);
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(hydrationInProgress()).toBe(true);
+    await gate.release();
+    await quiesce();
+    await quiesce();
+    expect(mounts).toBe(1);
+    expect(page.container.textContent).toBe("1");
+    expect(hydrationInProgress()).toBe(false);
+    expect(page.warnings).toEqual([]);
+    expect(page.errors).toEqual([]);
+  });
+});
+
+describe("the traces tier — codec face", () => {
+  test("a `data` chunk that names `trace` waits for the tier before it decodes", async () => {
+    const gate = gatedTrace();
+    const applied: string[] = [];
+    const { host } = makeHost({ applyData: (c: any) => applied.push(c.key) });
+    installServerComponents(host, { tiers: gate.tiers });
+    const WIRE = "tier-trace/data-wire";
+    let controller!: ReadableStreamDefaultController<Uint8Array>;
+    const response = new Response(
+      new ReadableStream<Uint8Array>({
+        start(c) {
+          controller = c;
+        }
+      }),
+      { headers: { "X-Frame-Stream": WIRE } }
+    );
+    const send = (chunk: any) => controller.enqueue(createChunk(JSON.stringify(chunk)));
+    const done = applyFrameResponse(response, host, { as: WIRE, version: 1 });
+    send({ type: "start", id: WIRE, version: 1 });
+    // The chunk the sink stamps `trace` on: the one whose node is the
+    // trace plugin's (an inert node here — the wait is what is pinned).
+    send({
+      type: "data",
+      id: WIRE,
+      version: 1,
+      key: "arg:user",
+      node: null,
+      initial: true,
+      tiers: ["trace"]
+    });
+    send({ type: "html", id: WIRE, version: 1, html: "<p>after</p>" });
+    await pump();
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(applied).toEqual([]);
+    expect(host.get(WIRE)).toBeUndefined();
+    await gate.release();
+    await pump();
+    expect(resident()).toBe(true);
+    expect(applied).toEqual(["arg:user"]);
+    send({ type: "complete", id: WIRE, version: 1 });
+    controller.close();
+    await done;
+  });
+});
diff --git a/packages/web/test/consistency/tier-wire-preload.spec.tsx b/packages/web/test/consistency/tier-wire-preload.spec.tsx
new file mode 100644
index 000000000..ea893a3d5
--- /dev/null
+++ b/packages/web/test/consistency/tier-wire-preload.spec.tsx
@@ -0,0 +1,337 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * The live wire tier's timing pin (frames savings pass §1, row "live wire";
+ * §3 row C2). The race: a `live()` loop's first response — SSE framing,
+ * the loop's wire slot on the call context — reaches the handler before
+ * `@solidjs/web/frames/wire` has loaded. Lost, the response would be read
+ * as a plain frame stream: no join, no supersession, no reconnect with a
+ * have-list. The bound: PRELOAD-AT-CALL + AWAIT.
+ *
+ *  - `live()`'s decorator fires the handler's `onLive` hook at the CALL,
+ *    before the first fetch: the import starts there and races only the
+ *    request.
+ *  - The handler's live arm AWAITS residency: with the tier gated, the
+ *    response head resolves nothing — the body is not read, nothing lands
+ *    in the store, the mount shows its fallback; there is no HOLD (no frame
+ *    exists to hold; nothing registers under frames-rulings 3.1 — the wait
+ *    is the dispatch's own await). The install lets the arm through: the
+ *    body is read through the tier, the content lands, the connection is
+ *    the loop's.
+ *  - A live response carries `X-Frame-Tiers: wire` (the server's
+ *    announcement, pinned server-side in tier-announce.spec); read through
+ *    the tier, it joins the same load — one import.
+ *  - A non-live call never loads the tier: a plain frame stream reads
+ *    through the eager transport, and the handler's `bump` / `resume` are
+ *    no-ops without it.
+ *  - Reconnect through the tier: a death reconnects with the ordinal and
+ *    the ledger the tier kept of what the mount shows (the have-list).
+ *  - The degraded first connect, ACCEPTED: content a plain call applied
+ *    before the tier was resident kept no ledger (the ledger is the
+ *    tier's), so the live connect over that mount sends no have-list —
+ *    and, nothing resident answering `resume`, no `Last-Event-ID` either
+ *    (the server does not read the ordinal for a frame render: it compares
+ *    `Last-Event-ID` to a value digest a frame answer never has) — and the
+ *    server answers with a full snapshot. The live response's own root
+ *    resets the ledger with the tier resident; the next reconnect names it.
+ *
+ * A tier, once resident, stays so for the worker: each test gates the load
+ * itself (`installServerComponents({ tiers })` replaces the built-in loader)
+ * and drops it between tests (`tierLoads`, the runtime's test seam).
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createRoot, createSignal, Loading } from "solid-js";
+import { dynamic } from "@solidjs/web";
+import { installServerComponents } from "../../frames/src/client.js";
+import { tierLoads } from "../../frames/src/frame-client.js";
+import {
+  FRAME_HAVE_HEADER,
+  FRAME_TIERS_HEADER,
+  decodeHaveList
+} from "../../frames/src/frame-transport.js";
+import { createServerReference, live } from "../../server-functions/src/client.js";
+import { LAST_EVENT_ID_HEADER, frameAddress } from "../../server-functions/src/shared.js";
+import {
+  freshFid,
+  makeHost,
+  openFrameResponse,
+  openLiveFrameResponse,
+  pump,
+  stubLiveFetch,
+  until
+} from "./support.js";
+
+/** The wire tier's load, gated by the test; `release()` installs the real module. */
+function gatedWire() {
+  delete (tierLoads as any).wire;
+  let resolve!: (m: any) => void;
+  const loader = vi.fn(() => new Promise<any>(r => (resolve = r)));
+  return {
+    tiers: { wire: loader },
+    loader,
+    release: async () => resolve(await import("../../frames/src/wire-tier.js"))
+  };
+}
+const resident = () => !!(tierLoads as any).wire?.r;
+
+const headerOf = (init: any, name: string) => init && init.headers && init.headers[name];
+
+/** The root: a title hole, with the server's digests. */
+const rootHtml = (title: string) => `<article><h1><!--lh:1-->${title}<!--lh:/1--></h1></article>`;
+const digestedRoot = (id: string, version: number, title: string, digest: string) => ({
+  type: "html",
+  id,
+  version,
+  html: rootHtml(title),
+  digest,
+  holes: { "lh:1": digest.slice(0, 15) + "f" }
+});
+
+/** Mount `<Loading fallback=…><Comp/></Loading>` into the body. */
+function mountUnderLoading(Comp: any) {
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  let div!: HTMLDivElement;
+  const dispose = createRoot(d => {
+    <div ref={div}>
+      <Loading fallback={<span class="fb">fallback</span>}>
+        <Comp />
+      </Loading>
+    </div>;
+    container.appendChild(div);
+    return d;
+  });
+  return {
+    div,
+    cleanup() {
+      dispose();
+      container.remove();
+    }
+  };
+}
+
+const cleanups: (() => void)[] = [];
+afterEach(() => {
+  for (const c of cleanups.splice(0)) c();
+  vi.unstubAllGlobals();
+  delete (globalThis as any)._$SC;
+  document.body.innerHTML = "";
+});
+
+describe("the live wire tier — preload-at-call", () => {
+  test("`live()`'s call starts the import before the first fetch; the response arm awaits residency (nothing lands, the fallback shows, no hold); the install lets it through — the announced header joins the same load, and a death reconnects with the ordinal and the have-list the tier kept", async () => {
+    const gate = gatedWire();
+    const fid = freshFid("tier-wire-a");
+    const WIRE = `${fid}/wire`;
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    const { held, urls, inits } = stubLiveFetch(WIRE, 2);
+    // The server's announcement on the live response (tier-announce.spec).
+    for (const h of held) h.response.headers.set(FRAME_TIERS_HEADER, "wire");
+    const getRoom = live(createServerReference(fid));
+    const address = frameAddress(fid, []);
+    // Declaring the reference loads nothing; the CALL starts the import —
+    // synchronously, before anything has iterated, before any fetch.
+    expect(gate.loader).not.toHaveBeenCalled();
+    const src: any = getRoom();
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(urls).toHaveLength(0);
+    expect(resident()).toBe(false);
+    const status: string[] = [];
+    src.onstatus = (s: string) => status.push(s);
+    let mounts = 0;
+    const Page = dynamic(() => (mounts++, src));
+    const m = mountUnderLoading(Page);
+    cleanups.push(m.cleanup);
+    await pump();
+    // The loop connected (the live address); the response head is in. The
+    // arm awaits the tier: the body is NOT read — the chunks sit in it —
+    // nothing is in the store, no frame exists under the address (so there
+    // is nothing to hold and nothing registered), the mount shows its
+    // fallback, the loop has not been told "connected".
+    expect(urls).toHaveLength(1);
+    expect(urls[0]).toContain("/live/");
+    held[0].send({ type: "start", id: WIRE, version: 1 });
+    held[0].send(digestedRoot(WIRE, 1, "v1", "a000000000000001"));
+    await pump();
+    expect(resident()).toBe(false);
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(host.get(address)).toBeUndefined();
+    expect(m.div.querySelector(".fb")).not.toBeNull();
+    expect(m.div.querySelector("h1")).toBeNull();
+    expect(status).toEqual([]);
+
+    // The install: the arm proceeds through the tier — the body is read
+    // (the loop's event-stream reader), the version moves, the content
+    // lands, the loop is connected. The header's `wire` joined the load
+    // already running: one import.
+    await gate.release();
+    await until(() => m.div.querySelector("h1") !== null, 3000);
+    expect(resident()).toBe(true);
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    expect(m.div.querySelector("h1")!.textContent).toBe("v1");
+    expect(m.div.querySelector(".fb")).toBeNull();
+    expect(mounts).toBe(1);
+    expect(status).toEqual(["connected"]);
+    // A first connect over nothing shown: no position, no have-list.
+    expect(headerOf(inits[0], LAST_EVENT_ID_HEADER)).toBeUndefined();
+    expect(headerOf(inits[0], FRAME_HAVE_HEADER)).toBeUndefined();
+
+    // Death → the reconnect goes through the tier: the ordinal, and the
+    // have-list of what the mount shows — kept by the tier at apply time.
+    const h1 = m.div.querySelector("h1")!;
+    held[0].close();
+    await until(() => urls.length === 2, 3000);
+    expect(status.slice(0, 2)).toEqual(["connected", "reconnecting"]);
+    expect(headerOf(inits[1], LAST_EVENT_ID_HEADER)).toBe("1");
+    expect(decodeHaveList(headerOf(inits[1], FRAME_HAVE_HEADER))).toEqual({
+      "": "a000000000000001",
+      "lh:1": "a00000000000000f"
+    });
+    // The content stood through the backoff; the reconnect morphs in place.
+    expect(m.div.querySelector("h1")).toBe(h1);
+    held[1].send({ type: "start", id: WIRE, version: 1 });
+    held[1].send({
+      type: "hole",
+      id: WIRE,
+      version: 1,
+      key: "lh:1",
+      html: "v2",
+      digest: "a000000000000002"
+    });
+    await until(() => h1.textContent === "v2", 3000);
+    expect(m.div.querySelector("h1")).toBe(h1);
+    expect(mounts).toBe(1);
+    held[1].send({ type: "complete", id: WIRE, version: 1 });
+    held[1].close();
+    await until(() => status.includes("closed"), 3000);
+  }, 10000);
+
+  test("a non-live call never loads the tier: a plain frame stream reads through the eager transport, and a refetch's bump has no connection to cancel", async () => {
+    const gate = gatedWire();
+    const fid = freshFid("tier-wire-b");
+    const WIRE = `${fid}/wire`;
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    const responses = [openFrameResponse(WIRE), openFrameResponse(WIRE)];
+    let calls = 0;
+    vi.stubGlobal("fetch", async () => responses[calls++].response);
+    const getPanel = createServerReference(fid);
+    const [tick, setTick] = createSignal(0);
+    const Page = dynamic(() => (tick(), getPanel() as any));
+    const m = mountUnderLoading(Page);
+    cleanups.push(m.cleanup);
+    await pump();
+    expect(calls).toBe(1);
+    responses[0].send({ type: "start", id: WIRE, version: 1 });
+    responses[0].send(digestedRoot(WIRE, 1, "plain", "b000000000000001"));
+    responses[0].send({ type: "complete", id: WIRE, version: 1 });
+    responses[0].close();
+    await pump();
+    expect(m.div.querySelector("h1")!.textContent).toBe("plain");
+    expect(gate.loader).not.toHaveBeenCalled();
+    expect(resident()).toBe(false);
+    // A refetch of the same call: the next version — `bump` runs with the
+    // tier absent (nothing to cancel), the morph lands.
+    const h1 = m.div.querySelector("h1")!;
+    setTick(1);
+    await pump();
+    expect(calls).toBe(2);
+    responses[1].send({ type: "start", id: WIRE, version: 1 });
+    responses[1].send(digestedRoot(WIRE, 1, "plain-2", "b000000000000002"));
+    responses[1].send({ type: "complete", id: WIRE, version: 1 });
+    responses[1].close();
+    await until(() => h1.textContent === "plain-2", 3000);
+    expect(m.div.querySelector("h1")).toBe(h1);
+    expect(gate.loader).not.toHaveBeenCalled();
+    expect(resident()).toBe(false);
+  });
+
+  test("the degraded first connect (accepted): content a plain call applied before the tier was resident kept no ledger — the live connect sends no have-list and no position (a full snapshot); the live response's own root resets the ledger, and the reconnect names it", async () => {
+    const gate = gatedWire();
+    const fid = freshFid("tier-wire-c");
+    const WIRE = `${fid}/wire`;
+    const { host } = makeHost();
+    installServerComponents(host, { tiers: gate.tiers });
+    const address = frameAddress(fid, []);
+    // One fetch stub for the plain call, then the loop's two connects.
+    const plain = openFrameResponse(WIRE);
+    const lives = [openLiveFrameResponse(WIRE), openLiveFrameResponse(WIRE)];
+    const urls: string[] = [];
+    const inits: any[] = [];
+    vi.stubGlobal("fetch", async (input: any, init: any) => {
+      urls.push(typeof input === "string" ? input : input.url);
+      inits.push(init);
+      const n = urls.length;
+      if (n === 1) return plain.response;
+      const next = lives[n - 2];
+      if (!next) throw new Error(`unexpected fetch #${n}`);
+      if (init && init.signal)
+        init.signal.addEventListener("abort", () => next.abort(init.signal.reason), { once: true });
+      return next.response;
+    });
+    // The plain call: its root carries the server's digests, applied with
+    // the tier ABSENT — the ledger is the tier's, so nothing kept it.
+    const getPanel = createServerReference(fid);
+    const Plain = dynamic(() => getPanel() as any);
+    const m = mountUnderLoading(Plain);
+    cleanups.push(m.cleanup);
+    await pump();
+    expect(urls).toHaveLength(1);
+    plain.send({ type: "start", id: WIRE, version: 1 });
+    plain.send(digestedRoot(WIRE, 1, "plain", "c000000000000001"));
+    plain.send({ type: "complete", id: WIRE, version: 1 });
+    plain.close();
+    await pump();
+    expect(m.div.querySelector("h1")!.textContent).toBe("plain");
+    expect(gate.loader).not.toHaveBeenCalled();
+    expect(host.get(address)).toBeDefined();
+
+    // A `live()` call of the same function (the same address): the import
+    // starts at the call; the first connect asks `resume` with the tier not
+    // resident — nothing answers: no have-list, no position. Degraded (the
+    // server renders a full snapshot where a conditional one was possible),
+    // not wrong.
+    const getRoom = live(createServerReference(fid));
+    const src: any = getRoom();
+    expect(gate.loader).toHaveBeenCalledTimes(1);
+    const status: string[] = [];
+    src.onstatus = (s: string) => status.push(s);
+    const Live = dynamic(() => src);
+    const m2 = mountUnderLoading(Live);
+    cleanups.push(m2.cleanup);
+    await pump();
+    expect(urls).toHaveLength(2);
+    expect(urls[1]).toContain("/live/");
+    expect(headerOf(inits[1], FRAME_HAVE_HEADER)).toBeUndefined();
+    expect(headerOf(inits[1], LAST_EVENT_ID_HEADER)).toBeUndefined();
+
+    // The full snapshot arrives; the install lets the arm read it. Its root
+    // resets the ledger — with the tier resident now, it is kept.
+    lives[0].send({ type: "start", id: WIRE, version: 1 });
+    lives[0].send(digestedRoot(WIRE, 1, "live", "c000000000000002"));
+    await gate.release();
+    await until(() => m2.div.querySelector("h1") !== null, 3000);
+    expect(resident()).toBe(true);
+    expect(m2.div.querySelector("h1")!.textContent).toBe("live");
+    // The plain mount is bound to the same address: the store moved to the
+    // live response's version and it morphed too.
+    expect(m.div.querySelector("h1")!.textContent).toBe("live");
+    expect(status).toEqual(["connected"]);
+
+    // Death → the reconnect names the ordinal (the address's second
+    // version) and the ledger the live root seeded.
+    lives[0].close();
+    await until(() => urls.length === 3, 3000);
+    expect(headerOf(inits[2], LAST_EVENT_ID_HEADER)).toBe("2");
+    expect(decodeHaveList(headerOf(inits[2], FRAME_HAVE_HEADER))).toEqual({
+      "": "c000000000000002",
+      "lh:1": "c00000000000000f"
+    });
+    lives[1].send({ type: "start", id: WIRE, version: 1 });
+    lives[1].send({ type: "complete", id: WIRE, version: 1 });
+    lives[1].close();
+    await until(() => status.includes("closed"), 3000);
+  }, 10000);
+});
diff --git a/packages/web/test/dynamic-component.type-tests.tsx b/packages/web/test/dynamic-component.type-tests.tsx
new file mode 100644
index 000000000..2d6cbbf71
--- /dev/null
+++ b/packages/web/test/dynamic-component.type-tests.tsx
@@ -0,0 +1,67 @@
+/** @jsxImportSource @solidjs/web */
+
+// `dynamicComponent` is `dynamic` with the tag arm removed, and its SOURCE
+// TYPE is the user's guard: a source that can answer with a tag name is a
+// compile error here and fine on `dynamic`. A server component reference is
+// typed as the server function's declared answer — a `Component<P>` (or
+// `LiveSource<Component<P>>` for a `live` declaration, an intersection that
+// is still a `Component<P>`) — so it needs no special case in the union.
+import { dynamic, dynamicComponent } from "@solidjs/web";
+import type { LiveSource } from "@solidjs/web/server-functions/client";
+import type { Component, Element as SolidElement } from "solid-js";
+
+declare const Editor: Component<{ value: string }>;
+declare const Viewer: Component<{ value: string }>;
+declare const editing: () => boolean;
+declare const tag: () => "input" | "textarea";
+
+// A server function answering with a server component: on the client its
+// call is a promise of the component; a `live` declaration's call is the
+// branded iterable, typed as the component itself.
+declare function getStory(
+  id: number
+): Promise<Component<{ comment: (p: { cid: number; children?: SolidElement }) => SolidElement }>>;
+declare function feed(room: string): LiveSource<Component<{ compose: () => SolidElement }>>;
+
+// --- dynamicComponent: components only -----------------------------------
+
+const Active = dynamicComponent(() => (editing() ? Editor : Viewer));
+<Active value="x" />;
+// @ts-expect-error props are the resolved component's
+<Active value={1} />;
+
+const Story = dynamicComponent(() => getStory(1));
+<Story comment={p => <b>{p.cid}</b>} />;
+// @ts-expect-error the slot's props are the server component's
+<Story comment={(p: { nope: string }) => p.nope} />;
+
+const Feed = dynamicComponent(() => feed("room"));
+<Feed compose={() => <input />} />;
+
+dynamicComponent(() => (editing() ? Editor : undefined));
+dynamicComponent(() => (editing() ? Editor : null));
+dynamicComponent(() => editing() && Editor);
+dynamicComponent(() => Editor, { static: true });
+dynamicComponent(() => getStory(1), { deferStream: true });
+
+// A tag name is not a component — use `dynamic` for one.
+// @ts-expect-error a tag name
+dynamicComponent(() => "input");
+// @ts-expect-error a tag name from a union
+dynamicComponent(() => tag());
+// @ts-expect-error a promise of a tag name
+dynamicComponent(() => Promise.resolve("input" as const));
+// @ts-expect-error a source that MAY answer with a tag name
+dynamicComponent(() => (editing() ? Editor : "input"));
+// @ts-expect-error an arbitrary string
+dynamicComponent(() => "my-element" as string);
+
+// --- dynamic: the full contract, unchanged --------------------------------
+
+dynamic(() => "input");
+dynamic(() => tag());
+dynamic(() => Promise.resolve("input" as const));
+const Field = dynamic(() => (editing() ? Editor : "input"));
+<Field value="x" />;
+dynamic(() => getStory(1));
+dynamic(() => feed("room"));
diff --git a/packages/web/test/frames-assets-client.spec.ts b/packages/web/test/frames-assets-client.spec.ts
new file mode 100644
index 000000000..6b871fce5
--- /dev/null
+++ b/packages/web/test/frames-assets-client.spec.ts
@@ -0,0 +1,385 @@
+/** @vitest-environment jsdom */
+// The frames client's stylesheet gate and inline-style application — the
+// stream face's analogue of the document runtime's `$dfs` / `$dfc`
+// (`ensureStylesheet`, `applyInlineStyles`, `#segmentReady`'s style term).
+// Pinned before anything moved (frames savings pass §3 row C5: the SC layer
+// audit's one 0-coverage gap, §2.4) and kept through the move: the code is
+// now the ASSETS TIER (`@solidjs/web/frames/assets`, frames/src/
+// assets-tier.ts), resident here — the tier's load is warmed once, so these
+// pins read the gate and the pass as a warm page does; the tier's own
+// timing (what happens while it is NOT resident) is
+// consistency/tier-assets-ready.spec.
+//
+//  - A stylesheet named by the record is inserted the moment the segment's
+//    content and reveal are both in the store (the placeholder may still be
+//    missing — the load overlaps the rest of the stream) and the segment
+//    reveals only once the link has SETTLED: `load`, or `error` (an erroring
+//    sheet must not hold content forever — the `$dfc` policy). A link already
+//    in the document counts as settled. One link per href, document-wide;
+//    one waiter per frame on a pending link, however many flushes re-check.
+//  - The gate is the ASSETS record, not the reveal chunk's `waitForStyles`
+//    flag: the flag is the server's note of what it emitted; the client
+//    reads the record.
+//  - Inline styles never gate. They land in the head, deduped by
+//    `data-asset` id, in entry order, at the record's arrival — before the
+//    segment's content shows, as the document face orders them.
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+import {
+  createFrame,
+  createFrameHost,
+  prepareTier,
+  tierLoaders
+} from "../frames/src/frame-client.js";
+
+beforeAll(async () => {
+  // The frames client entry (client.ts) wires this loader in production;
+  // these pins drive the runtime module directly, so wire and warm it here.
+  tierLoaders.assets ??= () => import("../frames/src/assets-tier.js");
+  await prepareTier("assets");
+});
+
+afterEach(() => {
+  document.head.replaceChildren();
+  document.body.replaceChildren();
+});
+
+/** A boundary in the body with a frame on it. */
+function mount() {
+  const boundary = document.createElement("div");
+  document.body.appendChild(boundary);
+  return { boundary, frame: createFrame(boundary) };
+}
+
+/** The shell: one pending placeholder for segment `key`, its fallback in the template. */
+const shell = (key: string, fallback = "loading") =>
+  `<section><template id="pl-${key}">${fallback}</template><!--pl-${key}--></section>`;
+
+/** The records of one revealed segment: content, reveal gate, assets. */
+function segment(key: string, html: string, assets?: Record<string, unknown>) {
+  const r: Record<string, unknown> = {
+    [`seg:${key}`]: { kind: "html", value: html },
+    [`seg:${key}:reveal`]: true
+  };
+  if (assets) r[`seg:${key}:assets`] = { type: "assets", key, ...assets };
+  return r;
+}
+
+const links = () => [...document.head.querySelectorAll<HTMLLinkElement>('link[rel="stylesheet"]')];
+const styles = () => [...document.head.querySelectorAll<HTMLStyleElement>("style[data-asset]")];
+const settle = (link: Element, event: "load" | "error" = "load") =>
+  link.dispatchEvent(new Event(event));
+/** Whether segment `key` is still pending: its placeholder template is in the range. */
+const pending = (root: Element, key: string) => root.querySelector(`template#pl-${key}`) !== null;
+
+describe("the stylesheet gate (ensureStylesheet)", () => {
+  it("inserts the segment's stylesheet at once and reveals only when the link loads", () => {
+    const { boundary, frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    frame.apply({ version: 1, r: segment("c", "<p>styled</p>", { styles: ["/c.css"] }) });
+    // The link is in the head, pending; the segment is not revealed.
+    expect(links().map(l => l.getAttribute("href"))).toEqual(["/c.css"]);
+    expect(pending(boundary, "c")).toBe(true);
+    expect(boundary.querySelector("p")).toBeNull();
+    // A re-check before the load changes nothing: no second link, still held.
+    frame.apply({ version: 1, r: {} });
+    expect(links()).toHaveLength(1);
+    expect(pending(boundary, "c")).toBe(true);
+    // The load settles the gate: the segment reveals.
+    settle(links()[0]);
+    expect(pending(boundary, "c")).toBe(false);
+    expect(boundary.querySelector("p")!.textContent).toBe("styled");
+  });
+
+  it("an erroring stylesheet settles the gate too: the segment reveals (the $dfc policy)", () => {
+    const { boundary, frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    frame.apply({ version: 1, r: segment("c", "<p>unstyled</p>", { styles: ["/missing.css"] }) });
+    expect(pending(boundary, "c")).toBe(true);
+    settle(links()[0], "error");
+    expect(pending(boundary, "c")).toBe(false);
+    expect(boundary.querySelector("p")!.textContent).toBe("unstyled");
+  });
+
+  it("dedupes by href: two segments naming one sheet share one link and both reveal on its load", () => {
+    const { boundary, frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("a") + shell("b") } } });
+    frame.apply({
+      version: 1,
+      r: {
+        ...segment("a", "<p>a</p>", { styles: ["/shared.css"] }),
+        ...segment("b", "<p>b</p>", { styles: ["/shared.css", "/b.css"] })
+      }
+    });
+    expect(links().map(l => l.getAttribute("href"))).toEqual(["/shared.css", "/b.css"]);
+    expect(pending(boundary, "a")).toBe(true);
+    expect(pending(boundary, "b")).toBe(true);
+    // `b` names two sheets: one loading does not reveal it.
+    settle(links()[0]);
+    expect(pending(boundary, "a")).toBe(false);
+    expect(pending(boundary, "b")).toBe(true);
+    settle(links()[1]);
+    expect(pending(boundary, "b")).toBe(false);
+    expect(boundary.textContent).toBe("ab");
+  });
+
+  it("a stylesheet already in the document counts as settled: the segment reveals at once, no second link", () => {
+    const doc = document.createElement("link");
+    doc.rel = "stylesheet";
+    doc.setAttribute("href", "/doc.css");
+    document.head.appendChild(doc);
+    const { boundary, frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    frame.apply({ version: 1, r: segment("c", "<p>in</p>", { styles: ["/doc.css"] }) });
+    expect(links()).toEqual([doc]);
+    expect(pending(boundary, "c")).toBe(false);
+    expect(boundary.querySelector("p")!.textContent).toBe("in");
+  });
+
+  it("a link this gate created and settled is settled for every later segment naming it", () => {
+    const { boundary, frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("a") + shell("b") } } });
+    frame.apply({ version: 1, r: segment("a", "<p>a</p>", { styles: ["/x.css"] }) });
+    settle(links()[0]);
+    expect(pending(boundary, "a")).toBe(false);
+    // A later segment over the same sheet: no wait, no second link.
+    frame.apply({ version: 1, r: segment("b", "<p>b</p>", { styles: ["/x.css"] }) });
+    expect(links()).toHaveLength(1);
+    expect(pending(boundary, "b")).toBe(false);
+  });
+
+  it("an attributed entry `{ href, attrs }` carries its attributes onto the link it creates", () => {
+    const { frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    frame.apply({
+      version: 1,
+      r: segment("c", "<p>x</p>", {
+        styles: [{ href: "/print.css", attrs: { media: "print", crossorigin: "", nonce: "n1" } }]
+      })
+    });
+    const [link] = links();
+    expect(link.getAttribute("href")).toBe("/print.css");
+    expect(link.getAttribute("media")).toBe("print");
+    expect(link.getAttribute("crossorigin")).toBe("");
+    expect(link.getAttribute("nonce")).toBe("n1");
+  });
+
+  it("inserts the link even while the placeholder is missing, so the load overlaps the rest of the stream", () => {
+    const { boundary, frame } = mount();
+    // The outer segment carries the inner's placeholder; the inner's records
+    // land first (content, reveal, assets), its placeholder not yet in the DOM.
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("outer") } } });
+    frame.apply({ version: 1, r: segment("inner", "<p>inner</p>", { styles: ["/inner.css"] }) });
+    expect(links().map(l => l.getAttribute("href"))).toEqual(["/inner.css"]);
+    expect(boundary.querySelector("p")).toBeNull();
+    // The sheet loads before the outer reveals: nothing to reveal into yet.
+    settle(links()[0]);
+    expect(boundary.querySelector("p")).toBeNull();
+    // The outer reveals, bringing the inner's placeholder: the inner reveals
+    // in the same pass — its sheet is settled.
+    frame.apply({ version: 1, r: segment("outer", shell("inner")) });
+    expect(pending(boundary, "outer")).toBe(false);
+    expect(pending(boundary, "inner")).toBe(false);
+    expect(boundary.querySelector("p")!.textContent).toBe("inner");
+  });
+
+  it("the link is inserted at the reveal, not at the assets record: content without a reveal gate requests nothing", () => {
+    // The gate's order: content, reveal, THEN styles. An assets record whose
+    // segment has no reveal yet (a grouped reveal still owed) does not start
+    // the sheet's load — pinned as today's behaviour.
+    const { frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    frame.apply({
+      version: 1,
+      r: {
+        "seg:c": { kind: "html", value: "<p>x</p>" },
+        "seg:c:assets": { type: "assets", key: "c", styles: ["/late.css"] }
+      }
+    });
+    expect(links()).toEqual([]);
+    frame.apply({ version: 1, r: { "seg:c:reveal": true } });
+    expect(links().map(l => l.getAttribute("href"))).toEqual(["/late.css"]);
+  });
+
+  it("one waiter per frame on a pending link, however many flushes re-check; a shared pending sheet re-flushes every frame", () => {
+    const a = mount();
+    const b = mount();
+    a.frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    b.frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    a.frame.apply({ version: 1, r: segment("c", "<p>a</p>", { styles: ["/both.css"] }) });
+    b.frame.apply({ version: 1, r: segment("c", "<p>b</p>", { styles: ["/both.css"] }) });
+    const [link] = links();
+    expect(links()).toHaveLength(1);
+    // Re-checks (unrelated writes) do not pile up waiters.
+    a.frame.apply({ version: 1, r: { x: 1 } });
+    a.frame.apply({ version: 1, r: { y: 1 } });
+    b.frame.apply({ version: 1, r: { x: 1 } });
+    expect((link as any)._$frWaiters.size).toBe(2);
+    settle(link);
+    expect((link as any)._$frWaiters).toBeNull();
+    expect(a.boundary.textContent).toBe("a");
+    expect(b.boundary.textContent).toBe("b");
+  });
+
+  it("a frame disposed while its sheet pends: the settle reveals nothing and throws nothing", () => {
+    const { boundary, frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    frame.apply({ version: 1, r: segment("c", "<p>x</p>", { styles: ["/d.css"] }) });
+    frame.dispose();
+    expect(() => settle(links()[0])).not.toThrow();
+    expect(boundary.querySelector("p")).toBeNull();
+  });
+
+  it("the gate is the assets record, not the reveal chunk's `waitForStyles` flag", () => {
+    // Through the host (chunk form): a reveal with `waitForStyles: false`
+    // whose segment's assets record names a stylesheet still waits for it;
+    // `waitForStyles: true` with no stylesheet in the record waits for nothing.
+    const host = createFrameHost();
+    const { boundary } = mount();
+    const frame = createFrame(boundary, { id: "wfs", host });
+    const chunk = (c: Record<string, unknown>) =>
+      host.apply({ id: "wfs", version: 1, ...c } as any);
+    chunk({ type: "html", html: shell("a") + shell("b") });
+    chunk({ type: "assets", key: "a", styles: ["/a.css"] });
+    chunk({ type: "fragment", key: "a", html: "<p>a</p>" });
+    chunk({ type: "reveal", keys: ["a"], waitForStyles: false });
+    expect(links().map(l => l.getAttribute("href"))).toEqual(["/a.css"]);
+    expect(pending(boundary, "a")).toBe(true);
+    chunk({ type: "fragment", key: "b", html: "<p>b</p>" });
+    chunk({ type: "reveal", keys: ["b"], waitForStyles: true });
+    expect(pending(boundary, "b")).toBe(false);
+    settle(links()[0]);
+    expect(pending(boundary, "a")).toBe(false);
+    expect(boundary.textContent).toBe("ab");
+    frame.dispose();
+  });
+});
+
+describe("inline styles (applyInlineStyles)", () => {
+  it("land in the head in entry order, with their attributes, before the segment's content shows", () => {
+    const { boundary, frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    const mo = new MutationObserver(() => {});
+    mo.observe(document.documentElement, { childList: true, subtree: true });
+    frame.apply({
+      version: 1,
+      r: segment("c", "<p>inline</p>", {
+        inlineStyles: [
+          { id: "s1", content: ".a{color:red}" },
+          { id: "s2", content: ".b{color:blue}", attrs: { nonce: "n2", media: "screen" } },
+          { id: "s3" }
+        ]
+      })
+    });
+    const added = mo
+      .takeRecords()
+      .flatMap(r => [...r.addedNodes])
+      .filter(n => n.nodeType === 1) as Element[];
+    mo.disconnect();
+    // Head first, then the content.
+    const firstContent = added.findIndex(n => n.tagName === "P");
+    const lastStyle = added.map(n => n.tagName).lastIndexOf("STYLE");
+    expect(firstContent).toBeGreaterThan(-1);
+    expect(lastStyle).toBeGreaterThan(-1);
+    expect(lastStyle).toBeLessThan(firstContent);
+    expect(styles().map(s => s.getAttribute("data-asset"))).toEqual(["s1", "s2", "s3"]);
+    expect(styles()[0].textContent).toBe(".a{color:red}");
+    expect(styles()[1].getAttribute("nonce")).toBe("n2");
+    expect(styles()[1].getAttribute("media")).toBe("screen");
+    // An entry without content is an empty element, not "undefined".
+    expect(styles()[2].textContent).toBe("");
+    expect(boundary.querySelector("p")!.textContent).toBe("inline");
+  });
+
+  it("never gate: a segment with inline styles alone reveals at once", () => {
+    const { boundary, frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    frame.apply({
+      version: 1,
+      r: segment("c", "<p>now</p>", { inlineStyles: [{ id: "only", content: "p{}" }] })
+    });
+    expect(pending(boundary, "c")).toBe(false);
+    expect(boundary.querySelector("p")!.textContent).toBe("now");
+  });
+
+  it("are idempotent by `data-asset` id: a second segment (or a re-apply) with the same id adds no second element and rewrites nothing", () => {
+    const { boundary, frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("a") + shell("b") } } });
+    frame.apply({
+      version: 1,
+      r: {
+        ...segment("a", "<p>a</p>", { inlineStyles: [{ id: "shared", content: "first" }] }),
+        ...segment("b", "<p>b</p>", { inlineStyles: [{ id: "shared", content: "second" }] })
+      }
+    });
+    expect(styles()).toHaveLength(1);
+    expect(styles()[0].textContent).toBe("first");
+    expect(boundary.textContent).toBe("ab");
+    // A new version re-sending the record: the element in the head is adopted.
+    frame.apply({
+      version: 2,
+      r: {
+        "": { kind: "html", value: shell("a") },
+        ...segment("a", "<p>a2</p>", { inlineStyles: [{ id: "shared", content: "third" }] })
+      }
+    });
+    expect(styles()).toHaveLength(1);
+    expect(styles()[0].textContent).toBe("first");
+    expect(boundary.textContent).toBe("a2");
+  });
+
+  it("adopt a document-emitted `<style data-asset>` instead of duplicating it", () => {
+    const doc = document.createElement("style");
+    doc.setAttribute("data-asset", "doc");
+    doc.textContent = "server";
+    document.head.appendChild(doc);
+    const { frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    frame.apply({
+      version: 1,
+      r: segment("c", "<p>x</p>", { inlineStyles: [{ id: "doc", content: "client" }] })
+    });
+    expect(styles()).toEqual([doc]);
+    expect(doc.textContent).toBe("server");
+  });
+
+  it("ride the same record as stylesheets: the sheet gates, the inline style lands at the record's arrival", () => {
+    const { boundary, frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    frame.apply({
+      version: 1,
+      r: segment("c", "<p>both</p>", {
+        styles: ["/gate.css"],
+        inlineStyles: [{ id: "with-sheet", content: "p{}" }]
+      })
+    });
+    // Held on the sheet; the inline style is already in the head (the
+    // document face writes a fragment's <style> with its markup, before the
+    // swap — the stream face lands it at the record, before the reveal).
+    expect(pending(boundary, "c")).toBe(true);
+    expect(styles().map(s => s.getAttribute("data-asset"))).toEqual(["with-sheet"]);
+    settle(links()[0]);
+    expect(pending(boundary, "c")).toBe(false);
+    expect(styles()).toHaveLength(1);
+  });
+
+  it("land at the record's arrival even before the segment's reveal gate (a grouped reveal still owed)", () => {
+    const { boundary, frame } = mount();
+    frame.apply({ version: 1, r: { "": { kind: "html", value: shell("c") } } });
+    frame.apply({
+      version: 1,
+      r: {
+        "seg:c": { kind: "html", value: "<p>grouped</p>" },
+        "seg:c:assets": {
+          type: "assets",
+          key: "c",
+          inlineStyles: [{ id: "early", content: "p{}" }]
+        }
+      }
+    });
+    expect(styles().map(s => s.getAttribute("data-asset"))).toEqual(["early"]);
+    expect(pending(boundary, "c")).toBe(true);
+    frame.apply({ version: 1, r: { "seg:c:reveal": true } });
+    expect(pending(boundary, "c")).toBe(false);
+    expect(styles()).toHaveLength(1);
+  });
+});
diff --git a/packages/web/test/frames-binding-slots.spec.tsx b/packages/web/test/frames-binding-slots.spec.tsx
index 4ef25c690..af7db8f82 100644
--- a/packages/web/test/frames-binding-slots.spec.tsx
+++ b/packages/web/test/frames-binding-slots.spec.tsx
@@ -20,13 +20,14 @@
 // The server side is hand-framed Responses (marker-bearing html and slot
 // records, exactly what the server face emits — pinned by
 // test/server/frame-binding-slots.spec.tsx) behind a stubbed fetch.
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeAll, beforeEach, describe, expect, test, vi } from "vitest";
 import { createSignal, flush, Loading, OBSERVE } from "solid-js";
-// From the packaged entry, not `../src`: the frames client writes positions
+// From the packaged entry, not `../src`: the bind tier writes positions
 // through `@solidjs/web`'s `assign` (the shared instance an app has), and
 // delegated dispatch must find the root registered by the SAME instance.
 import { dynamic, render } from "@solidjs/web";
 import { installServerComponents, createFrameHost } from "../frames/src/client.js";
+import { prepareTier } from "../frames/src/frame-client.js";
 import { createJSONDataTable } from "../serialization/src/serializer.js";
 import { createServerReference } from "../server-functions/src/client.js";
 import { createChunk } from "../server-functions/src/shared.js";
@@ -44,6 +45,13 @@ function frameResponse(id: string, chunks: any[]) {
 
 const ID = "todos/list";
 
+// Binding-slot positions are the BIND TIER's (`@solidjs/web/frames/bind`,
+// loaded through `prepareTier("bind")` at the first marker met — plan step
+// C6). These cells pin the positions' behaviour with the tier RESIDENT, so
+// it is warmed once here; the un-announced hold and the install's flush
+// are pinned in consistency/tier-bind-hold.spec.tsx.
+beforeAll(() => prepareTier("bind"));
+
 type Todo = { id: string; title: string; completed: boolean };
 
 // The markup the shared `TodoRow` renders on the server (stream face: markers
diff --git a/packages/web/test/frames-container-lazy-codec.spec.tsx b/packages/web/test/frames-container-lazy-codec.spec.tsx
new file mode 100644
index 000000000..cf19d43c7
--- /dev/null
+++ b/packages/web/test/frames-container-lazy-codec.spec.tsx
@@ -0,0 +1,216 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ */
+// The traces tier — codec face. The container-trace materializer is solid's
+// projection machinery, the store engine's one edge into a server-component
+// page, so the frames client no longer installs it at module load: it is the
+// `trace` TIER (`@solidjs/web/frames/trace`, frames savings pass §3 row C3),
+// loaded through the tier mechanism. On the stream face the SERVER announces
+// it: the sink mints `trace` where it serializes a trace, and the `data`
+// chunk that carries the plugin's node leaves with `tiers: ["trace"]` in-band
+// (test/server/tier-announce.spec pins the sink's half). The transport
+// starts the load at that chunk and AWAITS it before the chunk decodes (the
+// plugin materializes AT decode, so the install has to come first; nothing
+// after a decode revives), as it awaits the codec itself. A response whose
+// data never carries a trace announces nothing and loads nothing.
+//
+// S1's node scan (`prepareData` inspecting each chunk's tree) is not kept:
+// the announcement rides the very chunk the scan would have found the node
+// in, from the same site that serialized it, so the scan is unreachable
+// behind it (the plan's §3 row C3 / §5 — measured +79 B min / +25 B br on
+// the eager client to keep; dropped). An un-announced chunk from a producer
+// that predates the tier decodes the inert marker (the plugin's hookless
+// fallback) — a skew the frames server and client, one package, never ship.
+//
+// A tier, once resident, stays so for the worker: the gated loader is
+// installed per test (`installServerComponents({ tiers })` replaces the
+// built-in entry) and the load dropped between tests (`tierLoads`, the
+// runtime's test seam). The behaviour of a resident tier is pinned in
+// lifecycle-matrix/container-args.spec.tsx; the document face in
+// frames-container-lazy-document.spec.tsx.
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createRoot, Loading, untrack } from "solid-js";
+import { dynamic } from "../src/index.js";
+import { getFrameHost, installServerComponents } from "../frames/src/client.js";
+import { tierLoads } from "../frames/src/frame-client.js";
+import { createServerReference } from "../server-functions/src/client.js";
+import {
+  isMaterializedContainer,
+  setContainerTraceResolver,
+  toBorderForm
+} from "../frames/src/frame-container-plugin.js";
+import { frameResponse, createDataSource, pump } from "./lifecycle-matrix/harness.js";
+
+const getPlain = createServerReference("lazy/containers/plain");
+const getTraced = createServerReference("lazy/containers/traced");
+const traceTierResident = () => !!(tierLoads as any).trace?.r;
+
+const slotArticle =
+  "<article><h1>T</h1><ul><!--slot:comment#0:start--><!--slot:comment#0:end--></ul></article>";
+
+// Harness-side server half: the sink envelopes any value the resolver claims.
+const traces = new WeakMap<object, any>();
+setContainerTraceResolver((v: unknown) =>
+  typeof v === "object" && v !== null ? traces.get(v) : undefined
+);
+function traceProducer() {
+  const queue: IteratorResult<any>[] = [];
+  const waiters: ((r: IteratorResult<any>) => void)[] = [];
+  const put = (r: IteratorResult<any>) => {
+    const w = waiters.shift();
+    w ? w(r) : queue.push(r);
+  };
+  const iterate = () => ({
+    [Symbol.asyncIterator]() {
+      return {
+        next: () => {
+          const b = queue.shift();
+          return b
+            ? Promise.resolve(b)
+            : new Promise<IteratorResult<any>>(res => waiters.push(res));
+        }
+      };
+    }
+  });
+  return {
+    trace: { array: false, subscribe: iterate },
+    push: (value: any) => put({ done: false, value }),
+    end: () => put({ done: true, value: undefined })
+  };
+}
+
+/** The tier's load, gated by the test; `release()` installs the real module. */
+function gateTraceTier() {
+  delete (tierLoads as any).trace;
+  let resolve!: (m: any) => void;
+  const loader = vi.fn(() => new Promise<any>(r => (resolve = r)));
+  installServerComponents(undefined, { tiers: { trace: loader } });
+  return { loader, release: async () => resolve(await import("../frames/src/trace-tier.js")) };
+}
+
+function mount(Comp: any, props: Record<string, any>) {
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  let div!: HTMLDivElement;
+  const dispose = createRoot(d => {
+    <div ref={div}>
+      <Loading fallback={<span>shell-fallback</span>}>
+        <Comp {...props} />
+      </Loading>
+    </div>;
+    container.appendChild(div);
+    return d;
+  });
+  return {
+    div,
+    cleanup() {
+      dispose();
+      container.remove();
+    }
+  };
+}
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe("codec face: the traces tier loads behind the data chunk that announces it", () => {
+  test("a data chunk WITHOUT a trace announces nothing and decodes with nothing loaded", async () => {
+    const gated = gateTraceTier();
+    const data = createDataSource();
+    const initial = data.chunks("plain", 1, { user: { name: "Ada" } });
+    vi.stubGlobal("fetch", async () =>
+      frameResponse("plain", [
+        { type: "start", id: "plain", version: 1 },
+        ...initial,
+        {
+          type: "slot",
+          id: "plain",
+          version: 1,
+          key: "comment#0",
+          args: { user: { $ref: "user" } }
+        },
+        { type: "html", id: "plain", version: 1, html: slotArticle },
+        { type: "complete", id: "plain", version: 1 }
+      ])
+    );
+    const Page = dynamic(() => getPlain() as any);
+    const m = mount(Page, { comment: (p: any) => <li>{p.user.name}</li> });
+    await pump(3);
+    expect(m.div.querySelector("li")!.textContent).toBe("Ada");
+    // The codec loaded (the data decoded); the tier was never asked for.
+    expect(gated.loader).not.toHaveBeenCalled();
+    expect((tierLoads as any).trace).toBeUndefined();
+    m.cleanup();
+  });
+
+  test("a data chunk WITH a trace announces the tier and awaits it before it decodes: the {$ref} resolves to a live store", async () => {
+    const gated = gateTraceTier();
+    const producer = traceProducer();
+    const user = {};
+    traces.set(user, producer.trace);
+    const late: any[] = [];
+    const data = createDataSource();
+    const initial = data.chunks("traced", 1, { user: toBorderForm(user, true) }, c => late.push(c));
+    // What the sink emits for this chunk: the trace's announcement rides it.
+    initial[0].tiers = ["trace"];
+    vi.stubGlobal("fetch", async () =>
+      frameResponse("traced", [
+        { type: "start", id: "traced", version: 1 },
+        ...initial,
+        {
+          type: "slot",
+          id: "traced",
+          version: 1,
+          key: "comment#0",
+          args: { user: { $ref: "user" } }
+        },
+        { type: "html", id: "traced", version: 1, html: slotArticle },
+        { type: "complete", id: "traced", version: 1 }
+      ])
+    );
+    let received: any;
+    let mounts = 0;
+    const Page = dynamic(() => getTraced() as any);
+    const m = mount(Page, {
+      comment: (p: any) => {
+        mounts++;
+        received = untrack(() => p.user);
+        return (
+          <Loading fallback={<i>fill-wait</i>}>
+            <li>{p.user.name}</li>
+          </Loading>
+        );
+      }
+    });
+    await pump(3);
+    // The announcement started the load at the chunk — and the chunk is
+    // held behind it: nothing decoded, the record and the shell behind it
+    // in the sequential drain wait too (chunk ORDER is the contract).
+    expect(gated.loader).toHaveBeenCalledTimes(1);
+    expect(traceTierResident()).toBe(false);
+    expect(m.div.querySelector("article")).toBeNull();
+    expect(mounts).toBe(0);
+
+    // The load settles: the install, then the drain resumes — the data
+    // decodes with the materializer resident.
+    await gated.release();
+    await pump(3);
+    expect(traceTierResident()).toBe(true);
+    expect(mounts).toBe(1);
+    // Decoded AFTER the load: a live (pending) container, not an inert marker.
+    expect(isMaterializedContainer(received)).toBe(true);
+    expect(m.div.textContent).toContain("fill-wait");
+
+    // The snapshot lands through the (lazily loaded) codec's data table:
+    // the fill's suspended read settles on the live store. The shared host
+    // routes data by the call's ADDRESS (the transport rewrote the stream's
+    // root id to it; an argless call's address is its function id).
+    producer.push({ name: "Ada" });
+    await pump();
+    for (const c of late.splice(0)) getFrameHost().apply({ ...c, id: "lazy/containers/traced" });
+    await pump();
+    expect(m.div.querySelector("li")!.textContent).toBe("Ada");
+    m.cleanup();
+    producer.end();
+  });
+});
diff --git a/packages/web/test/frames-container-lazy-document.spec.tsx b/packages/web/test/frames-container-lazy-document.spec.tsx
new file mode 100644
index 000000000..9adfd9c5e
--- /dev/null
+++ b/packages/web/test/frames-container-lazy-document.spec.tsx
@@ -0,0 +1,181 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ */
+// The traces tier — document face. A t=0 record (`_$HY.r["sc:slot:<fid>:
+// <occ>"]`) carries the container as a `{ $tr, $ta }` marker literal that the
+// host revives at arg-read — but the frames client no longer installs the
+// materializer at module load (it is the `trace` tier, `@solidjs/web/frames/
+// trace`), so the first such record finds the tier absent. The adopt-time
+// sync's held-set predicate (`needsTrace`: a marker in the record's args
+// while the tier is not resident) starts the load — the PRODUCTION loader,
+// here through the test alias to the tier's source — and HOLDS the
+// occurrence: its server-rendered interior stays on screen, no fill mounts,
+// and when the load settles the install's flush re-syncs the frame and
+// mounts the fill with the live store (nested references sharing it, as the
+// resident path pins). A re-sent record after that revives synchronously.
+//
+// This page carries no `sc:tiers` record — the un-announced fallback: the
+// readiness check itself starts the load, the same DOM, later (the
+// announced path, where `installServerComponents` starts the import from the
+// record before any boundary adopts, is hydration/welcome-status-lazy.spec).
+//
+// Its own spec file: a tier, once resident, stays so for the worker, and
+// the "not loaded" half is observable only before the first install (see
+// frames-container-lazy-codec.spec.tsx for the codec face).
+import { afterAll, afterEach, beforeAll, describe, expect, test, vi } from "vitest";
+import { createMemo, createRoot, flush, Loading, untrack } from "solid-js";
+import { dynamic } from "../src/index.js";
+import { getFrameHost, installServerComponents } from "../frames/src/client.js";
+import { tierLoads } from "../frames/src/frame-client.js";
+import { createServerReference } from "../server-functions/src/client.js";
+import { pump } from "./lifecycle-matrix/harness.js";
+
+const getAdopt = createServerReference("lazy/containers/adopt");
+const traceTierResident = () => !!(tierLoads as any).trace?.r;
+const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
+
+/** A hand-cranked trace: an async iterable whose yields the test pushes. */
+function traceProducer() {
+  const queue: IteratorResult<any>[] = [];
+  const waiters: ((r: IteratorResult<any>) => void)[] = [];
+  const put = (r: IteratorResult<any>) => {
+    const w = waiters.shift();
+    w ? w(r) : queue.push(r);
+  };
+  return {
+    subscribe: () => ({
+      [Symbol.asyncIterator]() {
+        return {
+          next: () => {
+            const b = queue.shift();
+            return b
+              ? Promise.resolve(b)
+              : new Promise<IteratorResult<any>>(res => waiters.push(res));
+          }
+        };
+      }
+    }),
+    push: (value: any) => put({ done: false, value }),
+    end: () => put({ done: true, value: undefined })
+  };
+}
+
+const adoptFid = "lazy/containers/adopt";
+const producer = traceProducer();
+beforeAll(() => {
+  const marker = { $tr: producer.subscribe(), $ta: 0 };
+  document.body.innerHTML =
+    '<div id="page">' +
+    `<solid-frame data-fid="${adoptFid}" style="display:contents">` +
+    "<article><h1>Adopt</h1><ul><!--slot:comment#c1:start-->" +
+    '<li class="ssr-fill">server-rendered-fill</li>' +
+    "<!--slot:comment#c1:end--></ul></article>" +
+    "</solid-frame></div>";
+  (window as any)._$HY = {
+    done: true,
+    r: {
+      [`sc:slot:${adoptFid}:comment#c1`]: {
+        cid: "c1",
+        user: marker,
+        filters: { deep: { user: marker } }
+      }
+    }
+  };
+});
+
+afterAll(() => {
+  delete (window as any)._$HY;
+  document.body.innerHTML = "";
+});
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe("document face: an adopted record's marker holds the occurrence until the traces tier loads", () => {
+  test("held with the server interior on screen, then mounted with the live store (nested references share it)", async () => {
+    installServerComponents();
+    // Nothing announced, nothing loaded yet.
+    expect((tierLoads as any).trace).toBeUndefined();
+    expect(getFrameHost().revive).toBeUndefined();
+    vi.stubGlobal("fetch", async () => {
+      throw new Error("t=0 adoption must not fetch");
+    });
+
+    let mounts = 0;
+    let same: boolean | undefined;
+    const names: string[] = [];
+    const Page = dynamic(() => getAdopt() as any);
+    const container = document.createElement("div");
+    document.body.appendChild(container);
+    let div!: HTMLDivElement;
+    const dispose = createRoot(d => {
+      <div ref={div}>
+        <Loading fallback={<span>shell-fallback</span>}>
+          <Page
+            comment={(p: any) => {
+              mounts++;
+              same = untrack(() => p.user === p.filters.deep.user);
+              const name = createMemo(() => {
+                const v = p.user.name;
+                names.push(v);
+                return v;
+              });
+              return (
+                <Loading fallback={<i>fill-wait</i>}>
+                  <li class="live-fill">{name()}</li>
+                </Loading>
+              );
+            }}
+          />
+        </Loading>
+      </div>;
+      container.appendChild(div);
+      return d;
+    });
+    // The local answer resolves over microtasks; the module load needs a
+    // task. Settle the former only, so the hold is observable.
+    const frame = document.querySelector(`[data-fid="${adoptFid}"]`)!;
+    for (let i = 0; i < 20; i++) {
+      flush();
+      await Promise.resolve();
+    }
+    // Adopted in place (the frame is bound under the call's address — an
+    // argless call's address is its function id), and HELD: the sync found
+    // the marker and started the load (detection, the un-announced
+    // fallback); no fill mounted, the server-rendered interior untouched,
+    // the tier still loading.
+    expect((tierLoads as any).trace).toBeTruthy();
+    expect(traceTierResident()).toBe(false);
+    expect(getFrameHost().get(adoptFid)).toBeTruthy();
+    expect(frame).not.toBe(null);
+    expect(mounts).toBe(0);
+    expect(frame.querySelector("li.ssr-fill")!.textContent).toBe("server-rendered-fill");
+
+    // The load settles; the install wires the shared host's reviver and
+    // flushes the frame, which re-syncs and mounts the occurrence.
+    for (let i = 0; i < 200 && !traceTierResident(); i++) await sleep(10);
+    expect(traceTierResident()).toBe(true);
+    expect(getFrameHost().revive).toBeTypeOf("function");
+    await pump();
+    expect(mounts).toBe(1);
+    // ONE store for both references; uninitialized until the trace feeds
+    // it, so the fill's own boundary covers the read.
+    expect(same).toBe(true);
+    expect(div.textContent).toContain("fill-wait");
+
+    producer.push({ name: "Ada" });
+    await pump();
+    expect(div.querySelector("li.live-fill")!.textContent).toBe("Ada");
+    expect(names).toEqual(["Ada"]);
+
+    producer.push([[["name"], "Grace"]]);
+    await pump();
+    expect(div.querySelector("li.live-fill")!.textContent).toBe("Grace");
+    expect(names).toEqual(["Ada", "Grace"]);
+    expect(mounts).toBe(1);
+
+    producer.end();
+    dispose();
+    container.remove();
+  });
+});
diff --git a/packages/web/test/frames-errored-reset-refetch.spec.tsx b/packages/web/test/frames-errored-reset-refetch.spec.tsx
index fda8f83f7..08680696d 100644
--- a/packages/web/test/frames-errored-reset-refetch.spec.tsx
+++ b/packages/web/test/frames-errored-reset-refetch.spec.tsx
@@ -33,8 +33,15 @@
 // (its fallback is content); a keyed error chunk (a fragment's or a live
 // hole's diagnostic) is not the frame's error. Both are controls here.
 import { afterEach, describe, expect, test, vi } from "vitest";
-import { createRoot, createSignal, Errored, Loading, resetErrorHalt } from "solid-js";
-import { dynamic } from "../src/index.js";
+import {
+  createRoot,
+  createSignal,
+  Errored,
+  Loading,
+  resetErrorHalt,
+  type Component
+} from "solid-js";
+import { dynamic, dynamicComponent } from "../src/index.js";
 import { installServerComponents } from "../frames/src/client.js";
 import { createServerReference, GET } from "../server-functions/src/client.js";
 import { frameAddress } from "../server-functions/src/shared.js";
@@ -81,7 +88,16 @@ function mount(code: () => any) {
   };
 }
 
-describe("a frame's error is an errored async value (3.3)", () => {
+// Every arm runs through both entry points: `dynamic` and its component-only
+// sibling `dynamicComponent` share one implementation (the hoisted factory
+// memo the re-ask depends on included), and the sibling is the documented
+// server-component mount, so the contract is pinned on it by name.
+const VIA: ReadonlyArray<[string, (source: () => any) => Component<any>]> = [
+  ["dynamic", dynamic],
+  ["dynamicComponent", dynamicComponent]
+];
+
+describe.each(VIA)("a frame's error is an errored async value (3.3) — via %s", (_via, dyn) => {
   test("(a) the frame errors → the client <Errored> catches (never an empty frame) → reset() → a new request, the new content shows", async () => {
     const { host } = makeHost();
     installServerComponents(host);
@@ -93,7 +109,7 @@ describe("a frame's error is an errored async value (3.3)", () => {
       return call === 1 ? errored("srv", "boom") : content("srv", "recovered");
     });
     const getStory = createServerReference("frames-reset/story");
-    const Page = dynamic(() => getStory() as any);
+    const Page = dyn(() => getStory() as any);
     let resetFn: (() => void) | undefined;
     const m = mount(() => (
       <Errored
@@ -145,7 +161,7 @@ describe("a frame's error is an errored async value (3.3)", () => {
       return call === 1 ? errored("srv", "boom") : content("srv", "recovered");
     });
     const getStory = createServerReference("frames-reset/inner");
-    const Page = dynamic(() => getStory() as any);
+    const Page = dyn(() => getStory() as any);
     let resetFn: (() => void) | undefined;
     const m = mount(() => (
       <Loading fallback={<span class="shell">shell-fallback</span>}>
@@ -183,7 +199,7 @@ describe("a frame's error is an errored async value (3.3)", () => {
       return call === 1 ? errored("srv", "boom") : content("srv", "recovered");
     });
     const getStory = GET(createServerReference("frames-reset/get"));
-    const Page = dynamic(() => getStory(7, "x") as any);
+    const Page = dyn(() => getStory(7, "x") as any);
     let resetFn: (() => void) | undefined;
     const m = mount(() => (
       <Errored
@@ -217,7 +233,7 @@ describe("a frame's error is an errored async value (3.3)", () => {
       return content("srv", "recovered");
     });
     const getStory = createServerReference("frames-reset/wire");
-    const Page = dynamic(() => getStory() as any);
+    const Page = dyn(() => getStory() as any);
     let resetFn: (() => void) | undefined;
     const m = mount(() => (
       <Errored
@@ -265,7 +281,7 @@ describe("a frame's error is an errored async value (3.3)", () => {
     );
     const error = vi.spyOn(console, "error").mockImplementation(() => {});
     const getStory = createServerReference("frames-reset/uncaught");
-    const Page = dynamic(() => getStory() as any);
+    const Page = dyn(() => getStory() as any);
     const m = mount(() => (
       <Loading fallback={<span class="shell">shell-fallback</span>}>
         <Page />
@@ -291,7 +307,7 @@ describe("a frame's error is an errored async value (3.3)", () => {
       return call === 1 ? held.response : content("srv", "recovered");
     });
     const getStory = createServerReference("frames-reset/late");
-    const Page = dynamic(() => getStory() as any);
+    const Page = dyn(() => getStory() as any);
     let resetFn: (() => void) | undefined;
     const m = mount(() => (
       <Errored
@@ -335,7 +351,7 @@ describe("a frame's error is an errored async value (3.3)", () => {
     const held = openFrameResponse("srv");
     vi.stubGlobal("fetch", async () => held.response);
     const getStory = createServerReference("frames-reset/truncated");
-    const Page = dynamic(() => getStory() as any);
+    const Page = dyn(() => getStory() as any);
     const m = mount(() => (
       <Errored fallback={err => <span class="err">failed: {(err() as any)?.message}</span>}>
         <Loading fallback={<span class="shell">shell-fallback</span>}>
@@ -365,7 +381,7 @@ describe("a frame's error is an errored async value (3.3)", () => {
     });
     const getStory = createServerReference("frames-reset/refetch");
     const [tick, setTick] = createSignal(0);
-    const Page = dynamic(() => (tick(), getStory() as any));
+    const Page = dyn(() => (tick(), getStory() as any));
     let resetFn: (() => void) | undefined;
     const m = mount(() => (
       <Errored
@@ -419,7 +435,7 @@ describe("a frame's error is an errored async value (3.3)", () => {
       ])
     );
     const getStory = createServerReference("frames-reset/server-caught");
-    const Page = dynamic(() => getStory() as any);
+    const Page = dyn(() => getStory() as any);
     const m = mount(() => (
       <Errored fallback={<span class="err">client fallback</span>}>
         <Loading fallback={<span class="shell">shell-fallback</span>}>
diff --git a/packages/web/test/frames-hn-client.spec.tsx b/packages/web/test/frames-hn-client.spec.tsx
index a6fb1b47e..7dac165e6 100644
--- a/packages/web/test/frames-hn-client.spec.tsx
+++ b/packages/web/test/frames-hn-client.spec.tsx
@@ -11,16 +11,26 @@
 //    already contains the comments AND the client wrappers' markup; slots
 //    claim their rendered DOM via ctx.existing (Astro-style opaque slots) —
 //    zero hydration data, the page source carries each text once.
-import { afterEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeAll, describe, expect, test, vi } from "vitest";
 import { createRoot, createSignal, flush, Loading } from "solid-js";
 import { dynamic } from "../src/index.js";
 import { installServerComponents, createFrame, createFrameHost } from "../frames/src/client.js";
+import { prepareTier } from "../frames/src/frame-client.js";
 import { createJSONDataTable } from "../serialization/src/serializer.js";
 import { createServerReference } from "../server-functions/src/client.js";
 import { createChunk } from "../server-functions/src/shared.js";
 
 const settle = () => new Promise(r => setTimeout(r));
 
+// The hand-framed responses below announce no tier; the story comments are
+// `{$frame}` regions, so the frames client's REGIONS TIER
+// (`@solidjs/web/frames/regions`, loaded through `prepareTier("regions")` at
+// the first record naming one) is warmed here — these cells pin the slice's
+// UX with the tier resident, as the production host has it after that
+// first load; the load itself is pinned in
+// `test/consistency/tier-regions-hold.spec.tsx`.
+beforeAll(() => prepareTier("regions"));
+
 function frameResponse(chunks: any[]) {
   const body = new ReadableStream({
     start(c) {
diff --git a/packages/web/test/frames-live-resume.spec.tsx b/packages/web/test/frames-live-resume.spec.tsx
index f0786abad..ac69657be 100644
--- a/packages/web/test/frames-live-resume.spec.tsx
+++ b/packages/web/test/frames-live-resume.spec.tsx
@@ -10,16 +10,26 @@
 // as the have-list header (digests are opaque 16-hex strings — stand-ins
 // here). Never derived from the DOM; a fragment received
 // but not yet revealed is not claimed.
-import { afterEach, describe, expect, test, vi } from "vitest";
+//
+// The ledger, the encoder and the resume request are the LIVE WIRE TIER's
+// (frames savings pass §3 row C2, `@solidjs/web/frames/wire`): the frame
+// hands every applied record to the tier's `have`, the handler's `resume`
+// answers through its `resume`, and `haveOf(frame)` reads what a mount
+// shows (`Frame.have()` left the interface with the move). The tier is
+// warmed here (`prepareTier("wire")`), so every cell runs resident — the
+// shape a live page is in once `live()`'s preload-at-call has landed;
+// `tier-wire-preload.spec` pins the load itself.
+import { afterEach, beforeAll, describe, expect, test, vi } from "vitest";
 import { createRoot, Loading } from "solid-js";
 import { dynamic } from "../src/index.js";
 import { installServerComponents } from "../frames/src/client.js";
+import { prepareTier } from "../frames/src/frame-client.js";
 import {
   FRAME_HAVE_BUDGET,
   FRAME_HAVE_HEADER,
-  decodeHaveList,
-  encodeHaveList
+  decodeHaveList
 } from "../frames/src/frame-transport.js";
+import { encodeHaveList, haveOf } from "../frames/src/wire-tier.js";
 import { createServerReference, live } from "../server-functions/src/client.js";
 import { LAST_EVENT_ID_HEADER } from "../server-functions/src/shared.js";
 import { makeHost, pump, stubLiveFetch, until } from "./lifecycle-matrix/harness.js";
@@ -57,6 +67,7 @@ function mountUnderLoading(Comp: any) {
 
 const headerOf = (init: any, name: string) => init && init.headers && init.headers[name];
 
+beforeAll(() => prepareTier("wire"));
 afterEach(() => vi.unstubAllGlobals());
 
 describe("have-list encoding", () => {
@@ -112,7 +123,7 @@ describe("the mount's ledger and the resume request", () => {
     await pump();
     expect(m.div.querySelector("h1")!.textContent).toBe("v1");
     const frame: any = host.get(ID);
-    expect(frame.have()).toEqual({ "": "a000000000000001", "lh:1": "a000000000000002" });
+    expect(haveOf(frame)).toEqual({ "": "a000000000000001", "lh:1": "a000000000000002" });
 
     // A fragment RECEIVED but not revealed is not claimed...
     held[0].send({
@@ -125,12 +136,12 @@ describe("the mount's ledger and the resume request", () => {
       holes: { "lh:0": "a000000000000004" }
     });
     await pump();
-    expect(frame.have()).toEqual({ "": "a000000000000001", "lh:1": "a000000000000002" });
+    expect(haveOf(frame)).toEqual({ "": "a000000000000001", "lh:1": "a000000000000002" });
     // ...until its reveal lands it in the DOM.
     held[0].send({ type: "reveal", id: ID, version: 1, keys: ["0"] });
     await pump();
     expect(m.div.querySelector(".body")!.textContent).toBe("B1");
-    expect(frame.have()).toEqual({
+    expect(haveOf(frame)).toEqual({
       "": "a000000000000001",
       "lh:1": "a000000000000002",
       "0": "a000000000000003",
@@ -147,7 +158,7 @@ describe("the mount's ledger and the resume request", () => {
     });
     await pump();
     expect(m.div.querySelector("h1")!.textContent).toBe("v2");
-    expect(frame.have()["lh:1"]).toBe("a000000000000005");
+    expect(haveOf(frame)!["lh:1"]).toBe("a000000000000005");
 
     // Death → the reconnect names the version ordinal and the ledger.
     held[0].close();
@@ -205,7 +216,7 @@ describe("the mount's ledger and the resume request", () => {
     held[0].send({ type: "start", id: ID + "-plain", version: 1 });
     held[0].send({ type: "html", id: ID + "-plain", version: 1, html: "<article>plain</article>" });
     await pump();
-    expect((host.get(ID + "-plain") as any).have()).toBeUndefined();
+    expect(haveOf(host.get(ID + "-plain")!)).toBeUndefined();
     held[0].close();
     await until(() => urls.length === 2, 3000);
     expect(headerOf(inits[1], LAST_EVENT_ID_HEADER)).toBe("1");
@@ -255,7 +266,7 @@ describe("the mount's ledger and the resume request", () => {
     expect(button.hasAttribute("disabled")).toBe(false);
     expect(button.hasAttribute("aria-busy")).toBe(false);
     expect(button.getAttribute("data-lha")).toBe("0");
-    expect((host.get(AID) as any).have()["lha:0"]).toBe("a000000000000004");
+    expect(haveOf(host.get(AID)!)!["lha:0"]).toBe("a000000000000004");
     // `open` on <details> is the user's toggle: the morph's exception
     // holds for attr holes too — never removed, never set.
     held[0].send({
diff --git a/packages/web/test/frames-live-showing.spec.tsx b/packages/web/test/frames-live-showing.spec.tsx
index 5867040b9..bcc99ad37 100644
--- a/packages/web/test/frames-live-showing.spec.tsx
+++ b/packages/web/test/frames-live-showing.spec.tsx
@@ -6,14 +6,19 @@
 // live call, read outside any hydration scope. Its own file: the frames
 // client indexes the page's boundaries once per module instance (extended
 // only by reveals), so this page must be the module's first.
-import { describe, expect, test } from "vitest";
+import { beforeAll, describe, expect, test } from "vitest";
 import { createRoot, Loading } from "solid-js";
 import { dynamic } from "../src/index.js";
 import { installServerComponents } from "../frames/src/client.js";
+import { prepareTier } from "../frames/src/frame-client.js";
 import { createServerReference, live } from "../server-functions/src/client.js";
 import { frameAddress } from "../server-functions/src/shared.js";
 import { makeHost, pump, stubLiveFetch, until } from "./lifecycle-matrix/harness.js";
 
+// The live arm is the live wire tier's (plan §3 row C2): warmed, so every
+// cell runs resident (`tier-wire-preload.spec` pins the load itself).
+beforeAll(() => prepareTier("wire"));
+
 function articleHtml(title: string) {
   return (
     `<article><h1>${title}</h1>` +
diff --git a/packages/web/test/frames-live.spec.tsx b/packages/web/test/frames-live.spec.tsx
index aa6ba7c68..795fdca3b 100644
--- a/packages/web/test/frames-live.spec.tsx
+++ b/packages/web/test/frames-live.spec.tsx
@@ -13,10 +13,17 @@
 // equals-gate keeps the instance; a completion (every frame complete)
 // completes the iteration. Supersession by another response is a death;
 // an undeclared frame's death is an error; `onstatus` reports the wire.
-import { afterEach, describe, expect, test, vi } from "vitest";
+//
+// The live arm is the LIVE WIRE TIER's (frames savings pass §3 row C2,
+// `@solidjs/web/frames/wire`): the handler awaits its load before the body
+// is read. Warmed here (`prepareTier("wire")`) so every cell runs resident —
+// the shape a live page is in once `live()`'s preload-at-call has landed;
+// `consistency/tier-wire-preload.spec` pins the load itself.
+import { afterEach, beforeAll, describe, expect, test, vi } from "vitest";
 import { createMemo, createRoot, createSignal, Errored, Loading } from "solid-js";
 import { dynamic } from "../src/index.js";
 import { installServerComponents } from "../frames/src/client.js";
+import { prepareTier } from "../frames/src/frame-client.js";
 import { createServerReference, live } from "../server-functions/src/client.js";
 import { frameAddress } from "../server-functions/src/shared.js";
 import {
@@ -72,6 +79,7 @@ function mountUnderLoading(Comp: any, props: Record<string, any> = {}) {
 
 const wait = (ms: number) => new Promise(r => setTimeout(r, ms));
 
+beforeAll(() => prepareTier("wire"));
 afterEach(() => vi.unstubAllGlobals());
 
 describe("frames consume live: death vs complete", () => {
diff --git a/packages/web/test/frames-occlusion-client.spec.tsx b/packages/web/test/frames-occlusion-client.spec.tsx
index a930159c7..d9712166d 100644
--- a/packages/web/test/frames-occlusion-client.spec.tsx
+++ b/packages/web/test/frames-occlusion-client.spec.tsx
@@ -8,15 +8,24 @@
 // documentBoundary must drain those records into the host BEFORE binding
 // the adopting frame, so the first slot sync claims WITH real args and the
 // wrapper mounts the body from the frame store on expand — zero network.
-import { afterEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeAll, describe, expect, test, vi } from "vitest";
 import { createRoot, createSignal, flush, Loading } from "solid-js";
 import { dynamic } from "../src/index.js";
 import { installServerComponents, createFrameHost } from "../frames/src/client.js";
+import { prepareTier } from "../frames/src/frame-client.js";
 import { createJSONDataTable } from "../serialization/src/serializer.js";
 import { createServerReference } from "../server-functions/src/client.js";
 
 const settle = () => new Promise(r => setTimeout(r));
 
+// Occluded regions are the REGIONS TIER's (`@solidjs/web/frames/regions`,
+// loaded through `prepareTier("regions")` at the first record naming one;
+// the document pages here announce nothing). Warmed, so these cells pin the
+// occlusion records with the tier resident; the load itself — the hold,
+// the `sc:region:` html landing in the store before it — is pinned in
+// `test/consistency/tier-regions-hold.spec.tsx`.
+beforeAll(() => prepareTier("regions"));
+
 function makeHost() {
   const table = createJSONDataTable();
   return createFrameHost({
diff --git a/packages/web/test/frames-optimistic-hold.spec.tsx b/packages/web/test/frames-optimistic-hold.spec.tsx
index 9e6ec5958..f226e0319 100644
--- a/packages/web/test/frames-optimistic-hold.spec.tsx
+++ b/packages/web/test/frames-optimistic-hold.spec.tsx
@@ -16,7 +16,7 @@
 //   multi-flight  — the mutation returns plain data; the action then
 //                   `refresh`es the source the boundary reads, and the
 //                   refetched region arrives on its own response.
-import { afterEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeAll, describe, expect, test, vi } from "vitest";
 import {
   action,
   createMemo,
@@ -29,7 +29,7 @@ import {
 } from "solid-js";
 import { dynamic } from "../src/index.js";
 import { installServerComponents } from "../frames/src/client.js";
-import { FRAME_ID_ATTR } from "../frames/src/frame-client.js";
+import { FRAME_ID_ATTR, prepareTier } from "../frames/src/frame-client.js";
 import {
   SERVER_COMPONENT,
   SERVER_COMPONENT_ADDRESS,
@@ -161,6 +161,14 @@ function expectHeld(trace: string[]) {
   expect(trace.at(-1)).toBe("true/true");
 }
 
+// The nested-region cells below (`{$frame}` args in hand-framed responses
+// that announce no tier) run with the frames client's REGIONS TIER
+// (`@solidjs/web/frames/regions`, loaded through `prepareTier("regions")` at
+// the first record naming one) RESIDENT — what this file pins is the hold
+// of optimism over a region's fill, not the tier's load (that is
+// `test/consistency/tier-regions-hold.spec.tsx`).
+beforeAll(() => prepareTier("regions"));
+
 const unsubscribes: (() => void)[] = [];
 afterEach(() => {
   vi.unstubAllGlobals();
diff --git a/packages/web/test/frames-used-region-client.spec.tsx b/packages/web/test/frames-used-region-client.spec.tsx
index 5d30f0a33..26c62d2d0 100644
--- a/packages/web/test/frames-used-region-client.spec.tsx
+++ b/packages/web/test/frames-used-region-client.spec.tsx
@@ -12,15 +12,24 @@
 // config doesn't compile hydratable JSX, so claimRender's registry path —
 // which needs `_hk` on the adopted wrapper — can't engage here.)
 // Own spec file: the boundary marker index is a once-per-boot module cache.
-import { afterEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeAll, describe, expect, test, vi } from "vitest";
 import { createRoot, flush, Loading } from "solid-js";
 import { dynamic } from "../src/index.js";
 import { installServerComponents, createFrameHost } from "../frames/src/client.js";
+import { prepareTier } from "../frames/src/frame-client.js";
 import { createJSONDataTable } from "../serialization/src/serializer.js";
 import { createServerReference } from "../server-functions/src/client.js";
 
 const settle = () => new Promise(r => setTimeout(r));
 
+// The `{$frame}` region the changed record introduces is the REGIONS TIER's
+// (`@solidjs/web/frames/regions`, loaded through `prepareTier("regions")` at
+// the first record naming one; the hand-applied chunks here announce
+// nothing). Warmed, so this cell pins the #547 guarantee with the tier
+// resident; the load itself is pinned in
+// `test/consistency/tier-regions-hold.spec.tsx`.
+beforeAll(() => prepareTier("regions"));
+
 function makeHost() {
   const table = createJSONDataTable();
   return createFrameHost({
diff --git a/packages/web/test/harness/__artifacts__/dynamic-component-parity-inline.json b/packages/web/test/harness/__artifacts__/dynamic-component-parity-inline.json
new file mode 100644
index 000000000..26eae2386
--- /dev/null
+++ b/packages/web/test/harness/__artifacts__/dynamic-component-parity-inline.json
@@ -0,0 +1,5 @@
+{
+  "name": "dynamic-component-parity-inline",
+  "shell": "<main _hk=2><!--$--><section _hk=40 id=\"panel\"><h2>client</h2><!--$--><button _hk=42 id=\"panel-counter\"><!--$-->Panel<!--/-->: <!--$-->0<!--/--></button><!--/--></section><!--/--><!--$--><solid-frame data-fid=\"dynamic-component-parity/note-inline\" style=\"display:contents\"><article id=\"content\"><h1>note v1</h1><ul><!--slot:counter#0:start--><button _hk=sc-dynamic-component-parity/note-inline-counter#0-0 id=\"note-counter\"><!--$-->Count<!--/-->: <!--$-->0<!--/--></button><!--slot:counter#0:end--></ul></article></solid-frame><!--/--></main><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"$B\"]=($R[0]={5000:$R[1]=($R[2]=($R[3]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"5_fr\":$R[4]=($R[5]=$R[3]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);($R[7]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[2],$R[6]=(self._$SC||(self._$SC={c:{},a:{},b:{},r(i,a){var c=this.c[i]||(this.c[i]=(p,b)=>self._$SC.impl(i,p,b));if(!a)return c;this.a[a]=i;this.reg&&this.reg(a,i);return this.b[a]||(this.b[a]=Object.assign(p=>c(p,()=>a),{[Symbol.for(\"solid.component-binding\")]:{component:c,address:a}}))}})).r(\"dynamic-component-parity/note-inline\",\"dynamic-component-parity/note-inline:1xvb\"));_$HY.r[\"sc:live\"]=$R[8]=($R[9]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[10]=($R[11]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"sc:slot:dynamic-component-parity/note-inline:counter#0\"]=$R[12]=($R[13]=$R[3]()).p;$R[7]($R[13],$R[14]={label:\"Count\"});$R[7]($R[5],!0);$R[10].return(void 0);</script>",
+  "rest": ""
+}
\ No newline at end of file
diff --git a/packages/web/test/harness/__artifacts__/dynamic-component-parity-streamed.json b/packages/web/test/harness/__artifacts__/dynamic-component-parity-streamed.json
new file mode 100644
index 000000000..7951ecb14
--- /dev/null
+++ b/packages/web/test/harness/__artifacts__/dynamic-component-parity-streamed.json
@@ -0,0 +1,5 @@
+{
+  "name": "dynamic-component-parity-streamed",
+  "shell": "<main _hk=2><!--$--><section _hk=40 id=\"panel\"><h2>client</h2><!--$--><button _hk=42 id=\"panel-counter\"><!--$-->Panel<!--/-->: <!--$-->0<!--/--></button><!--/--></section><!--/--><!--$--><template id=\"pl-5\"></template><p _hk=50 class=\"fb\">shell-fallback</p><!--pl-5--><!--/--></main><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"$B\"]=($R[0]={5000:$R[1]=($R[2]=($R[3]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"5_fr\":$R[4]=($R[5]=$R[3]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);</script>",
+  "rest": "<template id=\"5\"><solid-frame data-fid=\"dynamic-component-parity/note-streamed\" style=\"display:contents\"><article id=\"content\"><h1>note v1</h1><ul><!--slot:counter#0:start--><button _hk=sc-dynamic-component-parity/note-streamed-counter#0-0 id=\"note-counter\"><!--$-->Count<!--/-->: <!--$-->0<!--/--></button><!--slot:counter#0:end--></ul></article></solid-frame></template><script>($R[7]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[2],$R[6]=(self._$SC||(self._$SC={c:{},a:{},b:{},r(i,a){var c=this.c[i]||(this.c[i]=(p,b)=>self._$SC.impl(i,p,b));if(!a)return c;this.a[a]=i;this.reg&&this.reg(a,i);return this.b[a]||(this.b[a]=Object.assign(p=>c(p,()=>a),{[Symbol.for(\"solid.component-binding\")]:{component:c,address:a}}))}})).r(\"dynamic-component-parity/note-streamed\",\"dynamic-component-parity/note-streamed:1xvb\"));_$HY.r[\"sc:live\"]=$R[8]=($R[9]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[10]=($R[11]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"sc:slot:dynamic-component-parity/note-streamed:counter#0\"]=$R[12]=($R[13]=$R[3]()).p;$df(\"5\");function $df(e){return _$HY.f?_$HY.f(e):$dfr(e)}function $dfr(e,n,o,t){if(!(n=document.getElementById(e)))return 0;if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dq=_$HY.dq||{})[e]=1,0;for(;o&&(8!==o.nodeType||o.nodeValue!==\"pl-\"+e);)t=o.nextSibling,o.remove(),o=t;t=o.parentNode,o.replaceWith(n.content),n.remove(),(_$HY.v=_$HY.v||{})[e]=1,_$HY.fe(e,t),_$HY.hp&&_$HY.hp[e]&&($dh(_$HY.hp[e]),delete _$HY.hp[e]),$dfd();return 1}function $dfl(e,o,n){if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dlq=_$HY.dlq||{})[e]=1,0;if(o._$fl)return 1;for(n=o.nextSibling;n;){if(8===n.nodeType&&n.nodeValue===\"pl-\"+e){o.parentNode&&o.parentNode.insertBefore(o.content.cloneNode(!0),n),o._$fl=1,$dfd();return 1}n=n.nextSibling}return 0}function $dflj(e,i){for(i=0;i<e.length;i++)$dfl(e[i])}function $dfd(e,i){if(e=_$HY.dq){_$HY.dq=0;for(i in e)$df(i)}if(e=_$HY.dlq){_$HY.dlq=0;for(i in e)$dfl(i)}}function $dfs(e,c,d){(_$HY.sc=_$HY.sc||{})[e]=c,d&&((_$HY.sd=_$HY.sd||{})[e]=1)}function $dfg(e,g,i,k){if(!(g=_$HY.sg&&_$HY.sg[e]))return;for(i=0;i<g.length;i++)if(_$HY.sc&&_$HY.sc[g[i]]>0)return;for(i=0;i<g.length;i++)k=g[i],delete _$HY.sg[k],$df(k)}function $dfc(e){if(--_$HY.sc[e]<=0){delete _$HY.sc[e],_$HY.sg&&_$HY.sg[e]?$dfg(e):!(_$HY.sd&&_$HY.sd[e])&&$df(e);_$HY.sd&&delete _$HY.sd[e]}}function $dfj(e,i,n){for(i=0;i<e.length;i++)if(_$HY.sc&&_$HY.sc[e[i]]>0){for(n=0;n<e.length;n++)(_$HY.sg=_$HY.sg||{})[e[n]]=e;return}for(i=0;i<e.length;i++)$df(e[i])}function $dfe(e,t,k){(t=e.target)&&t.getAttribute&&!t._$dc&&(k=t.getAttribute(\"data-dfc\"))&&(t._$dc=1,$dfc(k))}document.addEventListener(\"load\",$dfe,!0);document.addEventListener(\"error\",$dfe,!0);</script><script>$R[7]($R[13],$R[14]={label:\"Count\"});$R[7]($R[5],!0);</script><script>$R[10].return(void 0);</script>"
+}
\ No newline at end of file
diff --git a/packages/web/test/harness/__artifacts__/frame-live-document-loaded.json b/packages/web/test/harness/__artifacts__/frame-live-document-loaded.json
index 1198e0748..1e11542f2 100644
--- a/packages/web/test/harness/__artifacts__/frame-live-document-loaded.json
+++ b/packages/web/test/harness/__artifacts__/frame-live-document-loaded.json
@@ -1,5 +1,5 @@
 {
   "name": "frame-live-document-loaded",
-  "shell": "<main _hk=1><template id=\"pl-2\"></template><p _hk=20 class=\"fb\">shell-fallback</p><!--pl-2--></main><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"$B\"]=($R[0]={2000:$R[1]=($R[2]=($R[3]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"2_fr\":$R[4]=($R[5]=$R[3]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);($R[7]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[2],$R[6]=(self._$SC||(self._$SC={c:{},a:{},b:{},r(i,a){var c=this.c[i]||(this.c[i]=(p,b)=>self._$SC.impl(i,p,b));if(!a)return c;this.a[a]=i;this.reg&&this.reg(a,i);return this.b[a]||(this.b[a]=Object.assign(p=>c(p,()=>a),{[Symbol.for(\"solid.component-binding\")]:{component:c,address:a}}))}})).r(\"frame-live-doc/room-loaded\",\"frame-live-doc/room-loaded:1xvb\"));_$HY.r[\"sc:live\"]=$R[8]=($R[9]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[10]=($R[11]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"sc:slot:frame-live-doc/room-loaded:composer#0\"]=$R[12]=($R[13]=$R[3]()).p;$R[7]($R[13],$R[14]={room:\"a\"});</script>",
+  "shell": "<main _hk=1><template id=\"pl-2\"></template><p _hk=20 class=\"fb\">shell-fallback</p><!--pl-2--></main><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"$B\"]=($R[0]={2000:$R[1]=($R[2]=($R[3]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"2_fr\":$R[4]=($R[5]=$R[3]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);($R[7]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[2],$R[6]=(self._$SC||(self._$SC={c:{},a:{},b:{},r(i,a){var c=this.c[i]||(this.c[i]=(p,b)=>self._$SC.impl(i,p,b));if(!a)return c;this.a[a]=i;this.reg&&this.reg(a,i);return this.b[a]||(this.b[a]=Object.assign(p=>c(p,()=>a),{[Symbol.for(\"solid.component-binding\")]:{component:c,address:a}}))}})).r(\"frame-live-doc/room-loaded\",\"frame-live-doc/room-loaded:1xvb\"));_$HY.r[\"sc:live\"]=$R[8]=($R[9]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[10]=($R[11]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"sc:tiers\"]=$R[12]=[\"wire\"];_$HY.r[\"sc:slot:frame-live-doc/room-loaded:composer#0\"]=$R[13]=($R[14]=$R[3]()).p;$R[7]($R[14],$R[15]={room:\"a\"});</script>",
   "rest": "<template id=\"2\"><solid-frame data-fid=\"frame-live-doc/room-loaded\" style=\"display:contents\"><article><h1><!--lh:0-->room v1<!--lh:/0--></h1><ul><!--slot:composer#0:start--><input _hk=sc-frame-live-doc/room-loaded-composer#0-0 class=\"draft\" value=\"\" placeholder=\"Message #a\"><!--slot:composer#0:end--></ul></article></solid-frame></template><script>$df(\"2\");function $df(e){return _$HY.f?_$HY.f(e):$dfr(e)}function $dfr(e,n,o,t){if(!(n=document.getElementById(e)))return 0;if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dq=_$HY.dq||{})[e]=1,0;for(;o&&(8!==o.nodeType||o.nodeValue!==\"pl-\"+e);)t=o.nextSibling,o.remove(),o=t;t=o.parentNode,o.replaceWith(n.content),n.remove(),(_$HY.v=_$HY.v||{})[e]=1,_$HY.fe(e,t),_$HY.hp&&_$HY.hp[e]&&($dh(_$HY.hp[e]),delete _$HY.hp[e]),$dfd();return 1}function $dfl(e,o,n){if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dlq=_$HY.dlq||{})[e]=1,0;if(o._$fl)return 1;for(n=o.nextSibling;n;){if(8===n.nodeType&&n.nodeValue===\"pl-\"+e){o.parentNode&&o.parentNode.insertBefore(o.content.cloneNode(!0),n),o._$fl=1,$dfd();return 1}n=n.nextSibling}return 0}function $dflj(e,i){for(i=0;i<e.length;i++)$dfl(e[i])}function $dfd(e,i){if(e=_$HY.dq){_$HY.dq=0;for(i in e)$df(i)}if(e=_$HY.dlq){_$HY.dlq=0;for(i in e)$dfl(i)}}function $dfs(e,c,d){(_$HY.sc=_$HY.sc||{})[e]=c,d&&((_$HY.sd=_$HY.sd||{})[e]=1)}function $dfg(e,g,i,k){if(!(g=_$HY.sg&&_$HY.sg[e]))return;for(i=0;i<g.length;i++)if(_$HY.sc&&_$HY.sc[g[i]]>0)return;for(i=0;i<g.length;i++)k=g[i],delete _$HY.sg[k],$df(k)}function $dfc(e){if(--_$HY.sc[e]<=0){delete _$HY.sc[e],_$HY.sg&&_$HY.sg[e]?$dfg(e):!(_$HY.sd&&_$HY.sd[e])&&$df(e);_$HY.sd&&delete _$HY.sd[e]}}function $dfj(e,i,n){for(i=0;i<e.length;i++)if(_$HY.sc&&_$HY.sc[e[i]]>0){for(n=0;n<e.length;n++)(_$HY.sg=_$HY.sg||{})[e[n]]=e;return}for(i=0;i<e.length;i++)$df(e[i])}function $dfe(e,t,k){(t=e.target)&&t.getAttribute&&!t._$dc&&(k=t.getAttribute(\"data-dfc\"))&&(t._$dc=1,$dfc(k))}document.addEventListener(\"load\",$dfe,!0);document.addEventListener(\"error\",$dfe,!0);</script><script>$R[7]($R[5],!0);</script><script>$R[10].return(void 0);</script>"
 }
\ No newline at end of file
diff --git a/packages/web/test/harness/__artifacts__/frame-live-document-streamed.json b/packages/web/test/harness/__artifacts__/frame-live-document-streamed.json
index 425d5129e..124c57d98 100644
--- a/packages/web/test/harness/__artifacts__/frame-live-document-streamed.json
+++ b/packages/web/test/harness/__artifacts__/frame-live-document-streamed.json
@@ -1,5 +1,5 @@
 {
   "name": "frame-live-document-streamed",
-  "shell": "<main _hk=1><template id=\"pl-2\"></template><p _hk=20 class=\"fb\">shell-fallback</p><!--pl-2--></main><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"$B\"]=($R[0]={2000:$R[1]=($R[2]=($R[3]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"2_fr\":$R[4]=($R[5]=$R[3]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);($R[7]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[2],$R[6]=(self._$SC||(self._$SC={c:{},a:{},b:{},r(i,a){var c=this.c[i]||(this.c[i]=(p,b)=>self._$SC.impl(i,p,b));if(!a)return c;this.a[a]=i;this.reg&&this.reg(a,i);return this.b[a]||(this.b[a]=Object.assign(p=>c(p,()=>a),{[Symbol.for(\"solid.component-binding\")]:{component:c,address:a}}))}})).r(\"frame-live-doc/room-streamed\",\"frame-live-doc/room-streamed:1xvb\"));_$HY.r[\"sc:live\"]=$R[8]=($R[9]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[10]=($R[11]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"sc:slot:frame-live-doc/room-streamed:composer#0\"]=$R[12]=($R[13]=$R[3]()).p;$R[7]($R[13],$R[14]={room:\"a\"});</script>",
+  "shell": "<main _hk=1><template id=\"pl-2\"></template><p _hk=20 class=\"fb\">shell-fallback</p><!--pl-2--></main><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"$B\"]=($R[0]={2000:$R[1]=($R[2]=($R[3]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"2_fr\":$R[4]=($R[5]=$R[3]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);($R[7]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[2],$R[6]=(self._$SC||(self._$SC={c:{},a:{},b:{},r(i,a){var c=this.c[i]||(this.c[i]=(p,b)=>self._$SC.impl(i,p,b));if(!a)return c;this.a[a]=i;this.reg&&this.reg(a,i);return this.b[a]||(this.b[a]=Object.assign(p=>c(p,()=>a),{[Symbol.for(\"solid.component-binding\")]:{component:c,address:a}}))}})).r(\"frame-live-doc/room-streamed\",\"frame-live-doc/room-streamed:1xvb\"));_$HY.r[\"sc:live\"]=$R[8]=($R[9]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[10]=($R[11]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"sc:tiers\"]=$R[12]=[\"wire\"];_$HY.r[\"sc:slot:frame-live-doc/room-streamed:composer#0\"]=$R[13]=($R[14]=$R[3]()).p;$R[7]($R[14],$R[15]={room:\"a\"});</script>",
   "rest": "<template id=\"2\"><solid-frame data-fid=\"frame-live-doc/room-streamed\" style=\"display:contents\"><article><h1><!--lh:0-->room v1<!--lh:/0--></h1><ul><!--slot:composer#0:start--><input _hk=sc-frame-live-doc/room-streamed-composer#0-0 class=\"draft\" value=\"\" placeholder=\"Message #a\"><!--slot:composer#0:end--></ul></article></solid-frame></template><script>$df(\"2\");function $df(e){return _$HY.f?_$HY.f(e):$dfr(e)}function $dfr(e,n,o,t){if(!(n=document.getElementById(e)))return 0;if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dq=_$HY.dq||{})[e]=1,0;for(;o&&(8!==o.nodeType||o.nodeValue!==\"pl-\"+e);)t=o.nextSibling,o.remove(),o=t;t=o.parentNode,o.replaceWith(n.content),n.remove(),(_$HY.v=_$HY.v||{})[e]=1,_$HY.fe(e,t),_$HY.hp&&_$HY.hp[e]&&($dh(_$HY.hp[e]),delete _$HY.hp[e]),$dfd();return 1}function $dfl(e,o,n){if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dlq=_$HY.dlq||{})[e]=1,0;if(o._$fl)return 1;for(n=o.nextSibling;n;){if(8===n.nodeType&&n.nodeValue===\"pl-\"+e){o.parentNode&&o.parentNode.insertBefore(o.content.cloneNode(!0),n),o._$fl=1,$dfd();return 1}n=n.nextSibling}return 0}function $dflj(e,i){for(i=0;i<e.length;i++)$dfl(e[i])}function $dfd(e,i){if(e=_$HY.dq){_$HY.dq=0;for(i in e)$df(i)}if(e=_$HY.dlq){_$HY.dlq=0;for(i in e)$dfl(i)}}function $dfs(e,c,d){(_$HY.sc=_$HY.sc||{})[e]=c,d&&((_$HY.sd=_$HY.sd||{})[e]=1)}function $dfg(e,g,i,k){if(!(g=_$HY.sg&&_$HY.sg[e]))return;for(i=0;i<g.length;i++)if(_$HY.sc&&_$HY.sc[g[i]]>0)return;for(i=0;i<g.length;i++)k=g[i],delete _$HY.sg[k],$df(k)}function $dfc(e){if(--_$HY.sc[e]<=0){delete _$HY.sc[e],_$HY.sg&&_$HY.sg[e]?$dfg(e):!(_$HY.sd&&_$HY.sd[e])&&$df(e);_$HY.sd&&delete _$HY.sd[e]}}function $dfj(e,i,n){for(i=0;i<e.length;i++)if(_$HY.sc&&_$HY.sc[e[i]]>0){for(n=0;n<e.length;n++)(_$HY.sg=_$HY.sg||{})[e[n]]=e;return}for(i=0;i<e.length;i++)$df(e[i])}function $dfe(e,t,k){(t=e.target)&&t.getAttribute&&!t._$dc&&(k=t.getAttribute(\"data-dfc\"))&&(t._$dc=1,$dfc(k))}document.addEventListener(\"load\",$dfe,!0);document.addEventListener(\"error\",$dfe,!0);</script><script>$R[7]($R[5],!0);</script><script>$R[10].return(void 0);</script>"
 }
\ No newline at end of file
diff --git a/packages/web/test/harness/__artifacts__/frame-live-document-switched.json b/packages/web/test/harness/__artifacts__/frame-live-document-switched.json
index 394a680a4..98dbe2201 100644
--- a/packages/web/test/harness/__artifacts__/frame-live-document-switched.json
+++ b/packages/web/test/harness/__artifacts__/frame-live-document-switched.json
@@ -1,5 +1,5 @@
 {
   "name": "frame-live-document-switched",
-  "shell": "<main _hk=1><template id=\"pl-2\"></template><p _hk=20 class=\"fb\">shell-fallback</p><!--pl-2--></main><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"$B\"]=($R[0]={2000:$R[1]=($R[2]=($R[3]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"2_fr\":$R[4]=($R[5]=$R[3]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);($R[7]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[2],$R[6]=(self._$SC||(self._$SC={c:{},a:{},b:{},r(i,a){var c=this.c[i]||(this.c[i]=(p,b)=>self._$SC.impl(i,p,b));if(!a)return c;this.a[a]=i;this.reg&&this.reg(a,i);return this.b[a]||(this.b[a]=Object.assign(p=>c(p,()=>a),{[Symbol.for(\"solid.component-binding\")]:{component:c,address:a}}))}})).r(\"frame-live-doc/room-switched\",\"frame-live-doc/room-switched:1xvb\"));_$HY.r[\"sc:live\"]=$R[8]=($R[9]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[10]=($R[11]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"sc:slot:frame-live-doc/room-switched:composer#0\"]=$R[12]=($R[13]=$R[3]()).p;$R[7]($R[13],$R[14]={room:\"a\"});</script>",
+  "shell": "<main _hk=1><template id=\"pl-2\"></template><p _hk=20 class=\"fb\">shell-fallback</p><!--pl-2--></main><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"$B\"]=($R[0]={2000:$R[1]=($R[2]=($R[3]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"2_fr\":$R[4]=($R[5]=$R[3]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);($R[7]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[2],$R[6]=(self._$SC||(self._$SC={c:{},a:{},b:{},r(i,a){var c=this.c[i]||(this.c[i]=(p,b)=>self._$SC.impl(i,p,b));if(!a)return c;this.a[a]=i;this.reg&&this.reg(a,i);return this.b[a]||(this.b[a]=Object.assign(p=>c(p,()=>a),{[Symbol.for(\"solid.component-binding\")]:{component:c,address:a}}))}})).r(\"frame-live-doc/room-switched\",\"frame-live-doc/room-switched:1xvb\"));_$HY.r[\"sc:live\"]=$R[8]=($R[9]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[10]=($R[11]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"sc:tiers\"]=$R[12]=[\"wire\"];_$HY.r[\"sc:slot:frame-live-doc/room-switched:composer#0\"]=$R[13]=($R[14]=$R[3]()).p;$R[7]($R[14],$R[15]={room:\"a\"});</script>",
   "rest": "<template id=\"2\"><solid-frame data-fid=\"frame-live-doc/room-switched\" style=\"display:contents\"><article><h1><!--lh:0-->room v1<!--lh:/0--></h1><ul><!--slot:composer#0:start--><input _hk=sc-frame-live-doc/room-switched-composer#0-0 class=\"draft\" value=\"\" placeholder=\"Message #a\"><!--slot:composer#0:end--></ul></article></solid-frame></template><script>$df(\"2\");function $df(e){return _$HY.f?_$HY.f(e):$dfr(e)}function $dfr(e,n,o,t){if(!(n=document.getElementById(e)))return 0;if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dq=_$HY.dq||{})[e]=1,0;for(;o&&(8!==o.nodeType||o.nodeValue!==\"pl-\"+e);)t=o.nextSibling,o.remove(),o=t;t=o.parentNode,o.replaceWith(n.content),n.remove(),(_$HY.v=_$HY.v||{})[e]=1,_$HY.fe(e,t),_$HY.hp&&_$HY.hp[e]&&($dh(_$HY.hp[e]),delete _$HY.hp[e]),$dfd();return 1}function $dfl(e,o,n){if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dlq=_$HY.dlq||{})[e]=1,0;if(o._$fl)return 1;for(n=o.nextSibling;n;){if(8===n.nodeType&&n.nodeValue===\"pl-\"+e){o.parentNode&&o.parentNode.insertBefore(o.content.cloneNode(!0),n),o._$fl=1,$dfd();return 1}n=n.nextSibling}return 0}function $dflj(e,i){for(i=0;i<e.length;i++)$dfl(e[i])}function $dfd(e,i){if(e=_$HY.dq){_$HY.dq=0;for(i in e)$df(i)}if(e=_$HY.dlq){_$HY.dlq=0;for(i in e)$dfl(i)}}function $dfs(e,c,d){(_$HY.sc=_$HY.sc||{})[e]=c,d&&((_$HY.sd=_$HY.sd||{})[e]=1)}function $dfg(e,g,i,k){if(!(g=_$HY.sg&&_$HY.sg[e]))return;for(i=0;i<g.length;i++)if(_$HY.sc&&_$HY.sc[g[i]]>0)return;for(i=0;i<g.length;i++)k=g[i],delete _$HY.sg[k],$df(k)}function $dfc(e){if(--_$HY.sc[e]<=0){delete _$HY.sc[e],_$HY.sg&&_$HY.sg[e]?$dfg(e):!(_$HY.sd&&_$HY.sd[e])&&$df(e);_$HY.sd&&delete _$HY.sd[e]}}function $dfj(e,i,n){for(i=0;i<e.length;i++)if(_$HY.sc&&_$HY.sc[e[i]]>0){for(n=0;n<e.length;n++)(_$HY.sg=_$HY.sg||{})[e[n]]=e;return}for(i=0;i<e.length;i++)$df(e[i])}function $dfe(e,t,k){(t=e.target)&&t.getAttribute&&!t._$dc&&(k=t.getAttribute(\"data-dfc\"))&&(t._$dc=1,$dfc(k))}document.addEventListener(\"load\",$dfe,!0);document.addEventListener(\"error\",$dfe,!0);</script><script>$R[7]($R[5],!0);</script><script>$R[10].return(void 0);</script>"
 }
\ No newline at end of file
diff --git a/packages/web/test/harness/__artifacts__/welcome-status-loaded.json b/packages/web/test/harness/__artifacts__/welcome-status-loaded.json
index 7201e0bd7..c6900fe80 100644
--- a/packages/web/test/harness/__artifacts__/welcome-status-loaded.json
+++ b/packages/web/test/harness/__artifacts__/welcome-status-loaded.json
@@ -1,5 +1,5 @@
 {
   "name": "welcome-status-loaded",
-  "shell": "<solid-frame data-fid=\"parity/welcome-loaded\" style=\"display:contents\"><section class=\"reply\"><!--slot:status#0:start--><div _hk=sc-parity/welcome-loaded-status#0-0 class=\"status\"><!--$--><span _hk=sc-parity/welcome-loaded-status#0-1000 class=\"meter\">¶ <!--$-->1<!--/--></span><!--/--><!--$--><template id=\"pl-sc-parity/welcome-loaded-status#0-2\"></template><template id=\"pl-sc-parity/welcome-loaded-status#0-20\"></template><span _hk=sc-parity/welcome-loaded-status#0-200 class=\"ticker\">…</span><!--pl-sc-parity/welcome-loaded-status#0-20--><!--pl-sc-parity/welcome-loaded-status#0-2--><!--/--></div><!--slot:status#0:end--></section></solid-frame><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"sc:live\"]=$R[0]=($R[1]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[2]=($R[3]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"$B\"]=($R[4]={\"sc:slot:parity/welcome-loaded:status#0\":$R[5]=($R[6]=($R[7]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"sc-parity/welcome-loaded-status#0-1_fr\":$R[8]=($R[9]=$R[7]()).p,\"sc-parity/welcome-loaded-status#0-20_fr\":$R[10]=($R[11]=$R[7]()).p,\"sc-parity/welcome-loaded-status#0-2_fr\":$R[12]=($R[13]=$R[7]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);($R[21]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[6],$R[14]={progress:$R[15]=($R[16]=$R[7]()).p,stats:$R[17]=($R[18]=$R[7]()).p,usage:$R[19]={$tr:$R[20]=$R[3](),$ta:0}});$R[20].next($R[22]={state:\"thinking\",tokens:5,parts:1});$R[21]($R[16],\"writing\");$R[21]($R[9],!0);$R[21]($R[11],!0);</script>",
-  "rest": "<script>$R[21]($R[18],$R[23]={tokens:42,rate:7});</script><template id=\"sc-parity/welcome-loaded-status#0-2\"><span _hk=sc-parity/welcome-loaded-status#0-2000 class=\"done\"><!--$-->42<!--/--> tokens · <!--$-->7<!--/--> tok/s</span></template><script>$df(\"sc-parity/welcome-loaded-status#0-2\");function $df(e){return _$HY.f?_$HY.f(e):$dfr(e)}function $dfr(e,n,o,t){if(!(n=document.getElementById(e)))return 0;if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dq=_$HY.dq||{})[e]=1,0;for(;o&&(8!==o.nodeType||o.nodeValue!==\"pl-\"+e);)t=o.nextSibling,o.remove(),o=t;t=o.parentNode,o.replaceWith(n.content),n.remove(),(_$HY.v=_$HY.v||{})[e]=1,_$HY.fe(e,t),_$HY.hp&&_$HY.hp[e]&&($dh(_$HY.hp[e]),delete _$HY.hp[e]),$dfd();return 1}function $dfl(e,o,n){if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dlq=_$HY.dlq||{})[e]=1,0;if(o._$fl)return 1;for(n=o.nextSibling;n;){if(8===n.nodeType&&n.nodeValue===\"pl-\"+e){o.parentNode&&o.parentNode.insertBefore(o.content.cloneNode(!0),n),o._$fl=1,$dfd();return 1}n=n.nextSibling}return 0}function $dflj(e,i){for(i=0;i<e.length;i++)$dfl(e[i])}function $dfd(e,i){if(e=_$HY.dq){_$HY.dq=0;for(i in e)$df(i)}if(e=_$HY.dlq){_$HY.dlq=0;for(i in e)$dfl(i)}}function $dfs(e,c,d){(_$HY.sc=_$HY.sc||{})[e]=c,d&&((_$HY.sd=_$HY.sd||{})[e]=1)}function $dfg(e,g,i,k){if(!(g=_$HY.sg&&_$HY.sg[e]))return;for(i=0;i<g.length;i++)if(_$HY.sc&&_$HY.sc[g[i]]>0)return;for(i=0;i<g.length;i++)k=g[i],delete _$HY.sg[k],$df(k)}function $dfc(e){if(--_$HY.sc[e]<=0){delete _$HY.sc[e],_$HY.sg&&_$HY.sg[e]?$dfg(e):!(_$HY.sd&&_$HY.sd[e])&&$df(e);_$HY.sd&&delete _$HY.sd[e]}}function $dfj(e,i,n){for(i=0;i<e.length;i++)if(_$HY.sc&&_$HY.sc[e[i]]>0){for(n=0;n<e.length;n++)(_$HY.sg=_$HY.sg||{})[e[n]]=e;return}for(i=0;i<e.length;i++)$df(e[i])}function $dfe(e,t,k){(t=e.target)&&t.getAttribute&&!t._$dc&&(k=t.getAttribute(\"data-dfc\"))&&(t._$dc=1,$dfc(k))}document.addEventListener(\"load\",$dfe,!0);document.addEventListener(\"error\",$dfe,!0);</script><script>$R[21]($R[13],!0);</script><script>$R[20].next($R[24]=[$R[25]=[$R[26]=[\"state\"],\"done\"],$R[27]=[$R[28]=[\"tokens\"],9],$R[29]=[$R[30]=[\"parts\"],2]]);</script><script>$R[20].return(void 0);</script><script>$R[2].next($R[31]={type:\"slot\",fid:\"parity/welcome-loaded\",key:\"status#0\",args:$R[32]={progress:\"streaming\",stats:$R[17],usage:$R[19]}});</script><script>$R[2].return(void 0);</script>"
+  "shell": "<solid-frame data-fid=\"parity/welcome-loaded\" style=\"display:contents\"><section class=\"reply\"><!--slot:status#0:start--><div _hk=sc-parity/welcome-loaded-status#0-0 class=\"status\"><!--$--><span _hk=sc-parity/welcome-loaded-status#0-1000 class=\"meter\">¶ <!--$-->1<!--/--></span><!--/--><!--$--><template id=\"pl-sc-parity/welcome-loaded-status#0-2\"></template><template id=\"pl-sc-parity/welcome-loaded-status#0-20\"></template><span _hk=sc-parity/welcome-loaded-status#0-200 class=\"ticker\">…</span><!--pl-sc-parity/welcome-loaded-status#0-20--><!--pl-sc-parity/welcome-loaded-status#0-2--><!--/--></div><!--slot:status#0:end--></section></solid-frame><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"sc:live\"]=$R[0]=($R[1]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[2]=($R[3]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"sc:tiers\"]=$R[4]=[\"trace\"];_$HY.r[\"$B\"]=($R[5]={\"sc:slot:parity/welcome-loaded:status#0\":$R[6]=($R[7]=($R[8]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"sc-parity/welcome-loaded-status#0-1_fr\":$R[9]=($R[10]=$R[8]()).p,\"sc-parity/welcome-loaded-status#0-20_fr\":$R[11]=($R[12]=$R[8]()).p,\"sc-parity/welcome-loaded-status#0-2_fr\":$R[13]=($R[14]=$R[8]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);($R[22]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[7],$R[15]={progress:$R[16]=($R[17]=$R[8]()).p,stats:$R[18]=($R[19]=$R[8]()).p,usage:$R[20]={$tr:$R[21]=$R[3](),$ta:0}});$R[21].next($R[23]={state:\"thinking\",tokens:5,parts:1});$R[22]($R[17],\"writing\");$R[22]($R[10],!0);$R[22]($R[12],!0);</script>",
+  "rest": "<script>$R[22]($R[19],$R[24]={tokens:42,rate:7});</script><template id=\"sc-parity/welcome-loaded-status#0-2\"><span _hk=sc-parity/welcome-loaded-status#0-2000 class=\"done\"><!--$-->42<!--/--> tokens · <!--$-->7<!--/--> tok/s</span></template><script>$df(\"sc-parity/welcome-loaded-status#0-2\");function $df(e){return _$HY.f?_$HY.f(e):$dfr(e)}function $dfr(e,n,o,t){if(!(n=document.getElementById(e)))return 0;if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dq=_$HY.dq||{})[e]=1,0;for(;o&&(8!==o.nodeType||o.nodeValue!==\"pl-\"+e);)t=o.nextSibling,o.remove(),o=t;t=o.parentNode,o.replaceWith(n.content),n.remove(),(_$HY.v=_$HY.v||{})[e]=1,_$HY.fe(e,t),_$HY.hp&&_$HY.hp[e]&&($dh(_$HY.hp[e]),delete _$HY.hp[e]),$dfd();return 1}function $dfl(e,o,n){if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dlq=_$HY.dlq||{})[e]=1,0;if(o._$fl)return 1;for(n=o.nextSibling;n;){if(8===n.nodeType&&n.nodeValue===\"pl-\"+e){o.parentNode&&o.parentNode.insertBefore(o.content.cloneNode(!0),n),o._$fl=1,$dfd();return 1}n=n.nextSibling}return 0}function $dflj(e,i){for(i=0;i<e.length;i++)$dfl(e[i])}function $dfd(e,i){if(e=_$HY.dq){_$HY.dq=0;for(i in e)$df(i)}if(e=_$HY.dlq){_$HY.dlq=0;for(i in e)$dfl(i)}}function $dfs(e,c,d){(_$HY.sc=_$HY.sc||{})[e]=c,d&&((_$HY.sd=_$HY.sd||{})[e]=1)}function $dfg(e,g,i,k){if(!(g=_$HY.sg&&_$HY.sg[e]))return;for(i=0;i<g.length;i++)if(_$HY.sc&&_$HY.sc[g[i]]>0)return;for(i=0;i<g.length;i++)k=g[i],delete _$HY.sg[k],$df(k)}function $dfc(e){if(--_$HY.sc[e]<=0){delete _$HY.sc[e],_$HY.sg&&_$HY.sg[e]?$dfg(e):!(_$HY.sd&&_$HY.sd[e])&&$df(e);_$HY.sd&&delete _$HY.sd[e]}}function $dfj(e,i,n){for(i=0;i<e.length;i++)if(_$HY.sc&&_$HY.sc[e[i]]>0){for(n=0;n<e.length;n++)(_$HY.sg=_$HY.sg||{})[e[n]]=e;return}for(i=0;i<e.length;i++)$df(e[i])}function $dfe(e,t,k){(t=e.target)&&t.getAttribute&&!t._$dc&&(k=t.getAttribute(\"data-dfc\"))&&(t._$dc=1,$dfc(k))}document.addEventListener(\"load\",$dfe,!0);document.addEventListener(\"error\",$dfe,!0);</script><script>$R[22]($R[14],!0);</script><script>$R[21].next($R[25]=[$R[26]=[$R[27]=[\"state\"],\"done\"],$R[28]=[$R[29]=[\"tokens\"],9],$R[30]=[$R[31]=[\"parts\"],2]]);</script><script>$R[21].return(void 0);</script><script>$R[2].next($R[32]={type:\"slot\",fid:\"parity/welcome-loaded\",key:\"status#0\",args:$R[33]={progress:\"streaming\",stats:$R[18],usage:$R[20]}});</script><script>$R[2].return(void 0);</script>"
 }
\ No newline at end of file
diff --git a/packages/web/test/harness/__artifacts__/welcome-status-streamed.json b/packages/web/test/harness/__artifacts__/welcome-status-streamed.json
index d48a7bb80..ef1ebbb6b 100644
--- a/packages/web/test/harness/__artifacts__/welcome-status-streamed.json
+++ b/packages/web/test/harness/__artifacts__/welcome-status-streamed.json
@@ -1,5 +1,5 @@
 {
   "name": "welcome-status-streamed",
-  "shell": "<solid-frame data-fid=\"parity/welcome-streamed\" style=\"display:contents\"><section class=\"reply\"><!--slot:status#0:start--><div _hk=sc-parity/welcome-streamed-status#0-0 class=\"status\"><!--$--><span _hk=sc-parity/welcome-streamed-status#0-1000 class=\"meter\">¶ <!--$-->1<!--/--></span><!--/--><!--$--><template id=\"pl-sc-parity/welcome-streamed-status#0-2\"></template><template id=\"pl-sc-parity/welcome-streamed-status#0-20\"></template><span _hk=sc-parity/welcome-streamed-status#0-200 class=\"ticker\">…</span><!--pl-sc-parity/welcome-streamed-status#0-20--><!--pl-sc-parity/welcome-streamed-status#0-2--><!--/--></div><!--slot:status#0:end--></section></solid-frame><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"sc:live\"]=$R[0]=($R[1]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[2]=($R[3]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"$B\"]=($R[4]={\"sc:slot:parity/welcome-streamed:status#0\":$R[5]=($R[6]=($R[7]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"sc-parity/welcome-streamed-status#0-1_fr\":$R[8]=($R[9]=$R[7]()).p,\"sc-parity/welcome-streamed-status#0-20_fr\":$R[10]=($R[11]=$R[7]()).p,\"sc-parity/welcome-streamed-status#0-2_fr\":$R[12]=($R[13]=$R[7]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);($R[21]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[6],$R[14]={progress:$R[15]=($R[16]=$R[7]()).p,stats:$R[17]=($R[18]=$R[7]()).p,usage:$R[19]={$tr:$R[20]=$R[3](),$ta:0}});$R[20].next($R[22]={state:\"thinking\",tokens:5,parts:1});$R[21]($R[16],\"writing\");$R[21]($R[9],!0);$R[21]($R[11],!0);</script>",
-  "rest": "<script>$R[20].next($R[23]=[$R[24]=[$R[25]=[\"state\"],\"done\"],$R[26]=[$R[27]=[\"tokens\"],9],$R[28]=[$R[29]=[\"parts\"],2]]);</script><script>$R[20].return(void 0);</script><script>$R[2].next($R[30]={type:\"slot\",fid:\"parity/welcome-streamed\",key:\"status#0\",args:$R[31]={progress:\"streaming\",stats:$R[17],usage:$R[19]}});</script><script>$R[21]($R[18],$R[32]={tokens:42,rate:7});</script><template id=\"sc-parity/welcome-streamed-status#0-2\"><span _hk=sc-parity/welcome-streamed-status#0-2000 class=\"done\"><!--$-->42<!--/--> tokens · <!--$-->7<!--/--> tok/s</span></template><script>$df(\"sc-parity/welcome-streamed-status#0-2\");function $df(e){return _$HY.f?_$HY.f(e):$dfr(e)}function $dfr(e,n,o,t){if(!(n=document.getElementById(e)))return 0;if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dq=_$HY.dq||{})[e]=1,0;for(;o&&(8!==o.nodeType||o.nodeValue!==\"pl-\"+e);)t=o.nextSibling,o.remove(),o=t;t=o.parentNode,o.replaceWith(n.content),n.remove(),(_$HY.v=_$HY.v||{})[e]=1,_$HY.fe(e,t),_$HY.hp&&_$HY.hp[e]&&($dh(_$HY.hp[e]),delete _$HY.hp[e]),$dfd();return 1}function $dfl(e,o,n){if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dlq=_$HY.dlq||{})[e]=1,0;if(o._$fl)return 1;for(n=o.nextSibling;n;){if(8===n.nodeType&&n.nodeValue===\"pl-\"+e){o.parentNode&&o.parentNode.insertBefore(o.content.cloneNode(!0),n),o._$fl=1,$dfd();return 1}n=n.nextSibling}return 0}function $dflj(e,i){for(i=0;i<e.length;i++)$dfl(e[i])}function $dfd(e,i){if(e=_$HY.dq){_$HY.dq=0;for(i in e)$df(i)}if(e=_$HY.dlq){_$HY.dlq=0;for(i in e)$dfl(i)}}function $dfs(e,c,d){(_$HY.sc=_$HY.sc||{})[e]=c,d&&((_$HY.sd=_$HY.sd||{})[e]=1)}function $dfg(e,g,i,k){if(!(g=_$HY.sg&&_$HY.sg[e]))return;for(i=0;i<g.length;i++)if(_$HY.sc&&_$HY.sc[g[i]]>0)return;for(i=0;i<g.length;i++)k=g[i],delete _$HY.sg[k],$df(k)}function $dfc(e){if(--_$HY.sc[e]<=0){delete _$HY.sc[e],_$HY.sg&&_$HY.sg[e]?$dfg(e):!(_$HY.sd&&_$HY.sd[e])&&$df(e);_$HY.sd&&delete _$HY.sd[e]}}function $dfj(e,i,n){for(i=0;i<e.length;i++)if(_$HY.sc&&_$HY.sc[e[i]]>0){for(n=0;n<e.length;n++)(_$HY.sg=_$HY.sg||{})[e[n]]=e;return}for(i=0;i<e.length;i++)$df(e[i])}function $dfe(e,t,k){(t=e.target)&&t.getAttribute&&!t._$dc&&(k=t.getAttribute(\"data-dfc\"))&&(t._$dc=1,$dfc(k))}document.addEventListener(\"load\",$dfe,!0);document.addEventListener(\"error\",$dfe,!0);</script><script>$R[21]($R[13],!0);</script><script>$R[2].return(void 0);</script>"
+  "shell": "<solid-frame data-fid=\"parity/welcome-streamed\" style=\"display:contents\"><section class=\"reply\"><!--slot:status#0:start--><div _hk=sc-parity/welcome-streamed-status#0-0 class=\"status\"><!--$--><span _hk=sc-parity/welcome-streamed-status#0-1000 class=\"meter\">¶ <!--$-->1<!--/--></span><!--/--><!--$--><template id=\"pl-sc-parity/welcome-streamed-status#0-2\"></template><template id=\"pl-sc-parity/welcome-streamed-status#0-20\"></template><span _hk=sc-parity/welcome-streamed-status#0-200 class=\"ticker\">…</span><!--pl-sc-parity/welcome-streamed-status#0-20--><!--pl-sc-parity/welcome-streamed-status#0-2--><!--/--></div><!--slot:status#0:end--></section></solid-frame><script>(self.$R=self.$R||{})[\"\"]=[];_$HY.r[\"sc:live\"]=$R[0]=($R[1]=(stream) => new ReadableStream({ start(controller) {\n\tstream.on({\n\t\tnext(value) {\n\t\t\ttry {\n\t\t\t\tcontroller.enqueue(value);\n\t\t\t} catch (_error) {}\n\t\t},\n\t\tthrow(value) {\n\t\t\tcontroller.error(value);\n\t\t},\n\t\treturn() {\n\t\t\ttry {\n\t\t\t\tcontroller.close();\n\t\t\t} catch (_error) {}\n\t\t}\n\t});\n} }))($R[2]=($R[3]=() => {\n\tconst buffer = [];\n\tconst listeners = [];\n\tlet alive = true;\n\tlet success = false;\n\tlet count = 0;\n\tconst internal = {\n\t\tflush(value, mode, x) {\n\t\t\tfor (x = 0; x < count; x++) {\n\t\t\t\tconst listener = listeners[x];\n\t\t\t\tif (listener) listener[mode](value);\n\t\t\t}\n\t\t},\n\t\tup(listener, x, z, current) {\n\t\t\tfor (x = 0, z = buffer.length; x < z; x++) {\n\t\t\t\tcurrent = buffer[x];\n\t\t\t\tif (!alive && x === z - 1) listener[success ? \"return\" : \"throw\"](current);\n\t\t\t\telse listener.next(current);\n\t\t\t}\n\t\t},\n\t\ton(listener, temp = 0) {\n\t\t\tlet subscribed = alive;\n\t\t\tif (alive) {\n\t\t\t\tfor (temp = 0; temp < count; temp++) if (!listeners[temp]) break;\n\t\t\t\tif (temp === count) count++;\n\t\t\t\tlisteners[temp] = listener;\n\t\t\t}\n\t\t\tinternal.up(listener);\n\t\t\treturn () => {\n\t\t\t\tif (alive && subscribed) {\n\t\t\t\t\tsubscribed = false;\n\t\t\t\t\tlisteners[temp] = void 0;\n\t\t\t\t\twhile (count > 0 && !listeners[count - 1]) count--;\n\t\t\t\t\tlisteners.length = count;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t};\n\treturn {\n\t\t__SEROVAL_STREAM__: true,\n\t\ton(listener) {\n\t\t\treturn internal.on(listener);\n\t\t},\n\t\tnext(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"next\");\n\t\t\t}\n\t\t},\n\t\tthrow(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"throw\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = false;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t},\n\t\treturn(value) {\n\t\t\tif (alive) {\n\t\t\t\tbuffer.push(value);\n\t\t\t\tinternal.flush(value, \"return\");\n\t\t\t\talive = false;\n\t\t\t\tsuccess = true;\n\t\t\t\tlisteners.length = 0;\n\t\t\t}\n\t\t}\n\t};\n})());_$HY.r[\"sc:tiers\"]=$R[4]=[\"trace\"];_$HY.r[\"$B\"]=($R[5]={\"sc:slot:parity/welcome-streamed:status#0\":$R[6]=($R[7]=($R[8]=() => {\n\tconst resolver = {\n\t\tp: 0,\n\t\ts: 0,\n\t\tf: 0\n\t};\n\tresolver.p = new Promise((resolve, reject) => {\n\t\tresolver.s = resolve;\n\t\tresolver.f = reject;\n\t});\n\treturn resolver;\n})()).p,\"sc-parity/welcome-streamed-status#0-1_fr\":$R[9]=($R[10]=$R[8]()).p,\"sc-parity/welcome-streamed-status#0-20_fr\":$R[11]=($R[12]=$R[8]()).p,\"sc-parity/welcome-streamed-status#0-2_fr\":$R[13]=($R[14]=$R[8]()).p});(b=>{for(var k in b)_$HY.r[k]=b[k];delete _$HY.r[\"$B\"]})(_$HY.r[\"$B\"]);($R[22]=(resolver, data) => {\n\tresolver.s(data);\n\tresolver.p.s = 1;\n\tresolver.p.v = data;\n})($R[7],$R[15]={progress:$R[16]=($R[17]=$R[8]()).p,stats:$R[18]=($R[19]=$R[8]()).p,usage:$R[20]={$tr:$R[21]=$R[3](),$ta:0}});$R[21].next($R[23]={state:\"thinking\",tokens:5,parts:1});$R[22]($R[17],\"writing\");$R[22]($R[10],!0);$R[22]($R[12],!0);</script>",
+  "rest": "<script>$R[22]($R[19],$R[24]={tokens:42,rate:7});</script><template id=\"sc-parity/welcome-streamed-status#0-2\"><span _hk=sc-parity/welcome-streamed-status#0-2000 class=\"done\"><!--$-->42<!--/--> tokens · <!--$-->7<!--/--> tok/s</span></template><script>$df(\"sc-parity/welcome-streamed-status#0-2\");function $df(e){return _$HY.f?_$HY.f(e):$dfr(e)}function $dfr(e,n,o,t){if(!(n=document.getElementById(e)))return 0;if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dq=_$HY.dq||{})[e]=1,0;for(;o&&(8!==o.nodeType||o.nodeValue!==\"pl-\"+e);)t=o.nextSibling,o.remove(),o=t;t=o.parentNode,o.replaceWith(n.content),n.remove(),(_$HY.v=_$HY.v||{})[e]=1,_$HY.fe(e,t),_$HY.hp&&_$HY.hp[e]&&($dh(_$HY.hp[e]),delete _$HY.hp[e]),$dfd();return 1}function $dfl(e,o,n){if(!(o=document.getElementById(\"pl-\"+e)))return(_$HY.dlq=_$HY.dlq||{})[e]=1,0;if(o._$fl)return 1;for(n=o.nextSibling;n;){if(8===n.nodeType&&n.nodeValue===\"pl-\"+e){o.parentNode&&o.parentNode.insertBefore(o.content.cloneNode(!0),n),o._$fl=1,$dfd();return 1}n=n.nextSibling}return 0}function $dflj(e,i){for(i=0;i<e.length;i++)$dfl(e[i])}function $dfd(e,i){if(e=_$HY.dq){_$HY.dq=0;for(i in e)$df(i)}if(e=_$HY.dlq){_$HY.dlq=0;for(i in e)$dfl(i)}}function $dfs(e,c,d){(_$HY.sc=_$HY.sc||{})[e]=c,d&&((_$HY.sd=_$HY.sd||{})[e]=1)}function $dfg(e,g,i,k){if(!(g=_$HY.sg&&_$HY.sg[e]))return;for(i=0;i<g.length;i++)if(_$HY.sc&&_$HY.sc[g[i]]>0)return;for(i=0;i<g.length;i++)k=g[i],delete _$HY.sg[k],$df(k)}function $dfc(e){if(--_$HY.sc[e]<=0){delete _$HY.sc[e],_$HY.sg&&_$HY.sg[e]?$dfg(e):!(_$HY.sd&&_$HY.sd[e])&&$df(e);_$HY.sd&&delete _$HY.sd[e]}}function $dfj(e,i,n){for(i=0;i<e.length;i++)if(_$HY.sc&&_$HY.sc[e[i]]>0){for(n=0;n<e.length;n++)(_$HY.sg=_$HY.sg||{})[e[n]]=e;return}for(i=0;i<e.length;i++)$df(e[i])}function $dfe(e,t,k){(t=e.target)&&t.getAttribute&&!t._$dc&&(k=t.getAttribute(\"data-dfc\"))&&(t._$dc=1,$dfc(k))}document.addEventListener(\"load\",$dfe,!0);document.addEventListener(\"error\",$dfe,!0);</script><script>$R[22]($R[14],!0);</script><script>$R[21].next($R[25]=[$R[26]=[$R[27]=[\"state\"],\"done\"],$R[28]=[$R[29]=[\"tokens\"],9],$R[30]=[$R[31]=[\"parts\"],2]]);</script><script>$R[21].return(void 0);</script><script>$R[2].next($R[32]={type:\"slot\",fid:\"parity/welcome-streamed\",key:\"status#0\",args:$R[33]={progress:\"streaming\",stats:$R[18],usage:$R[20]}});</script><script>$R[2].return(void 0);</script>"
 }
\ No newline at end of file
diff --git a/packages/web/test/harness/dynamic-component-parity.tsx b/packages/web/test/harness/dynamic-component-parity.tsx
new file mode 100644
index 000000000..0d48cc614
--- /dev/null
+++ b/packages/web/test/harness/dynamic-component-parity.tsx
@@ -0,0 +1,85 @@
+/**
+ * @jsxImportSource @solidjs/web
+ *
+ * `dynamicComponent` parity fixture: one page, two mounts — a plain client
+ * component (a sync source) and a NON-LIVE server component reference (an
+ * async source, under `<Loading>`) — each through ONE entry point, `dynamic`
+ * or `dynamicComponent`. Same tree on both sides so hydration ids agree;
+ * only the SOURCE of the note differs (the server's in-process answer, the
+ * client's server reference).
+ *
+ * Two variants, as in frame-nonlive-document-3666: `inline` settles on a
+ * microtask (the boundary settles before the shell flush; no fallback
+ * markup), `streamed` takes a timer (fallback in the shell, the frame
+ * streamed later with its `_fr` record).
+ *
+ * Shared by test/server/dynamic-component-parity.spec.tsx (renders the page
+ * through each entry point, asserts the documents are byte-identical — same
+ * markup, same hydration keys, same records — and writes the artifact) and
+ * test/hydration/dynamic-component-parity.spec.tsx (hydrates the artifact
+ * with each entry point).
+ */
+import { createSignal, Loading, type Component } from "solid-js";
+import { dynamic, dynamicComponent } from "@solidjs/web";
+
+export const VIAS = ["dynamic", "dynamicComponent"] as const;
+export type Via = (typeof VIAS)[number];
+export const VARIANTS = ["inline", "streamed"] as const;
+export type Variant = (typeof VARIANTS)[number];
+export const fidFor = (variant: Variant) => `dynamic-component-parity/note-${variant}`;
+export const artifactFor = (variant: Variant) => `dynamic-component-parity-${variant}`;
+export const ARGS = ["a"];
+
+/** The entry point under test, as the one shape both share. */
+export const mountOf = (via: Via): ((source: () => any) => Component<any>) =>
+  via === "dynamic" ? dynamic : dynamicComponent;
+
+/** A client component with state of its own — the button proves interactivity. */
+export function Counter(props: { id: string; label: string }) {
+  const [count, setCount] = createSignal(0);
+  return (
+    <button id={props.id} onClick={() => setCount(count() + 1)}>
+      {props.label}: {count()}
+    </button>
+  );
+}
+
+/** A plain client component, mounted through the entry point from a sync source. */
+export function Panel(props: { title: string }) {
+  return (
+    <section id="panel">
+      <h2>{props.title}</h2>
+      <Counter id="panel-counter" label="Panel" />
+    </section>
+  );
+}
+
+/** The page: the client component, then the note under a `Loading`, both through `via`. */
+export function makeApp(via: Via, noteSource: () => any) {
+  const mount = mountOf(via);
+  return () => {
+    const Client = mount(() => Panel);
+    const Note = mount(noteSource);
+    return (
+      <main>
+        <Client title="client" />
+        <Loading fallback={<p class="fb">shell-fallback</p>}>
+          <Note counter={(p: any) => <Counter id="note-counter" label={p.label} />} />
+        </Loading>
+      </main>
+    );
+  };
+}
+
+/** The server component: static markup plus a client slot. */
+export function makeNoteComponent(title: string) {
+  const NoteComponent = (props: { counter: any }) => (
+    <article id="content">
+      <h1>{title}</h1>
+      <ul>
+        <props.counter label="Count" />
+      </ul>
+    </article>
+  );
+  return NoteComponent;
+}
diff --git a/packages/web/test/hydration/adopted-claim-args-address.spec.tsx b/packages/web/test/hydration/adopted-claim-args-address.spec.tsx
index 5e73a461c..7c1e36288 100644
--- a/packages/web/test/hydration/adopted-claim-args-address.spec.tsx
+++ b/packages/web/test/hydration/adopted-claim-args-address.spec.tsx
@@ -16,8 +16,9 @@
  *
  * Argless calls (address === id) mask the break, which is why the
  * adopted-slot suites never caught it: this spec pins the args-bearing case
- * by seeding an `_$SC.a` address record so the adopted frame binds a
- * hash-suffixed address while the markup's `_hk` keys carry the wire id.
+ * by mounting the call's BINDING (`_$SC.r(id, address)`, what a serialized
+ * reference resolves to) so the adopted frame binds a hash-suffixed address
+ * while the markup's `_hk` keys carry the wire id.
  */
 import { afterEach, describe, expect, test, vi } from "vitest";
 import { flush } from "solid-js";
@@ -68,18 +69,18 @@ describe("adopted claim scope on an args-bearing call", () => {
     vi.stubGlobal("fetch", () => {
       throw new Error("fetch must not be called");
     });
-    installServerComponents(makeHost());
-    // The args-bearing call's address record (`_$SC.a`, address -> id), as
-    // the document's hydration references would have written it. This is
-    // what splits address from wire id: documentAddress() resolves the
-    // frame's store to ADDRESS while the page's keys stay under FID.
-    (globalThis as any)._$SC.a = { [ADDRESS]: FID };
+    const host = makeHost();
+    installServerComponents(host);
 
     const ssrNode = container.querySelector(".comment")!;
     const ssrButton = ssrNode.querySelector("button")!;
 
     const seen: any[] = [];
-    const Thread = (globalThis as any)._$SC.r(FID);
+    // The args-bearing call's BINDING, as the document's hydration reference
+    // resolves it (`_$SC.r(id, address)`): the mount binds the frame's store
+    // to ADDRESS — the address rides with the binding — while the page's
+    // keys stay under FID. This is what splits address from wire id.
+    const Thread = (globalThis as any)._$SC.r(FID, ADDRESS);
     const dispose = hydrate(
       () => (
         <Thread
@@ -109,6 +110,10 @@ describe("adopted claim scope on an args-bearing call", () => {
     expect(nowNode).toBe(ssrNode);
     expect(container.querySelector("button")).toBe(ssrButton);
     expect(document.querySelectorAll(".comment").length).toBe(1);
+    // ...under the call's ADDRESS (the store the binding named), not the
+    // wire id.
+    expect(host.get(ADDRESS)).toBeDefined();
+    expect(host.get(FID)).toBeUndefined();
 
     dispose();
     container.remove();
diff --git a/packages/web/test/hydration/binding-slot-adoption.spec.tsx b/packages/web/test/hydration/binding-slot-adoption.spec.tsx
index 7e7cc595f..c153f66a0 100644
--- a/packages/web/test/hydration/binding-slot-adoption.spec.tsx
+++ b/packages/web/test/hydration/binding-slot-adoption.spec.tsx
@@ -11,12 +11,19 @@
 // client state moves them, handlers dispatch, refs fire with the adopted
 // elements. (Morphs around owned positions after a later response are
 // pinned by test/frames-binding-slots.spec.tsx.)
-import { afterEach, describe, expect, test, vi } from "vitest";
+import { afterEach, beforeAll, describe, expect, test, vi } from "vitest";
 import { createSignal, flush } from "solid-js";
 import { hydrate } from "@solidjs/web";
 import { installServerComponents, createFrameHost } from "../../frames/src/client.js";
+import { prepareTier } from "../../frames/src/frame-client.js";
 import { createJSONDataTable } from "../../serialization/src/serializer.js";
 
+// Binding-slot positions are the BIND TIER's (`@solidjs/web/frames/bind`,
+// plan step C6), warmed here so the attach is the t=0 sync's; the hold an
+// un-announced page takes and the install's flush are pinned in
+// consistency/tier-bind-hold.spec.tsx.
+beforeAll(() => prepareTier("bind"));
+
 const settle = () => new Promise(r => setTimeout(r));
 const cycle = async () => {
   flush();
diff --git a/packages/web/test/hydration/container-trace-hold-helpers.tsx b/packages/web/test/hydration/container-trace-hold-helpers.tsx
new file mode 100644
index 000000000..12bb87e85
--- /dev/null
+++ b/packages/web/test/hydration/container-trace-hold-helpers.tsx
@@ -0,0 +1,313 @@
+/**
+ * @jsxImportSource @solidjs/web
+ *
+ * Shared fixture for the container-trace HOLD specs (the traces tier,
+ * document face — frames savings pass §3 row C3, S1's hold re-based onto the
+ * tier mechanism): a server component whose slot calls interleave two
+ * trace-carrying fills with two ordinary ones, followed by a keyed sibling.
+ *
+ * The page as the server left it — `renderToStream` with the frame sink,
+ * `frameTransformDirectResult(thread, { id: FID })` rendered inline at t=0:
+ *
+ * ```tsx
+ * const thread = (props) => {
+ *   const u1 = createProjection(async function* (d) { d.name = "Ada"; yield; }, { name: "" });
+ *   const u2 = createProjection(async function* (d) { d.name = "Grace"; yield; }, { name: "" });
+ *   return (
+ *     <ul class="thread">
+ *       <li><props.comment $key="c1" cid="c1" user={u1} /></li>
+ *       <li><props.note text="n1" /></li>
+ *       <li><props.comment $key="c2" cid="c2" user={u2} /></li>
+ *       <li><props.note text="n2" /></li>
+ *     </ul>
+ *   );
+ * };
+ * // page
+ * <>
+ *   <After text={label()} />
+ *   <Inline comment={commentFill} note={noteFill} />
+ *   <After text={label()} />
+ * </>
+ * ```
+ *
+ * `$key` names the calls because the sink's structural-repeat probe reads a
+ * pending projection's keys (a pre-existing server-side finding, noted in
+ * the review report). The fills below are the exact JSX the server ran, so
+ * the `_hk` chains in FRAME_HTML are what they mint. Records are rebuilt
+ * from the server's data script by hand (seroval streams for the traces,
+ * settled `_fr` stamps for the fills' inline boundaries) so the specs can
+ * decide WHEN each trace emits.
+ *
+ * The HOLD under test is the tier mechanism's: the adopt-time sync finds a
+ * `{ $tr }` marker in a record's args while the `trace` tier is absent,
+ * starts the load (`prepareTier("trace")`, the test's gated loader) and
+ * holds the occurrence; the frame's hold registers as a pending boundary
+ * (frames-rulings 3.1 / 3.2). `gateTraceTier` owns the load; `release()`
+ * settles it with the REAL tier module (`frames/src/trace-tier.ts`), so what
+ * installs is production's. A tier, once resident, stays so for the
+ * worker; the gate re-arms it by dropping the load (`tierLoads`, the
+ * runtime's test seam), the way S1's `force` re-held through its host.
+ */
+import { expect, vi } from "vitest";
+import { createStream } from "seroval";
+import { createSignal, flush, Loading, untrack } from "solid-js";
+import { getFrameHost, installServerComponents } from "../../frames/src/client.js";
+import { prepareTier, tierLoads } from "../../frames/src/frame-client.js";
+
+/**
+ * The server rendered under `hold/thread`; a spec picks its own fid per
+ * test (the frames client remembers claimed boundaries per worker, and
+ * solid's fragment ledger keys by hydration id), and every key below is
+ * rebuilt from it — fids only ever appear inside prefix-scoped keys.
+ */
+export const FID = "hold/thread";
+
+/**
+ * The server's markup, in the three pieces the page emitted (scripts
+ * stripped): a keyed sibling BEFORE the frame (`_hk=0`), the frame, and a
+ * keyed sibling AFTER it. The server consumed two root ids for the
+ * component (`NoHydration`'s owner and the slot props' zone), so the
+ * trailing sibling is `_hk=3`. Specs compose the page they need; the frame's
+ * own keys are prefix-scoped (`sc-<fid>-<occurrence>-`) and the same in any
+ * composition.
+ */
+export const P_BEFORE = `<p _hk=0 class="after">after</p>`;
+export const frameHtml = (fid: string = FID) =>
+  `<solid-frame data-fid="${fid}" style="display:contents"><ul class="thread">` +
+  `<li><!--slot:comment#c1:start--><div _hk=sc-${fid}-comment#c1-0 class="c"><b>c1</b><!--$--><span _hk=sc-${fid}-comment#c1-2000 class="name">Ada</span><!--/--><button>0</button></div><!--slot:comment#c1:end--></li>` +
+  `<li><!--slot:note#0:start--><em _hk=sc-${fid}-note#0-0>n1</em><!--slot:note#0:end--></li>` +
+  `<li><!--slot:comment#c2:start--><div _hk=sc-${fid}-comment#c2-0 class="c"><b>c2</b><!--$--><span _hk=sc-${fid}-comment#c2-2000 class="name">Grace</span><!--/--><button>0</button></div><!--slot:comment#c2:end--></li>` +
+  `<li><!--slot:note#1:start--><em _hk=sc-${fid}-note#1-0>n2</em><!--slot:note#1:end--></li>` +
+  `</ul></solid-frame>`;
+export const FRAME_HTML = frameHtml();
+export const P_AFTER = `<p _hk=3 class="after">after</p>`;
+
+export const traceState = () =>
+  (globalThis as any)[Symbol.for("solid.container-trace-state")] as
+    | { materializeTrace?: Function }
+    | undefined;
+
+/** Whether the traces tier is resident in this worker (the runtime's own stamp). */
+export const traceTierResident = () => !!(tierLoads as any).trace?.r;
+
+export const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
+
+/** A settled `_fr` stamp, as the document's data script leaves one. */
+function settledFragment() {
+  const fr: any = Promise.resolve(true);
+  fr.s = 1;
+  fr.v = true;
+  return fr;
+}
+
+export interface Streams {
+  c1: any;
+  c2: any;
+}
+
+/**
+ * Install `_$HY` with the page's records. The traces are the caller's
+ * streams: `emit` decides which snapshots the document already delivered
+ * before hydration starts (the default: both, as the server's script does).
+ */
+export function installRecords(
+  options: { fid?: string; emit?: (s: Streams) => void; hy?: Record<string, any> } = {}
+): Streams {
+  const fid = options.fid ?? FID;
+  const streams: Streams = { c1: createStream(), c2: createStream() };
+  (globalThis as any)._$HY = {
+    events: [],
+    completed: new WeakSet(),
+    fe() {},
+    ...options.hy,
+    r: {
+      [`sc:slot:${fid}:comment#c1`]: { cid: "c1", user: { $tr: streams.c1, $ta: 0 } },
+      [`sc:slot:${fid}:note#0`]: { text: "n1" },
+      [`sc:slot:${fid}:comment#c2`]: { cid: "c2", user: { $tr: streams.c2, $ta: 0 } },
+      [`sc:slot:${fid}:note#1`]: { text: "n2" },
+      [`sc-${fid}-comment#c1-2_fr`]: settledFragment(),
+      [`sc-${fid}-comment#c2-2_fr`]: settledFragment()
+    }
+  };
+  if (options.emit) options.emit(streams);
+  else {
+    streams.c1.next({ name: "Ada" });
+    streams.c2.next({ name: "Grace" });
+    streams.c1.return(undefined);
+    streams.c2.return(undefined);
+  }
+  return streams;
+}
+
+/**
+ * A stand-in for the hydration runtime's fragment ledger (`_$HY.fr`): what
+ * the frames client subscribes to for reveals. Two uses here — a reveal
+ * re-indexes boundary elements (the frames client indexes the document ONCE
+ * per worker, so a second page in the same worker is invisible to
+ * `findBoundaryElement` until a reveal rescans), and a reveal re-drains the
+ * adopted boundary's records (the #2978 cascade), which record retention
+ * exercises.
+ */
+export function fakeLedger() {
+  const subs: ((id: string, parent?: ParentNode) => void)[] = [];
+  return {
+    ledger: {
+      subscribe(cb: (id: string, parent?: ParentNode) => void) {
+        subs.push(cb);
+        return () => {
+          const i = subs.indexOf(cb);
+          if (i >= 0) subs.splice(i, 1);
+        };
+      },
+      pending: () => false,
+      claim() {},
+      release() {}
+    },
+    reveal(parent: ParentNode) {
+      for (const cb of [...subs]) cb("reveal", parent);
+    },
+    get subscribers() {
+      return subs.length;
+    }
+  };
+}
+
+export function mountShell(html: string = P_BEFORE + FRAME_HTML): HTMLDivElement {
+  const container = document.createElement("div");
+  container.innerHTML = html;
+  document.body.appendChild(container);
+  return container;
+}
+
+/** The fills, verbatim from the server render (see the header). */
+export const mounts: { comment: string[]; note: string[]; stores: any[] } = {
+  comment: [],
+  note: [],
+  stores: []
+};
+export const commentFill = (p: any) => {
+  mounts.comment.push(untrack(() => p.cid));
+  mounts.stores.push(untrack(() => p.user));
+  const [n, setN] = createSignal(0);
+  return (
+    <div class="c">
+      <b>{p.cid}</b>
+      <Loading fallback={<i>…</i>}>
+        <span class="name">{p.user.name}</span>
+      </Loading>
+      <button onClick={() => setN(n() + 1)}>{n()}</button>
+    </div>
+  );
+};
+export const noteFill = (p: any) => {
+  mounts.note.push(untrack(() => p.text));
+  return <em>{p.text}</em>;
+};
+export const After = (props: { text: string }) => <p class="after">{props.text}</p>;
+
+export function resetMounts() {
+  mounts.comment.length = 0;
+  mounts.note.length = 0;
+  mounts.stores.length = 0;
+}
+
+/**
+ * The production frames client with the traces tier's LOAD gated by the
+ * test: `installServerComponents` with a `trace` loader whose import
+ * settles when `release()` says so — with the real tier module, so the
+ * install (the materializer onto the plugin's shared state, the shared
+ * host's `revive`) is production's. The frame holds a trace-carrying
+ * occurrence on this load exactly as it would on the chunk's fetch.
+ *
+ * Re-arms the tier if an earlier test in this worker installed it (one
+ * load per name per page in the runtime; the test seam drops it), so every
+ * spec file can hold as often as it needs. `loader` counts the asks: one
+ * per hold however many occurrences wait on it.
+ */
+export function gateTraceTier() {
+  delete (tierLoads as any).trace;
+  let resolve!: (m: { install(): void }) => void;
+  const promise = new Promise<{ install(): void }>(r => (resolve = r));
+  const loader = vi.fn(() => promise);
+  installServerComponents(undefined, { tiers: { trace: loader } });
+  const host = getFrameHost();
+  const release = async () => {
+    resolve(await import("../../frames/src/trace-tier.js"));
+    // The install and the frames' re-sync run on the load's continuation;
+    // give them the microtasks and a flush.
+    for (let i = 0; i < 10; i++) {
+      await Promise.resolve();
+      flush();
+    }
+  };
+  return { host, loader, release };
+}
+
+/**
+ * The resident configuration: the traces tier installed before `hydrate()`,
+ * as the production host has it once the load has settled (the real
+ * loader, or an earlier gate's module — either installs production's).
+ */
+export async function residentTraceTier() {
+  installServerComponents();
+  if (!traceTierResident()) {
+    // A previous gate may have left a pending loader entry; the real module
+    // settles it either way.
+    delete (tierLoads as any).trace;
+    installServerComponents(undefined, {
+      tiers: { trace: () => import("../../frames/src/trace-tier.js") }
+    });
+    await prepareTier("trace");
+  }
+  return getFrameHost();
+}
+
+export function captureWarnings() {
+  const warnings: string[] = [];
+  vi.spyOn(console, "warn").mockImplementation((...args: any[]) => {
+    warnings.push(args.map(String).join(" "));
+  });
+  vi.spyOn(console, "error").mockImplementation((...args: any[]) => {
+    warnings.push(args.map(String).join(" "));
+  });
+  return warnings;
+}
+
+/** Every server node of the page, in document order, for identity checks. */
+export function snapshotNodes(container: HTMLElement, fid: string = FID) {
+  return {
+    c1: container.querySelector(`[_hk="sc-${fid}-comment#c1-0"]`)!,
+    c1name: container.querySelector(`[_hk="sc-${fid}-comment#c1-2000"]`)!,
+    c2: container.querySelector(`[_hk="sc-${fid}-comment#c2-0"]`)!,
+    c2name: container.querySelector(`[_hk="sc-${fid}-comment#c2-2000"]`)!,
+    n0: container.querySelector(`[_hk="sc-${fid}-note#0-0"]`)!,
+    n1: container.querySelector(`[_hk="sc-${fid}-note#1-0"]`)!,
+    before: container.querySelector("p.after")!
+  };
+}
+
+/** The claim held: the same nodes, once each, nothing fresh beside them. */
+export function expectClaimed(
+  container: HTMLElement,
+  before: ReturnType<typeof snapshotNodes>,
+  fid: string = FID
+) {
+  const now = snapshotNodes(container, fid);
+  for (const key of Object.keys(before) as (keyof typeof before)[]) {
+    expect(now[key], key).toBe(before[key]);
+  }
+  expect(container.querySelectorAll(".c").length).toBe(2);
+  expect(container.querySelectorAll("em").length).toBe(2);
+  expect(container.querySelectorAll("span.name").length).toBe(2);
+  expect(container.querySelector("i")).toBe(null);
+}
+
+export function cleanupHold() {
+  vi.unstubAllGlobals();
+  vi.restoreAllMocks();
+  delete (globalThis as any)._$HY;
+  delete (globalThis as any)._$SC;
+  delete (globalThis as any).$R;
+  document.body.innerHTML = "";
+  resetMounts();
+}
diff --git a/packages/web/test/hydration/container-trace-hold-hydration-end.spec.tsx b/packages/web/test/hydration/container-trace-hold-hydration-end.spec.tsx
new file mode 100644
index 000000000..bd9bb8bdb
--- /dev/null
+++ b/packages/web/test/hydration/container-trace-hold-hydration-end.spec.tsx
@@ -0,0 +1,146 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * The traces tier's HOLD and hydration end — RE-PINNED under frames-rulings
+ * 3.1 (ruled 2026-10-05): hydration WAITS for the load; the mount claims
+ * BEFORE done.
+ *
+ * The frame holds a trace-carrying occurrence (server interior on screen)
+ * while the tier's chunk loads. The hold is one more reason in the frame's
+ * registered hold (3.2 — one `initBoundaryResume` registration per frame
+ * while a sync leaves an adopt-time occurrence waiting), so from solid's
+ * point of view hydration is still in progress: the root pass is over, but
+ * a pending boundary stands. `onHydrationEnd` does not fire, `_$HY.done`
+ * does not latch. The load settles, the late mount CLAIMS the server markup
+ * (the frames' scoped re-entry, `claimRender` — never a fresh render beside
+ * it), the hold releases, and only then is hydration done; the fill is
+ * live: the materialized store readable, handlers bound, the claimed
+ * sibling after the frame hydrated as normal.
+ *
+ * S1's original pin (`9927ddddd`) asserted the opposite order — done
+ * before the claim, the hold "a frame's business" — the private notion of
+ * done 3.1 rejects; the claim assertions are kept, the order inverted
+ * (3.1 "Consequences"; the plan's §3 row C3 and §5).
+ *
+ * The load is the test's (`gateTraceTier`); the production loader's path
+ * is `welcome-status-lazy.spec`. This spec pins the ORDERING against
+ * hydration end.
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createSignal, flush } from "solid-js";
+import { sharedConfig } from "solid-js/internal";
+import { hydrate } from "@solidjs/web";
+import {
+  After,
+  captureWarnings,
+  cleanupHold,
+  commentFill,
+  expectClaimed,
+  FID,
+  gateTraceTier,
+  installRecords,
+  mounts,
+  mountShell,
+  noteFill,
+  sleep,
+  snapshotNodes,
+  traceTierResident
+} from "./container-trace-hold-helpers.jsx";
+
+describe("container-trace hold vs hydration end (frames-rulings 3.1)", () => {
+  afterEach(cleanupHold);
+
+  test("hydration waits for the load; the late mount claims the server markup before done", async () => {
+    installRecords();
+    const container = mountShell();
+    const before = snapshotNodes(container);
+    const warnings = captureWarnings();
+    vi.stubGlobal("fetch", () => {
+      throw new Error("fetch must not be called");
+    });
+    const gated = gateTraceTier();
+    expect(traceTierResident()).toBe(false);
+
+    const [label, setLabel] = createSignal("after");
+    const Thread = (globalThis as any)._$SC.r(FID);
+    let mountsAtEnd = -1;
+    let inProgressAtEnd: boolean | undefined;
+    const dispose = hydrate(
+      () => (
+        <>
+          <After text={label()} />
+          <Thread comment={commentFill} note={noteFill} />
+        </>
+      ),
+      container
+    );
+    sharedConfig.onHydrationEnd!(() => {
+      mountsAtEnd = mounts.comment.length;
+      inProgressAtEnd = sharedConfig.isHydrationInProgress!();
+    });
+    flush();
+
+    // The root pass is over; the ordinary fills claimed in it; the two
+    // trace-carrying occurrences are HELD on the tier's load — asked once.
+    expect(gated.loader).toHaveBeenCalledTimes(1);
+    expect(mounts.note).toEqual(["n1", "n2"]);
+    expect(mounts.comment).toEqual([]);
+    expect(sharedConfig.hydrating).toBe(false);
+    // 3.1: the hold is a pending boundary — hydration is NOT done.
+    expect(sharedConfig.isHydrationInProgress!()).toBe(true);
+    await sleep(0);
+    flush();
+    expect(sharedConfig.isHydrationInProgress!()).toBe(true);
+    expect(mountsAtEnd).toBe(-1);
+    expect((globalThis as any)._$HY.done).toBeUndefined();
+    expect(warnings).toEqual([]);
+    // Still held: server interior untouched, the tier not resident.
+    expect(mounts.comment).toEqual([]);
+    expect(container.querySelector(`[_hk="sc-${FID}-comment#c1-0"]`)).toBe(before.c1);
+    expect(traceTierResident()).toBe(false);
+
+    // The load settles: the install, one flush per live frame, the mounts.
+    await gated.release();
+    await sleep(10);
+    flush();
+
+    // Mounted once each, as CLAIMS: every server node is still the node.
+    expect(traceTierResident()).toBe(true);
+    expect(mounts.comment).toEqual(["c1", "c2"]);
+    expect(mounts.note).toEqual(["n1", "n2"]);
+    expectClaimed(container, before);
+    expect(warnings).toEqual([]);
+
+    // The order 3.2 pins: the claims, then the hold's release, then done.
+    // At the end callback both fills had mounted; done came after them.
+    expect(mountsAtEnd).toBe(2);
+    expect(inProgressAtEnd).toBe(false);
+    expect(sharedConfig.isHydrationInProgress!()).toBe(false);
+    expect(sharedConfig.done).toBe(true);
+    expect((globalThis as any)._$HY.done).toBe(true);
+
+    // The materialized stores read (snapshot replayed from the stream).
+    expect(before.c1name.textContent).toBe("Ada");
+    expect(before.c2name.textContent).toBe("Grace");
+
+    // Interactive: the claimed buttons' handlers are bound; the claimed
+    // sibling beside the frame is live.
+    const buttons = container.querySelectorAll("button");
+    expect(buttons.length).toBe(2);
+    buttons[0].click();
+    flush();
+    buttons[1].click();
+    flush();
+    buttons[1].click();
+    flush();
+    expect(buttons[0].textContent).toBe("1");
+    expect(buttons[1].textContent).toBe("2");
+    setLabel("later");
+    flush();
+    expect(before.before.textContent).toBe("later");
+
+    dispose();
+    container.remove();
+  });
+});
diff --git a/packages/web/test/hydration/container-trace-hold-id-determinism.spec.tsx b/packages/web/test/hydration/container-trace-hold-id-determinism.spec.tsx
new file mode 100644
index 000000000..35e7b2a27
--- /dev/null
+++ b/packages/web/test/hydration/container-trace-hold-id-determinism.spec.tsx
@@ -0,0 +1,157 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * Hydration-id determinism across the HOLD. Two trace-carrying fills
+ * interleaved with two ordinary ones: the ordinary fills claim in the root
+ * pass, the trace fills after the tier's load. Every fill must claim its own
+ * markup, and the page must hydrate identically whether the traces tier was
+ * resident at t=0 or arrived late — fills claim under prefix-scoped owners
+ * (`sc-<fid>-<occurrence>-`, `claimRender`), so their keys never depend on
+ * the ambient counter; what COULD differ is what the component consumes
+ * from the ambient owner, which is the keyed siblings' business.
+ *
+ * The materializer's root used to be created under the reviving owner
+ * (`createRoot` inherits a child id), so a resident revival at t=0 consumed
+ * one root id PER TRACE and a late revival (no ambient owner) none — the
+ * sibling after the frame hydrated under a different key in the two runs.
+ * The root is detached (A2b's port of S1's fix): id-neutral at any time.
+ *
+ * Lazy and resident interleave freely here: the gate re-arms the tier.
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createSignal, flush } from "solid-js";
+import { hydrate } from "@solidjs/web";
+import {
+  After,
+  captureWarnings,
+  cleanupHold,
+  commentFill,
+  expectClaimed,
+  fakeLedger,
+  FID,
+  frameHtml,
+  gateTraceTier,
+  installRecords,
+  mounts,
+  mountShell,
+  noteFill,
+  P_AFTER,
+  P_BEFORE,
+  residentTraceTier,
+  sleep,
+  snapshotNodes
+} from "./container-trace-hold-helpers.jsx";
+
+describe("container-trace hold: id determinism", () => {
+  afterEach(cleanupHold);
+
+  let n = 0;
+  async function run(mode: "lazy" | "resident", tail: string, page: (T: any) => any) {
+    const fid = `${FID}/${mode}${++n}`;
+    const ledger = fakeLedger();
+    installRecords({ fid, hy: { fr: ledger.ledger } });
+    const container = mountShell(P_BEFORE + frameHtml(fid) + tail);
+    const before = snapshotNodes(container, fid);
+    const warnings = captureWarnings();
+    vi.stubGlobal("fetch", () => {
+      throw new Error("fetch must not be called");
+    });
+    const gated = mode === "lazy" ? gateTraceTier() : undefined;
+    if (!gated) await residentTraceTier();
+    // A second page in this worker: let the boundary index see it.
+    ledger.reveal(container);
+    const T = (globalThis as any)._$SC.r(fid);
+    const dispose = hydrate(() => page(T), container);
+    flush();
+    if (gated) {
+      // The pass claimed the ordinary fills and held the trace fills.
+      expect(mounts.note).toEqual(["n1", "n2"]);
+      expect(mounts.comment).toEqual([]);
+      expect(gated.loader).toHaveBeenCalledTimes(1);
+      await gated.release();
+    }
+    await sleep(10);
+    flush();
+    return { container, before, warnings, dispose, fid };
+  }
+
+  const [label] = createSignal("after");
+
+  test("lazy: ordinary fills claim in the pass, trace fills claim after the load", async () => {
+    const r = await run("lazy", "", T => (
+      <>
+        <After text={label()} />
+        <T comment={commentFill} note={noteFill} />
+      </>
+    ));
+    expect(mounts.comment).toEqual(["c1", "c2"]);
+    expect(mounts.note).toEqual(["n1", "n2"]);
+    expectClaimed(r.container, r.before, r.fid);
+    expect(r.before.before.textContent).toBe("after");
+    expect(r.warnings).toEqual([]);
+    r.dispose();
+  });
+
+  test("resident at t=0: the same claims, the same sibling key", async () => {
+    const r = await run("resident", "", T => (
+      <>
+        <After text={label()} />
+        <T comment={commentFill} note={noteFill} />
+      </>
+    ));
+    expect(mounts.comment).toEqual(["c1", "c2"]);
+    expect(mounts.note).toEqual(["n1", "n2"]);
+    expectClaimed(r.container, r.before, r.fid);
+    expect(r.warnings).toEqual([]);
+    r.dispose();
+  });
+
+  test("the materializer consumes no ambient id: a sibling AFTER the frame keys the same in both runs", async () => {
+    // One frame, two traces revived at t=0: with the old owned root the
+    // trailing sibling landed two ids further on than with no trace at
+    // all. Both runs must agree with each other; what they agree ON is the
+    // component's own consumption (see the `.fails` pin below).
+    const keys: string[] = [];
+    for (const mode of ["lazy", "resident"] as const) {
+      const r = await run(mode, P_AFTER, T => (
+        <>
+          <After text={label()} />
+          <T comment={commentFill} note={noteFill} />
+          <After text={label()} />
+        </>
+      ));
+      const miss = r.warnings.find(w => w.includes("Hydration key miss"));
+      keys.push(miss ? miss.match(/key miss for "([^"]+)"/)![1] : "claimed");
+      r.dispose();
+      cleanupHold();
+    }
+    expect(keys[0]).toBe(keys[1]);
+  });
+
+  // Frames-rulings 3.4 ("the client consumes what the server consumed"), the
+  // reading the plan's step C3 hands this pin to: pre-existing, independent
+  // of the hold — the server consumes root ids for the component
+  // (`NoHydration`'s owner in `serverOwned`, and more depending on position
+  // — one when the component is the first child, two after a keyed
+  // sibling), while the adopting client component consumes none, so a
+  // keyed sibling AFTER a document boundary misses its key. 3.4 decides it
+  // as a C10 parity bug to fix without a new ruling — once the server's
+  // consumption is pinned (it varies by position), possibly as server-side
+  // normalization. Not this step's; stays `.fails` until that fix (3c).
+  test.fails(
+    "a keyed sibling after the frame claims the server's node (frames-rulings 3.4)",
+    async () => {
+      const r = await run("resident", P_AFTER, T => (
+        <>
+          <After text={label()} />
+          <T comment={commentFill} note={noteFill} />
+          <After text={label()} />
+        </>
+      ));
+      expect(r.warnings).toEqual([]);
+      expect(r.container.querySelectorAll("p.after").length).toBe(2);
+      r.dispose();
+    }
+  );
+});
diff --git a/packages/web/test/hydration/container-trace-hold-interruption.spec.tsx b/packages/web/test/hydration/container-trace-hold-interruption.spec.tsx
new file mode 100644
index 000000000..2d58145cb
--- /dev/null
+++ b/packages/web/test/hydration/container-trace-hold-interruption.spec.tsx
@@ -0,0 +1,179 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * Interruptions DURING the hold. The frame holds a trace-carrying occurrence
+ * until the traces tier's load settles, then re-syncs (the install's flush of
+ * every live frame → `#syncSlots`). Three things can happen in between:
+ *
+ *  (a) the occurrence's record is REPLACED — a refetch of the same call
+ *      (a higher-version slot write), or an address switch re-binding the
+ *      frame to another call's store. The hold is the t=0 mount deferred, and
+ *      the outcome must be what a resident run shows: ONE mount — the claim,
+ *      with the record the server interior was rendered from (the held one,
+ *      `#heldRecords`) — followed by the replacement applied as the args
+ *      change it is, so the DOM ends on the new values. (Claiming with the
+ *      NEW args instead would trust markup rendered from the old ones; a
+ *      claim never rewrites a text hole, so every differing text would stay
+ *      stale for good — frames-rulings 3.6.);
+ *  (b) the frame is DISPOSED — the install's flush skips it (it left the
+ *      live set) and the settlement is a no-op (no mount, no error);
+ *  (c) two occurrences wait on the same load — one load per name
+ *      (`prepareTier` is idempotent), one re-sync, both mount.
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createSignal, flush } from "solid-js";
+import { hydrate } from "@solidjs/web";
+import { createStream } from "seroval";
+import {
+  After,
+  captureWarnings,
+  cleanupHold,
+  commentFill,
+  fakeLedger,
+  FID,
+  frameHtml,
+  gateTraceTier,
+  installRecords,
+  mounts,
+  mountShell,
+  noteFill,
+  P_BEFORE,
+  sleep,
+  snapshotNodes,
+  type Streams
+} from "./container-trace-hold-helpers.jsx";
+
+describe("container-trace hold: interruptions", () => {
+  afterEach(cleanupHold);
+
+  let n = 0;
+  function setup(emit?: (s: Streams) => void) {
+    const fid = `${FID}/int${++n}`;
+    const ledger = fakeLedger();
+    const streams = installRecords({ fid, emit, hy: { fr: ledger.ledger } });
+    const container = mountShell(P_BEFORE + frameHtml(fid));
+    const before = snapshotNodes(container, fid);
+    const warnings = captureWarnings();
+    vi.stubGlobal("fetch", () => {
+      throw new Error("fetch must not be called");
+    });
+    const gated = gateTraceTier();
+    ledger.reveal(container);
+    const T = (globalThis as any)._$SC.r(fid);
+    const [label] = createSignal("after");
+    const dispose = hydrate(
+      () => (
+        <>
+          <After text={label()} />
+          <T comment={commentFill} note={noteFill} />
+        </>
+      ),
+      container
+    );
+    flush();
+    // Held: ordinary fills claimed, trace fills waiting, the load asked once.
+    expect(mounts.note).toEqual(["n1", "n2"]);
+    expect(mounts.comment).toEqual([]);
+    expect(gated.loader).toHaveBeenCalledTimes(1);
+    return { fid, container, before, warnings, gated, dispose, streams };
+  }
+
+  test("(a) a refetch replaces the record while held: one mount (the claim, with the held args), then the replacement applies", async () => {
+    const s = setup();
+    // The refetch's stream (same call, next version — the store is one
+    // response's, frames-rulings 1.1 / 1.4: the bump replaces the records
+    // wholesale, so the response carries every occurrence's) — a new record
+    // for `comment#c1` (new args, a new trace), the others re-sent equal.
+    const v2 = createStream<any>();
+    v2.next({ name: "Ada (v2)" });
+    const refetch = [
+      { key: "comment#c1", args: { cid: "c1v2", user: { $tr: v2, $ta: 0 } } },
+      { key: "note#0", args: { text: "n1" } },
+      { key: "comment#c2", args: { cid: "c2", user: { $tr: s.streams.c2, $ta: 0 } } },
+      { key: "note#1", args: { text: "n2" } }
+    ];
+    for (const r of refetch)
+      s.gated.host.apply({ type: "slot", id: s.fid, version: 1, ...r } as any);
+    flush();
+    expect(mounts.comment).toEqual([]);
+
+    await s.gated.release();
+    await sleep(10);
+    flush();
+    // One mount per occurrence, with the HELD args (the claim); the
+    // replacement arrived as a props update, not a second mount.
+    expect(mounts.comment.sort()).toEqual(["c1", "c2"]);
+    // Claimed (the markup is the range's), updated to the new record's
+    // values by the live mount.
+    expect(s.container.querySelector(`[_hk="sc-${s.fid}-comment#c1-0"]`)).toBe(s.before.c1);
+    expect(s.before.c1.querySelector("b")!.textContent).toBe("c1v2");
+    expect(s.before.c1name.textContent).toBe("Ada (v2)");
+    expect(s.before.c2name.textContent).toBe("Grace");
+    expect(s.container.querySelectorAll(".c").length).toBe(2);
+    expect(s.warnings).toEqual([]);
+    s.dispose();
+  });
+
+  test("(a') an address switch re-binds the frame while held: the new address's record mounts, once", async () => {
+    const s = setup();
+    const address = `${s.fid}:switched`;
+    // The other call's store, warm: the full record set under its address.
+    const sw = createStream<any>();
+    sw.next({ name: "Switched" });
+    const seed = [
+      { key: "comment#c1", args: { cid: "c1s", user: { $tr: sw, $ta: 0 } } },
+      { key: "note#0", args: { text: "n1" } },
+      { key: "comment#c2", args: { cid: "c2", user: { $tr: s.streams.c2, $ta: 0 } } },
+      { key: "note#1", args: { text: "n2" } }
+    ];
+    for (const r of seed)
+      s.gated.host.apply({ type: "slot", id: address, version: 0, ...r } as any);
+    const frame = s.gated.host.get(s.fid)!;
+    expect(frame).toBeTruthy();
+    frame.rebind(address);
+    flush();
+    expect(s.gated.host.get(address)).toBe(frame);
+    expect(s.gated.host.get(s.fid)).toBeUndefined();
+    expect(mounts.comment).toEqual([]);
+
+    await s.gated.release();
+    await sleep(10);
+    flush();
+    expect(mounts.comment.sort()).toEqual(["c1", "c2"]);
+    expect(s.container.querySelector(`[_hk="sc-${s.fid}-comment#c1-0"]`)).toBe(s.before.c1);
+    expect(s.before.c1.querySelector("b")!.textContent).toBe("c1s");
+    expect(s.before.c1name.textContent).toBe("Switched");
+    expect(s.container.querySelectorAll(".c").length).toBe(2);
+    expect(s.warnings).toEqual([]);
+    s.dispose();
+  });
+
+  test("(b) the frame is disposed while held: the settlement is a no-op", async () => {
+    const s = setup();
+    s.dispose();
+    expect(s.gated.host.get(s.fid)).toBeUndefined();
+    await s.gated.release();
+    await sleep(10);
+    flush();
+    expect(mounts.comment).toEqual([]);
+    expect(s.warnings).toEqual([]);
+    s.container.remove();
+  });
+
+  test("(c) two occurrences on one load: one import, one re-sync, both mount", async () => {
+    const s = setup();
+    // Both occurrences were found held on every sync that saw them (the
+    // adopt sync and the registration-flush drain); `prepareTier` answered
+    // each ask with the same load.
+    expect(s.gated.loader).toHaveBeenCalledTimes(1);
+    await s.gated.release();
+    await sleep(10);
+    flush();
+    expect(mounts.comment).toEqual(["c1", "c2"]);
+    // Nothing asks again once the tier is resident.
+    expect(s.gated.loader).toHaveBeenCalledTimes(1);
+    expect(s.warnings).toEqual([]);
+    s.dispose();
+  });
+});
diff --git a/packages/web/test/hydration/container-trace-hold-record-retention.spec.tsx b/packages/web/test/hydration/container-trace-hold-record-retention.spec.tsx
new file mode 100644
index 000000000..f22c8ed63
--- /dev/null
+++ b/packages/web/test/hydration/container-trace-hold-record-retention.spec.tsx
@@ -0,0 +1,138 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * Record retention across the hold. The adopted boundary drains the
+ * document's `sc:slot:` records into the frame's store once per key
+ * (`adoptBoundary.drainRecords`, `appliedRecords`), and the frame keeps the
+ * record under `slot:<occurrence>` until the occurrence mounts or leaves.
+ * While an occurrence is HELD on the traces tier, the document keeps doing
+ * what it does:
+ *
+ *  - reveals re-drain (`fr.subscribe` → `drainRecords`) — the held key is
+ *    already applied, so the re-drain must neither re-apply nor drop it;
+ *  - a later data script pushes a NEW key into `_$HY.r` — the re-drain
+ *    applies that one, and only that one;
+ *  - the live channel (`sc:live`) re-sends the occurrence's record with the
+ *    same marker — a store write with equal args, which must not disturb
+ *    the hold or double-mount at release.
+ *
+ * At release the held occurrence mounts exactly once, from its record.
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createSignal, flush } from "solid-js";
+import { hydrate } from "@solidjs/web";
+import {
+  After,
+  captureWarnings,
+  cleanupHold,
+  commentFill,
+  expectClaimed,
+  fakeLedger,
+  FID,
+  frameHtml,
+  gateTraceTier,
+  installRecords,
+  mounts,
+  mountShell,
+  noteFill,
+  P_BEFORE,
+  sleep,
+  snapshotNodes
+} from "./container-trace-hold-helpers.jsx";
+
+describe("container-trace hold: record retention", () => {
+  afterEach(cleanupHold);
+
+  test("re-drains and a live re-send during the hold apply the held record once", async () => {
+    const fid = `${FID}/retain`;
+    const ledger = fakeLedger();
+    // The live channel, as the document's first script creates it: a
+    // ReadableStream of ops the client pumps.
+    let liveController!: ReadableStreamDefaultController<any>;
+    const live = new ReadableStream<any>({
+      start(c) {
+        liveController = c;
+      }
+    });
+    installRecords({ fid, hy: { fr: ledger.ledger } });
+    const hy = (globalThis as any)._$HY;
+    hy.r["sc:live"] = live;
+    const container = mountShell(P_BEFORE + frameHtml(fid));
+    const before = snapshotNodes(container, fid);
+    const warnings = captureWarnings();
+    vi.stubGlobal("fetch", () => {
+      throw new Error("fetch must not be called");
+    });
+    const gated = gateTraceTier();
+    // Count the slot applies the boundary routes into the store, by key.
+    const applied: Record<string, number> = {};
+    const origApply = gated.host.apply.bind(gated.host);
+    gated.host.apply = (chunk: any) => {
+      if (chunk.type === "slot") applied[chunk.key] = (applied[chunk.key] ?? 0) + 1;
+      return origApply(chunk);
+    };
+    ledger.reveal(container);
+    const T = (globalThis as any)._$SC.r(fid);
+    const [label] = createSignal("after");
+    const dispose = hydrate(
+      () => (
+        <>
+          <After text={label()} />
+          <T comment={commentFill} note={noteFill} />
+        </>
+      ),
+      container
+    );
+    flush();
+    expect(mounts.note).toEqual(["n1", "n2"]);
+    expect(mounts.comment).toEqual([]);
+    const drained = { ...applied };
+    expect(drained["comment#c1"]).toBe(1);
+    expect(drained["comment#c2"]).toBe(1);
+
+    // A reveal elsewhere in the page: the boundary re-drains. Nothing new
+    // for it, so nothing re-applies.
+    ledger.reveal(container);
+    flush();
+    expect(applied).toEqual(drained);
+
+    // A later data script lands a new key, and a reveal drains it: only
+    // the new key applies (it names no occurrence in the markup; it just
+    // sits in the store).
+    hy.r[`sc:slot:${fid}:comment#c9`] = { cid: "c9" };
+    ledger.reveal(container);
+    flush();
+    expect(applied["comment#c9"]).toBe(1);
+    expect(applied["comment#c1"]).toBe(1);
+    expect(applied["comment#c2"]).toBe(1);
+
+    // The live channel re-sends `comment#c1` with the same marker (the
+    // producer's end-of-stream flush does this on every page). Another
+    // store write — equal args — while the occurrence is still held.
+    const record = hy.r[`sc:slot:${fid}:comment#c1`];
+    liveController.enqueue({ type: "slot", fid, key: "comment#c1", args: { ...record } });
+    liveController.close();
+    await sleep(10);
+    flush();
+    expect(applied["comment#c1"]).toBe(2);
+    expect(mounts.comment).toEqual([]);
+    expect(container.querySelector(`[_hk="sc-${fid}-comment#c1-0"]`)).toBe(before.c1);
+
+    // Release: each held occurrence mounts exactly once, from its record.
+    await gated.release();
+    await sleep(10);
+    flush();
+    expect(mounts.comment).toEqual(["c1", "c2"]);
+    expectClaimed(container, before, fid);
+    expect(before.c1name.textContent).toBe("Ada");
+    expect(before.c2name.textContent).toBe("Grace");
+    // Settled: no further writes, no second mount.
+    await sleep(10);
+    flush();
+    expect(mounts.comment).toEqual(["c1", "c2"]);
+    expect(warnings).toEqual([]);
+    dispose();
+    container.remove();
+  });
+});
diff --git a/packages/web/test/hydration/container-trace-hold-snapshot.spec.tsx b/packages/web/test/hydration/container-trace-hold-snapshot.spec.tsx
new file mode 100644
index 000000000..fcc4b2b47
--- /dev/null
+++ b/packages/web/test/hydration/container-trace-hold-snapshot.spec.tsx
@@ -0,0 +1,197 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * Snapshot consistency across the hold. A trace is a seroval stream whose
+ * `.on()` replays its buffer synchronously at subscribe, so the store a late
+ * materialization builds is the fold of EVERYTHING the document delivered
+ * so far — the snapshot and every patch that landed while the load was
+ * pending — exactly the state a resident materializer would hold at the
+ * same point. Patches after that are live emissions either way.
+ *
+ * On SCREEN the two must agree too. The claim pass trusts the server's
+ * markup (a text hole is never rewritten during a claim), and the markup
+ * shows the SNAPSHOT — so the materializer, told it is read for a CLAIM
+ * (`revive(value, claiming)` from the adopt-time mount, frames-rulings 3.6
+ * (iii)), applies the snapshot at once and parks a replayed backlog beyond
+ * it until hydration ends, where the fill's reads re-run outside hydration
+ * and the DOM catches up (the store-shaped async-iterable hydration does the
+ * same with its buffered backlog). Both the late claim (under the tier's
+ * hold — the park releases after the hold, 3.2's order) and the resident
+ * t=0 claim go through that, so a trace past the markup renders its current
+ * state in either run.
+ *
+ * Two timelines, each run lazy (held) and resident, store state compared:
+ *  - "during": snapshot before hydrate; patches arrive during the wait
+ *    (resident: the same beats after its t=0 mount) — a live update there;
+ *  - "ahead": snapshot AND patches already delivered before hydrate (the
+ *    trace moved past the markup before the client booted).
+ */
+import { afterEach, describe, expect, test, vi } from "vitest";
+import { createSignal, flush } from "solid-js";
+import { materializeContainerTrace } from "solid-js/internal/container-trace";
+import { hydrate } from "@solidjs/web";
+import { createStream } from "seroval";
+import {
+  After,
+  captureWarnings,
+  cleanupHold,
+  commentFill,
+  expectClaimed,
+  fakeLedger,
+  FID,
+  frameHtml,
+  gateTraceTier,
+  installRecords,
+  mounts,
+  mountShell,
+  noteFill,
+  P_BEFORE,
+  residentTraceTier,
+  sleep,
+  snapshotNodes,
+  type Streams
+} from "./container-trace-hold-helpers.jsx";
+
+describe("container-trace hold: snapshot consistency", () => {
+  afterEach(cleanupHold);
+
+  let n = 0;
+  async function run(
+    mode: "lazy" | "resident",
+    emit: (s: Streams) => void,
+    duringWait: (s: Streams) => void
+  ) {
+    const fid = `${FID}/snap-${mode}${++n}`;
+    const ledger = fakeLedger();
+    const streams = installRecords({ fid, emit, hy: { fr: ledger.ledger } });
+    const container = mountShell(P_BEFORE + frameHtml(fid));
+    const before = snapshotNodes(container, fid);
+    const warnings = captureWarnings();
+    vi.stubGlobal("fetch", () => {
+      throw new Error("fetch must not be called");
+    });
+    const gated = mode === "lazy" ? gateTraceTier() : undefined;
+    if (!gated) await residentTraceTier();
+    ledger.reveal(container);
+    const T = (globalThis as any)._$SC.r(fid);
+    const [label] = createSignal("after");
+    const dispose = hydrate(
+      () => (
+        <>
+          <After text={label()} />
+          <T comment={commentFill} note={noteFill} />
+        </>
+      ),
+      container
+    );
+    flush();
+    if (gated) expect(mounts.comment).toEqual([]);
+    else expect(mounts.comment).toEqual(["c1", "c2"]);
+    // The wait: emissions land in the stream's buffer (lazy: nothing has
+    // subscribed yet; resident: the live store folds them as they come).
+    duringWait(streams);
+    flush();
+    if (gated) {
+      await gated.release();
+    }
+    await sleep(10);
+    flush();
+    expect(mounts.comment).toEqual(["c1", "c2"]);
+    expectClaimed(container, before, fid);
+    const store = mounts.stores[0];
+    return { fid, container, before, warnings, dispose, store, streams };
+  }
+
+  const snapshotOnly = (s: Streams) => {
+    s.c1.next({ name: "Ada", edits: 0 });
+    s.c2.next({ name: "Grace" });
+    s.c2.return(undefined);
+  };
+  const twoPatches = (s: Streams) => {
+    s.c1.next([[["edits"], 1]]);
+    s.c1.next([
+      [["name"], "Ada (edited)"],
+      [["edits"], 2]
+    ]);
+  };
+
+  test("patches arriving during the wait replay fully: the late store equals the resident one", async () => {
+    const lazy = await run("lazy", snapshotOnly, twoPatches);
+    expect(lazy.store.name).toBe("Ada (edited)");
+    expect(lazy.store.edits).toBe(2);
+    expect(lazy.before.c1name.textContent).toBe("Ada (edited)");
+    expect(lazy.warnings).toEqual([]);
+    // A patch after the mount is a live update on the same store.
+    lazy.streams.c1.next([[["name"], "Ada (live)"]]);
+    flush();
+    expect(lazy.store.name).toBe("Ada (live)");
+    expect(lazy.before.c1name.textContent).toBe("Ada (live)");
+    lazy.dispose();
+    cleanupHold();
+
+    const resident = await run("resident", snapshotOnly, twoPatches);
+    expect(resident.store.name).toBe("Ada (edited)");
+    expect(resident.store.edits).toBe(2);
+    expect(resident.before.c1name.textContent).toBe("Ada (edited)");
+    expect(resident.warnings).toEqual([]);
+    resident.dispose();
+  });
+
+  test("a trace already past the markup: the late store is the fold of all of it", async () => {
+    const ahead = (s: Streams) => {
+      snapshotOnly(s);
+      twoPatches(s);
+      s.c1.return(undefined);
+    };
+    const lazy = await run("lazy", ahead, () => {});
+    expect(lazy.store.name).toBe("Ada (edited)");
+    expect(lazy.store.edits).toBe(2);
+    // Mounted under the hold as a CLAIM: the fill read the snapshot ("Ada",
+    // the markup's text), the park released after the hold (3.2's order)
+    // and the hole caught up.
+    expect(lazy.before.c1name.textContent).toBe("Ada (edited)");
+    expect(lazy.warnings).toEqual([]);
+    lazy.dispose();
+    cleanupHold();
+
+    const resident = await run("resident", ahead, () => {});
+    expect(resident.store.name).toBe("Ada (edited)");
+    expect(resident.store.edits).toBe(2);
+    // The resident t=0 claim ran against markup showing "Ada"; the parked
+    // backlog applied at hydration end and the hole caught up.
+    expect(resident.before.c1name.textContent).toBe("Ada (edited)");
+    expect(resident.warnings).toEqual([]);
+    resident.dispose();
+  });
+
+  // The seam itself: only a CLAIM parks (keyed on the claim since the traces
+  // tier — plan step C3; frames-rulings 3.6 "Landed"). A trace materialized
+  // for a fresh mount (no server markup to agree with) is the fold of its
+  // whole backlog at once, no beat paid; one materialized for a claim
+  // outside the document's pass (a frame's late claim) shows the snapshot
+  // and folds on the next microtask.
+  test("the backlog parks for a claim only", async () => {
+    const ahead = () => {
+      const s = createStream();
+      s.next({ name: "Ada", edits: 0 });
+      s.next([[["edits"], 1]]);
+      s.next([
+        [["name"], "Ada (edited)"],
+        [["edits"], 2]
+      ]);
+      return s;
+    };
+    const fresh = materializeContainerTrace({ $tr: ahead() as any });
+    expect(fresh.name).toBe("Ada (edited)");
+    expect(fresh.edits).toBe(2);
+
+    const claimed = materializeContainerTrace({ $tr: ahead() as any }, true);
+    expect(claimed.name).toBe("Ada");
+    expect(claimed.edits).toBe(0);
+    await sleep(0);
+    flush();
+    expect(claimed.name).toBe("Ada (edited)");
+    expect(claimed.edits).toBe(2);
+  });
+});
diff --git a/packages/web/test/hydration/dynamic-component-parity-inline-via-dynamic.spec.tsx b/packages/web/test/hydration/dynamic-component-parity-inline-via-dynamic.spec.tsx
new file mode 100644
index 000000000..d67cfaaae
--- /dev/null
+++ b/packages/web/test/hydration/dynamic-component-parity-inline-via-dynamic.spec.tsx
@@ -0,0 +1,15 @@
+/**
+ * @jsxImportSource @solidjs/web
+ *
+ * The cross arm: the `dynamicComponent` document hydrated through `dynamic`
+ * — the two entry points share one owner shape, so a document either
+ * rendered is a document either hydrates. Inline variant. One page per
+ * file: the frames client's boundary index is module state. See
+ * ./dynamic-component-parity-run.tsx.
+ */
+import { test } from "vitest";
+import { runParity } from "./dynamic-component-parity-run.jsx";
+
+test("dynamicComponent document, hydrated through dynamic — inline", async () => {
+  await runParity("inline", "dynamic");
+});
diff --git a/packages/web/test/hydration/dynamic-component-parity-inline.spec.tsx b/packages/web/test/hydration/dynamic-component-parity-inline.spec.tsx
new file mode 100644
index 000000000..8c4ac8156
--- /dev/null
+++ b/packages/web/test/hydration/dynamic-component-parity-inline.spec.tsx
@@ -0,0 +1,14 @@
+/**
+ * @jsxImportSource @solidjs/web
+ *
+ * `dynamicComponent` hydrates the `dynamicComponent` document — a client
+ * component and a non-live server component, inline (settled before the
+ * shell flush). One page per file: the frames client's boundary index is
+ * module state. See ./dynamic-component-parity-run.tsx.
+ */
+import { test } from "vitest";
+import { runParity } from "./dynamic-component-parity-run.jsx";
+
+test("dynamicComponent document, hydrated through dynamicComponent — inline", async () => {
+  await runParity("inline", "dynamicComponent");
+});
diff --git a/packages/web/test/hydration/dynamic-component-parity-run.tsx b/packages/web/test/hydration/dynamic-component-parity-run.tsx
new file mode 100644
index 000000000..c913181f5
--- /dev/null
+++ b/packages/web/test/hydration/dynamic-component-parity-run.tsx
@@ -0,0 +1,167 @@
+/**
+ * @jsxImportSource @solidjs/web
+ *
+ * `dynamicComponent` — client half. Replays the artifacts
+ * test/server/dynamic-component-parity.spec.tsx wrote (the page rendered
+ * through the server `dynamicComponent`, asserted byte-identical to the
+ * server `dynamic`'s) and hydrates with EITHER client entry point:
+ * `dynamicComponent` (the documented server-component mount) and `dynamic`.
+ * Either must adopt the document — no hydration key miss, the same nodes for
+ * the client component, the frame and the article, the value memo's record
+ * adopted (`computes === 1`, no request) — and both client slots must be
+ * live after. One (variant, via) per spec file: the frames client's boundary
+ * index and claim set are module state.
+ */
+import { expect, vi } from "vitest";
+import { flush } from "solid-js";
+import { hydrate } from "@solidjs/web";
+import { installServerComponents } from "../../frames/src/client.js";
+import { createServerReference } from "../../server-functions/src/client.js";
+import { makeHost } from "../lifecycle-matrix/harness.js";
+import {
+  ARGS,
+  artifactFor,
+  fidFor,
+  makeApp,
+  type Variant,
+  type Via
+} from "../harness/dynamic-component-parity.jsx";
+import { applyChunk, drain } from "./frame-live-document-helpers.js";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const artifactsDir = resolve(dirname(fileURLToPath(import.meta.url)), "../harness/__artifacts__");
+function loadArtifact(name: string): { shell: string; rest: string } {
+  const file = resolve(artifactsDir, `${name}.json`);
+  if (!existsSync(file))
+    throw new Error(
+      `Missing artifact "${name}" — run the server spec first: ` +
+        `vitest run --config vite.config.server.mjs test/server/dynamic-component-parity.spec.tsx`
+    );
+  return JSON.parse(readFileSync(file, "utf-8"));
+}
+
+export async function runParity(variant: Variant, via: Via) {
+  const FID = fidFor(variant);
+  const { shell, rest } = loadArtifact(artifactFor(variant));
+  (globalThis as any)._$HY = { events: [], completed: new WeakSet(), r: {}, fe() {} };
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const { host } = makeHost();
+  installServerComponents(host);
+
+  const urls: string[] = [];
+  vi.stubGlobal("fetch", async (input: any) => {
+    urls.push(typeof input === "string" ? input : input.url);
+    throw new Error("unexpected fetch");
+  });
+
+  const note = createServerReference(FID);
+  let computes = 0;
+  const App = makeApp(via, () => {
+    computes++;
+    return note(...ARGS);
+  });
+
+  const shown: string[] = [];
+  const observe = () => {
+    const text = container.querySelector("main")?.textContent ?? container.textContent!;
+    if (shown[shown.length - 1] !== text) shown.push(text);
+  };
+  const mo = new MutationObserver(observe);
+
+  applyChunk(container, shell, true);
+  // `streamed`: the late fragment lands AFTER hydrate, below.
+  if (variant === "inline") applyChunk(container, rest, false);
+  mo.observe(container, { childList: true, subtree: true, characterData: true });
+  observe();
+
+  const nodes = () => ({
+    panel: container.querySelector("#panel"),
+    panelButton: container.querySelector("#panel-counter"),
+    frame: container.querySelector(`solid-frame[data-fid="${FID}"]`),
+    article: container.querySelector("#content"),
+    h1: container.querySelector("h1"),
+    noteButton: container.querySelector("#note-counter")
+  });
+  let before = nodes();
+  expect(before.panel, "client component in the document").not.toBeNull();
+
+  const warnings: string[] = [];
+  vi.spyOn(console, "warn").mockImplementation((...args: unknown[]) => {
+    warnings.push(args.map(String).join(" "));
+  });
+  const errors: string[] = [];
+  vi.spyOn(console, "error").mockImplementation((...args: unknown[]) => {
+    errors.push(args.map(String).join(" "));
+  });
+
+  const dispose = hydrate(() => <App />, container);
+  flush();
+  await drain();
+  observe();
+
+  if (variant === "streamed") {
+    expect(container.querySelector("h1")).toBeNull();
+    expect(container.querySelector("main")!.textContent).toContain("shell-fallback");
+    applyChunk(container, rest, false);
+    observe();
+    await drain();
+    observe();
+    before = nodes();
+  }
+
+  await drain();
+  observe();
+  const after = nodes();
+
+  console.log(`[${variant} via ${via}]`, {
+    computes,
+    urls,
+    warnings,
+    errors,
+    shown,
+    samePanel: after.panel === before.panel,
+    sameFrame: after.frame === before.frame,
+    sameArticle: after.article === before.article,
+    sameH1: after.h1 === before.h1,
+    html: container.innerHTML
+  });
+
+  expect(warnings.filter(w => w.includes("Hydration key miss"))).toEqual([]);
+  expect(errors).toEqual([]);
+  // The factory runs the source once (the hydration warm-up); the value
+  // memo adopts the server's record and never re-runs it.
+  expect(computes, "source runs once on the client").toBe(1);
+  expect(urls, "no request left the browser").toEqual([]);
+  // With the content in the document at hydration the boundary never
+  // selects its fallback (in `streamed` the server's own fallback is
+  // legitimately showing until the fragment lands).
+  if (variant === "inline") expect(shown.some(t => t.includes("shell-fallback"))).toBe(false);
+  expect(after.frame, "frame present").not.toBeNull();
+  expect(after.h1!.textContent).toBe("note v1");
+  expect(after.panel, "same client component node").toBe(before.panel);
+  expect(after.panelButton, "same client button node").toBe(before.panelButton);
+  expect(after.frame, "same frame node").toBe(before.frame);
+  expect(after.article, "same article node").toBe(before.article);
+  expect(after.h1, "same h1 node").toBe(before.h1);
+  expect(container.querySelector("main")!.textContent).not.toContain("shell-fallback");
+
+  // Interactivity: the client component's own state, and the client slot
+  // inside the server component.
+  (after.panelButton as HTMLButtonElement).click();
+  flush();
+  await drain();
+  expect(container.querySelector("#panel-counter")!.textContent).toBe("Panel: 1");
+  (after.noteButton as HTMLButtonElement).click();
+  flush();
+  await drain();
+  expect(container.querySelector("#note-counter")!.textContent).toBe("Count: 1");
+  expect(container.querySelector("#content")).toBe(after.article);
+  expect(container.querySelector("#panel")).toBe(after.panel);
+
+  mo.disconnect();
+  dispose();
+  container.remove();
+}
diff --git a/packages/web/test/hydration/dynamic-component-parity-streamed-via-dynamic.spec.tsx b/packages/web/test/hydration/dynamic-component-parity-streamed-via-dynamic.spec.tsx
new file mode 100644
index 000000000..076a14335
--- /dev/null
+++ b/packages/web/test/hydration/dynamic-component-parity-streamed-via-dynamic.spec.tsx
@@ -0,0 +1,14 @@
+/**
+ * @jsxImportSource @solidjs/web
+ *
+ * The cross arm, streamed: the `dynamicComponent` document hydrated through
+ * `dynamic`, the frame landing as a late fragment after hydrate. One page
+ * per file: the frames client's boundary index is module state. See
+ * ./dynamic-component-parity-run.tsx.
+ */
+import { test } from "vitest";
+import { runParity } from "./dynamic-component-parity-run.jsx";
+
+test("dynamicComponent document, hydrated through dynamic — streamed", async () => {
+  await runParity("streamed", "dynamic");
+});
diff --git a/packages/web/test/hydration/dynamic-component-parity-streamed.spec.tsx b/packages/web/test/hydration/dynamic-component-parity-streamed.spec.tsx
new file mode 100644
index 000000000..da8efca36
--- /dev/null
+++ b/packages/web/test/hydration/dynamic-component-parity-streamed.spec.tsx
@@ -0,0 +1,15 @@
+/**
+ * @jsxImportSource @solidjs/web
+ *
+ * `dynamicComponent` hydrates the `dynamicComponent` document — streamed
+ * variant: the fallback is in the shell, the frame lands as a late fragment
+ * after hydrate, with its `_fr` record. One page per file: the frames
+ * client's boundary index is module state. See
+ * ./dynamic-component-parity-run.tsx.
+ */
+import { test } from "vitest";
+import { runParity } from "./dynamic-component-parity-run.jsx";
+
+test("dynamicComponent document, hydrated through dynamicComponent — streamed", async () => {
+  await runParity("streamed", "dynamicComponent");
+});
diff --git a/packages/web/test/hydration/welcome-status-lazy.spec.tsx b/packages/web/test/hydration/welcome-status-lazy.spec.tsx
new file mode 100644
index 000000000..f3b4b5e50
--- /dev/null
+++ b/packages/web/test/hydration/welcome-status-lazy.spec.tsx
@@ -0,0 +1,23 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ *
+ * Lazy: the loaded document, hydrated with the traces tier NOT resident —
+ * the production wiring end to end: the shell's data script announces the
+ * tier (`_$HY.r["sc:tiers"] = ["trace"]`), `installServerComponents` starts
+ * the import from the record, the adopted boundary holds the `status#0`
+ * occurrence (its server-rendered interior stays on screen, the hold a
+ * pending boundary under frames-rulings 3.1) until the load settles, then
+ * mounts the fill, which claims the same server nodes in place: a late
+ * attach, never a re-render, and no key misses. One configuration per spec
+ * file — see welcome-status-parity.tsx for why (and a tier, once resident,
+ * stays so for the worker — the resident specs would pre-empt the hold).
+ */
+import { afterEach, describe, test } from "vitest";
+import { cleanupWelcomeStatusParity, runWelcomeStatusParity } from "./welcome-status-parity.jsx";
+
+describe("welcome/status parity — hydration (loaded, the traces tier loads lazily)", () => {
+  afterEach(cleanupWelcomeStatusParity);
+  test("the adopted fill is held until the tier loads, then claims the server nodes with no key misses", () =>
+    runWelcomeStatusParity("loaded", { lazy: true }));
+});
diff --git a/packages/web/test/hydration/welcome-status-parity.tsx b/packages/web/test/hydration/welcome-status-parity.tsx
index b574aa815..09ecf1a8a 100644
--- a/packages/web/test/hydration/welcome-status-parity.tsx
+++ b/packages/web/test/hydration/welcome-status-parity.tsx
@@ -16,18 +16,39 @@
  * paths the client allocates must be byte-identical to what the ssr compile
  * minted — any extra reactive scope the client wraps an arg read in shows up
  * as a hydration key miss and a re-rendered (or blank) range.
+ *
+ * The `usage` arg is a container trace, and the frames client loads the
+ * materializer as its TRACES TIER (`@solidjs/web/frames/trace`, through
+ * `prepareTier("trace")` — plan step C3). Two configurations, one per spec
+ * file:
+ *   - resident (default): the tier is installed before `hydrate()`, as the
+ *     production host has it once that load has settled — the claim walk
+ *     revives synchronously and the fill claims in the root pass;
+ *   - `lazy`: the production host wiring with nothing installed, the page
+ *     as the browser runs it — the shell's data script ANNOUNCES the tier
+ *     (`_$HY.r["sc:tiers"] = ["trace"]`, the artifact's), `installServer
+ *     Components` starts the import from the record before any boundary
+ *     adopts, and the adopt-time sync HOLDS the `status#0` occurrence
+ *     (server interior on screen; the frame's hold registered, hydration
+ *     not done — frames-rulings 3.1) until the load settles, then mounts
+ *     the fill, which claims the same nodes in place. Same assertions: the
+ *     attach is late, never a re-render.
  */
 import { expect, vi } from "vitest";
 import { existsSync, readFileSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { flush } from "solid-js";
+import { sharedConfig } from "solid-js/internal";
 import { hydrate } from "@solidjs/web";
 import { installServerComponents, createFrameHost } from "../../frames/src/client.js";
+import { prepareTier, tierLoads } from "../../frames/src/frame-client.js";
 import { createJSONDataTable } from "../../serialization/src/serializer.js";
 import { reviveContainerTraces } from "../../frames/src/frame-container-plugin.js";
 import { FID, statusFill } from "../harness/frames-welcome.jsx";
 
+const traceTierResident = () => !!(tierLoads as any).trace?.r;
+
 const artifactsDir = resolve(dirname(fileURLToPath(import.meta.url)), "../harness/__artifacts__");
 
 const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
@@ -81,7 +102,10 @@ export function cleanupWelcomeStatusParity() {
   document.body.innerHTML = "";
 }
 
-export async function runWelcomeStatusParity(mode: "loaded" | "streamed") {
+export async function runWelcomeStatusParity(
+  mode: "loaded" | "streamed",
+  options: { lazy?: boolean } = {}
+) {
   const { shell, rest } = loadArtifact(mode);
   const fid = FID(mode);
   const container = document.createElement("div");
@@ -90,19 +114,39 @@ export async function runWelcomeStatusParity(mode: "loaded" | "streamed") {
   vi.stubGlobal("fetch", () => {
     throw new Error("fetch must not be called");
   });
-  installServerComponents(makeHost());
 
   const warnings: string[] = [];
   vi.spyOn(console, "warn").mockImplementation((...args: any[]) => {
     warnings.push(args.map(String).join(" "));
   });
 
+  // The shell (its data scripts included) parses before the client entry
+  // runs, as in a browser; the lazy configuration depends on that order —
+  // the entry's `installServerComponents` reads the announcement the
+  // shell's script wrote.
   applyChunk(container, shell, true);
   if (mode === "loaded") applyChunk(container, rest, false);
 
+  if (options.lazy) {
+    expect(traceTierResident()).toBe(false);
+    // The document announced the tier (the artifact's record, minted where
+    // the sink serialized the trace — B's re-recorded fixture).
+    expect((globalThis as any)._$HY.r["sc:tiers"]).toEqual(["trace"]);
+    installServerComponents();
+    // The import started at install, from the record — before any boundary
+    // adopted (the production loader, through the test alias).
+    expect((tierLoads as any).trace).toBeTruthy();
+    expect(traceTierResident()).toBe(false);
+  } else {
+    installServerComponents(makeHost());
+    await prepareTier("trace");
+    expect(traceTierResident()).toBe(true);
+  }
+
   const frame = container.querySelector(`solid-frame[data-fid="${fid}"]`)!;
   const ssrStatus = container.querySelector(".status");
   expect(ssrStatus).toBeTruthy();
+  const ssrText = frame.textContent;
 
   const SC = (globalThis as any)._$SC.r(fid);
   const dispose = hydrate(() => <SC status={statusFill} />, container);
@@ -110,8 +154,22 @@ export async function runWelcomeStatusParity(mode: "loaded" | "streamed") {
   await Promise.resolve();
   flush();
 
+  if (options.lazy) {
+    // The hold: the root pass adopted the boundary with the tier absent, so
+    // `status#0` is not mounted yet and the server-rendered interior stands
+    // untouched — exactly what was on screen; the frame's hold is a pending
+    // boundary, so hydration is not done (3.1).
+    expect(frame.textContent).toBe(ssrText);
+    expect(sharedConfig.isHydrationInProgress!()).toBe(true);
+    // The load settles on its own schedule; wait for the install, then for
+    // the flush it triggers.
+    for (let i = 0; i < 200 && !traceTierResident(); i++) await sleep(10);
+    expect(traceTierResident()).toBe(true);
+  }
+
   if (mode === "streamed") applyChunk(container, rest, false);
   await settle();
+  if (options.lazy) expect(sharedConfig.isHydrationInProgress!()).toBe(false);
 
   if (process.env.DEBUG_DOM)
     process.stdout.write(
diff --git a/packages/web/test/lifecycle-matrix/MATRIX.md b/packages/web/test/lifecycle-matrix/MATRIX.md
index b635160cc..71f6b44a9 100644
--- a/packages/web/test/lifecycle-matrix/MATRIX.md
+++ b/packages/web/test/lifecycle-matrix/MATRIX.md
@@ -63,7 +63,7 @@ is mount-kind-independent; enumerated once where it is richest) · **existing**
 | `{$ref}` object args resolve via the streamed data table (rich values incl. Date) | `call-driven-args` › `call-driven/args/data-refs` | pass |
 | `{$ref}` re-sent, decodes EQUAL → adopted silently (no re-call, no props churn) | `call-driven-args` › `call-driven/args/data-refs` (same value) | pass |
 | `{$ref}` re-sent, decodes DIFFERENT → live-props update | `call-driven-args` › `call-driven/args/data-refs` (different value) | pass |
-| `{$frame}` region: streams into the wrapper; interior survives root morphs; REBINDS on wire-name change (new stream reaches the same element) | `call-driven-args` › `call-driven/args/regions` | pass |
+| `{$frame}` region: streams into the wrapper; interior survives root morphs; REBINDS on wire-name change (new stream reaches the same element) | `call-driven-args` › `call-driven/args/regions` | pass — with the frames client's REGIONS TIER resident (`@solidjs/web/frames/regions`, frames savings pass §3 row C4; warmed by `prepareTier("regions")` as the production host has it after the first record naming a region). The tier's load — the adopt-time hold under frames-rulings 3.1, the stream record pending until the install, the occluded `sc:region:` html seeding the bound frame — is pinned in `test/consistency/tier-regions-hold.spec.tsx` |
 | promise arg: read suspends on the fill's own `<Loading>`, settles on the patch record | `call-driven-args` › `call-driven/args/async-values` (promise) | pass |
 | async-iterable arg: read updates per yield; last value holds between yields | `call-driven-args` › `call-driven/args/async-values` (iterable) | pass |
 | async-occluded region records at adoption | — | existing — `frames-occlusion-client.spec.tsx` (sync + promise-valued `sc:region:` records) |
@@ -79,10 +79,23 @@ classification must never probe a pending container's properties (they
 throw not-ready) — containers test FIRST, by WeakSet, on both faces. The
 producer and server faces are pinned in `test/server/container-traces.spec.tsx`,
 the client faces in `container-args.spec.tsx`, and the materializer's unit semantics
-in solid `test/container-trace.spec.ts`.
+in solid `test/container-trace.spec.ts`. The materializer is the store engine's one
+edge into a server-component page, so the frames client carries the whole client half
+as its TRACES TIER (`@solidjs/web/frames/trace` — solid's materializer through its own
+`solid-js/internal/container-trace` entry, plus the plugin's revive walk), loaded
+through the tier mechanism (`prepareTier("trace")`): announced by the server where it
+serializes a trace, held on by the adopt-time sync otherwise (frames savings pass §3
+row C3). Those load paths are pinned in `test/frames-container-lazy-*.spec.tsx`,
+`test/hydration/welcome-status-lazy.spec.tsx`, the `test/hydration/container-trace-hold-*`
+specs and `test/consistency/tier-trace-hold.spec.tsx`; the cells below run with the
+tier resident.
 
 | Cell | Spec / test | Status |
 | --- | --- | --- |
+| codec face, tier not resident: the `data` chunk whose node tree carries the trace plugin's node announces `trace` (`chunk.tiers`) and the transport awaits the tier BEFORE the chunk decodes (the `{$ref}` resolves to a live store); a `data` chunk without one announces and loads nothing | `frames-container-lazy-codec` | pass |
+| document face, tier not resident: an adopted record's marker holds the occurrence (server interior on screen, no fill; the frame's hold a pending boundary — frames-rulings 3.1) until the load settles, then the fill mounts with the live store; nested references share it | `frames-container-lazy-document`, `consistency/tier-trace-hold` | pass |
+| document face under `hydrate()`, tier not resident, announced (`sc:tiers`): the import starts at install; the fill claims the server nodes in place after the load — no key misses, no re-render; hydration-done after the claim | `hydration/welcome-status-lazy` | pass |
+| held occurrence whose record a refetch replaced meanwhile: one mount, with the record it was HELD on (the claim), then the replacement as an args change | `hydration/container-trace-hold-interruption` (a, a'), `consistency/tier-trace-hold` | pass |
 | container `{$ref}` arg materializes live: reference synchronous, reads suspend until the snapshot, patch batches update granularly (sibling reads don't re-fire), trace end latches | `container-args` › `call-driven/args/containers` (materializes live) | pass — closed gap: the client's arg classification (`slotArgsProxy` async probe, `#refArgsUnchanged` compare) detonated pending containers; both now classify containers first, trap-safe |
 | updates flow through the store — never a re-call, node identity survives | `container-args` › `call-driven/args/containers` (materializes live) | pass |
 | one container, many references: every `{$ref}` to the same trace resolves to the SAME live store instance | `container-args` › `call-driven/args/containers` (two arg positions) | pass |
diff --git a/packages/web/test/lifecycle-matrix/call-driven-args.spec.tsx b/packages/web/test/lifecycle-matrix/call-driven-args.spec.tsx
index cee6eb030..cf25a85f0 100644
--- a/packages/web/test/lifecycle-matrix/call-driven-args.spec.tsx
+++ b/packages/web/test/lifecycle-matrix/call-driven-args.spec.tsx
@@ -5,14 +5,24 @@
 // Lifecycle matrix — mount kind: FRESH CALL-DRIVEN MOUNT, crossed with the
 // ARG TIER dimension: scalars ride the chunk, `{$ref}` args resolve against
 // the response's streamed data table (async values settle through patch
-// records), `{$frame}` args are nested server regions. See MATRIX.md.
-import { afterEach, describe, expect, test, vi } from "vitest";
+// records), `{$frame}` args are nested server regions — the frames client's
+// REGIONS TIER (`@solidjs/web/frames/regions`, frames savings pass §3 row
+// C4), fetched through `prepareTier("regions")` behind the server's
+// announcement or the first record naming a region. The region cell runs
+// with it RESIDENT (warmed below, as the production host has it after that
+// first load); the load itself — the hold, the buffered record — is pinned
+// in `test/consistency/tier-regions-hold.spec.tsx`. See MATRIX.md.
+import { afterEach, beforeAll, describe, expect, test, vi } from "vitest";
 import { createMemo, createRoot, createSignal, flush, Loading } from "solid-js";
 import { dynamic } from "../../src/index.js";
 import { installServerComponents } from "../../frames/src/client.js";
+import { prepareTier } from "../../frames/src/frame-client.js";
 import { createServerReference } from "../../server-functions/src/client.js";
 import { makeHost, frameResponse, dataChunks, createDataSource, pump, settle } from "./harness.js";
 
+// The regions tier, resident before any cell runs (see the header).
+beforeAll(() => prepareTier("regions"));
+
 const getScalars = createServerReference("matrix/args/scalars");
 const getRef = createServerReference("matrix/args/ref");
 const getRefSame = createServerReference("matrix/args/ref-same");
diff --git a/packages/web/test/lifecycle-matrix/call-driven-slots.spec.tsx b/packages/web/test/lifecycle-matrix/call-driven-slots.spec.tsx
index 27e47705a..5ab74ebc8 100644
--- a/packages/web/test/lifecycle-matrix/call-driven-slots.spec.tsx
+++ b/packages/web/test/lifecycle-matrix/call-driven-slots.spec.tsx
@@ -436,6 +436,14 @@ describe("call-driven/cleanup-disposal", () => {
   });
 });
 
+// A raw slot callback owns its range: it places its output before the
+// range's end marker over `ctx.existing` (the frame never writes an
+// interior — a Solid fill does the same through `insert`).
+function fillRange(ctx: any, node: Node) {
+  for (const n of ctx.existing) n.remove();
+  ctx.range.end.before(node);
+}
+
 describe("raw-frame/re-call-path", () => {
   // Through solid-web's slotsFor every invoked occurrence registers
   // ctx.onUpdate (live props), so a stream args-change NEVER re-calls there.
@@ -448,11 +456,11 @@ describe("raw-frame/re-call-path", () => {
       host,
       id: "raw/recall",
       slots: {
-        comment: (props: any) => {
+        comment: (props: any, ctx: any) => {
           calls.push(props.text);
           const li = document.createElement("li");
           li.textContent = props.text;
-          return li;
+          fillRange(ctx, li);
         }
       }
     });
@@ -505,7 +513,7 @@ describe("raw-frame/re-call-path", () => {
           ctx.onCleanup(() => cleaned.push(props.text));
           const li = document.createElement("li");
           li.textContent = props.text;
-          return li;
+          fillRange(ctx, li);
         }
       }
     });
diff --git a/packages/web/test/lifecycle-matrix/container-args.spec.tsx b/packages/web/test/lifecycle-matrix/container-args.spec.tsx
index f4b9c61f3..c7ed75780 100644
--- a/packages/web/test/lifecycle-matrix/container-args.spec.tsx
+++ b/packages/web/test/lifecycle-matrix/container-args.spec.tsx
@@ -18,12 +18,19 @@
 //
 // The producer halves (classification, envelope, wire shape) and real-core
 // server faces are pinned in `test/server/container-traces.spec.tsx`; the
-// materializer's
-// unit semantics in solid `test/container-trace.spec.ts`. See MATRIX.md.
+// materializer's unit semantics in solid `test/container-trace.spec.ts`; the
+// LOAD of the materializer — the frames client's traces tier
+// (`@solidjs/web/frames/trace`), fetched through `prepareTier("trace")`
+// behind the server's announcement or the first adopt-time record whose
+// args carry a trace — in `test/frames-container-lazy-*.spec.tsx` and the
+// `test/hydration/container-trace-hold-*` specs. These cells run with it
+// RESIDENT (warmed below, as the production host has it after that first
+// load) and pin what the two faces do with it. See MATRIX.md.
 import { afterAll, afterEach, beforeAll, describe, expect, test, vi } from "vitest";
 import { createMemo, createRoot, flush, Loading } from "solid-js";
 import { dynamic } from "../../src/index.js";
 import { installServerComponents } from "../../frames/src/client.js";
+import { prepareTier } from "../../frames/src/frame-client.js";
 import { createServerReference } from "../../server-functions/src/client.js";
 import {
   toBorderForm,
@@ -113,6 +120,8 @@ function mountUnderLoading(Comp: any, props: Record<string, any> = {}) {
 // before any runtime is resident).
 const adoptFid = "matrix/containers/adopt";
 const adoptProducer = traceProducer();
+// The traces tier, resident before any cell runs (see the header).
+beforeAll(() => prepareTier("trace"));
 beforeAll(() => {
   const marker = { $tr: adoptProducer.trace.subscribe(), $ta: 0 };
   document.body.innerHTML =
diff --git a/packages/web/test/preload-links-frame-client.spec.ts b/packages/web/test/preload-links-frame-client.spec.ts
index d245b3e09..b6fb05509 100644
--- a/packages/web/test/preload-links-frame-client.spec.ts
+++ b/packages/web/test/preload-links-frame-client.spec.ts
@@ -1,6 +1,20 @@
 /** @vitest-environment jsdom */
-import { afterEach, describe, expect, it } from "vitest";
-import { createFrame, createFrameHost } from "../frames/src/frame-client.js";
+import { afterEach, beforeAll, describe, expect, it } from "vitest";
+import {
+  createFrame,
+  createFrameHost,
+  prepareTier,
+  tierLoaders
+} from "../frames/src/frame-client.js";
+
+beforeAll(async () => {
+  // Preloads apply through the ASSETS TIER (`@solidjs/web/frames/assets`,
+  // frames savings pass §3 row C5); the client entry wires its loader in
+  // production — wire and warm it here, so these pins read a resident tier
+  // (the buffer-until-install arm is consistency/tier-assets-ready.spec).
+  tierLoaders.assets ??= () => import("../frames/src/assets-tier.js");
+  await prepareTier("assets");
+});
 
 afterEach(() => {
   document.head.replaceChildren();
diff --git a/packages/web/test/runtime/preload-links.spec.js b/packages/web/test/runtime/preload-links.spec.js
index 3dbc67cd3..fe21a1f2c 100644
--- a/packages/web/test/runtime/preload-links.spec.js
+++ b/packages/web/test/runtime/preload-links.spec.js
@@ -671,7 +671,10 @@ describe("typed preload links", () => {
         id: "late-links",
         version: 1,
         key: "",
-        preloads: [{ href: "/late-frame.webp", attrs: { as: "image", fetchpriority: "high" } }]
+        preloads: [{ href: "/late-frame.webp", attrs: { as: "image", fetchpriority: "high" } }],
+        // The first assets chunk of the stream, minted after the head left:
+        // it announces the `assets` tier in-band (frames savings pass §2).
+        tiers: ["assets"]
       }
     ]);
   });
diff --git a/packages/web/test/server-functions-live-loop.spec.tsx b/packages/web/test/server-functions-live-loop.spec.tsx
new file mode 100644
index 000000000..12a389695
--- /dev/null
+++ b/packages/web/test/server-functions-live-loop.spec.tsx
@@ -0,0 +1,459 @@
+/**
+ * `live()`'s reconnect loop, driven from the client side alone: a stubbed
+ * `fetch` answers each (re)connect with a body framed the way the server
+ * frames one — the codec's chunk stream, or the same payloads as server-sent
+ * events — and ENDS it the way the test says (cleanly, by dropping, or not
+ * at all until the request's signal aborts). The server suite drives the
+ * same loop end to end against the real handler; this one pins the loop's
+ * own branches, each from the consumer's side: first-connect failure vs
+ * post-connect death, the fail-fast 4xx set and its exceptions (408/425/429,
+ * Retry-After), the reader's cursor riding back as `Last-Event-ID`, the
+ * `online` wake, the consumer ending the iteration mid-connect and
+ * mid-backoff, a caller's signal (`invoke`) ending it for good, the GET
+ * composition, and the handler's local answers (a hit at the call, a
+ * deferred hit, a hit at connect).
+ */
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import {
+  GET,
+  configureServerFunctionsClient,
+  createServerReference,
+  getServerFunctionsCodec,
+  invoke,
+  live
+} from "../server-functions/src/client.js";
+import {
+  BODY_FORMAT_HEADER,
+  BodyFormat,
+  LAST_EVENT_ID_HEADER,
+  createChunk,
+  createEventChunk
+} from "../server-functions/src/shared.js";
+
+beforeEach(() => {
+  configureServerFunctionsClient({
+    endpoint: "/_server",
+    fetch: null as any,
+    prepareRequest: init => init,
+    responseHandler: null as any
+  });
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+  configureServerFunctionsClient({
+    endpoint: "/_server",
+    fetch: null as any,
+    prepareRequest: init => init,
+    responseHandler: null as any
+  });
+});
+
+const never = new Promise<never>(() => {});
+
+/** A source whose answer is `values`, then — unless `complete` — parks forever. */
+function source(values: unknown[], complete = false) {
+  return (async function* () {
+    for (const value of values) yield value;
+    if (!complete) await never;
+  })();
+}
+
+/**
+ * The codec's chunk payloads for `value`, as the server's encoder would
+ * frame them: collected until the encoder reports done, or — for a value
+ * that parks (an open stream) — until it goes quiet.
+ */
+async function payloads(value: unknown): Promise<string[]> {
+  const { serializeJSON } = await import("../serialization/src/serializer.js");
+  return new Promise((resolve, reject) => {
+    const out: string[] = [];
+    let quiet: ReturnType<typeof setTimeout> | undefined;
+    serializeJSON(value, {
+      ...getServerFunctionsCodec(),
+      onParse(node) {
+        out.push(JSON.stringify(node));
+        clearTimeout(quiet);
+        quiet = setTimeout(() => resolve(out), 20);
+      },
+      onDone() {
+        clearTimeout(quiet);
+        resolve(out);
+      },
+      onError: reject
+    });
+  });
+}
+
+type Framing = (payload: string, index: number) => Uint8Array;
+const chunked: Framing = payload => createChunk(payload);
+const events: Framing = (payload, index) => createEventChunk(payload, `ev-${index + 1}`);
+
+/**
+ * A live answer: the payloads, one per pull, then the body ends the way
+ * `end` says — "close" (the source completed), "error" (the connection
+ * dropped), "hang" (open until the request's signal aborts, as a real
+ * fetch's body would be).
+ */
+function answer(
+  payloads: string[],
+  framing: Framing,
+  end: "close" | "error" | "hang",
+  signal?: AbortSignal | null,
+  reason: unknown = new Error("connection lost")
+) {
+  let index = 0;
+  const body = new ReadableStream<Uint8Array>({
+    pull(controller) {
+      if (index < payloads.length) {
+        controller.enqueue(framing(payloads[index], index));
+        index++;
+        return;
+      }
+      if (end === "close") controller.close();
+      else if (end === "error") controller.error(reason);
+      else if (signal) {
+        if (signal.aborted) controller.error(signal.reason);
+        else
+          signal.addEventListener("abort", () => controller.error(signal.reason), { once: true });
+      }
+    }
+  });
+  return new Response(body, {
+    headers: {
+      "content-type": framing === events ? "text/event-stream" : "text/plain",
+      [BODY_FORMAT_HEADER]: BodyFormat.Serialized
+    }
+  });
+}
+
+/** The runtime's bodiless answer: a one-value stream of `undefined`. */
+const voidAnswer = () =>
+  new Response(null, { status: 204, headers: { [BODY_FORMAT_HEADER]: BodyFormat.Void } });
+
+/** A refusal: no runtime encoding at 4xx is the peer saying no. */
+const refusal = (status: number, headers: Record<string, string> = {}) =>
+  new Response(null, { status, headers });
+
+type Sent = { address: string; init: RequestInit; headers: Headers };
+
+/**
+ * A `fetch` answering each call from `answers` in order (the last one
+ * repeats), honoring the request's signal the way a real one does: an
+ * aborted signal rejects the call.
+ */
+function server(...answers: Array<(sent: Sent) => Response | Promise<Response>>) {
+  const calls: Sent[] = [];
+  vi.stubGlobal("fetch", (address: string, init: RequestInit) => {
+    const sent = { address, init, headers: new Headers(init.headers) };
+    calls.push(sent);
+    const signal = init.signal;
+    if (signal && signal.aborted) return Promise.reject(signal.reason);
+    return Promise.resolve(answers[Math.min(calls.length - 1, answers.length - 1)](sent));
+  });
+  return calls;
+}
+
+/** Status emissions, and (optionally) the `online` wake fired after each death. */
+function watch(iterable: any, wakeOnReconnect = false) {
+  const states: string[] = [];
+  const errors: unknown[] = [];
+  iterable.onstatus = (state: string, error?: unknown) => {
+    states.push(state);
+    if (error !== undefined) errors.push(error);
+    // The loop registers its `online` listener right after it announces
+    // the reconnect; the wake must land after that.
+    if (wakeOnReconnect && state === "reconnecting")
+      setTimeout(() => dispatchEvent(new Event("online")), 0);
+  };
+  return { states, errors };
+}
+
+async function drain(iterable: AsyncIterable<unknown>) {
+  const values: unknown[] = [];
+  for await (const value of iterable) values.push(value);
+  return values;
+}
+
+describe("live(): the loop from the consumer's side", () => {
+  test("live expects a server function reference", () => {
+    expect(() => live((() => {}) as any)).toThrow(/server function reference/);
+  });
+
+  test("a streamed answer flows to completion; the handler's onLive fires at the call, before the fetch", async () => {
+    const onLive = vi.fn();
+    // A handler with no intercept: the call has no local-answer seam.
+    configureServerFunctionsClient({ responseHandler: { onLive, handle: () => undefined } as any });
+    const calls = server(() => answer(body, chunked, "close"));
+    const body = await payloads(source([1, 2], true));
+    const src = live(createServerReference("loop/stream"));
+    const iterable = src();
+    expect(onLive).toHaveBeenCalledTimes(1);
+    expect(calls).toHaveLength(0);
+    const { states } = watch(iterable);
+
+    expect(await drain(iterable)).toEqual([1, 2]);
+    expect(calls).toHaveLength(1);
+    expect(calls[0].address).toBe("/_server/live/loop%2Fstream");
+    expect(calls[0].init.method).toBe("POST");
+    expect(states).toEqual(["connected", "closed"]);
+  });
+
+  test("a first-connect failure is the call's rejection — no status, no retry", async () => {
+    const calls = server(() => Promise.reject(new Error("refused")));
+    const iterable = live(createServerReference("loop/first"))();
+    const { states } = watch(iterable);
+    await expect(drain(iterable)).rejects.toThrow("refused");
+    expect(calls).toHaveLength(1);
+    expect(states).toEqual([]);
+  });
+
+  test("a death reconnects on the `online` wake, re-yielding the answer; the reader's cursor rides back as Last-Event-ID", async () => {
+    const body = await payloads(source([1, 2]));
+    const calls = server(
+      () => answer(body, events, "error"),
+      () => voidAnswer()
+    );
+    const iterable = live(createServerReference("loop/death"))();
+    const { states, errors } = watch(iterable, true);
+
+    expect(await drain(iterable)).toEqual([1, 2, undefined]);
+    expect(calls).toHaveLength(2);
+    expect(calls[0].headers.has(LAST_EVENT_ID_HEADER)).toBe(false);
+    expect(calls[1].headers.get(LAST_EVENT_ID_HEADER)).toBe(`ev-${body.length}`);
+    expect(states).toEqual(["connected", "reconnecting", "connected", "closed"]);
+    expect(errors).toHaveLength(1);
+    expect((errors[0] as Error).message).toBe("connection lost");
+  });
+
+  test("a 4xx on reconnect fails fast: the error surfaces, the iteration closes with it", async () => {
+    const body = await payloads(source([1]));
+    const calls = server(
+      () => answer(body, chunked, "error"),
+      () => refusal(403)
+    );
+    const iterable = live(createServerReference("loop/refused"))();
+    const { states, errors } = watch(iterable, true);
+    const values: unknown[] = [];
+    let failure: any;
+    try {
+      for await (const value of iterable) values.push(value);
+    } catch (error) {
+      failure = error;
+    }
+    expect(values).toEqual([1]);
+    expect(failure.status).toBe(403);
+    expect(calls).toHaveLength(2);
+    expect(states).toEqual(["connected", "reconnecting", "closed"]);
+    // the death's error, then the refusal closing it
+    expect(errors).toHaveLength(2);
+    expect(errors[1]).toBe(failure);
+  });
+
+  test.each([408, 425, 429])("%s on reconnect is transient: the loop retries", async status => {
+    const body = await payloads(source([1]));
+    const calls = server(
+      () => answer(body, chunked, "error"),
+      () => refusal(status),
+      () => voidAnswer()
+    );
+    const iterable = live(createServerReference(`loop/transient-${status}`))();
+    const { states } = watch(iterable, true);
+    expect(await drain(iterable)).toEqual([1, undefined]);
+    expect(calls).toHaveLength(3);
+    expect(states).toEqual(["connected", "reconnecting", "reconnecting", "connected", "closed"]);
+  });
+
+  test("Retry-After on a refusal names the wait and the loop honors it instead of failing fast", async () => {
+    const body = await payloads(source([1]));
+    const calls = server(
+      () => answer(body, chunked, "error"),
+      () => refusal(403, { "Retry-After": "0" }),
+      () => voidAnswer()
+    );
+    const iterable = live(createServerReference("loop/retry-after"))();
+    // no `online` wake: the named (zero) wait is what lets the retry go
+    const { states, errors } = watch(iterable, false);
+    const started = performance.now();
+    // the first death sleeps the backoff (500ms) unless woken — wake that
+    // one by hand, the Retry-After one must wake itself
+    iterable.onstatus = (state: string, error?: unknown) => {
+      states.push(state);
+      if (error !== undefined) errors.push(error);
+      if (state === "reconnecting" && states.filter(s => s === "reconnecting").length === 1)
+        setTimeout(() => dispatchEvent(new Event("online")), 0);
+    };
+    expect(await drain(iterable)).toEqual([1, undefined]);
+    expect(performance.now() - started).toBeLessThan(400);
+    expect(calls).toHaveLength(3);
+    expect((errors[1] as any).retryAfter).toBe(0);
+    expect(states).toEqual(["connected", "reconnecting", "reconnecting", "connected", "closed"]);
+  });
+
+  test("the consumer ending the iteration while connecting: the arriving stream is closed, the wire severed", async () => {
+    let release!: (response: Response) => void;
+    const calls = server(() => new Promise<Response>(resolve => (release = resolve)));
+    const body = await payloads(source([1], true));
+    const iterable = live(createServerReference("loop/return-connecting"))();
+    const { states } = watch(iterable);
+    const it = iterable[Symbol.asyncIterator]();
+    const pending = it.next();
+    while (!calls.length) await new Promise(resolve => setTimeout(resolve, 0));
+    expect(await it.return!(undefined)).toEqual({ done: true, value: undefined });
+    expect(calls[0].init.signal!.aborted).toBe(true);
+    release(answer(body, chunked, "close"));
+    expect(await pending).toEqual({ done: true, value: undefined });
+    expect(states).toEqual(["closed"]);
+  });
+
+  test("the consumer ending the iteration during the backoff: the sleep is cut, the loop exits", async () => {
+    const body = await payloads(source([1]));
+    const calls = server(() => answer(body, chunked, "error"));
+    const iterable = live(createServerReference("loop/return-backoff"))();
+    const reconnecting = new Promise<void>(resolve => {
+      iterable.onstatus = (state: string) => state === "reconnecting" && resolve();
+    });
+    const it = iterable[Symbol.asyncIterator]();
+    expect(await it.next()).toEqual({ done: false, value: 1 });
+    const pending = it.next();
+    await reconnecting;
+    expect(await it.return!(undefined)).toEqual({ done: true, value: undefined });
+    expect(await pending).toEqual({ done: true, value: undefined });
+    expect(calls).toHaveLength(1);
+  });
+
+  test("a caller's signal (invoke) aborting a connected stream ends the iteration for good, as a rejection", async () => {
+    const body = await payloads(source([1]));
+    const controller = new AbortController();
+    const calls = server(sent => answer(body, chunked, "hang", sent.init.signal));
+    const iterable = invoke(live(createServerReference("loop/invoke-abort")), {
+      signal: controller.signal
+    }) as any;
+    const { states, errors } = watch(iterable);
+    const it = iterable[Symbol.asyncIterator]();
+    expect(await it.next()).toEqual({ done: false, value: 1 });
+    const pending = it.next();
+    controller.abort(new Error("caller done"));
+    await expect(pending).rejects.toThrow("caller done");
+    expect(calls).toHaveLength(1);
+    expect(states).toEqual(["connected", "closed"]);
+    expect((errors[0] as Error).message).toBe("caller done");
+    // ended for good: the loop does not go on
+    expect(await it.next()).toEqual({ done: true, value: undefined });
+  });
+
+  test("a caller's signal aborting during the backoff wakes the sleep; the connect it would make rejects", async () => {
+    const body = await payloads(source([1]));
+    const controller = new AbortController();
+    const calls = server(() => answer(body, chunked, "error"));
+    const iterable = invoke(live(createServerReference("loop/invoke-backoff")), {
+      signal: controller.signal
+    }) as any;
+    const states: string[] = [];
+    iterable.onstatus = (state: string) => {
+      states.push(state);
+      if (state === "reconnecting") setTimeout(() => controller.abort(new Error("gone")), 0);
+    };
+    await expect(drain(iterable)).rejects.toThrow("gone");
+    // the sleep was cut by the abort; the reconnect's fetch saw the aborted signal
+    expect(calls).toHaveLength(2);
+    expect(calls[1].init.signal!.aborted).toBe(true);
+    expect(states).toEqual(["connected", "reconnecting", "closed"]);
+  });
+
+  test("a host without a global EventTarget: the backoff is a plain timer, no `online` wake to attach", async () => {
+    vi.stubGlobal("addEventListener", undefined);
+    vi.stubGlobal("removeEventListener", undefined);
+    const body = await payloads(source([1]));
+    // the drop names its wait so the test need not sit out the backoff
+    const dropped = Object.assign(new Error("lost"), { retryAfter: 0 });
+    const calls = server(
+      () => answer(body, chunked, "error", undefined, dropped),
+      () => voidAnswer()
+    );
+    const iterable = live(createServerReference("loop/no-event-target"))();
+    const { states } = watch(iterable);
+    expect(await drain(iterable)).toEqual([1, undefined]);
+    expect(calls).toHaveLength(2);
+    expect(states).toEqual(["connected", "reconnecting", "connected", "closed"]);
+  });
+
+  test("live(GET(fn)) connects through the declaration's channel, at the live address, over GET", async () => {
+    const calls = server(() => voidAnswer());
+    const iterable = live(GET(createServerReference("loop/get")))(7);
+    expect(await drain(iterable)).toEqual([undefined]);
+    expect(calls).toHaveLength(1);
+    expect(calls[0].init.method).toBe("GET");
+    expect(calls[0].address).toBe("/_server/live/loop%2Fget?args=%5B7%5D");
+  });
+
+  describe("the handler's local answer", () => {
+    test("a hit at the call is yielded first and marks the iteration adopted: the connect goes to the wire without asking again", async () => {
+      const intercept = vi.fn(() => ({ n: 1 }));
+      configureServerFunctionsClient({
+        responseHandler: { intercept, handle: () => undefined } as any
+      });
+      const calls = server(() => voidAnswer());
+      const iterable = live(createServerReference("loop/local-hit"))();
+      expect(intercept).toHaveBeenCalledTimes(1);
+      expect(await drain(iterable)).toEqual([{ n: 1 }, undefined]);
+      expect(intercept).toHaveBeenCalledTimes(1);
+      expect(calls).toHaveLength(1);
+    });
+
+    test("a deferred hit is awaited: a value lands first, nothing goes straight to the wire", async () => {
+      // answered at the call only (a boundary still arriving); the connect
+      // that follows a miss finds nothing local
+      const local = [Promise.resolve("doc"), Promise.resolve(undefined)];
+      configureServerFunctionsClient({
+        responseHandler: { intercept: () => local.shift(), handle: () => undefined } as any
+      });
+      const calls = server(() => voidAnswer());
+      expect(await drain(live(createServerReference("loop/local-deferred"))())).toEqual([
+        "doc",
+        undefined
+      ]);
+      expect(calls).toHaveLength(1);
+      // the next call's deferred answer settles to nothing: a miss after all
+      expect(await drain(live(createServerReference("loop/local-deferred"))())).toEqual([
+        undefined
+      ]);
+      expect(calls).toHaveLength(2);
+    });
+
+    test("the consumer ending the iteration while a deferred hit is pending: the answer, landing, is not yielded", async () => {
+      let land!: (value: unknown) => void;
+      configureServerFunctionsClient({
+        responseHandler: {
+          intercept: () => new Promise(resolve => (land = resolve)),
+          handle: () => undefined
+        } as any
+      });
+      const calls = server(() => voidAnswer());
+      const iterable = live(createServerReference("loop/local-returned"))();
+      const it = iterable[Symbol.asyncIterator]();
+      const pending = it.next();
+      expect(await it.return!(undefined)).toEqual({ done: true, value: undefined });
+      land("late");
+      expect(await pending).toEqual({ done: true, value: undefined });
+      expect(calls).toHaveLength(0);
+    });
+
+    test("a miss at the call but a hit at connect answers the connect locally: a one-value stream, no wire", async () => {
+      let asked = 0;
+      configureServerFunctionsClient({
+        responseHandler: {
+          intercept: () => (asked++ === 0 ? undefined : "local"),
+          handle: () => undefined
+        } as any
+      });
+      const calls = server(() => voidAnswer());
+      const iterable = live(createServerReference("loop/connect-hit"))();
+      const { states } = watch(iterable);
+      expect(await drain(iterable)).toEqual(["local"]);
+      expect(asked).toBe(2);
+      expect(calls).toHaveLength(0);
+      expect(states).toEqual(["connected", "closed"]);
+    });
+  });
+});
diff --git a/packages/web/test/server/dynamic-component-parity.spec.tsx b/packages/web/test/server/dynamic-component-parity.spec.tsx
new file mode 100644
index 000000000..7e229dfd4
--- /dev/null
+++ b/packages/web/test/server/dynamic-component-parity.spec.tsx
@@ -0,0 +1,119 @@
+/**
+ * @jsxImportSource @solidjs/web
+ */
+// `dynamicComponent` — server half. The page of
+// test/harness/dynamic-component-parity.tsx rendered through `dynamic` and
+// through `dynamicComponent` over the in-process answer of a NON-LIVE server
+// component (a promise of the component wrapped by
+// `frameTransformDirectResult`) and a sync client component. The two
+// documents must be byte-identical: the entry points share one
+// implementation with one owner shape (factory / value / render memo), so
+// the hydration keys, the frame markup and the `_fr` record all agree.
+// Writes the chunk artifacts test/hydration/dynamic-component-parity.spec.tsx
+// replays (from the `dynamicComponent` render — the documented mount).
+import { describe, expect, test } from "vitest";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { renderToStream } from "@solidjs/web";
+import { frameTransformDirectResult, ServerComponentPlugin } from "../../frames/src/frame-sink.js";
+import {
+  ARGS,
+  VARIANTS,
+  VIAS,
+  artifactFor,
+  fidFor,
+  makeApp,
+  makeNoteComponent,
+  type Via
+} from "../harness/dynamic-component-parity.jsx";
+
+const artifactsDir = resolve(dirname(fileURLToPath(import.meta.url)), "../harness/__artifacts__");
+mkdirSync(artifactsDir, { recursive: true });
+
+const sleep = (ms: number) => new Promise<void>(r => setTimeout(r, ms));
+
+function collectChunks(code: () => any): Promise<{ shell: string; rest: string }> {
+  return new Promise(resolvePromise => {
+    const chunks: string[] = [];
+    let shell = "";
+    let shellDone = false;
+    renderToStream(code, {
+      plugins: [ServerComponentPlugin],
+      onCompleteShell() {
+        shellDone = true;
+      }
+    } as any).pipe({
+      write(chunk: string) {
+        chunks.push(chunk);
+        if (shellDone && !shell) shell = chunks.join("");
+      },
+      end() {
+        const full = chunks.join("");
+        if (!shell) shell = full;
+        resolvePromise({ shell, rest: full.slice(shell.length) });
+      }
+    });
+  });
+}
+
+const visibleText = (html: string) =>
+  html.replace(/<script[\s\S]*?<\/script>/g, "").replace(/<[^>]*>/g, "");
+// The `_hk` family — the framework's hydration keys (`ssrHydrationKey`), one
+// per claimable element, including the memo-derived paths under each mount.
+const hydrationKeys = (html: string) => [...html.matchAll(/ _hk=([^ >]+)/g)].map(m => m[1]);
+
+describe("dynamicComponent — the server twin renders exactly what dynamic renders", () => {
+  for (const variant of VARIANTS) {
+    const FID = fidFor(variant);
+    test(`${variant}: same document, same hydration keys; writes the artifact`, async () => {
+      const Inline = frameTransformDirectResult(makeNoteComponent("note v1"), {
+        id: FID,
+        args: ARGS
+      }) as any;
+      const source =
+        variant === "inline"
+          ? () => Promise.resolve(Inline)
+          : async () => {
+              await sleep(5);
+              return Inline;
+            };
+
+      const rendered = {} as Record<Via, { shell: string; rest: string }>;
+      for (const via of VIAS) {
+        const App = makeApp(via, source);
+        rendered[via] = await collectChunks(() => <App />);
+        const full = rendered[via].shell + rendered[via].rest;
+        console.log(
+          `${FID} via ${via} SHELL:\n${rendered[via].shell}\n\nREST:\n${rendered[via].rest}`
+        );
+
+        expect(visibleText(full)).toContain("client");
+        expect(visibleText(full)).toContain("note v1");
+        expect(full).toContain(`data-fid="${FID}"`);
+        if (variant === "inline") {
+          expect(visibleText(rendered[via].shell)).not.toContain("shell-fallback");
+          expect(rendered[via].rest).toBe("");
+        } else {
+          expect(visibleText(rendered[via].shell)).toContain("shell-fallback");
+          expect(rendered[via].rest).toContain(`data-fid="${FID}"`);
+        }
+      }
+
+      // Same hydration keys (the owner shape), stated on their own before
+      // the byte-for-byte comparison says the same thing less legibly.
+      expect(
+        hydrationKeys(rendered.dynamicComponent.shell + rendered.dynamicComponent.rest)
+      ).toEqual(hydrationKeys(rendered.dynamic.shell + rendered.dynamic.rest));
+      expect(hydrationKeys(rendered.dynamic.shell).length).toBeGreaterThan(0);
+      expect(rendered.dynamicComponent.shell).toBe(rendered.dynamic.shell);
+      expect(rendered.dynamicComponent.rest).toBe(rendered.dynamic.rest);
+
+      const { shell, rest } = rendered.dynamicComponent;
+      writeFileSync(
+        resolve(artifactsDir, `${artifactFor(variant)}.json`),
+        JSON.stringify({ name: artifactFor(variant), shell, rest }, null, 2)
+      );
+    });
+  }
+});
diff --git a/packages/web/test/server/frame-binding-slots.spec.tsx b/packages/web/test/server/frame-binding-slots.spec.tsx
index a5760faa3..b6bb2b2aa 100644
--- a/packages/web/test/server/frame-binding-slots.spec.tsx
+++ b/packages/web/test/server/frame-binding-slots.spec.tsx
@@ -771,18 +771,18 @@ describe("binding slots — document face (t=0)", () => {
       '<li class="todo completed" _s:class="row#2:done=completed,row#2:editing=editing" hidden _s:hidden="row#2:removed">'
     );
     expect(html).toContain(
-      '<input type="checkbox" _s:checked="row#1:done" _s:on:input="row#1:toggle" _s:ref="row#1:checkbox">'
+      '<input type="checkbox" _s:checked="row#1:done" _s:on:input="row#1:toggle" _s:ref="row#1:checkbox" _hk>'
     );
     expect(html).toContain(
-      '<input type="checkbox" checked _s:checked="row#2:done" _s:on:input="row#2:toggle" _s:ref="row#2:checkbox">'
+      '<input type="checkbox" checked _s:checked="row#2:done" _s:on:input="row#2:toggle" _s:ref="row#2:checkbox" _hk>'
     );
     expect(html).toContain('<label _s:style="row#1:opacity=opacity">a</label>');
     expect(html).toContain('<label style="opacity:0.5" _s:style="row#2:opacity=opacity">b</label>');
     expect(html).toContain(
-      '<button class="destroy" _s:class="row#1:buttonClass" _s:aria-busy="row#1:busy" _s:on:click="row#1:remove">×</button>'
+      '<button class="destroy" _s:class="row#1:buttonClass" _s:aria-busy="row#1:busy" _s:on:click="row#1:remove" _hk>×</button>'
     );
     expect(html).toContain(
-      '<button class="destroy done" _s:class="row#2:buttonClass" aria-busy _s:aria-busy="row#2:busy" _s:on:click="row#2:remove">×</button>'
+      '<button class="destroy done" _s:class="row#2:buttonClass" aria-busy _s:aria-busy="row#2:busy" _s:on:click="row#2:remove" _hk>×</button>'
     );
     // Handlers and refs never serialize or run on the server.
     expect(html).not.toContain("toggle:");
@@ -793,6 +793,46 @@ describe("binding slots — document face (t=0)", () => {
     expect(findings()).toEqual([]);
   });
 
+  it("the replay-window stamp: a bare ` _hk` on the document face's EVENT-slot consumers only — not on a ref-only or attribute-only consumer, never on the stream face", async () => {
+    // The bootstrap queues a delegated event only under an `_hk` ancestor
+    // (frames savings pass §1, bind row): the element whose handler the
+    // bind tier installs must carry one, or a click before the tier lands
+    // is lost. Bare — no key: nothing gathers it, nothing claims it, the
+    // dev completion sweep passes over it once the tier marks it completed.
+    // Ref-only and attribute-only consumers queue nothing, and carry nothing.
+    // The stream face: the bootstrap stopped queueing at `_$HY.done`, so a
+    // response's html has no window to keep open.
+    const ServerComp = (props: any) => {
+      const block = props.codeBlock();
+      return (
+        <div>
+          <button onClick={block.copy} class={block.cls}>
+            Copy
+          </button>
+          <span ref={block.el} />
+          <i aria-busy={block.busy}>…</i>
+        </div>
+      );
+    };
+    const fill = () => ({ copy: () => {}, cls: "c", el: () => {}, busy: true });
+    const Inline = frameTransformDirectResult(ServerComp, { id: "dsd0h" }) as any;
+    const html = plain(await document(() => Inline({ codeBlock: fill })));
+    expect(html).toContain(
+      '<button class="c" _s:class="codeBlock:cls" _s:on:click="codeBlock:copy" _hk>Copy</button>'
+    );
+    expect(html).toContain('<span _s:ref="codeBlock:el"></span>');
+    expect(html).toContain('<i aria-busy _s:aria-busy="codeBlock:busy">…</i>');
+    // Four bytes per stamped element, no key to allocate or gather.
+    expect(html.match(/ _hk[ >]/g)).toHaveLength(1);
+    const chunks = await collect(renderServerComponent(ServerComp, { frame: { id: "ds0h" } }));
+    const stream = plain(chunks.find(c => c.type === "html").html);
+    expect(stream).toContain(
+      '<button _s:class="codeBlock:cls" _s:on:click="codeBlock:copy">Copy</button>'
+    );
+    expect(stream).not.toContain("_hk");
+    expect(findings()).toEqual([]);
+  });
+
   it("a `$key`ed call in a component prop runs the fill ONCE and emits ONE record at t=0", async () => {
     const ServerComp = (props: any) => (
       <ul>
@@ -815,7 +855,7 @@ describe("binding slots — document face (t=0)", () => {
     const html = plain(await document(() => Inline({ row: fill })));
     expect(fill).toHaveBeenCalledTimes(2);
     expect(html).toContain(
-      '<li class="todo done" _s:class="row#2:done=done" _s:hidden="row#2:removed"><input type="checkbox" checked _s:checked="row#2:done" _s:on:input="row#2:toggle"><label>b</label><button _s:on:click="row#2:remove">×</button></li>'
+      '<li class="todo done" _s:class="row#2:done=done" _s:hidden="row#2:removed"><input type="checkbox" checked _s:checked="row#2:done" _s:on:input="row#2:toggle" _hk><label>b</label><button _s:on:click="row#2:remove" _hk>×</button></li>'
     );
     expect(html.match(/sc:slot:dsd0k:row#1"/g)).toHaveLength(1);
     expect(html.match(/sc:slot:dsd0k:row#2"/g)).toHaveLength(1);
@@ -848,7 +888,7 @@ describe("binding slots — document face (t=0)", () => {
     expect(fill).toHaveBeenCalledTimes(2);
     expect(badge).toHaveBeenCalledTimes(2);
     expect(html).toContain(
-      '<li class="todo done" _s:class="row#1:done=done" _s:hidden="row#1:removed"><input type="checkbox" checked _s:checked="row#1:done" _s:on:input="row#1:toggle"><label>b</label><button _s:on:click="row#1:remove">×</button></li>'
+      '<li class="todo done" _s:class="row#1:done=done" _s:hidden="row#1:removed"><input type="checkbox" checked _s:checked="row#1:done" _s:on:input="row#1:toggle" _hk><label>b</label><button _s:on:click="row#1:remove" _hk>×</button></li>'
     );
     expect(html.match(/sc:slot:dsd0u:row#0"/g)).toHaveLength(1);
     expect(html.match(/sc:slot:dsd0u:row#1"/g)).toHaveLength(1);
@@ -882,7 +922,7 @@ describe("binding slots — document face (t=0)", () => {
     expect(fill).toHaveBeenCalledTimes(1);
     expect(note).toHaveBeenCalledTimes(2);
     expect(html).toContain(
-      '<button class="c" _s:class="codeBlock:cls" _s:on:click="codeBlock:copy">Copy</button><button _s:on:click="codeBlock:copy" _s:ref="codeBlock:el">Copy too</button>'
+      '<button class="c" _s:class="codeBlock:cls" _s:on:click="codeBlock:copy" _hk>Copy</button><button _s:on:click="codeBlock:copy" _s:ref="codeBlock:el" _hk>Copy too</button>'
     );
     expect(html.match(/<!--slot:note:start--><b[^>]*>new<\/b><!--slot:note:end-->/g)).toHaveLength(
       2
@@ -928,7 +968,7 @@ describe("binding slots — document face (t=0)", () => {
       ])
     );
     expect(seen).toEqual([undefined, undefined]);
-    expect(html).toContain('<button type="button" _s:on:click="codeBlock:copy">Copy</button>');
+    expect(html).toContain('<button type="button" _s:on:click="codeBlock:copy" _hk>Copy</button>');
     expect(html).toMatch(/<div _hk=\d+ class="a"><\/div>/);
     expect(findings()).toEqual([]);
   });
diff --git a/packages/web/test/server/frame-hn.spec.tsx b/packages/web/test/server/frame-hn.spec.tsx
index 5c45042b1..583d87664 100644
--- a/packages/web/test/server/frame-hn.spec.tsx
+++ b/packages/web/test/server/frame-hn.spec.tsx
@@ -12,7 +12,7 @@
 // serialization between html and slot args (transport dispatch case
 // 1) — and the request carries only the story id (client collapse state is
 // server-invisible).
-import { describe, expect, it } from "vitest";
+import { beforeAll, describe, expect, it } from "vitest";
 // @ts-expect-error jsdom ships no types; used only to fabricate a document
 import { JSDOM } from "jsdom";
 globalThis.document = new JSDOM("<body></body>").window.document;
@@ -24,7 +24,29 @@ import {
   registerServerFunction
 } from "../../server-functions/src/server.js";
 import { createJSONDataTable } from "../../serialization/src/serializer.js";
-import { createFrame, createFrameHost } from "../../frames/src/frame-client.js";
+import {
+  createFrame,
+  createFrameHost,
+  prepareTier,
+  tierLoaders
+} from "../../frames/src/frame-client.js";
+
+// The client half here is the frame RUNTIME alone (frame-client.ts), not
+// the frames client entry — so the entry's built-in tier loaders are not
+// registered. The nested regions this slice is about are the REGIONS TIER's
+// (`@solidjs/web/frames/regions`, frames savings pass §3 row C4): wire its
+// loader as the entry does and warm it, so every region binds as it would
+// on a page that announced it.
+tierLoaders.regions = () => import("../../frames/src/regions-tier.js");
+beforeAll(() => prepareTier("regions"));
+
+// A raw slot callback owns its range: it places its output before the
+// range's end marker over `ctx.existing` (the frame never writes an
+// interior — the Solid binding does the same through `insert`).
+function fillRange(ctx: any, node: Node) {
+  for (const n of ctx.existing) n.remove();
+  ctx.range.end.before(node);
+}
 
 type CommentData = { id: number; text: string; replies: CommentData[] };
 
@@ -130,7 +152,7 @@ describe("HN slice — the no-double-serialization proof over the real wire", ()
       host,
       id: "story-pane",
       slots: {
-        comment: (p: any) => {
+        comment: (p: any, ctx: any) => {
           const wrap = document.createElement("div");
           wrap.className = "comment";
           wrap.dataset.cid = String(p.cid);
@@ -138,7 +160,7 @@ describe("HN slice — the no-double-serialization proof over the real wire", ()
           toggle.className = "collapse";
           toggle.addEventListener("click", () => wrap.classList.toggle("collapsed"));
           wrap.append(toggle, p.children);
-          return wrap;
+          fillRange(ctx, wrap);
         }
       }
     });
@@ -164,11 +186,11 @@ describe("HN slice — the no-double-serialization proof over the real wire", ()
       host,
       id: "story-pane",
       slots: {
-        comment: (p: any) => {
+        comment: (p: any, ctx: any) => {
           const wrap = document.createElement("div");
           wrap.className = "comment collapsed-by-default";
           wrap.appendChild(p.children);
-          return wrap;
+          fillRange(ctx, wrap);
         }
       }
     });
diff --git a/packages/web/test/server/tier-announce.spec.tsx b/packages/web/test/server/tier-announce.spec.tsx
new file mode 100644
index 000000000..002925af3
--- /dev/null
+++ b/packages/web/test/server/tier-announce.spec.tsx
@@ -0,0 +1,278 @@
+/**
+ * @jsxImportSource @solidjs/web
+ */
+// The server-announced tier mechanism, server half (frames savings pass
+// §2, Phase B): both faces announce the frames-client tiers the render
+// MINTED — the stream face on the response head (`X-Frame-Tiers`, the tiers
+// the sync render pass produced) and in-band (`chunk.tiers` on the next
+// chunk out, for a tier first needed after the head left); the document
+// face as the `_$HY.r["sc:tiers"]` hydration record (re-written cumulative
+// at each new mint) plus a `modulepreload` per tier whose chunk URL the
+// integration gave (`frameTransformDirectResult`'s `tierUrls`). Nothing is
+// announced when nothing is minted: a response or page with no tiered
+// feature carries no header, no `tiers` member, no record, no link.
+//
+// The mint sites: a binding-slot position read (`bind`), a nested
+// server-content region (`regions`), an assets chunk (`assets`), a traced
+// container in a slot arg (`trace`), a `live` response (`wire`).
+import { describe, expect, it } from "vitest";
+import { Loading, renderToStream, renderToString, useHead } from "@solidjs/web";
+import { createMemo, createProjection } from "solid-js";
+import {
+  frameTransformDirectResult,
+  renderServerComponent,
+  serverComponentResponse,
+  ServerComponentPlugin
+} from "../../frames/src/frame-sink.js";
+import { FRAME_TIERS_HEADER } from "../../frames/src/frame-transport.js";
+import { ChunkReader } from "../../server-functions/src/shared.js";
+
+const wait = (ms: number) => new Promise(r => setTimeout(r, ms));
+const collect = (stream: any): Promise<any[]> => stream;
+
+/** Every chunk of a frame-stream Response's body, decoded. */
+async function bodyChunks(response: Response): Promise<any[]> {
+  const reader = new ChunkReader(response.body!);
+  const out: any[] = [];
+  for (let r = await reader.next(); !r.done; r = await reader.next())
+    out.push(JSON.parse(r.value as string));
+  return out;
+}
+
+function document(code: () => any, options: Record<string, unknown> = {}): Promise<string> {
+  return new Promise(resolve => {
+    const chunks: string[] = [];
+    renderToStream(code, { plugins: [ServerComponentPlugin], ...options } as any).pipe({
+      write: (c: string) => chunks.push(c),
+      end: () => resolve(chunks.join(""))
+    });
+  });
+}
+
+/** The value of the LAST `sc:tiers` assignment in a document, or undefined. */
+function tiersRecord(html: string): string[] | undefined {
+  // Seroval may assign the value a cross-reference slot (`$R[n]=`) first.
+  const all = [...html.matchAll(/_\$HY\.r\["sc:tiers"\]=(?:\$R\[\d+\]=)?(\[[^\]]*\])/g)];
+  return all.length ? JSON.parse(all[all.length - 1][1].replace(/`/g, '"')) : undefined;
+}
+
+// A server component with nothing tiered: markup and a direct-insert slot.
+const Plain = (props: any) => (
+  <section>
+    <h1>Story</h1>
+    {props.children}
+  </section>
+);
+// A binding slot: one property read off the call's return is a position.
+const Bound = (props: any) => {
+  const row = props.row({ id: 1 });
+  return <li class={row.cls}>item</li>;
+};
+// A region: server JSX passed as a slot arg.
+const Regioned = (props: any) => <div>{props.panel({ body: <p>server body</p> })}</div>;
+// A trace: a live projection (one over an async source — a settled sync
+// projection is a constant and ships as plain data) passed as a slot arg.
+const Traced = (props: any) => {
+  const user = createMemo(() => wait(5).then(() => ({ n: 1 })));
+  const proj = createProjection((draft: any) => {
+    draft.n = (user() as any).n;
+  }, {} as any);
+  return <div>{props.row({ data: proj })}</div>;
+};
+
+describe("tier announcement — stream face", () => {
+  it("announces nothing when nothing is minted: no header, no `tiers` on any chunk", async () => {
+    const response = serverComponentResponse(Plain, { frame: { id: "ta-none" } });
+    expect(response.headers.has(FRAME_TIERS_HEADER)).toBe(false);
+    const chunks = await bodyChunks(response);
+    expect(chunks.some(c => "tiers" in c)).toBe(false);
+    expect(chunks.find(c => c.type === "html").html).toContain("<h1>Story</h1>");
+  });
+
+  it("`bind`: a binding-slot position read in the sync pass is on the response head", async () => {
+    const response = serverComponentResponse(Bound, { frame: { id: "ta-bind" } });
+    expect(response.headers.get(FRAME_TIERS_HEADER)).toBe("bind");
+    const chunks = await bodyChunks(response);
+    // The head carried it; nothing is owed in-band.
+    expect(chunks.some(c => "tiers" in c)).toBe(false);
+    expect(chunks.find(c => c.type === "html").html).toContain('_s:class="row#0:cls"');
+  });
+
+  it("`regions`: a nested region is announced, once, and rides the head", async () => {
+    const response = serverComponentResponse(Regioned, { frame: { id: "ta-reg" } });
+    expect(response.headers.get(FRAME_TIERS_HEADER)).toBe("regions");
+    const chunks = await bodyChunks(response);
+    expect(chunks.find(c => c.type === "slot").args.body).toEqual({
+      $frame: "ta-reg.panel#0.body"
+    });
+  });
+
+  it("`trace`: a traced container in a slot arg announces on its own data chunk", async () => {
+    const response = serverComponentResponse(Traced, { frame: { id: "ta-tr" } });
+    const chunks = await bodyChunks(response);
+    // The announcement rides the record's data chunk itself: the mint
+    // (`argBorderForm` meeting the container) precedes the serializer's
+    // synchronous emission of the initial node, so the chunk whose node
+    // tree needs the tier is the chunk that names it — the client awaits
+    // the tier before decoding exactly that chunk. (A live projection is
+    // pending at first render; the hole that calls the slot re-pulls after
+    // the sync pass, so the head did not know — the in-band form is what
+    // carries this one.)
+    const data = chunks.filter(c => c.type === "data" && c.key === "arg:row#0:data");
+    expect(data.length).toBeGreaterThan(0);
+    expect(data[0].tiers).toEqual(["trace"]);
+    expect(data[0].initial).toBe(true);
+    // Once: the later patch nodes and every other chunk carry nothing.
+    expect(chunks.filter(c => c.tiers).length).toBe(1);
+    // Head and body agree: a tier is announced by one or the other.
+    const head = response.headers.get(FRAME_TIERS_HEADER);
+    expect(head === null || head === "trace").toBe(true);
+  });
+
+  it("`wire`: a `live` response announces the wire tier", async () => {
+    const response = serverComponentResponse(Plain, { frame: { id: "ta-wire" }, live: true });
+    expect(response.headers.get(FRAME_TIERS_HEADER)).toBe("wire");
+    expect(response.headers.get("Content-Type")).toBe("text/event-stream");
+    // Not read: a live body stays open for its heartbeat; cancel it.
+    await response.body!.cancel();
+  });
+
+  it("several tiers: comma-separated, in mint order", async () => {
+    const Both = (props: any) => {
+      const row = props.row({ id: 1 });
+      return (
+        <ul>
+          <li class={row.cls}>{props.panel({ body: <p>x</p> })}</li>
+        </ul>
+      );
+    };
+    const response = serverComponentResponse(Both, { frame: { id: "ta-both" } });
+    expect(response.headers.get(FRAME_TIERS_HEADER)!.split(",").sort()).toEqual([
+      "bind",
+      "regions"
+    ]);
+    await bodyChunks(response);
+  });
+
+  it("a tier first minted after the head left rides in-band on the next chunk (`assets`, `bind` inside a late segment)", async () => {
+    // The style-gated fragment: a stylesheet registered inside a boundary
+    // that resolves after the shell flush. Its assets chunk is the first
+    // the sink emits after the mint, so the chunk carries the name. The
+    // binding-slot read inside the same late content is minted after the
+    // head too; both ride the next chunk out.
+    const Late = (props: any) => {
+      const data = createMemo(() => wait(10).then(() => "late"));
+      return (
+        <Loading fallback={<p>waiting</p>}>
+          {(() => {
+            const v = data() as any;
+            useHead({ tag: "link", props: { rel: "stylesheet", href: "/late.css" } });
+            const row = props.row({ id: v });
+            return <b class={row.cls}>{v}</b>;
+          })()}
+        </Loading>
+      );
+    };
+    const response = serverComponentResponse(Late, { frame: { id: "ta-late" } });
+    // The head knew nothing yet: no header.
+    expect(response.headers.has(FRAME_TIERS_HEADER)).toBe(false);
+    const chunks = await bodyChunks(response);
+    const announced = chunks.filter(c => c.tiers);
+    expect(announced.length).toBeGreaterThan(0);
+    const names = announced.flatMap(c => c.tiers).sort();
+    expect(names).toEqual(["assets", "bind"]);
+    // The announcement precedes (or is) the chunk that needs it: the
+    // `assets` chunk carries `assets`; the fragment with the `_s:` marker
+    // does not precede the chunk naming `bind`.
+    const assets = chunks.find(c => c.type === "assets");
+    expect(assets.tiers).toContain("assets");
+    const bindAt = chunks.findIndex(c => c.tiers && c.tiers.includes("bind"));
+    const fragmentAt = chunks.findIndex(c => c.type === "fragment");
+    expect(bindAt).toBeLessThanOrEqual(fragmentAt);
+    expect(chunks[fragmentAt].html).toContain("_s:class=");
+    // Reveal is style-gated, as before.
+    expect(chunks.find(c => c.type === "reveal").waitForStyles).toBe(true);
+  });
+
+  it("a stream consumed without a Response (renderServerComponent) announces in-band only", async () => {
+    const chunks = await collect(renderServerComponent(Bound, { frame: { id: "ta-direct" } }));
+    const announced = chunks.filter(c => c.tiers);
+    expect(announced.length).toBe(1);
+    expect(announced[0].tiers).toEqual(["bind"]);
+    // On the first emission after the read: the slot chunk left at the
+    // call, the property read came after it, so the shell's html — the
+    // chunk that carries the `_s:` marker — is what announces it.
+    expect(announced[0].type).toBe("html");
+    expect(announced[0].html).toContain('_s:class="row#0:cls"');
+  });
+});
+
+describe("tier announcement — document face", () => {
+  it("announces nothing when nothing is minted: no record, no link", async () => {
+    const Inline = frameTransformDirectResult(Plain, {
+      id: "td-none",
+      tierUrls: { bind: "/tier-bind.js" }
+    }) as any;
+    const html = await document(() => Inline({ children: () => <i>client</i> }));
+    expect(html).toContain("<h1>Story</h1>");
+    expect(tiersRecord(html)).toBeUndefined();
+    expect(html).not.toContain("modulepreload");
+  });
+
+  it("`bind`: the record names it; a `modulepreload` for the given URL joins the head", async () => {
+    const Inline = frameTransformDirectResult(Bound, {
+      id: "td-bind",
+      tierUrls: { bind: "/assets/tier-bind.js" }
+    }) as any;
+    const html = await document(() => (
+      <html>
+        <head>
+          <title>t</title>
+        </head>
+        <body>{Inline({ row: () => ({ cls: "x" }) })}</body>
+      </html>
+    ));
+    expect(tiersRecord(html)).toEqual(["bind"]);
+    expect(html).toContain('<link rel="modulepreload" href="/assets/tier-bind.js">');
+    // In the head, with the shell.
+    expect(html.indexOf("modulepreload")).toBeLessThan(html.indexOf("</head>"));
+    expect(html).toContain('_s:class="row#0:cls"');
+  });
+
+  it("without `tierUrls` the record alone announces the name — no link", async () => {
+    const Inline = frameTransformDirectResult(Bound, { id: "td-nourl" }) as any;
+    const html = await document(() => Inline({ row: () => ({ cls: "x" }) }));
+    expect(tiersRecord(html)).toEqual(["bind"]);
+    expect(html).not.toContain("modulepreload");
+  });
+
+  it("`regions` and `trace`: minted by the document slot props, cumulative across components", async () => {
+    const R = frameTransformDirectResult(Regioned, { id: "td-reg" }) as any;
+    const T = frameTransformDirectResult(Traced, { id: "td-tr" }) as any;
+    const html = await document(() => [
+      R({ panel: (p: any) => <div>{p.body}</div> }),
+      T({ row: (p: any) => <b>{p.data.n}</b> })
+    ]);
+    // The last write is the complete set; the first component's tier is
+    // not lost to the second's.
+    expect(tiersRecord(html)).toEqual(["regions", "trace"]);
+    expect(html).toMatch(/_\$HY\.r\["sc:tiers"\]=(?:\$R\[\d+\]=)?\["regions"\]/);
+  });
+
+  it("`wire`: an inline `live` answer announces the wire tier", async () => {
+    const Inline = frameTransformDirectResult(Plain, { id: "td-wire" }) as any;
+    // The in-process `live` declaration's brand (server-functions' `brandLive`).
+    Inline[Symbol.for("solid.LiveSource")] = true;
+    const html = await document(() => Inline({ children: () => <i>c</i> }));
+    expect(tiersRecord(html)).toEqual(["wire"]);
+  });
+
+  it("a sync render (renderToString) announces nothing — the client detects", () => {
+    const Inline = frameTransformDirectResult(Bound, { id: "td-sync" }) as any;
+    const html = renderToString(() => Inline({ row: () => ({ cls: "x" }) }), {
+      plugins: [ServerComponentPlugin]
+    } as any);
+    expect(html).toContain('_s:class="row#0:cls"');
+    expect(tiersRecord(html)).toBeUndefined();
+  });
+});
diff --git a/packages/web/tsconfig.build.json b/packages/web/tsconfig.build.json
index 87cdf33a6..780cf91ca 100644
--- a/packages/web/tsconfig.build.json
+++ b/packages/web/tsconfig.build.json
@@ -12,7 +12,12 @@
       "@solidjs/web": ["./src/index.ts"],
       "@solidjs/web/server-functions/client": ["./server-functions/src/client.ts"],
       "@solidjs/web/serialization": ["./serialization/src/serializer.ts"],
-      "@solidjs/web/serialization/decode": ["./serialization/src/serializer-decode.ts"]
+      "@solidjs/web/serialization/decode": ["./serialization/src/serializer-decode.ts"],
+      "@solidjs/web/frames/trace": ["./frames/src/trace-tier.ts"],
+      "@solidjs/web/frames/regions": ["./frames/src/regions-tier.ts"],
+      "@solidjs/web/frames/assets": ["./frames/src/assets-tier.ts"],
+      "@solidjs/web/frames/bind": ["./frames/src/bind-tier.ts"],
+      "@solidjs/web/frames/wire": ["./frames/src/wire-tier.ts"]
     }
   },
   "include": [
diff --git a/packages/web/vite.config.hydrate.mjs b/packages/web/vite.config.hydrate.mjs
index a62ff1ec8..1e1fda061 100644
--- a/packages/web/vite.config.hydrate.mjs
+++ b/packages/web/vite.config.hydrate.mjs
@@ -42,10 +42,14 @@ export default defineConfig({
         rootDir,
         "serialization/src/serializer-decode.ts"
       ),
-      "@solidjs/web/serialization": resolve(
-        rootDir,
-        "serialization/src/serializer.ts"
-      ),
+      "@solidjs/web/serialization": resolve(rootDir, "serialization/src/serializer.ts"),
+      // The frames client's tiers (lazy, through the packaged specifiers) —
+      // to the source, for the same single-instance reason.
+      "@solidjs/web/frames/trace": resolve(rootDir, "frames/src/trace-tier.ts"),
+      "@solidjs/web/frames/regions": resolve(rootDir, "frames/src/regions-tier.ts"),
+      "@solidjs/web/frames/assets": resolve(rootDir, "frames/src/assets-tier.ts"),
+      "@solidjs/web/frames/bind": resolve(rootDir, "frames/src/bind-tier.ts"),
+      "@solidjs/web/frames/wire": resolve(rootDir, "frames/src/wire-tier.ts"),
       "@solidjs/web": resolve(rootDir, "src/index.ts")
     }
   }
diff --git a/packages/web/vite.config.mjs b/packages/web/vite.config.mjs
index c8bd5ca9b..85a0f6b4f 100644
--- a/packages/web/vite.config.mjs
+++ b/packages/web/vite.config.mjs
@@ -51,18 +51,21 @@ export default defineConfig({
       // The frames specs stub fetch/createServerReference against the
       // runtime SOURCE, so route the specifier to that same module — one
       // instance, like every from-source consumer of this seam.
-      "@solidjs/web/server-functions/client": resolve(
-        rootDir,
-        "server-functions/src/client.ts"
-      ),
+      "@solidjs/web/server-functions/client": resolve(rootDir, "server-functions/src/client.ts"),
       "@solidjs/web/serialization/decode": resolve(
         rootDir,
         "serialization/src/serializer-decode.ts"
       ),
-      "@solidjs/web/serialization": resolve(
-        rootDir,
-        "serialization/src/serializer.ts"
-      )
+      "@solidjs/web/serialization": resolve(rootDir, "serialization/src/serializer.ts"),
+      // The frames client's tiers, lazy-imported through the packaged
+      // specifiers (external in their dist builds); route them to the
+      // source so a tier installs into the same client instance the specs
+      // drive.
+      "@solidjs/web/frames/trace": resolve(rootDir, "frames/src/trace-tier.ts"),
+      "@solidjs/web/frames/regions": resolve(rootDir, "frames/src/regions-tier.ts"),
+      "@solidjs/web/frames/assets": resolve(rootDir, "frames/src/assets-tier.ts"),
+      "@solidjs/web/frames/bind": resolve(rootDir, "frames/src/bind-tier.ts"),
+      "@solidjs/web/frames/wire": resolve(rootDir, "frames/src/wire-tier.ts")
     }
   }
 });
diff --git a/scripts/size/README.md b/scripts/size/README.md
index b39e216a3..453d329ee 100644
--- a/scripts/size/README.md
+++ b/scripts/size/README.md
@@ -6,7 +6,9 @@ app, a representative CSR app, a hydrating pair — with and without store
 primitives — that keeps the store engine pay-for-use under `hydrate()`, three
 compiled-template scenarios — a compiled floor and a JSX todo app in CSR and
 hydrating form — the frames client as a package, two server-component PAGES:
-base and live, and two server-entry floors: `getRequestEvent`/`isServer` and
+base and live, their two compiled counterparts — the same pages as JSX with
+the templates a real page has — and two server-entry floors:
+`getRequestEvent`/`isServer` and
 `renderToString`) with hard brotli limits on the eager entry chunk. CI fails
 when a scenario exceeds its limit and grew more than a small minified
 allowance over its base (see [The gate](#the-gate)) — that means tree-shaking regressed, or a deliberate
@@ -101,7 +103,13 @@ actually downloads. Rolldown is pinned exactly in `package.json`: its minifier
 decides the numbers, so an upgrade is a re-base recorded like any other cap
 change. Code splitting is real — a scenario's `import()` yields a lazy chunk
 that is reported and never counted; the seroval codec the page scenarios load
-lazily shows up that way at its true size.
+lazily shows up that way at its true size. The eager graph is the entry chunk
+**plus any chunk it imports statically**: when the entry and a lazy chunk
+share modules, Rolldown may hoist them into a chunk the entry `import`s at
+its top, and the browser fetches that before the entry runs. Such a chunk is
+counted (each file brotli'd on its own) and named in the output as `eager
+(… counted)`; the compiled live server-component page is the one scenario
+that splits this way (its ledger note says why).
 
 Scenarios bundle for the browser unless they set `platform`/`conditions`.
 The `server:` scenarios bundle for Node (Rolldown's node conditions, no
@@ -134,6 +142,26 @@ output — and the numbers — are the same on every host. The compiled app's
 own modules report as the `app` package. CI needs nothing beyond what it
 already does: the compiler is built before `pnpm build`.
 
+The two server-component page scenarios have compiled counterparts for the
+same reason (`page: compiled base …`, `page: compiled live …`;
+`fixtures/compiled/sc-base.jsx`, `sc-live.jsx`, the shared `sc-shell.jsx`):
+the hand-written `sc-base-app.js` / `sc-live-app.js` keep the runtime alive as
+values and never compile a template, so a change that drops the attribute
+runtime from those pages drops nothing from a page an application ships —
+compiled templates import `className`, `style`, `setAttribute`, `addEvent`
+and `delegateEvents` themselves. The compiled pages mount the same server
+component through `dynamicComponent()` over the same server-function
+reference (the live one through `live(GET(…))`, with `action` and
+`isPending`/`latest`), inside a compiled shell: links with a dynamic `class`
+and `style`, an `href`, a handler passed through as a prop, a search input
+with a `value` binding, `<For>`, `<Show>`, `<Errored>`/`<Loading>` and a
+`lazy()` child — and **no element spread** (the maintainer's ruling,
+2026-10-07: most server-component apps do not have client element spreads, so
+the compiled baseline must not carry one; `spread` is absent from both
+pages' rendered `web.js`). The hand-written pages stay as the frames-only
+floor (their caps are the frozen ones); the compiled pages are the number a
+real page moves by.
+
 ## Frozen floor caps
 
 The three floor scenarios — the signals floor, the simple app, and the
diff --git a/scripts/size/attribute.mjs b/scripts/size/attribute.mjs
index 8deb5701f..b86214c08 100644
--- a/scripts/size/attribute.mjs
+++ b/scripts/size/attribute.mjs
@@ -23,7 +23,11 @@ for (const scenario of scenarios) {
   if (filters.length && !filters.some(f => scenario.name.includes(f))) continue;
   const r = await bundle(scenario);
   console.log(`\n${r.name}`);
-  console.log(`  entry chunk: minified ${r.min} B   brotli ${r.br} B (${toKB(r.br)})`);
+  console.log(
+    `  ${r.eager.length ? "eager graph" : "entry chunk"}: minified ${r.min} B   brotli ${r.br} B (${toKB(r.br)})`
+  );
+  for (const c of r.eager)
+    console.log(`  eager chunk ${c.name} (counted): minified ${c.min} B   brotli ${c.br} B`);
   for (const c of r.lazy)
     console.log(`  lazy chunk ${c.name}: minified ${c.min} B   brotli ${c.br} B`);
   const rows = r.modules
diff --git a/scripts/size/bundle.mjs b/scripts/size/bundle.mjs
index 4907b4fcd..315c9e439 100644
--- a/scripts/size/bundle.mjs
+++ b/scripts/size/bundle.mjs
@@ -15,6 +15,18 @@
 // (size-limit did not split, so the harness used a stub for the codec; the
 // stub is gone and the lazy codec chunk is reported at its true size.)
 //
+// The eager graph is not always one chunk (2026-10-07): when a lazy chunk
+// and the entry share modules, Rolldown may hoist the shared modules into a
+// chunk the entry imports STATICALLY (`import "./web.js"` at its top) — the
+// browser fetches it before the entry runs, so it ships eagerly and counts.
+// The measured size is the entry plus every chunk it reaches through static
+// imports (each brotli'd on its own: two files are two compressions); only
+// chunks reached through `import()` alone are lazy. The first scenario to
+// split this way was the compiled live server-component page: `isPending`
+// on the page and a lazy route with a template put the whole runtime (~66 KB
+// minified) in a shared chunk; counted as lazy it would have read as half
+// the page. No other scenario splits; their numbers did not move.
+//
 // Compiled scenarios (2026-10-05): a scenario with `compile` is written as
 // JSX under fixtures/ and compiled here, at measure time, by the native
 // @solidjs/compiler of the checkout being measured (packagesRoot — the
@@ -159,9 +171,17 @@ export async function bundle(scenario) {
     });
     const chunks = output.filter(o => o.type === "chunk");
     const entry = chunks.find(c => c.isEntry);
-    const lazy = chunks
-      .filter(c => c !== entry)
-      .map(c => ({ name: c.fileName, min: c.code.length, br: brotli(c.code) }));
+    // The eager graph: the entry and every chunk it reaches through static
+    // imports (`chunk.imports`; `dynamicImports` are the lazy edges).
+    const eagerChunks = [entry];
+    for (const c of eagerChunks)
+      for (const name of c.imports) {
+        const dep = chunks.find(d => d.fileName === name);
+        if (dep && !eagerChunks.includes(dep)) eagerChunks.push(dep);
+      }
+    const measure = c => ({ name: c.fileName, min: c.code.length, br: brotli(c.code) });
+    const eager = eagerChunks.slice(1).map(measure);
+    const lazy = chunks.filter(c => !eagerChunks.includes(c)).map(measure);
     // Per-module contribution: Rolldown reports each module's tree-shaken,
     // rendered source. Minified on its own with the same minifier, a module
     // keeps its chunk-scope names (they are globals to a standalone minify),
@@ -170,25 +190,29 @@ export async function bundle(scenario) {
     // chunk the way esbuild's bytesInOutput did. Brotli compresses across
     // modules, so only the chunk total is compressed.
     const modules = [];
-    let standalone = 0;
-    for (const [id, m] of Object.entries(entry.modules)) {
-      if (!m.code) continue;
-      let min;
-      try {
-        min = minifySync(id, m.code).code.length;
-      } catch {
-        min = m.renderedLength;
+    for (const chunk of eagerChunks) {
+      const own = [];
+      let standalone = 0;
+      for (const [id, m] of Object.entries(chunk.modules)) {
+        if (!m.code) continue;
+        let min;
+        try {
+          min = minifySync(id, m.code).code.length;
+        } catch {
+          min = m.renderedLength;
+        }
+        standalone += min;
+        own.push({ id, min });
       }
-      standalone += min;
-      modules.push({ id, min });
+      const scale = standalone ? chunk.code.length / standalone : 1;
+      for (const m of own) modules.push({ id: m.id, min: Math.round(m.min * scale) });
     }
-    const scale = standalone ? entry.code.length / standalone : 1;
-    for (const m of modules) m.min = Math.round(m.min * scale);
     return {
       name: scenario.name,
       limit: scenario.limit,
-      min: entry.code.length,
-      br: brotli(entry.code),
+      min: eagerChunks.reduce((n, c) => n + c.code.length, 0),
+      br: brotli(entry.code) + eager.reduce((n, c) => n + c.br, 0),
+      eager,
       lazy,
       modules
     };
diff --git a/scripts/size/fixtures/compiled/sc-base.jsx b/scripts/size/fixtures/compiled/sc-base.jsx
new file mode 100644
index 000000000..012a8dada
--- /dev/null
+++ b/scripts/size/fixtures/compiled/sc-base.jsx
@@ -0,0 +1,27 @@
+// `page: compiled base server components`: the compiled counterpart of
+// sc-base-app.js — a hydrating client (no client stores) that installs the
+// frames transport and mounts one server component through
+// `dynamicComponent()` over a server-function reference, inside the compiled
+// shell of sc-shell.jsx (templates with ordinary attributes — no element
+// spread — For / Show / Loading / Errored, a lazy child). Compiled hydratable by the measured
+// checkout's @solidjs/compiler, like the `app: compiled hydrating` scenario.
+// The delta against the hand-written page is what the compiled templates
+// retain of @solidjs/web — the attribute runtime and the hydratable walk
+// helpers — plus the compiled app's own bytes (the `app` package).
+import { hydrate, dynamicComponent } from "@solidjs/web";
+import { installServerComponents } from "@solidjs/web/frames";
+import { createServerReference } from "@solidjs/web/server-functions/client";
+import Shell from "./sc-shell.jsx";
+
+installServerComponents();
+const getStory = createServerReference("story", "getStory");
+const Story = dynamicComponent(() => getStory());
+
+hydrate(
+  () => (
+    <Shell id={1}>
+      <Story id={1} />
+    </Shell>
+  ),
+  document.body
+);
diff --git a/scripts/size/fixtures/compiled/sc-comments.jsx b/scripts/size/fixtures/compiled/sc-comments.jsx
new file mode 100644
index 000000000..4de093c80
--- /dev/null
+++ b/scripts/size/fixtures/compiled/sc-comments.jsx
@@ -0,0 +1,11 @@
+// The lazy child behind the comments <Loading> in sc-shell.jsx — the compiled
+// counterpart of the hand-written pages' lazy-page.js. Rolldown splits it
+// into its own chunk, which the gate reports and never counts.
+export default function Comments(props) {
+  return (
+    <section class="comments">
+      <h2>Comments for #{props.id}</h2>
+      <p>Nothing yet.</p>
+    </section>
+  );
+}
diff --git a/scripts/size/fixtures/compiled/sc-live.jsx b/scripts/size/fixtures/compiled/sc-live.jsx
new file mode 100644
index 000000000..ce2e64e22
--- /dev/null
+++ b/scripts/size/fixtures/compiled/sc-live.jsx
@@ -0,0 +1,42 @@
+// `page: compiled live server components`: the compiled counterpart of
+// sc-live-app.js — sc-base.jsx plus what a live page reaches for:
+// `live(GET(...))` on the server-function reference, an `action` for the
+// send path (dispatched from a compiled click handler), and
+// `isPending` / `latest` on a client signal (the router reads both, so every
+// real page retains the verdict) — read where a real page reads them, in a
+// template's `class` and a text hole. Still no client stores. Rolldown
+// splits this page's eager graph in two (the shared runtime in a chunk the
+// entry imports statically — the scenario's ledger note in scenarios.js);
+// bundle.mjs counts both.
+import { hydrate, dynamicComponent } from "@solidjs/web";
+import { action, createSignal, isPending, latest } from "solid-js";
+import { installServerComponents } from "@solidjs/web/frames";
+import { createServerReference, live, GET } from "@solidjs/web/server-functions/client";
+import Shell from "./sc-shell.jsx";
+
+installServerComponents();
+const getStory = live(GET(createServerReference("story", "getStory")));
+const Story = dynamicComponent(() => getStory());
+const vote = action(async function* () {});
+
+function VoteBar(props) {
+  const [votes, setVotes] = createSignal(0);
+  return (
+    <div class={{ votes: true, pending: isPending(votes) }}>
+      <button type="button" onClick={() => (setVotes(votes() + 1), vote(props.id))}>
+        ▲
+      </button>
+      <span>{latest(votes)}</span>
+    </div>
+  );
+}
+
+hydrate(
+  () => (
+    <Shell id={1}>
+      <VoteBar id={1} />
+      <Story id={1} />
+    </Shell>
+  ),
+  document.body
+);
diff --git a/scripts/size/fixtures/compiled/sc-shell.jsx b/scripts/size/fixtures/compiled/sc-shell.jsx
new file mode 100644
index 000000000..bc0d1ecc5
--- /dev/null
+++ b/scripts/size/fixtures/compiled/sc-shell.jsx
@@ -0,0 +1,85 @@
+// The client shell of a compiled server-component page, shared by
+// sc-base.jsx and sc-live.jsx: what surrounds the server component on a page
+// an application actually ships. The hand-written sc-base-app.js /
+// sc-live-app.js keep the same runtime pieces alive as values and never
+// compile a template, so the attribute runtime a compiled template imports
+// — `className`, `style`, `setAttribute`, `addEvent`, `delegateEvents` —
+// reaches those pages only through the bind tier's `assign` edge, and a
+// change that "removes" it there removes nothing from a real one. Here it
+// is reached the way compiled templates reach it. Each construct is here
+// because a real page has it:
+//
+// - a nav of links: `href` from a prop (`setAttribute`), `class` and `style`
+//   as dynamic values rather than object literals (the `className` / `style`
+//   runtime, not the compiler's static `classList.toggle` /
+//   `setStyleProperty` forms), the click handler passed through as a prop
+//   (`addEvent`: the compiler cannot see that `props.onSelect` is a function,
+//   so it defers the delegated/direct decision to the runtime);
+// - a search input with a `value` binding (`setProperty`) and a delegated
+//   `onInput`;
+// - a `<For>` over the tabs and a `<Show>` with a function child;
+// - the client signal + memo the hand-written pages keep (`d`), `<Errored>`
+//   and `<Loading>` around the server component, a `lazy()` child under its
+//   own `<Loading>` (the lazy chunk is reported, not counted).
+//
+// NO element spread (maintainer's ruling, 2026-10-07: most server-component
+// apps do not have client element spreads — the compiled baseline must not
+// carry one). `spread` / `assign` / `assignProp` and the store `merge` /
+// `omit` view records `spread` reads a source through must be absent from
+// these pages; the ledger in scenarios.js records the check.
+//
+// The server component itself is `props.children` — mounted by the entry
+// through `dynamicComponent()` over a server-function reference, as the
+// hand-written pages mount it.
+import { createMemo, createSignal, lazy } from "solid-js";
+
+const Comments = lazy(() => import("./sc-comments.jsx"));
+
+function Tab(props) {
+  return (
+    <a href={props.href} class={props.class} style={props.style} onClick={props.onSelect}>
+      {props.children}
+    </a>
+  );
+}
+
+const TABS = ["Top", "New", "Ask"];
+
+export default function Shell(props) {
+  const [tab, setTab] = createSignal(0);
+  const [query, setQuery] = createSignal("");
+  const label = createMemo(() => TABS[tab()]);
+  return (
+    <main class="page">
+      <nav class="tabs">
+        <For each={TABS}>
+          {(name, i) => (
+            <Tab
+              href={`/${name.toLowerCase()}`}
+              class={tab() === i() ? "tab active" : "tab"}
+              style={{ "--i": i() }}
+              onSelect={() => setTab(i())}
+            >
+              {name}
+            </Tab>
+          )}
+        </For>
+        <input
+          type="search"
+          placeholder="Search"
+          value={query()}
+          onInput={e => setQuery(e.target.value)}
+        />
+      </nav>
+      <Show when={query()} fallback={<h1>{label()}</h1>}>
+        {q => <h1>Results for “{q()}”</h1>}
+      </Show>
+      <Errored fallback={err => <p class="error">{err().message}</p>}>
+        <Loading fallback={<p>Loading story…</p>}>{props.children}</Loading>
+      </Errored>
+      <Loading fallback={<p>Loading comments…</p>}>
+        <Comments id={props.id} />
+      </Loading>
+    </main>
+  );
+}
diff --git a/scripts/size/floor-caps.json b/scripts/size/floor-caps.json
index 21b20bb9d..105f132d2 100644
--- a/scripts/size/floor-caps.json
+++ b/scripts/size/floor-caps.json
@@ -12,12 +12,12 @@
     "minified": 52841
   },
   "page: base server components (hydrating + dynamic + frames + sf reference)": {
-    "cap": "45.14 KB",
-    "minified": 146424
+    "cap": "33.92 KB",
+    "minified": 105252
   },
   "page: live server components (base + live/GET + action + isPending/latest)": {
-    "cap": "48.91 KB",
-    "minified": 158537
+    "cap": "37.53 KB",
+    "minified": 117301
   },
   "server: floor (getRequestEvent + isServer)": {
     "cap": "1.34 KB",
diff --git a/scripts/size/report.mjs b/scripts/size/report.mjs
index 0429f02df..11de6aa2e 100644
--- a/scripts/size/report.mjs
+++ b/scripts/size/report.mjs
@@ -41,7 +41,15 @@ const rows = head.map((h, i) => {
       : v.verdict === "warn"
         ? `⚠️ over by ${v.overBy} B, ${v.headroom} B minified headroom`
         : `❌ over by ${v.overBy} B`;
-  const lazy = h.lazy?.length ? h.lazy.map(c => `${c.name} ${toKB(c.br)}`).join(", ") : "";
+  const chunks = c => c.map(c => `${c.name} ${toKB(c.br)}`).join(", ");
+  // An eager chunk the entry imports statically is counted in `head`; it is
+  // named here so a split is visible in the comment that reports it.
+  const lazy = [
+    h.eager?.length ? `eager (counted): ${chunks(h.eager)}` : "",
+    h.lazy?.length ? chunks(h.lazy) : ""
+  ]
+    .filter(Boolean)
+    .join("; ");
   return `| ${h.name} | ${size} | ${change} | ${minChange} | ${minRecorded} | ${cap} | ${status} | ${lazy} |`;
 });
 
diff --git a/scripts/size/sc-base-app.js b/scripts/size/sc-base-app.js
index 0c349a03b..ac6ad4c72 100644
--- a/scripts/size/sc-base-app.js
+++ b/scripts/size/sc-base-app.js
@@ -1,19 +1,20 @@
 // The base server-component page: a hydrating client (no client stores)
 // that installs the frames transport and mounts one server component
-// through `dynamic()` over a server-function reference. This is the whole
-// eager graph such a page ships — signals floor, solid-js hydration, the
-// web runtime, the frames client and the server-function transport — with
-// the seroval codec left lazy as it is in production. Unlike the
-// "frames: eager client consumer" scenario, nothing is external here: this
-// measures the page, not the package.
-import { hydrate, Show, For, Loading, Errored, dynamic } from "@solidjs/web";
+// through `dynamicComponent()` over a server-function reference — the
+// documented mount (2026-10-07; `dynamic()` would also carry the element
+// runtime for its tag arm). This is the whole eager graph such a page ships
+// — signals floor, solid-js hydration, the web runtime, the frames client
+// and the server-function transport — with the seroval codec left lazy as
+// it is in production. Unlike the "frames: eager client consumer" scenario,
+// nothing is external here: this measures the page, not the package.
+import { hydrate, Show, For, Loading, Errored, dynamicComponent } from "@solidjs/web";
 import { createSignal, createMemo, lazy } from "solid-js";
 import { installServerComponents } from "@solidjs/web/frames";
 import { createServerReference } from "@solidjs/web/server-functions/client";
 
 installServerComponents();
 const getStory = createServerReference("story", "getStory");
-const Story = dynamic(() => getStory());
+const Story = dynamicComponent(() => getStory());
 const [n, setN] = createSignal(0);
 const Page = lazy(() => import("./lazy-page.js"));
 hydrate(() => {
diff --git a/scripts/size/sc-live-app.js b/scripts/size/sc-live-app.js
index bf3876f95..7b74aa001 100644
--- a/scripts/size/sc-live-app.js
+++ b/scripts/size/sc-live-app.js
@@ -5,14 +5,14 @@
 // stores: the store engine on this page, if any, is the frames client's
 // container-trace materializer, which is exactly what this scenario keeps
 // honest.
-import { hydrate, Show, For, Loading, Errored, dynamic } from "@solidjs/web";
+import { hydrate, Show, For, Loading, Errored, dynamicComponent } from "@solidjs/web";
 import { createSignal, createMemo, action, isPending, latest, lazy } from "solid-js";
 import { installServerComponents } from "@solidjs/web/frames";
 import { createServerReference, live, GET } from "@solidjs/web/server-functions/client";
 
 installServerComponents();
 const getStory = live(GET(createServerReference("story", "getStory")));
-const Story = dynamic(() => getStory());
+const Story = dynamicComponent(() => getStory());
 const send = action(async () => {});
 const [n, setN] = createSignal(0);
 const Page = lazy(() => import("./lazy-page.js"));
diff --git a/scripts/size/scenarios.js b/scripts/size/scenarios.js
index b80fab328..b83f9e0af 100644
--- a/scripts/size/scenarios.js
+++ b/scripts/size/scenarios.js
@@ -69,9 +69,33 @@ const floorMinified = Object.fromEntries(
 // Rolldown splits it the same way, so it shows up in the report as a lazy
 // chunk at its true size and stays out of the cap. (Under size-limit the
 // specifiers resolved to a stub because esbuild did not split there.) The
-// "frames: eager client consumer" scenario measures the package; these
-// measure the page. Subpath aliases first (see above).
+// frames client's TRACES TIER (`@solidjs/web/frames/trace` — plan step C3,
+// 2026-10-06: solid's container-trace materializer, reached through its own
+// `solid-js/internal/container-trace` entry, plus the plugin's client half;
+// the store engine's one edge into these pages) is its second dynamic import
+// and reports the same way: `trace.js` is the tier + the engine, lazy, not
+// counted; its REGIONS TIER (`@solidjs/web/frames/regions` — plan step C4,
+// 2026-10-06: nested server-content regions) is the third, `regions.js`,
+// and its ASSETS TIER (`@solidjs/web/frames/assets` — plan step C5,
+// 2026-10-06: the stylesheet gate, module / typed preloads, inline styles)
+// the fourth, `assets.js`, and its BIND TIER (`@solidjs/web/frames/bind` —
+// plan step C6, 2026-10-06: binding-slot positions, `assign` with them)
+// the fifth, `bind.js`, and its LIVE WIRE TIER (`@solidjs/web/frames/wire`
+// — plan step C2, 2026-10-06: a `live()` loop's connection — join / open /
+// supersede, the SSE reader, the lifetime told to the loop, the have-list
+// ledger and the resume request) the sixth, `wire.js` — each lazy, not
+// counted. The "frames: eager client consumer" scenario measures the
+// package; these measure the page.
+// Subpath aliases first (see above) — the tier specifiers before
+// `@solidjs/web/frames` and `solid-js/internal`, which would otherwise
+// swallow them.
 const pageAlias = {
+  "@solidjs/web/frames/trace": "../../packages/web/frames/dist/trace.js",
+  "@solidjs/web/frames/regions": "../../packages/web/frames/dist/regions.js",
+  "@solidjs/web/frames/assets": "../../packages/web/frames/dist/assets.js",
+  "@solidjs/web/frames/bind": "../../packages/web/frames/dist/bind.js",
+  "@solidjs/web/frames/wire": "../../packages/web/frames/dist/wire.js",
+  "solid-js/internal/container-trace": "../../packages/solid/dist/container-trace.js",
   "@solidjs/web/server-functions/client": "../../packages/web/server-functions/dist/client.js",
   "@solidjs/web/server-functions": "../../packages/web/server-functions/dist/client.js",
   "@solidjs/web/frames": "../../packages/web/frames/dist/client.js",
@@ -111,6 +135,17 @@ const framesAlias = {
 const framesExternal = [
   "solid-js",
   "solid-js/internal",
+  // The traces tier: lazily imported by the frames client (plan step C3,
+  // 2026-10-06) — external like the codec, so this scenario keeps measuring
+  // the eager graph alone; its own `solid-js` entry rides with it. The
+  // regions tier (C4), the assets tier (C5), the bind tier (C6) and the live
+  // wire tier (C2) likewise.
+  "solid-js/internal/container-trace",
+  "@solidjs/web/frames/trace",
+  "@solidjs/web/frames/regions",
+  "@solidjs/web/frames/assets",
+  "@solidjs/web/frames/bind",
+  "@solidjs/web/frames/wire",
   "@solidjs/web",
   "@solidjs/web/serialization",
   "@solidjs/web/serialization/decode"
@@ -3530,8 +3565,126 @@ module.exports = [
     // still pending have streamed in. Folded into one expression (from a
     // helper) before measuring. Cap set at measured + 10 B rounded up to
     // 0.01 KB. Accepted by the maintainer 2026-10-07.
-    limit: "14.02 KB",
-    capMinified: 44032,
+    // Frames savings pass C3 — the traces tier (2026-10-06): measured at
+    // 13,866 B against the Phase B head e05ba0283's 13,949 (-83 B; -484 B
+    // minified, 43,452 -> 42,968) and `next` @ 9d89df731's 13,787 (+79 B;
+    // -446 B minified). The container tier's client half left for the lazy
+    // `@solidjs/web/frames/trace` chunk (solid's materializer + the plugin's
+    // revive walk, memo and marker test: -951 B minified / -239 B brotli,
+    // measured on an edited dist copy); the trigger left behind — the loader
+    // entry and the container probe, the held-set predicate (`needsTrace`:
+    // the marker walk while the tier is absent), the `claiming` thread and
+    // the held-record mount — costs +467 / +156. Still 76 B over the 13.79 KB
+    // cap by Phase A's and B's own bytes (their notes); the minified size is
+    // below the recorded 43,414 B, so the gate passes by its minified rule.
+    // Cap unchanged (over it); recorded minified lowered to 42,968 B (the
+    // ratchet: a cap not lowered only ever has its recorded minified
+    // lowered).
+    // Frames savings pass C4 — the regions tier (2026-10-06): 13.79 -> 13.64 KB,
+    // measured at 13,629 B against the C3 head 89954fa1b's 13,866 (-237 B;
+    // -1,078 B minified, 42,968 -> 41,890) and `next` @ 9d89df731's 13,787
+    // (-158 B; -1,524 B minified). Nested server-content regions left for the
+    // lazy `@solidjs/web/frames/regions` chunk (the per-frame region cache,
+    // discovery in an adopted interior, the `{$frame}` arm of arg
+    // resolution with the wire-name rename, the bind of a frame over each
+    // region element, disposal: -1,596 B minified / -423 B brotli, measured
+    // on an edited dist copy); the glue left behind — the installed-module
+    // table, the loader entry, the `needsRegions` wait at the fresh-mount
+    // and update sites, the tier calls at bind / resolve / unmount / the
+    // staged preview, the `options` getter and the `parent` thread-up —
+    // costs +518 / +186. First time under the cap since Phase A: cap set at
+    // measured + 10 B at the 0.01 KB step (the ratchet); recorded minified
+    // 41,890 B.
+    // Frames savings pass C5 — the assets tier (2026-10-06, measured on its
+    // own branch off the C3 head): 13,332 B against 89954fa1b's 13,866
+    // (-534 B; -1,913 B minified, 42,968 -> 41,055) and `next` @ 9d89df731's
+    // 13,787 (-455 B; -2,359 B minified). The head mirror a segment's assets
+    // record drives (the stylesheet gate, module / typed preloads, inline
+    // styles) left for the lazy `@solidjs/web/frames/assets` chunk (2,040 B
+    // minified / 783 B brotli); the whole group measured -2,419 / -666 on an
+    // edited dist copy, and what stays eager — the record cases (+208 min),
+    // the reveal-readiness term with the load trigger and the assets walk's
+    // dispatch (+300 min) — costs +508 / +131.
+    // C5 follow-up (2026-10-06): the readiness term holds a segment whose
+    // record carries INLINE styles too while the tier is absent (its
+    // `<style>` is the tier's to land — revealing before the install was the
+    // unstyled window the term exists to prevent). Measured on the edited
+    // dist first: +22 min / +14 br; built the same on C5's branch, 13,346 B
+    // (41,077 B minified).
+    // Frames savings pass — Phases B + C3 + C4 + C5 integrated
+    // (2026-10-06, `wip/frames-tiers-integration`): 13.35 -> 13.10 KB,
+    // measured at 13,083 B (40,000 B minified) against the Phase A base
+    // 0aab93230's 13,804 (-721 B; -2,979 B minified, 42,979 -> 40,000) and
+    // `next` @ 9d89df731's 13,787 (-704 B; -3,414 B minified). The four
+    // steps' minified deltas sum to -2,980; the integration's one byte is
+    // the dispatch unification (C4's installed-module table folded into
+    // C5's resident stamp, `tierLoads[name].r = module`). Cap set at
+    // measured + 10 B at the 0.01 KB step (the ratchet); recorded minified
+    // 40,000 B.
+    // Frames savings pass C6 (2026-10-06, the bind tier): 13.10 -> 11.92 KB,
+    // measured at 11,901 B (36,007 B minified) against the integration base
+    // 6b7213d64's 13,086 (-1,185 B; -4,005 B minified, 40,012 -> 36,007)
+    // and `next` @ 9d89df731's 13,787 (-1,886 B; -7,407 B minified).
+    // Binding-slot positions — the consumer walk, the per-frame consumer
+    // sets and rebinders, the owned-position arms of the morph, the fill's
+    // bind (`assign` with it) — are `bind.js` (4,771 B minified / 1,844 B
+    // brotli, lazy, not counted). The eager client keeps the marker
+    // detection at the walk (`hasSlotMarker` → the 3.1 hold), the text-pair
+    // arm of `reconcileChildren` (a client-owned text node must survive a
+    // morph the tier has not seen — the pin at frames-binding-slots "a
+    // refetch re-sends the empty pairs"), `isAsyncValue` (shared with the
+    // tier through the entry) and the loader entry. The delegated-event
+    // replay window is the server's ` _hk` stamp on event-slot consumers
+    // (0 eager bytes; +106 min / +48 br in the chunk). Cap set at measured
+    // + 10 B at the 0.01 KB step (the ratchet); recorded minified 36,007 B.
+    // Frames residue pass, step 1 (2026-10-06): 11.92 -> 11.67 KB, measured
+    // at 11,654 B (35,250 B minified): the D list without the mirror
+    // (`documentAddress`, one dispose map, the zombie heuristic + `#slotNodes`,
+    // the default reveal seam, `showing`'s brand), `FRAME_HAVE_*` off the
+    // entry's export list, and the lean re-ask (`ctx.retry` from the sf
+    // client in place of the RPC-seam re-ask) — −757 min / −247 br. The
+    // capture arm stays (pinned by `lifecycle-matrix/remount`). Cap set at
+    // measured + 10 B at the 0.01 KB step (the ratchet); recorded minified
+    // 35,250 B.
+    // Frames residue pass, step 3 (2026-10-06): 11.67 -> 11.38 KB, measured
+    // at 11,367 B (34,272 B minified): every fill through `insert` — the
+    // Solid binding's static path (`normalizeSlotContent`,
+    // `isReactiveContent`, `settle`) and the runtime's own range writer
+    // (`#replaceRange`, the returned-nodes path) gone, the fill owns its
+    // range through `ctx.range`; the runtime's never-used comment-marker
+    // range mode (`#start` / `#end`) gone, the frame element IS the range —
+    // −978 min / −287 br. Cap set at measured + 10 B at the 0.01 KB step
+    // (the ratchet); recorded minified 34,272 B.
+    // Frames residue pass, step 4 (2026-10-06): 11.38 -> 11.21 KB, measured
+    // at 11,193 B (33,767 B minified): S-ref's pending read moved into the
+    // lazy decode table — a `{$ref}` to a key the response has not
+    // delivered is answered by the table with a promise it settles at the
+    // key's `data` chunk and rejects when the response ends (`closeData`);
+    // the host's `pendingRef` / `settleWait` / per-store waits are gone,
+    // what stays eager is the `record.pending` count and one fan-out
+    // helper — −505 min / −174 br (the decode chunk, lazy, +420 / +161).
+    // Cap set at measured + 10 B at the 0.01 KB step (the ratchet);
+    // recorded minified 33,767 B.
+    // Frames savings pass, C2 (2026-10-07): 11.21 -> 10.90 KB, measured at
+    // 10,888 B (32,802 B minified): the live wire moved into a lazy tier
+    // (`wire.js`, 1,922 / 934, reported not counted) — the connection
+    // bookkeeping (open-frame count, join of two loops on one address,
+    // supersession cancel), the have-list ledger and its encoder, the
+    // resume shape; what stays eager is the arm that awaits the tier's
+    // residency and the preload-at-call hook (`responseHandler.onLive`),
+    // ≈ +467 min / +162 br of carrier over the −1,432 / −472 ceiling —
+    // −965 min / −305 br. Cap set at measured + 10 B at the 0.01 KB step
+    // (the ratchet); recorded minified 32,802 B.
+    // Frames tiers, merged onto `next` @ 3c1d51267 (#3860, 2026-10-07):
+    // `next`'s 14.02 KB -> 11.13 KB, measured at 11,112 B by CI (Size run
+    // 37671002618) against `next`'s 14,012 (-2,900 B; -10,178 B minified,
+    // 43,596 -> 33,418). The branch's own ratchets above were measured on
+    // its pre-merge base; `next`'s bytes since (#3846's ChunkReader, #3865,
+    // #3874) land under them (+616 B minified, +224 B brotli over the C2
+    // note's 32,802 / 10,888). Cap set at measured + 10 B rounded up to
+    // 0.01 KB; recorded minified 33,418 B.
+    limit: "11.13 KB",
+    capMinified: 33418,
     alias: framesAlias,
     external: framesExternal
   },
@@ -3720,6 +3873,89 @@ module.exports = [
     // read, and verdict-lane stagedReaders. Cap set at measured + 10 B rounded
     // up to 0.01 KB. Accepted by the maintainer 2026-10-07. The cap is frozen
     // again at 45.14 KB.
+    // Frames savings pass C3 — the traces tier (2026-10-06): 44.89 -> 38.61 KB
+    // (floor-caps.json), measured at 38,598 B against the Phase B head
+    // e05ba0283's 45,210 (-6,612 B; -24,069 B minified, 146,097 -> 122,028)
+    // and `next` @ 9d89df731's 44,882 (-6,284 B). The store engine (signals
+    // `store/*`), solid's container-trace materializer (its own entry,
+    // `solid-js/internal/container-trace`) and the plugin's client half leave
+    // this page's eager chunk for `trace.js` — reported above as lazy, not
+    // counted, 25,409 B minified / 8,170 B brotli — which the frames client
+    // fetches when the document announces the tier (`_$HY.r["sc:tiers"]`) or
+    // an adopt-time record's args carry a trace. What stays: the store
+    // hydration adapters (`enableHydration`'s on every hydrating page, as
+    // before), the store symbols the chunk shares with the eager one, and
+    // the tier's trigger in the frames client (its note). Cap set at measured
+    // + 10 B at the 0.01 KB step (the ratchet); recorded minified 122,028 B.
+    // Frames savings pass C4 — the regions tier (2026-10-06): 38.61 -> 38.33 KB
+    // (floor-caps.json), measured at 38,317 B against the C3 head
+    // 89954fa1b's 38,598 (-281 B; -1,083 B minified, 122,028 -> 120,945) and
+    // `next` @ 9d89df731's 44,882 (-6,565 B). Nested server-content regions
+    // leave this page's eager chunk for `regions.js` — reported above as
+    // lazy, not counted, 1,872 B minified / 805 B brotli — which the frames
+    // client fetches when the document announces the tier or a record names
+    // a `{$frame}` region (the frames note). Cap set at measured + 10 B at
+    // the 0.01 KB step (the ratchet); recorded minified 120,945 B.
+    // Frames savings pass C5 — the assets tier (2026-10-06, measured on its
+    // own branch off the C3 head): 37,970 B (120,102 B minified): -628 /
+    // -1,926 against the C3 head, -6,912 / -25,655 against `next` @
+    // 9d89df731. The head mirror leaves for the lazy `assets.js` chunk
+    // (783 B brotli, reported, not counted). The C5 follow-up (inline styles
+    // hold while the tier is absent): 37,969 B (120,124 B minified), +22 min
+    // / -1 br.
+    // Frames savings pass — Phases B + C3 + C4 + C5 integrated
+    // (2026-10-06, `wip/frames-tiers-integration`): 37.98 -> 37.79 KB
+    // (floor-caps.json), measured at 37,772 B (119,044 B minified) against
+    // the Phase A base 0aab93230's 45,033 (-7,261 B; -26,575 B minified)
+    // and `next` @ 9d89df731's 44,882 (-7,110 B; -26,713 B minified). The
+    // three tier chunks ride beside the eager one — reported above as lazy,
+    // not counted: `trace.js` 25,419 B minified / 8,176 B brotli,
+    // `regions.js` 1,872 / 805, `assets.js` 2,040 / 783. Cap set at measured
+    // + 10 B at the 0.01 KB step (the ratchet); recorded minified 119,044 B.
+    // Frames savings pass C6 (2026-10-06, the bind tier): 37.79 -> 36.66 KB
+    // (floor-caps.json), measured at 36,647 B (115,087 B minified) against
+    // the integration base 6b7213d64's 37,747 (-1,100 B; -3,969 B minified)
+    // and `next` @ 9d89df731's 44,882 (-8,235 B; -30,670 B minified). The
+    // fourth tier chunk rides beside the eager one — reported above as
+    // lazy, not counted: `bind.js` 4,771 B minified / 1,844 B brotli. Cap
+    // set at measured + 10 B at the 0.01 KB step (the ratchet); recorded
+    // minified 115,087 B.
+    // Frames residue pass, step 1 (2026-10-06): 36.66 -> 36.50 KB, measured
+    // at 36,488 B (114,422 B minified): the frames client's D list, the lean
+    // re-ask (the sf client carries the `retry` thunks, +≈ 80 B minified,
+    // and the page still shrinks) — −665 min / −159 br. Cap set at measured
+    // + 10 B at the 0.01 KB step (the ratchet); recorded minified 114,422 B.
+    // Frames residue pass, step 3 (2026-10-06): 36.50 -> 36.29 KB, measured
+    // at 36,271 B (113,443 B minified): every fill through `insert`, the
+    // frame element as the range — −979 min / −217 br. Cap set at measured
+    // + 10 B at the 0.01 KB step (the ratchet); recorded minified 113,443 B.
+    // Frames residue pass, step 4 (2026-10-06): 36.29 -> 36.09 KB, measured
+    // at 36,071 B (112,938 B minified): S-ref's pending read in the decode
+    // table (lazy `decode.js` +420 / +161) — −505 min / −200 br. Cap set at
+    // measured + 10 B at the 0.01 KB step (the ratchet); recorded minified
+    // 112,938 B.
+    // Frames savings pass, C2 (2026-10-07): 36.09 -> 35.74 KB, measured at
+    // 35,722 B (112,003 B minified): the live wire in a lazy tier (`wire.js`
+    // 1,922 / 934, reported not counted) — −935 min / −349 br. Cap set at
+    // measured + 10 B at the 0.01 KB step (the ratchet); recorded minified
+    // 112,003 B.
+    // `dynamicComponent` (B.3-sync, 2026-10-07): 35.74 -> 33.58 KB, measured
+    // at 33,570 B (104,586 B minified): the fixture mounts its server
+    // component through `dynamicComponent`, the component-only sibling of
+    // `dynamic` (documentation/plans/frames-b3-sync.md), so `dynamic`'s
+    // string-tag arm — `staticElement`, `createElement`, `spread`, the
+    // prop-collection helpers, the SVG/MathML tables — is no longer
+    // reachable from this page: −7,417 min / −2,152 br (the edited-dist
+    // model said −7,423 / −2,158). `assign` and below stay for the lazy bind
+    // chunk. Cap set at measured + 10 B at the 0.01 KB step (the ratchet);
+    // recorded minified 104,586 B.
+    // Frames tiers, merged onto `next` @ 3c1d51267 (#3860, 2026-10-07):
+    // `next`'s 45.14 KB -> 33.92 KB (floor-caps.json), measured at 33,908 B
+    // by CI (Size run 37671002618) against `next`'s 45,291 (-11,383 B;
+    // -41,032 B minified, 146,284 -> 105,252). `next`'s bytes since the
+    // branch's base land under the `dynamicComponent` note's 33,570 /
+    // 104,586 (+666 B minified, +338 B brotli). Cap set at measured + 10 B
+    // rounded up to 0.01 KB; recorded minified 105,252 B.
     limit: floorCaps["page: base server components (hydrating + dynamic + frames + sf reference)"],
     capMinified:
       floorMinified["page: base server components (hydrating + dynamic + frames + sf reference)"],
@@ -3866,11 +4102,200 @@ module.exports = [
     // read, and verdict-lane stagedReaders. Cap set at measured + 10 B rounded
     // up to 0.01 KB. Accepted by the maintainer 2026-10-07. The cap is frozen
     // again at 48.91 KB.
+    // Frames savings pass C3 — the traces tier (2026-10-06): 48.60 -> 42.16 KB
+    // (floor-caps.json), measured at 42,147 B against the Phase B head
+    // e05ba0283's 48,873 (-6,726 B; -24,161 B minified, 158,060 -> 133,899)
+    // and `next` @ 9d89df731's 48,595 (-6,448 B). The same split as the base
+    // page (its note): the store engine, the materializer and the plugin's
+    // client half leave for `trace.js` (lazy, not counted, 25,409 B minified
+    // / 8,158 B brotli); the store hydration adapters stay. Cap set at
+    // measured + 10 B at the 0.01 KB step (the ratchet); recorded minified
+    // 133,899 B.
+    // Frames savings pass C4 — the regions tier (2026-10-06): 42.16 -> 41.90 KB
+    // (floor-caps.json), measured at 41,886 B against the C3 head
+    // 89954fa1b's 42,147 (-261 B; -1,083 B minified, 133,899 -> 132,816) and
+    // `next` @ 9d89df731's 48,595 (-6,709 B). The same split as the base page
+    // (its note): regions leave for `regions.js` (lazy, not counted, 1,872 B
+    // minified / 802 B brotli). Cap set at measured + 10 B at the 0.01 KB
+    // step (the ratchet); recorded minified 132,816 B.
+    // Frames savings pass C5 — the assets tier (2026-10-06, measured on its
+    // own branch off the C3 head): 41,651 B (131,973 B minified): -496 /
+    // -1,926 against the C3 head, -6,944 / -25,747 against `next` @
+    // 9d89df731; the same cut as the base page. The C5 follow-up (inline
+    // styles hold while the tier is absent): 41,650 B (131,995 B minified),
+    // +22 min / -1 br.
+    // Frames savings pass — Phases B + C3 + C4 + C5 integrated
+    // (2026-10-06, `wip/frames-tiers-integration`): 41.67 -> 41.44 KB
+    // (floor-caps.json), measured at 41,427 B (130,915 B minified) against
+    // the Phase A base 0aab93230's 48,715 (-7,288 B; -26,667 B minified)
+    // and `next` @ 9d89df731's 48,595 (-7,168 B; -26,805 B minified). The
+    // same split as the base page (its note); the chunks here: `trace.js`
+    // 25,419 / 8,173, `regions.js` 1,872 / 802, `assets.js` 2,040 / 783.
+    // Cap set at measured + 10 B at the 0.01 KB step (the ratchet);
+    // recorded minified 130,915 B.
+    // Frames savings pass C6 (2026-10-06, the bind tier): 41.44 -> 40.30 KB
+    // (floor-caps.json), measured at 40,286 B (126,964 B minified) against
+    // the integration base 6b7213d64's 41,396 (-1,110 B; -3,963 B minified)
+    // and `next` @ 9d89df731's 48,595 (-8,309 B; -30,756 B minified). The
+    // chunk here: `bind.js` 4,771 / 1,843 (it imports the eager frames
+    // entry, so Rolldown attaches it to the page's graph instead of
+    // splitting the shared runtime out of the entry — see bind-tier.ts).
+    // Cap set at measured + 10 B at the 0.01 KB step (the ratchet);
+    // recorded minified 126,964 B.
+    // Frames residue pass, step 1 (2026-10-06): 40.30 -> 40.14 KB, measured
+    // at 40,125 B (126,294 B minified): the frames client's D list and the
+    // lean re-ask — −670 min / −161 br. Cap set at measured + 10 B at the
+    // 0.01 KB step (the ratchet); recorded minified 126,294 B.
+    // Frames residue pass, step 3 (2026-10-06): 40.14 -> 39.92 KB, measured
+    // at 39,904 B (125,315 B minified): every fill through `insert`, the
+    // frame element as the range — −979 min / −221 br. Cap set at measured
+    // + 10 B at the 0.01 KB step (the ratchet); recorded minified 125,315 B.
+    // Frames residue pass, step 4 (2026-10-06): 39.92 -> 39.76 KB, measured
+    // at 39,747 B (124,810 B minified): S-ref's pending read in the decode
+    // table (lazy `decode.js` +420 / +161) — −505 min / −157 br. Cap set at
+    // measured + 10 B at the 0.01 KB step (the ratchet); recorded minified
+    // 124,810 B.
+    // Frames savings pass, C2 (2026-10-07): 39.76 -> 39.43 KB, measured at
+    // 39,412 B (123,903 B minified): the live wire in a lazy tier (`wire.js`
+    // 1,922 / 933, reported not counted — this page LOADS it at its first
+    // `live()` call, so its total transfer is 39,412 + 933 = 40,345 br
+    // against the base's 39,747) — −907 min / −335 br eager. Cap set at
+    // measured + 10 B at the 0.01 KB step (the ratchet); recorded minified
+    // 123,903 B.
+    // `dynamicComponent` (B.3-sync, 2026-10-07): 39.43 -> 37.26 KB, measured
+    // at 37,241 B (116,485 B minified): the fixture mounts through
+    // `dynamicComponent`, shedding `dynamic`'s string-tag arm as on the base
+    // page — −7,418 min / −2,171 br. Cap set at measured + 10 B at the
+    // 0.01 KB step (the ratchet); recorded minified 116,485 B.
+    // Frames tiers, merged onto `next` @ 3c1d51267 (#3860, 2026-10-07):
+    // `next`'s 48.91 KB -> 37.53 KB (floor-caps.json), measured at 37,512 B
+    // by CI (Size run 37671002618) against `next`'s 48,962 (-11,450 B;
+    // -41,096 B minified, 158,397 -> 117,301). `next`'s bytes since the
+    // branch's base land under the `dynamicComponent` note's 37,241 /
+    // 116,485 (+816 B minified, +271 B brotli). Cap set at measured + 10 B
+    // rounded up to 0.01 KB; recorded minified 117,301 B.
     limit: floorCaps["page: live server components (base + live/GET + action + isPending/latest)"],
     capMinified:
       floorMinified["page: live server components (base + live/GET + action + isPending/latest)"],
     alias: pageAlias
   },
+  // Compiled server-component PAGES (2026-10-07): the two page scenarios
+  // above are hand-written — they keep the runtime alive as values and never
+  // compile a template, so the attribute runtime a compiled template imports
+  // (`className`, `style`, `setAttribute`, `addEvent`, `delegateEvents`)
+  // reaches them only through the bind tier's `assign` edge, and a change
+  // that "removes" it from those pages removes nothing from a page an
+  // application ships. These two are the same pages as JSX under
+  // fixtures/compiled/ (sc-base.jsx, sc-live.jsx, the shared sc-shell.jsx),
+  // compiled hydratable by the measured checkout's @solidjs/compiler like
+  // the `app: compiled hydrating` scenario, with the templates a real page
+  // has — and NO element spread: the maintainer's ruling (2026-10-07) is
+  // that most server-component apps do not have client element spreads, so
+  // the compiled baseline must not carry one (`spread` must be absent from
+  // the rendered web.js of both pages; the notes record the check). The
+  // hand-written pages stay as the frames-only floor (frozen caps); these
+  // carry inline caps like the compiled app scenarios: measured + 10 B
+  // rounded up to 0.01 KB, with the minified recorded from the same run.
+  {
+    name: "page: compiled base server components (the base page as JSX: templates with class/style/attributes/events, For/Show; no spread)",
+    // sc-base-app.js as a compiled page: the same server-component mount
+    // (`dynamicComponent()` over a server-function reference, the frames
+    // transport installed), the same client signal + memo, `lazy()` child,
+    // Show / For / Loading / Errored — inside a compiled shell: links with
+    // `href` (`setAttribute`), a dynamic `class` and `style` value
+    // (`className`, `style`, and the `readShallow` the compiler wraps them
+    // in), a handler passed through as a prop (`addEvent`, `delegateEvents`),
+    // a search input with a `value` binding (`setProperty`), `<For>`, `<Show>`
+    // with a function child. The delta against the hand-written base page is
+    // what the compiled templates retain of @solidjs/web plus the compiled
+    // app's own bytes.
+    //
+    // Added 2026-10-07 on feat/web-dynamic-component @ 99915141a (#3870's
+    // head; the stack beneath is #3860 -> #3849 -> next). Measured locally
+    // (macOS, Node 26): 34,869 B (108,634 B minified; signals=33,849
+    // web/frames=26,261 solid=17,675 web=16,521 web/server-functions=12,364
+    // app=1,966) — +1,299 B brotli / +4,048 B minified over the hand-written
+    // base page's 33,570 / 104,586 on the same build: web +1,083
+    // (`template`/`getNextElement`/`getNextMarker` 632, `readShallow` 238,
+    // `setProperty` 217, `scope` 35), signals +1,192 (store/utils.js 1,071:
+    // `readShallow` calls `sourceKeys(value, SOURCE_PROXY)`, which retains
+    // the leaf/merge key walkers of the merge/omit view records — the one
+    // store-view cost left on a spread-free page; `merge`/`omit` themselves
+    // are absent), app +1,966. `spread` is absent (992 B with the spread the
+    // fixture first carried; store/utils.js was 3,510 then). The attribute
+    // runtime proper (`className` 713, `style` 454, `setAttribute` 368,
+    // `addEvent` 282, `delegateEvents` 184, `eventHandler` 1,108, `assign`
+    // 283 + `assignProp` 921 minified) is on BOTH pages: the hand-written one
+    // reaches all of it through the bind tier's `assign` import (Rolldown
+    // attaches bind.js to the entry graph); here the templates import
+    // everything but `assign`/`assignProp` directly — which is why a cut
+    // that drops the bind edge from the hand-written page saves only
+    // `assign`/`assignProp` here. On `next` @ 11e9fb653 (same harness; the
+    // fixture mounts with `dynamic`, which is all `next` has): 45,900 /
+    // 148,820 — the stack is −11,031 B brotli / −40,186 B minified on this
+    // page (−11,569 / −41,837 on the hand-written one). Mounted with
+    // `dynamic` instead of `dynamicComponent` on this head: 36,550 / 114,446
+    // — the sibling saves 1,681 B brotli / 5,812 B minified on this page,
+    // against 2,152 / 7,417 on the hand-written one (the templates already
+    // carry `readShallow` and the walk helpers `dynamic`'s tag arm shares).
+    // Cap at local measured + 10 B at the 0.01 KB step; CI (Linux, Node 24)
+    // must confirm — lower only.
+    // Merged onto `next` @ 3c1d51267 (#3860, 2026-10-07): 34.88 -> 35.09 KB,
+    // measured at 35,079 B by CI (Size run 37671002618; 109,300 B minified).
+    // The 34.88 KB above was local bytes on the branch's pre-merge base;
+    // `next`'s bytes since (#3846's ChunkReader, #3865, #3874 — the same
+    // +666 B minified as the hand-written base page) land under it. No cap
+    // on `next` (a new scenario; `next` cannot bundle the fixture). Cap set
+    // at CI measured + 10 B rounded up to 0.01 KB; recorded minified
+    // 109,300 B.
+    path: "fixtures/compiled/sc-base.jsx",
+    compile: { hydratable: true },
+    limit: "35.09 KB",
+    capMinified: 109300,
+    alias: pageAlias
+  },
+  {
+    name: "page: compiled live server components (the compiled base page + live/GET + action + isPending/latest)",
+    // sc-live-app.js as a compiled page: the compiled base page plus
+    // `live(GET(...))` on the reference, an `action` dispatched from a
+    // compiled click handler, `isPending` / `latest` read in a template's
+    // `class` and a text hole. Still no client stores, no spread.
+    //
+    // Added 2026-10-07 on feat/web-dynamic-component @ 99915141a. Measured
+    // locally (macOS, Node 26): 40,266 B (121,963 B minified; signals=41,889
+    // web/frames=27,502 solid=17,173 web/server-functions=16,912 web=16,047
+    // app=2,439). This page's eager graph is TWO chunks (bundle.mjs): with
+    // `isPending` on the page, the frames tiers (trace.js, bind.js) and the
+    // lazy comments route all reaching the core, Rolldown hoists the shared
+    // runtime — signals core, solid-js, @solidjs/web, 66,354 B minified —
+    // into a `web.js` the entry imports statically (entry 55,609 / 18,354 +
+    // web.js 66,354 / 21,912). It ships eagerly, so it is counted; the two
+    // compressions cost ≈ 1,223 B brotli over one chunk (39,043 concatenated)
+    // and the export glue ≈ 1.3 KB minified. The hand-written live page does
+    // not split only because its lazy page is empty: the same page with a
+    // template in its lazy route splits the same way. +5,397 B brotli /
+    // +13,329 B minified over the compiled base page (the hand-written pair
+    // is +3,671 / +11,899). `spread` absent, as on the base page. On `next`
+    // @ 11e9fb653 (same harness, `dynamic` mount, one chunk — no tiers to
+    // share with): 49,721 / 161,233 — the stack is −9,455 B brotli / −39,270
+    // B minified on this page (−11,647 / −42,051 on the hand-written one).
+    // Mounted with `dynamic` on this head: 42,002 / 127,779 (−1,736 /
+    // −5,816 for `dynamicComponent`). Cap at local measured + 10 B at the
+    // 0.01 KB step; CI (Linux, Node 24) must confirm — lower only.
+    // Merged onto `next` @ 3c1d51267 (#3860, 2026-10-07): 40.28 -> 40.61 KB,
+    // measured at 40,593 B by CI (Size run 37671002618; 122,779 B minified,
+    // the statically-imported web.js chunk counted). The 40.28 KB above was
+    // local bytes on the branch's pre-merge base; `next`'s bytes since land
+    // under it (+816 B minified, as on the hand-written live page). No cap
+    // on `next` (a new scenario; `next` cannot bundle the fixture). Cap set
+    // at CI measured + 10 B rounded up to 0.01 KB; recorded minified
+    // 122,779 B.
+    path: "fixtures/compiled/sc-live.jsx",
+    compile: { hydratable: true },
+    limit: "40.61 KB",
+    capMinified: 122779,
+    alias: pageAlias
+  },
   {
     name: "server: floor (getRequestEvent + isServer)",
     // What a server module that only asks "am I on the server / which
diff --git a/scripts/size/size.mjs b/scripts/size/size.mjs
index a6feaa86c..8a3ef32b8 100644
--- a/scripts/size/size.mjs
+++ b/scripts/size/size.mjs
@@ -1,6 +1,7 @@
 // The size gate: bundles every scenario in scenarios.js with Rolldown and
 // fails when an eager entry chunk exceeds its cap. Prints, per scenario, the
-// brotli and minified size of the entry chunk, the cap, the lazy chunks a
+// brotli and minified size of the eager graph (the entry chunk plus any
+// chunk it imports statically — bundle.mjs), the cap, the lazy chunks a
 // page would fetch later (reported, never counted), and the per-package
 // minified split so a bump is attributed in the log that reports it.
 //
@@ -69,6 +70,7 @@ for (const scenario of scenarios) {
     ...(scenario.minifiedAllowance !== undefined && {
       minifiedAllowance: scenario.minifiedAllowance
     }),
+    ...(r.eager.length && { eager: r.eager }),
     lazy: r.lazy,
     packages: Object.fromEntries(packages)
   });
@@ -77,6 +79,10 @@ for (const scenario of scenarios) {
   console.log(
     `     brotli ${toKB(r.br)} (${r.br} B)  minified ${r.min} B  cap ${r.limit}${over ? `  — over by ${r.br - cap} B` : ""}`
   );
+  if (r.eager.length)
+    console.log(
+      `     eager (statically imported by the entry, counted): ${r.eager.map(c => `${c.name} ${toKB(c.br)}`).join(", ")}`
+    );
   if (r.lazy.length)
     console.log(
       `     lazy (not counted): ${r.lazy.map(c => `${c.name} ${toKB(c.br)}`).join(", ")}`