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-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/documentation/plans/frames-savings-pass.md b/documentation/plans/frames-savings-pass.md
index 6faf90633..3fa31cea3 100644
--- a/documentation/plans/frames-savings-pass.md
+++ b/documentation/plans/frames-savings-pass.md
@@ -88,9 +88,13 @@ _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.
+`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                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -99,7 +103,7 @@ buffer with no hydration involvement.
 | **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.** 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.                                                                                                                                                            |
+| **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
@@ -361,10 +369,10 @@ cap on the same terms; no frames / page cap moved.
 | **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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | **−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. **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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | **≈ −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.                     |
+| **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).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | **−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)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| **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).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | **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                                                                                                                          | —                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 
@@ -373,8 +381,9 @@ 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),
@@ -462,7 +471,7 @@ Tier chunks (lazy, reported not counted; br):
 | `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)      |
+| `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)       |
diff --git a/documentation/server-components/server-components-principles.md b/documentation/server-components/server-components-principles.md
index 391ebb670..d2d72ef87 100644
--- a/documentation/server-components/server-components-principles.md
+++ b/documentation/server-components/server-components-principles.md
@@ -3207,6 +3207,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
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 335a8f0d5..d3a99a000 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,15 +31,19 @@ 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";
+// 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 {
@@ -94,6 +96,17 @@ tierLoaders.regions = () => import("@solidjs/web/frames/regions");
 // 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");
 
 // Build-time literal (see diagnostics.ts): dev-only guidance folds out of prod.
 const IS_DEV = "_SOLID_DEV_" as unknown as boolean;
@@ -136,6 +149,11 @@ export {
 } 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";
 export {
   FRAME_STREAM_HEADER,
   FRAME_HAVE_HEADER,
@@ -429,19 +447,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
@@ -561,225 +566,6 @@ 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;
@@ -833,7 +619,9 @@ function slotsFor(props: Record<string, any>, scope?: ClaimScope) {
           // 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.
+          // heuristic to misread. 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") {
@@ -858,7 +646,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,
diff --git a/packages/web/frames/src/frame-client.ts b/packages/web/frames/src/frame-client.ts
index e141d6c2c..dbc6ad277 100644
--- a/packages/web/frames/src/frame-client.ts
+++ b/packages/web/frames/src/frame-client.ts
@@ -517,96 +517,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
@@ -1118,9 +1103,9 @@ export const FRAME_APPLIED_EVENT = "frame:applied";
 // 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) — and `installServerComponents({ tiers })` adds or
-// replaces entries; a name with no loader is eager and resident by
-// definition (`bind`, `wire` today).
+// 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
@@ -1280,11 +1265,11 @@ class FrameImpl {
   // 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`).
   #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();
   // The release of the frame's hold with the integration while a sync
   // leaves an occurrence waiting to mount (see #syncSlots' end).
   #hold;
