Matrix: the address-switch dimension gets its two missing cells

The brenelz round exposed two lifecycle shapes the matrix never pinned:

- Byte-identical shell across a switch (dom-expressions#564's policy):
  slot-driven content ships its differences as records, so the new
  address's html can be the same bytes — root affinity is per stream,
  and the identical shell still answers the gate while the record-driven
  difference lands.
- Double-switch mid-flight: the gate re-arms per switch, only the LIVE
  call's answer settles it, the superseded call's late stream warms its
  own store without touching the boundary — and switching back
  re-materializes from that warm synchronously.

Plus the reveal-then-refetch cell over an adopted region (#2979's
follow-through): the reveal-driven record drain is a one-time repair,
and the region stays fully live for the refetch that follows.

MATRIX.md gains the address-switch section (the #2977 trio was never
tabled) and drops its two GAP rows — both were closed on this branch
(shell gate, occurrence-unmount cleanup); the stale test.fails comments
go with them.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ryansolid

packages/solid-web/test/frames-adopted-region-fragments.spec.tsx

@@ -132,6 +132,8 @@ function mountBoundary(fid: string) {
 }
 
 describe("deferred fragments inside an adopted region (#2978)", () => {
+  let host: any;
+
   beforeAll(() => {
     // The whole page, before any boundary lookup: one SSR'd boundary per test.
     document.body.innerHTML =
@@ -140,14 +142,16 @@ describe("deferred fragments inside an adopted region (#2978)", () => {
       boundaryHtml("deadlock/nested", "21", "outer-fallback") +
       boundaryHtml("deadlock/replaced", "31", "replaced-fallback") +
       boundaryHtml("deadlock/records", "41", "records-fallback") +
+      boundaryHtml("deadlock/refetch", "51", "refetch-fallback") +
       "</div>";
     (window as any)._$HY = { r: {}, fe() {} };
     enableHydration();
     installSwapRuntime();
     vi.stubGlobal("fetch", () => {
       throw new Error("fetch must not be called at t=0");
     });
-    installServerComponents(makeHost());
+    host = makeHost();
+    installServerComponents(host);
   });
 
   afterAll(() => {
@@ -315,4 +319,71 @@ describe("deferred fragments inside an adopted region (#2978)", () => {
 
     dispose();
   });
+
+  // #2979's follow-through: the reveal-driven drain is a one-time repair for
+  // records that rode the FRAGMENT — it must leave the region fully live.
+  // After the reveal, a refetch's stream is the region's ordinary future:
+  // its slot record updates the occurrence, its html morphs the interior,
+  // and the ledger (already resolved by the reveal) stays resolved.
+  test("reveal, then refetch: after the reveal-driven record drain a later stream still morphs and updates the occurrence", async () => {
+    declareFragment("51");
+
+    const Page = (window as any)._$SC.r("deadlock/refetch");
+    const appEl = document.getElementById("app") as HTMLElement;
+    let mount!: HTMLDivElement;
+    const dispose = createRoot(d => {
+      <div ref={mount}>
+        <Loading fallback={<span>shell-fallback</span>}>
+          <Page row={(p: { label: string }) => <b>row:{p.label}</b>} />
+        </Loading>
+      </div>;
+      appEl.appendChild(mount);
+      return d;
+    });
+    flush();
+    await settle();
+    flush();
+
+    completeHydrationPass();
+    await settle();
+
+    // The #2979 shape: the fragment's chunk carries the occurrence's markers
+    // AND the record naming its args.
+    (window as any)._$HY.r["sc:slot:deadlock/refetch:row#0"] = { label: "settled" };
+    deliverFragment("51", "<!--slot:row#0:start--><!--slot:row#0:end-->");
+    flush();
+    await settle();
+    flush();
+
+    const frameEl = document.querySelector('[data-fid="deadlock/refetch"]') as HTMLElement;
+    expect(frameEl.textContent).toContain("row:settled");
+    expect((window as any)._$HY.fr.pending()).toBe(false);
+
+    // The refetch: a navigation-shaped stream lands on the adopted boundary
+    // (the document wire id IS the argless call's address). Its record
+    // changes the occurrence's args; its html morphs around the slot range.
+    host.apply({
+      type: "slot",
+      id: "deadlock/refetch",
+      version: 1,
+      key: "row#0",
+      args: { label: "refetched" }
+    });
+    host.apply({
+      type: "html",
+      id: "deadlock/refetch",
+      version: 1,
+      html: "<h1>Page2</h1><section><!--slot:row#0:start--><!--slot:row#0:end--></section>"
+    });
+    flush();
+    await settle();
+    flush();
+
+    expect(frameEl.querySelector("h1")!.textContent).toBe("Page2");
+    expect(frameEl.textContent).toContain("row:refetched");
+    expect(frameEl.textContent).not.toContain("row:settled");
+    expect((window as any)._$HY.fr.pending()).toBe(false);
+
+    dispose();
+  });
 });

packages/solid-web/test/lifecycle-matrix/MATRIX.md

@@ -49,7 +49,7 @@ is mount-kind-independent; enumerated once where it is richest) · **existing**
 | args changed across responses — re-call path | `call-driven-slots` › `raw-frame/re-call-path` | pass — via a raw `createFrameElement`; unreachable through `dynamic()`: solid-web's `slotsFor` registers `ctx.onUpdate` for every invoked occurrence, so the frame never re-calls there |
 | `$key`ed occurrences across reorders (state follows key) | `call-driven-slots` › `call-driven/slot/keyed-reorder` | pass — live range relocates with its interior and signal state |
 | occurrence removed in a later response — DOM unmount | `call-driven-slots` › `call-driven/slot/occurrence-removed` (state reset half) | pass |
-| occurrence removed — fill's `onCleanup` runs at unmount | `call-driven-slots` › `call-driven/slot/occurrence-removed` (cleanup half) | **GAP** — solid `onCleanup` in a fill registers on the BOUNDARY owner; occurrence unmount runs only frame-level ctx cleanups, so consumer cleanup fires at boundary dispose, not occurrence unmount |
+| occurrence removed — fill's `onCleanup` runs at unmount | `call-driven-slots` › `call-driven/slot/occurrence-removed` (cleanup half) | pass — closed gap: a stream-mounted fill renders under a per-occurrence owner disposed at unmount (see closed-gap notes below) |
 | occurrence re-introduced after removal (fresh invocation, state reset) | `call-driven-slots` › `call-driven/slot/occurrence-removed` | pass |
 | re-sent identical record (dedupe: no re-call, no state loss) | `call-driven-slots` › `call-driven/slot/re-sent-identical-record` | pass |
 | adopted occurrence: identical re-send dedupes; changed record updates live | `document-adoption` › `t=0/adopted-occurrence-records` | pass |
@@ -86,20 +86,39 @@ is mount-kind-independent; enumerated once where it is richest) · **existing**
 | Cell | Spec / test | Status |
 | --- | --- | --- |
 | fill `onCleanup` fires on frame/boundary dispose, exactly once | `call-driven-slots` › `call-driven/cleanup-disposal` | pass |
-| fill `onCleanup` fires on occurrence unmount | `call-driven-slots` › `occurrence-removed` | **GAP** (see above) |
+| fill `onCleanup` fires on occurrence unmount | `call-driven-slots` › `occurrence-removed` | pass (see above) |
 | no double-dispose (second owner disposal is a no-op; ctx cleanups don't re-fire at frame dispose after occurrence unmount) | `call-driven-slots` › `cleanup-disposal` + `raw-frame/re-call-path` (ctx.onCleanup) | pass |
 | a disposed frame ignores late chunks (store warms; no DOM writes, no crash) | `call-driven-slots` › `cleanup-disposal` (late chunks) | pass |
 
+## Address switch on a live site
+
+The identity split (DR-1): an args change resolves to the SAME component, so
+the instance keeps its mount and rebinds to the new call's address. The
+binding resolves at response-header time — which is not an answer — so a
+re-armable gate holds the driving source's `isPending` until the new
+address's first content, server fallback, or error applies (#2977).
+
+| Cell | Spec / test | Status |
+| --- | --- | --- |
+| switch holds pending until the new address's first content applies | `call-driven-lifecycle` › `call-driven/args-switch-gate` | pass |
+| a shell carrying a server `<Loading>` fallback IS an answer (pending drops at the shell, not the late reveal) | `call-driven-lifecycle` › `args-switch-gate` (server fallback) | pass |
+| an errored stream is an answer (pending must not outlive the response) | `call-driven-lifecycle` › `args-switch-gate` (error) | pass |
+| byte-identical shell across the switch still answers (root affinity is per stream — dom-expressions#564; the difference ships as records) | `call-driven-lifecycle` › `args-switch-gate` (byte-identical) | pass |
+| double-switch mid-flight: the gate re-arms; the superseded call's late answer warms its store, never the live boundary; switching back re-materializes from that warm | `call-driven-lifecycle` › `args-switch-gate` (mid-flight) | pass |
+| adopted site: t=0 zero-network mount, then a switch holds pending until the new address answers | `document-adoption` › `t=0/adopted-switch-gate` | pass |
+
 ## Loading / reveal gating
 
 | Cell | Spec / test | Status |
 | --- | --- | --- |
 | fragment + reveal sequences reveal when ready, order-independently (reveal-before-content waits; independent segments reveal as their pairs complete) | `call-driven-lifecycle` › `call-driven/fragment-reveal-gating` | pass |
 | fallback reveal materializes the placeholder template for a late fragment; the real reveal swaps it out | `call-driven-lifecycle` › `fragment-reveal-gating` (fallback) | pass |
-| shell gate: fresh call-driven mount's covering `<Loading>` holds until first content applies | `call-driven-lifecycle` › `call-driven/shell-gate` | **GAP** — the boundary releases at response HEAD (when the transport resolves the call with its binding); between head and the first html record the user sees an empty `<dx-frame>` (the empty-frame flash) |
-| shell gate releases on an error record (no eternal fallback) | `call-driven-lifecycle` › `call-driven/shell-gate` (error) | pass — note it passes *because* nothing gates today; if the gate above is added, this cell keeps it honest about the error path |
+| shell gate: fresh call-driven mount's covering `<Loading>` holds until first content applies | `call-driven-lifecycle` › `call-driven/shell-gate` | pass — closed gap: the mount gates on the frame's first apply (no empty-frame flash) |
+| shell gate releases on an error record (no eternal fallback) | `call-driven-lifecycle` › `call-driven/shell-gate` (error) | pass — an `:error` record fires the apply notification, so the gate releases on a failed stream |
 | t=0 adoption × shell gate | — | n/a — adopted content is already on screen at mount; no covering fallback ever shows |
 | deferred segment reveals covering an unboundaried async client fill | — | existing — `frames-client.spec.tsx` (reveal seam reconstructs a client `<Loading>`) |
+| post-done fragment reveals into an adopted region (held-swap claim, nested cascade, records riding the fragment) | — | existing — `frames-adopted-region-fragments.spec.tsx` (#2978/#2979) |
+| reveal, then refetch: after the reveal-driven record drain a later stream still morphs the region and updates the occurrence | — | existing — `frames-adopted-region-fragments.spec.tsx` (reveal-then-refetch) |
 
 ## Not constructible in this config
 
@@ -119,14 +138,13 @@ is mount-kind-independent; enumerated once where it is richest) · **existing**
 
 ## GAP summary
 
-1. **Shell gate / empty-frame flash** (`call-driven-lifecycle.spec.tsx`):
-   a fresh call-driven mount's covering `<Loading>` releases when the call
-   resolves (response head), not when the frame first has content — a slow
-   body shows an empty boundary instead of the fallback. Expected: hold
-   until the first html record applies, releasing on an error record too.
-2. **Occurrence-unmount cleanup** (`call-driven-slots.spec.tsx`): `onCleanup`
-   inside a slot fill does not run when a later response drops the
-   occurrence — fills' reactive scopes belong to the boundary owner and only
-   dispose with the boundary. Expected: occurrence unmount disposes the
-   fill's scope (its `onCleanup` runs there), with no double-fire at
+No open gaps. The two the matrix originally surfaced are closed:
+
+1. **Shell gate / empty-frame flash** (`call-driven-lifecycle.spec.tsx`) —
+   closed: a fresh call-driven mount holds its covering `<Loading>` from
+   response head until the frame's first content applies, releasing on an
+   error record too (the runtime's error-apply notification).
+2. **Occurrence-unmount cleanup** (`call-driven-slots.spec.tsx`) — closed:
+   a stream-mounted fill renders under a per-occurrence owner that occurrence
+   unmount disposes (its `onCleanup` runs there), with no double-fire at
    boundary dispose.

packages/solid-web/test/lifecycle-matrix/call-driven-lifecycle.spec.tsx

@@ -32,6 +32,8 @@ const getShellErr = createServerReference("matrix/lc/shell-err");
 const getSwitch = createServerReference("matrix/lc/switch");
 const getSwitchFb = createServerReference("matrix/lc/switch-fb");
 const getSwitchErr = createServerReference("matrix/lc/switch-err");
+const getSwitchSame = createServerReference("matrix/lc/switch-same");
+const getSwitchTwice = createServerReference("matrix/lc/switch-twice");
 
 function articleHtml(title: string) {
   return (
@@ -201,10 +203,8 @@ describe("call-driven/second-response-newer-version", () => {
 });
 
 describe("call-driven/error-record", () => {
-  // Requires the runtime's error-apply notification (an :error record fires
-  // onApply so the shell gate releases and the empty frame mounts) —
-  // present in the runtime this branch links; marked test.fails on next
-  // until its dep bumps past it.
+  // Relies on the runtime's error-apply notification (an :error record fires
+  // onApply so the shell gate releases and the empty frame mounts).
   test("error/before-html: the record surfaces through frame.error; the boundary mounts empty, not stuck on fallback", async () => {
     const { host } = makeHost();
     installServerComponents(host);
@@ -470,10 +470,8 @@ describe("call-driven/shell-gate", () => {
     m.cleanup();
   });
 
-  // Requires the runtime's error-apply notification (an :error record fires
-  // onApply so the gate releases on a failed stream) — present in the
-  // runtime this branch links; marked test.fails on next until its dep
-  // bumps past it.
+  // Relies on the runtime's error-apply notification (an :error record fires
+  // onApply so the gate releases on a failed stream).
   test("the shell gate releases on an ERROR record too (an errored stream must not hold the fallback forever)", async () => {
     const { host } = makeHost();
     installServerComponents(host);
@@ -508,15 +506,15 @@ describe("call-driven/args-switch-gate", () => {
   //
   // Mounts the pending probe alongside the boundary so the test reads
   // exactly what the issue's `<button disabled={isPending(count)}>` reads.
-  function mountWithProbe(Comp: any, source: () => unknown) {
+  function mountWithProbe(Comp: any, source: () => unknown, props: Record<string, any> = {}) {
     const container = document.createElement("div");
     document.body.appendChild(container);
     let div!: HTMLDivElement;
     const dispose = createRoot(d => {
       <div ref={div}>
         <span data-probe>{isPending(source) ? "pending" : "idle"}</span>
         <Loading fallback={<span>shell-fallback</span>}>
-          <Comp />
+          <Comp {...props} />
         </Loading>
       </div>;
       container.appendChild(div);
@@ -660,4 +658,97 @@ describe("call-driven/args-switch-gate", () => {
 
     m.cleanup();
   });
+
+  // dom-expressions#564: root affinity is per STREAM, not per boundary.
+  // Slot-driven content ships its differences as records, so two calls'
+  // shells can be the same bytes — a value-skip keyed to the boundary would
+  // swallow the new stream's apply and the gate would wait forever on a
+  // morph that never differs.
+  test("a byte-identical shell across the switch is still an ANSWER: the gate settles and the record-driven difference lands", async () => {
+    const { host } = makeHost();
+    installServerComponents(host);
+    const held = heldPerArg();
+
+    const [count, setCount] = createSignal(0);
+    const Page = dynamic(() => getSwitchSame(count()) as any);
+    const m = mountWithProbe(Page, count, { comment: (p: any) => <li>{p.text}</li> });
+
+    await pump();
+    held[0].send({ type: "start", id: "srv", version: 1 });
+    held[0].send({ type: "slot", id: "srv", version: 1, key: "comment#0", args: { text: "zero" } });
+    held[0].send({ type: "html", id: "srv", version: 1, html: articleHtml("Same") });
+    await pump();
+    expect(m.div.querySelector("ul li")!.textContent).toBe("zero");
+    expect(m.probe()).toBe("idle");
+
+    setCount(1);
+    await pump();
+    expect(m.probe()).toBe("pending");
+
+    // The new address's shell: identical html, only the slot record differs.
+    held[1].send({ type: "start", id: "srv", version: 1 });
+    held[1].send({ type: "slot", id: "srv", version: 1, key: "comment#0", args: { text: "one" } });
+    held[1].send({ type: "html", id: "srv", version: 1, html: articleHtml("Same") });
+    held[1].close();
+    await pump();
+    expect(m.probe()).toBe("idle");
+    expect(m.div.querySelector("h1")!.textContent).toBe("Same");
+    expect(m.div.querySelector("ul li")!.textContent).toBe("one");
+
+    m.cleanup();
+  });
+
+  test("a second switch MID-FLIGHT re-arms the gate; the superseded call's late answer warms its store but never the live boundary", async () => {
+    const { host } = makeHost();
+    installServerComponents(host);
+    const held = heldPerArg();
+
+    const [count, setCount] = createSignal(0);
+    const Page = dynamic(() => getSwitchTwice(count()) as any);
+    const m = mountWithProbe(Page, count);
+
+    await pump();
+    held[0].send({ type: "start", id: "srv", version: 1 });
+    held[0].send({ type: "html", id: "srv", version: 1, html: articleHtml("Zero") });
+    await pump();
+    expect(m.probe()).toBe("idle");
+
+    setCount(1);
+    await pump();
+    expect(m.probe()).toBe("pending");
+
+    // The user switches again before the first switch answers: still one
+    // unanswered question, still pending, still the ORIGINAL content.
+    setCount(2);
+    await pump();
+    expect(m.probe()).toBe("pending");
+    expect(m.div.querySelector("h1")!.textContent).toBe("Zero");
+
+    // Only the LIVE call's answer settles the gate.
+    held[2].send({ type: "start", id: "srv", version: 1 });
+    held[2].send({ type: "html", id: "srv", version: 1, html: articleHtml("Two") });
+    held[2].close();
+    await pump();
+    expect(m.div.querySelector("h1")!.textContent).toBe("Two");
+    expect(m.probe()).toBe("idle");
+
+    // The superseded call's stream finally answers — into its own address's
+    // store (a warm), never the boundary that moved on.
+    held[1].send({ type: "start", id: "srv", version: 1 });
+    held[1].send({ type: "html", id: "srv", version: 1, html: articleHtml("One") });
+    held[1].close();
+    await pump();
+    expect(m.div.querySelector("h1")!.textContent).toBe("Two");
+    expect(m.probe()).toBe("idle");
+
+    // And that warm is real: switching back re-materializes the superseded
+    // answer instantly (the refetch it also fires morphs later, unanswered
+    // here) — the rebind's re-registration answers synchronously.
+    setCount(1);
+    await pump();
+    expect(m.div.querySelector("h1")!.textContent).toBe("One");
+    expect(m.probe()).toBe("idle");
+
+    m.cleanup();
+  });
 });