@@ -1651,17 +1636,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 tier's 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`).
+    // 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));
@@ -1737,24 +1726,27 @@ class FrameImpl {
       // at its end: the mount runs then and the read throws (L1).
       //
       // A fresh mount also waits for the TIER its occurrence needs (frames
-      // savings pass §2 — the server-announced tier mechanism): a data
-      // occurrence needs `bind` (its positions), 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, its positions at the server's values — until the install's
-      // flush re-syncs. On the adopt path this wait is one more reason in
-      // the frame's registered hold (3.1): the delegated-event replay window
-      // stays open, hydration-done waits.
+      // 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) ||
-          (consumers
-            ? !tierReady("bind")
-            : record && (needsRegions(record) || needsTrace(record.args))))
+        record &&
+        (record.pending || needsRegions(record) || needsTrace(record.args))
       ) {
         waiting = true;
         // Remember what the adopted interior was rendered from. A hold is
@@ -1765,7 +1757,11 @@ class FrameImpl {
         // 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).
-        if (this.#options.adopt)
+        // 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;
       }
@@ -1806,16 +1802,13 @@ class FrameImpl {
           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 {
+        // A data occurrence's mount never returns nodes to place; its
+        // consumer set is handed to the tier (`sync`), which keeps it per
+        // frame for the rebind below. (No `#slotNodes` entry: the zombie
+        // check above skips data occurrences — a replaced element is a
+        // consumer change, not a destroyed mount.)
+        if (consumers) B.sync(this, occurrence, consumers);
+        else {
           if (nodes) this.#replaceRange(occurrence, start, nodes);
           this.#slotNodes.set(occurrence, nodes);
         }
@@ -1832,16 +1825,9 @@ class FrameImpl {
       // 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
@@ -1851,7 +1837,13 @@ class FrameImpl {
         // 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.)
-        if (needsRegions(record)) continue;
+        // 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
@@ -1878,12 +1870,7 @@ class FrameImpl {
         // 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 (!consumers) {
           if (nodes) this.#replaceRange(occurrence, start, nodes);
           this.#slotNodes.set(occurrence, nodes);
         }
@@ -1891,6 +1878,17 @@ class FrameImpl {
       }
     }
 
+    // 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) {
@@ -1928,7 +1926,6 @@ class FrameImpl {
     // 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
@@ -1977,9 +1974,11 @@ class FrameImpl {
       // from its returned object, and returns undefined (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
@@ -2014,19 +2013,18 @@ class FrameImpl {
   #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);
     // 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.
+    // 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) {
@@ -2693,26 +2691,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);
     }
@@ -2813,61 +2810,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
@@ -2875,16 +2828,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;
@@ -3150,10 +3095,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/package.json b/packages/web/package.json
index 2b28be218..ded610021 100644
--- a/packages/web/package.json
+++ b/packages/web/package.json
@@ -345,6 +345,14 @@
       "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"
+    },
     "./types/*": "./types/*"
   },
   "scripts": {
diff --git a/packages/web/rollup.config.js b/packages/web/rollup.config.js
index bf3493764..3ba81543f 100644
--- a/packages/web/rollup.config.js
+++ b/packages/web/rollup.config.js
@@ -123,7 +123,7 @@ const externalizeSharedClient = {
 const externalizeFramesClient = {
   name: "externalize-frames-client",
   resolveId(source, importer) {
-    if (!importer || !/[\\/](trace|regions)-tier\.(js|ts)$/.test(importer)) return null;
+    if (!importer || !/[\\/](trace|regions|bind)-tier\.(js|ts)$/.test(importer)) return null;
     if (source === "./client.js") return { id: "@solidjs/web/frames", external: true };
     return null;
   }
@@ -411,7 +411,11 @@ export default [
       "@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"
+      "@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"
     ],
     // Prod build: strip `_SOLID_DEV_` like the main `dist/web.js` entry, so the
     // frame runtime's dev checks/warnings (marker-integrity diagnostics) do
@@ -436,7 +440,8 @@ export default [
       "@solidjs/web/serialization/decode",
       "@solidjs/web/frames/trace",
       "@solidjs/web/frames/regions",
-      "@solidjs/web/frames/assets"
+      "@solidjs/web/frames/assets",
+      "@solidjs/web/frames/bind"
     ],
     plugins: [replaceFlags(false, true), externalizeSharedTransport]
       .concat(plugins)
@@ -457,7 +462,8 @@ export default [
       "@solidjs/web/serialization/decode",
       "@solidjs/web/frames/trace",
       "@solidjs/web/frames/regions",
-      "@solidjs/web/frames/assets"
+      "@solidjs/web/frames/assets",
+      "@solidjs/web/frames/bind"
     ],
     plugins: [replaceDev(true), externalizeSharedTransport]
       .concat(plugins)
@@ -513,6 +519,35 @@ export default [
     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)
+  },
   {
     // 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/src/server.ts b/packages/web/src/server.ts
index c4fcf56b3..7052f00d7 100644
--- a/packages/web/src/server.ts
+++ b/packages/web/src/server.ts
@@ -4956,6 +4956,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);
@@ -5101,13 +5123,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;
 }
 
 /**
@@ -5209,7 +5237,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;
 
@@ -5217,11 +5247,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/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
index c09bdd036..629b73c19 100644
--- a/packages/web/test/consistency/tier-prepare.spec.tsx
+++ b/packages/web/test/consistency/tier-prepare.spec.tsx
@@ -87,6 +87,11 @@ afterEach(async () => {
 
 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");
@@ -129,8 +134,9 @@ describe("the held set — bind (adopt path, un-announced: detection starts the
     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 with the records they were held on.
-    bind.resolve();
+    // 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);
diff --git a/packages/web/test/consistency/tier-trace-hold.spec.tsx b/packages/web/test/consistency/tier-trace-hold.spec.tsx
index bbb094abe..d71953aef 100644
--- a/packages/web/test/consistency/tier-trace-hold.spec.tsx
+++ b/packages/web/test/consistency/tier-trace-hold.spec.tsx
@@ -16,6 +16,12 @@
  *    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).
@@ -157,6 +163,71 @@ describe("the traces tier — document face", () => {
     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");
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/harness/__artifacts__/welcome-status-streamed.json b/packages/web/test/harness/__artifacts__/welcome-status-streamed.json
index 455132146..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[\"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[21].next($R[24]=[$R[25]=[$R[26]=[\"state\"],\"done\"],$R[27]=[$R[28]=[\"tokens\"],9],$R[29]=[$R[30]=[\"parts\"],2]]);</script><script>$R[21].return(void 0);</script><script>$R[2].next($R[31]={type:\"slot\",fid:\"parity/welcome-streamed\",key:\"status#0\",args:$R[32]={progress:\"streaming\",stats:$R[18],usage:$R[20]}});</script><script>$R[22]($R[19],$R[33]={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[2].return(void 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/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/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/tsconfig.build.json b/packages/web/tsconfig.build.json
index 08cf20028..3500ceefb 100644
--- a/packages/web/tsconfig.build.json
+++ b/packages/web/tsconfig.build.json
@@ -15,7 +15,8 @@
       "@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/assets": ["./frames/src/assets-tier.ts"],
+      "@solidjs/web/frames/bind": ["./frames/src/bind-tier.ts"]
     }
   },
   "include": [
diff --git a/packages/web/vite.config.hydrate.mjs b/packages/web/vite.config.hydrate.mjs
index 324ecc812..6d8c5e47e 100644
--- a/packages/web/vite.config.hydrate.mjs
+++ b/packages/web/vite.config.hydrate.mjs
@@ -48,6 +48,7 @@ export default defineConfig({
       "@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": resolve(rootDir, "src/index.ts")
     }
   }
diff --git a/packages/web/vite.config.mjs b/packages/web/vite.config.mjs
index de6da5ffa..1d3a276d3 100644
--- a/packages/web/vite.config.mjs
+++ b/packages/web/vite.config.mjs
@@ -63,7 +63,8 @@ export default defineConfig({
       // 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/assets": resolve(rootDir, "frames/src/assets-tier.ts"),
+      "@solidjs/web/frames/bind": resolve(rootDir, "frames/src/bind-tier.ts")
     }
   }
 });
diff --git a/scripts/size/floor-caps.json b/scripts/size/floor-caps.json
index 419affcbe..cacccf274 100644
--- a/scripts/size/floor-caps.json
+++ b/scripts/size/floor-caps.json
@@ -12,12 +12,12 @@
     "minified": 52794
   },
   "page: base server components (hydrating + dynamic + frames + sf reference)": {
-    "cap": "37.79 KB",
-    "minified": 119044
+    "cap": "36.66 KB",
+    "minified": 115087
   },
   "page: live server components (base + live/GET + action + isPending/latest)": {
-    "cap": "41.44 KB",
-    "minified": 130915
+    "cap": "40.30 KB",
+    "minified": 126964
   },
   "server: floor (getRequestEvent + isServer)": {
     "cap": "1.34 KB",
diff --git a/scripts/size/scenarios.js b/scripts/size/scenarios.js
index c2e65389e..ad1713b33 100644
--- a/scripts/size/scenarios.js
+++ b/scripts/size/scenarios.js
@@ -78,7 +78,9 @@ const floorMinified = Object.fromEntries(
 // 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` — each lazy, not counted. The "frames: eager
+// 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` — 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
@@ -87,6 +89,7 @@ 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",
   "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",
@@ -130,11 +133,12 @@ const framesExternal = [
   // 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) and the assets tier (C5) likewise.
+  // regions tier (C4), the assets tier (C5) and the bind tier (C6) likewise.
   "solid-js/internal/container-trace",
   "@solidjs/web/frames/trace",
   "@solidjs/web/frames/regions",
   "@solidjs/web/frames/assets",
+  "@solidjs/web/frames/bind",
   "@solidjs/web",
   "@solidjs/web/serialization",
   "@solidjs/web/serialization/decode"
@@ -3489,8 +3493,24 @@ module.exports = [
     // 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.
-    limit: "13.10 KB",
-    capMinified: 40000,
+    // 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.
+    limit: "11.92 KB",
+    capMinified: 36007,
     alias: framesAlias,
     external: framesExternal
   },
@@ -3701,6 +3721,14 @@ module.exports = [
     // 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.
     limit: floorCaps["page: base server components (hydrating + dynamic + frames + sf reference)"],
     capMinified:
       floorMinified["page: base server components (hydrating + dynamic + frames + sf reference)"],
@@ -3853,6 +3881,15 @@ module.exports = [
     // 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.
     limit: floorCaps["page: live server components (base + live/GET + action + isPending/latest)"],
     capMinified:
       floorMinified["page: live server components (base + live/GET + action + isPending/latest)"],