diff --git a/packages/signals/docs/RULES-INDEX.md b/packages/signals/docs/RULES-INDEX.md
index de7f448eb..bc1517d8e 100644
--- a/packages/signals/docs/RULES-INDEX.md
+++ b/packages/signals/docs/RULES-INDEX.md
@@ -63,17 +63,17 @@ Status legend: **live** stated and standing · **ruled** carries an explicit rul
 | A16 | amended | `docs/SPEC-ASYNC-SEMANTICS.md:191` | scheduler.ts×1 | spec-async-semantics.test.ts×1 strict-read-pending-store.test.ts×2 uninitialized-visibility.test.ts×1 visibility-oracle-store.states.ts×2 visibility-oracle.states.ts×2 visibility-oracle.test.ts×1 | [ruled, amended in place 2026-07-06 (promoted from B5)] `isPending` never throws in untracked contexts — (was B5) `isPending` never throws in untracked contexts — thunks that throw real errors or read… |
 | A17 | amended | `docs/SPEC-ASYNC-SEMANTICS.md:49` | async.ts×3 constants.ts×1 lanes.ts×5 scheduler.ts×2 verdict.ts×1 map.ts×1 store.ts×3 | lane-uninitialized-landing-3648.test.ts×5 optimistic-read-lane-not-transaction-3698.test.ts×2 optimistic-undefined-override.test.ts×1 posture-store-parity.test.ts×1 refresh-await.test.ts×1 reveal-gating-contract.test.ts×3 spec-async-semantics.test.ts×10 createOptimisticStore.test.ts×2 kanban-a17-fixture.test.ts×3 optimistic-list-mutation-matrix.test.ts×1 optimistic-maparray-index-frame-f1.test.ts×1 optimistic-untracked-reads-f3-f5.test.ts×1 signal-store-twins-qd.test.ts×1 treeshake.test.ts×1 until.test.ts×1 visibility-oracle-store.states.ts×24 visibility-oracle-store.test.ts×1 visibility-oracle.states.ts×20 visibility-oracle.test.ts×1 | [ruled, amended in place 2026-07-06 (promoted from C4)] An active override is the displayed value until its transaction commits, and the graph's value until its own source answers — **Statement (curre… |
 | A18 | amended | `docs/SPEC-ASYNC-SEMANTICS.md:59` | action.ts×1 async.ts×2 core.ts×3 lanes.ts×8 scheduler.ts×2 types.ts×1 verdict.ts×1 map.ts×1 optimistic.ts×1 projection.ts×1 | body-end-supersession-visibility.test.ts×4 createOptimistic.test.ts×3 lane-contract.test.ts×1 lane-frame-deferred-run-3662.test.ts×1 lane-outside-view.test.ts×1 lane-uninitialized-landing-3648.test.ts×5 optimistic-move-duplicate-3548.test.ts×2 optimistic-read-lane-not-transaction-3698.test.ts×4 posture-store-parity.test.ts×5 spec-async-semantics.test.ts×3 flight-owned-transaction.test.ts×1 optimistic-list-mutation-matrix.test.ts×1 optimistic-untracked-reads-f3-f5.test.ts×1 signal-store-twins-qd.test.ts×1 superseded-before-first-commit.test.ts×4 visibility-oracle-store.states.ts×8 visibility-oracle-store.test.ts×1 visibility-oracle.states.ts×19 visibility-oracle.test.ts×1 | [ruled, amended in place 2026-07-07 (promoted from B4)] An override lives exactly as long as its own transaction; a newer truth from the source supersedes it in the graph immediately, on screen at com… |
-| A19 | amended | `docs/SPEC-ASYNC-SEMANTICS.md:119` | constants.ts×1 core.ts×6 scheduler.ts×2 types.ts×1 verdict.ts×4 store.ts×1 | lane-uninitialized-landing-3648.test.ts×2 spec-async-semantics.test.ts×3 superseded-before-first-commit.test.ts×3 uninitialized-visibility.test.ts×1 visibility-oracle-store.states.ts×8 visibility-oracle-store.test.ts×1 visibility-oracle.states.ts×14 visibility-oracle.test.ts×1 write-proposals-3494.test.ts×1 | [ruled, amended in place 2026-07-07 (promoted from C1)] `isPending(x)` ≡ the observable value is not final (three causes) — (was C1 — **partially reverses an earlier decision**) **Definition: `isPendi… |
+| A19 | amended | `docs/SPEC-ASYNC-SEMANTICS.md:119` | constants.ts×1 core.ts×6 scheduler.ts×2 types.ts×1 verdict.ts×4 store.ts×1 | lane-uninitialized-landing-3648.test.ts×2 spec-async-semantics.test.ts×3 derived-presence-async-3726.test.ts×2 superseded-before-first-commit.test.ts×3 uninitialized-visibility.test.ts×1 visibility-oracle-store.states.ts×8 visibility-oracle-store.test.ts×1 visibility-oracle.states.ts×14 visibility-oracle.test.ts×1 write-proposals-3494.test.ts×1 | [ruled, amended in place 2026-07-07 (promoted from C1)] `isPending(x)` ≡ the observable value is not final (three causes) — (was C1 — **partially reverses an earlier decision**) **Definition: `isPendi… |
 | A20 | superseded | `docs/SPEC-ASYNC-SEMANTICS.md:378` | — | question-scoped-pending.test.ts×2 spec-async-semantics.test.ts×3 createOptimisticStore.test.ts×1 | [superseded 2026-07-13 by A24] (superseded) Optimistic writes announce a store-wide pending — (**SUPERSEDED 2026-07-13 by A24** — the mask is deleted; optimistic writes are verdict-inert. Kept for the… |
 | A21 | superseded | `docs/SPEC-ASYNC-SEMANTICS.md:385` | — | question-scoped-pending.test.ts×3 spec-async-semantics.test.ts×3 | [superseded 2026-07-13 by A24] (superseded) The store-wide mask — (**SUPERSEDED 2026-07-13 by A24** — the store-wide mask is deleted with the mask model; nothing silences a new question. The effective… |
 | A22 | amended | `docs/SPEC-ASYNC-SEMANTICS.md:199` | store.ts×1 | createProjection.draft-lifetime-3585.test.ts×1 spec-async-semantics.test.ts×1 visibility-oracle-store.states.ts×1 | [ruled, amended in place 2026-07-08] Pending is per-node; store-wide only for the firewall's own work — **Pending is per-node: store-wide verdicts exist only as the firewall's own in-flight work (A9) … |
 | A23 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:209` | — | spec-async-semantics.test.ts×1 | [ruled 2026-07-08] The `isPending` probe is reads-only — **The `isPending` probe is reads-only — the thunk's return value is never inspected.** `isPending(() => store)` reads nothing and reports `fals… |
 | A24 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:127` | affects.ts×2 constants.ts×1 lanes.ts×2 types.ts×1 verdict.ts×3 affects.ts×1 optimistic.ts×1 | body-end-supersession-visibility.test.ts×1 optimistic-undefined-override.test.ts×1 reveal-gating-contract.test.ts×1 spec-async-semantics.test.ts×3 kanban-a17-fixture.test.ts×1 signal-store-twins-qd.test.ts×1 visibility-oracle-store.states.ts×4 visibility-oracle.states.ts×5 visibility-oracle.test.ts×1 | [ruled 2026-07-13] Question-scoped pending: pending iff a value change is in flight or an `affects()` mark is live — (**ruled 2026-07-13** — supersedes A20/A21; the converged model from the #2844/#272… |
-| A25 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:279` | projection.ts×1 | uninitialized-visibility.test.ts×3 visibility-oracle-store.states.ts×7 visibility-oracle-store.test.ts×1 | [ruled 2026-07-16] A derived store's seed is a draft, never an observable value — (**ruled 2026-07-16**, #2897) **A derived store's seed is a draft, never an observable value.** The seed exists for th… |
+| A25 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:279` | projection.ts×1 | derived-presence-async-3726.test.ts×2 uninitialized-visibility.test.ts×3 visibility-oracle-store.states.ts×7 visibility-oracle-store.test.ts×1 | [ruled 2026-07-16] A derived store's seed is a draft, never an observable value — (**ruled 2026-07-16**, #2897) **A derived store's seed is a draft, never an observable value.** The seed exists for th… |
 | A26 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:85` | — | action-await-contract.test.ts×2 posture-store-parity.test.ts×2 visibility-oracle-store.states.ts×2 visibility-oracle.states.ts×1 visibility-oracle.test.ts×1 | [ruled 2026-07-17] An ambient transaction window is one flush; parking is flush-driven — (**ruled 2026-07-17**, #2913; **enforcement hardened 2026-08-31**, #3141 — parking is flush-driven, and a trans… |
 | A27 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:271` | — | loading-value.test.ts×2 visibility-oracle.states.ts×18 visibility-oracle.test.ts×1 | [ruled 2026-08-10] The commit-#0 loading window is loading-class and verdict-quiet — (**ruled 2026-08-10**) **The commit-#0 loading window is loading-class and verdict-quiet.** A node born committed v… |
 | A28 | ruled, mechanism landed | `docs/SPEC-ASYNC-SEMANTICS.md:69` | constants.ts×1 core.ts×12 lanes.ts×2 scheduler.ts×3 types.ts×1 verdict.ts×2 store.ts×4 | createOptimistic.test.ts×5 held-derivation-not-a-proposal-3612.test.ts×1 latest-held-till-flush.test.ts×1 posture-store-parity.test.ts×5 question-scoped-pending.test.ts×3 snapshot-derived-store-rows.test.ts×1 createOptimisticStore.test.ts×10 optimistic-draft-visibility-3665.test.ts×5 optimistic-list-mutation-matrix.harness.ts×1 optimistic-list-mutation-matrix.test.ts×2 shallow.test.ts×1 woken-transaction-adopts-staged-bump.test.ts×1 treeshake.test.ts×2 verdict-contract.test.ts×1 visibility-oracle-store.states.ts×8 visibility-oracle.states.ts×8 | [ruled, mechanism landed 2026-09-15] A write becomes visible at flush — to every channel — (**ruled 2026-09-08**; supersedes the #2922 mid-tick pull) **A write becomes visible at flush — to every chan… |
-| A29 | amended | `docs/SPEC-ASYNC-SEMANTICS.md:93` | boundaries.ts×1 action.ts×1 constants.ts×1 core.ts×8 effect.ts×1 scheduler.ts×3 signals.ts×1 store.ts×1 | adoption-unchanged-key-read-3706.test.ts×9 body-end-supersession-visibility.test.ts×1 born-held.test.ts×3 boundary-not-born-held-3540.test.ts×4 createProjection.draft-lifetime-3585.test.ts×1 direct-commit-readers-posture.test.ts×1 held-conditional-memo.test.ts×1 held-frame-dependencies.test.ts×2 held-truth-lane-only.test.ts×3 l2-contract.test.ts×1 latest-held-till-flush.test.ts×2 optimistic-read-lane-not-transaction-3698.test.ts×3 posture-born-held-and-observation.test.ts×1 posture-store-parity.test.ts×6 optimistic-untracked-reads-f3-f5.test.ts×1 store-unchanged-read-independent-write-3688.test.ts×1 treeshake.test.ts×3 visibility-oracle-store.states.ts×5 visibility-oracle-store.test.ts×1 visibility-oracle.states.ts×9 visibility-oracle.test.ts×1 write-proposals-3494.test.ts×1 | [ruled, amended in place 2026-09-13 (#3408)] A tracked read served a live transaction's staged value enters that transaction — A tracked computation served a node's staged `_pendingValue` — a value a … |
+| A29 | amended | `docs/SPEC-ASYNC-SEMANTICS.md:93` | boundaries.ts×1 action.ts×1 constants.ts×1 core.ts×8 effect.ts×1 scheduler.ts×3 signals.ts×1 store.ts×1 | adoption-unchanged-key-read-3706.test.ts×9 body-end-supersession-visibility.test.ts×1 born-held.test.ts×3 boundary-not-born-held-3540.test.ts×4 createProjection.draft-lifetime-3585.test.ts×1 direct-commit-readers-posture.test.ts×1 held-conditional-memo.test.ts×1 held-frame-dependencies.test.ts×2 held-truth-lane-only.test.ts×3 l2-contract.test.ts×1 latest-held-till-flush.test.ts×2 optimistic-read-lane-not-transaction-3698.test.ts×3 posture-born-held-and-observation.test.ts×1 posture-store-parity.test.ts×6 derived-presence-async-3726.test.ts×3 optimistic-untracked-reads-f3-f5.test.ts×1 store-unchanged-read-independent-write-3688.test.ts×1 treeshake.test.ts×3 visibility-oracle-store.states.ts×5 visibility-oracle-store.test.ts×1 visibility-oracle.states.ts×9 visibility-oracle.test.ts×1 write-proposals-3494.test.ts×1 | [ruled, amended in place 2026-09-13 (#3408)] A tracked read served a live transaction's staged value enters that transaction — A tracked computation served a node's staged `_pendingValue` — a value a … |
 | A30 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:227` | async.ts×3 attribution.ts×1 constants.ts×1 core.ts×1 effect.ts×1 scheduler.ts×4 | async-landing-deps-3461.test.ts×3 held-conditional-effect.test.ts×1 held-conditional-memo.test.ts×1 held-frame-dependencies.test.ts×2 ispending-in-boundary-on-3528.test.ts×1 lane-frame-deferred-run-3662.test.ts×1 lane-frame-held-lane-3662.test.ts×1 posture-born-held-and-observation.test.ts×1 treeshake.test.ts×2 write-proposals-3494.test.ts×2 zombie-rerun-after-commit-3546.test.ts×2 | [ruled 2026-09-13 (#3410)] A memo's dependencies are the committed frame's until the frame is replaced — A pass that _staged_ its value has not replaced the committed frame, so the committed value sti… |
 | A31 | live | `docs/SPEC-ASYNC-SEMANTICS.md:101` | boundaries.ts×1 core.ts×1 verdict.ts×1 | ispending-combined-atomic-3442.test.ts×1 | [live 2026-09-14 (#3442)] A memo computes under its own lane posture, never its puller's — A memo's value is one shared slot every reader sees, so its pass runs under the lane posture the memo itself … |
 | A32 | ruled | `docs/SPEC-ASYNC-SEMANTICS.md:109` | core.ts×4 lanes.ts×1 store.ts×1 | visibility-oracle-store.states.ts×8 visibility-oracle-store.test.ts×1 visibility-oracle.states.ts×9 visibility-oracle.test.ts×1 | [ruled 2026-09-14] Children-forbidden readers see the frame, not the graph — `createTrackedEffect` and `onSettled` callbacks are effect-phase code that runs after the frame is decided. They read the f… |
diff --git a/packages/signals/tests/store/derived-presence-async-3726.test.ts b/packages/signals/tests/store/derived-presence-async-3726.test.ts
new file mode 100644
index 000000000..a982fdd6c
--- /dev/null
+++ b/packages/signals/tests/store/derived-presence-async-3726.test.ts
@@ -0,0 +1,406 @@
+/**
+ * #3726 — a presence read (`"length" in store`) on a derived store whose
+ * first run returned a pending promise stayed blank after a source write
+ * made the derive land synchronously: the landing left the reader's own
+ * node unchanged, so no value notification reached it, and the settle walk
+ * that releases readers parked on a superseded flight skipped the still
+ * uninitialized derive (#3181's uninitialized exemption, core `recompute`).
+ *
+ * On the hold model (L2) the core already holds, with no store-side patch:
+ * a reader of a derive with a flight up is the derive's reader — the pull
+ * links it (`pullFamily`, store.ts: "a derive with a flight up is read like a
+ * memo with one"), so it is parked on the derive itself, and the derive's
+ * first commit (uninitialized → a value) is a value change for every
+ * subscriber (`recompute`: `wasUninitialized` → `insertSubs`). The walk's
+ * exemption is moot: the readers re-run in the landing's flush, pull the
+ * settled derive without linking, and the stale link trims. The same
+ * reader under a transaction's hold re-runs as the transaction's work and
+ * reveals at its commit — the case PR #3732 left open.
+ *
+ * Rules: A25 (the seed is a draft, never observable — the readers show
+ * nothing until the first landing); A19 exc. 1 (uninitialized is loading,
+ * not pending — a verdict probe suspends until the landing); A29 (a node
+ * born into the future has no committed value: an untracked read of the
+ * held landing throws until the commit).
+ */
+import { describe, expect, it } from "vitest";
+import {
+  NotReadyError,
+  action,
+  createLoadingBoundary,
+  createMemo,
+  createOptimisticStore,
+  createRenderEffect,
+  createRoot,
+  createSignal,
+  createStore,
+  flush,
+  isPending,
+  mapArray,
+  untrack,
+  type Store
+} from "../../src/index.js";
+
+const tick = () => new Promise(r => setTimeout(r, 0));
+const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
+const microtasks = async () => {
+  for (let i = 0; i < 5; i++) await Promise.resolve();
+};
+
+describe("sync landing after a pending first flight wakes unchanged-node readers (#3726)", () => {
+  it("presence read inside a loading boundary shows the landed answer", async () => {
+    const [source, setSource] = createSignal<number[] | null>(null);
+    let resolve!: (v: number[]) => void;
+    let presence = "";
+    let sourceState = "";
+    createRoot(() => {
+      const [store] = createStore<number[]>(() => {
+        const s = source();
+        if (s) return s;
+        return new Promise<number[]>(r => (resolve = r));
+      }, []);
+      createLoadingBoundary(
+        () => {
+          createRenderEffect(
+            () => ("length" in store ? "present" : "missing"),
+            v => {
+              presence = v;
+            }
+          );
+          createRenderEffect(
+            () => (source() ? "resolved" : "pending"),
+            v => {
+              sourceState = v;
+            }
+          );
+        },
+        () => "fallback"
+      );
+    });
+    flush();
+    expect(presence).toBe("");
+    expect(sourceState).toBe("pending");
+
+    setSource([1]);
+    flush();
+    expect(sourceState).toBe("resolved");
+    expect(presence).toBe("present");
+
+    resolve([2, 2]);
+    await tick();
+    flush();
+    expect(presence).toBe("present");
+  });
+
+  it("readers of presence, length and keys wake when the landing leaves them unchanged", () => {
+    const [source, setSource] = createSignal<number[] | null>(null);
+    const seen: string[] = [];
+    createRoot(() => {
+      const [store] = createStore<number[]>(() => {
+        const s = source();
+        if (s) return s;
+        return new Promise<number[]>(() => {});
+      }, []);
+      createRenderEffect(
+        () => (0 in store ? "present" : "missing"),
+        v => {
+          seen.push(`in:${v}`);
+        }
+      );
+      createRenderEffect(
+        () => store.length,
+        v => {
+          seen.push(`length:${v}`);
+        }
+      );
+      createRenderEffect(
+        () => Object.keys(store).length,
+        v => {
+          seen.push(`keys:${v}`);
+        }
+      );
+    });
+    flush();
+    expect(seen).toEqual([]);
+
+    setSource([]);
+    flush();
+    expect(seen.sort()).toEqual(["in:missing", "keys:0", "length:0"]);
+  });
+
+  it("a landing held by a transaction keeps the seed invisible until the commit", async () => {
+    const [source, setSource] = createSignal<number[] | null>(null);
+    let release!: () => void;
+    let store!: Store<number[]>;
+    createRoot(() => {
+      [store] = createStore<number[]>(() => source() ?? new Promise(() => {}), [9, 9, 9]);
+    });
+    flush();
+
+    const done = action(function* () {
+      setSource([1]);
+      yield new Promise<void>(r => (release = r));
+    })();
+    flush();
+    expect(() => untrack(() => [...store])).toThrow(NotReadyError);
+
+    release();
+    await done;
+    await tick();
+    flush();
+    expect(untrack(() => [...store])).toEqual([1]);
+  });
+});
+
+describe("#3726 on the hold model — the parked reader is the derive's, woken by its first commit", () => {
+  it("the report's playground: one promise, its timer writes the source and resolves it; presence under <Loading>, source outside", async () => {
+    let presence = "";
+    let sourceState = "";
+    let shown: unknown;
+    createRoot(() => {
+      const [ready, setReady] = createSignal<number[]>();
+      const pending = new Promise<number[]>(resolve =>
+        setTimeout(() => {
+          setReady([1]);
+          resolve([1]);
+        }, 10)
+      );
+      const [data] = createStore<number[]>(() => ready() ?? pending, []);
+      createRenderEffect(
+        () => (ready() ? "resolved" : "pending"),
+        v => {
+          sourceState = v;
+        }
+      );
+      const boundary = createLoadingBoundary(
+        () => {
+          createRenderEffect(
+            () => ("length" in data ? "present" : "missing"),
+            v => {
+              presence = v;
+            }
+          );
+          return "content";
+        },
+        () => "fallback"
+      );
+      createRenderEffect(
+        () => boundary(),
+        v => {
+          shown = v;
+        }
+      );
+    });
+    // No manual flush: the scheduler's own microtask, as in the app.
+    await microtasks();
+    expect(shown).toBe("fallback");
+    expect(sourceState).toBe("pending");
+    expect(presence).toBe("");
+
+    // The timer: the source lands the derive synchronously and the
+    // superseded first flight resolves in the same tick.
+    await sleep(30);
+    await microtasks();
+    expect(sourceState).toBe("resolved");
+    expect(presence).toBe("present");
+    expect(shown).toBe("content");
+  });
+
+  it("a verdict reader parked on the first flight wakes at the sync landing", () => {
+    const [source, setSource] = createSignal<number[] | null>(null);
+    let pending: boolean | undefined;
+    let presence = "";
+    createRoot(() => {
+      const [store] = createStore<number[]>(() => source() ?? new Promise(() => {}), []);
+      createRenderEffect(
+        () => isPending(() => "length" in store),
+        v => {
+          pending = v;
+        }
+      );
+      createRenderEffect(
+        () => ("length" in store ? "present" : "missing"),
+        v => {
+          presence = v;
+        }
+      );
+    });
+    flush();
+    // A19 exc. 1: uninitialized is loading, not pending — the probe
+    // suspends with the plain reader; neither has run.
+    expect(pending).toBe(undefined);
+    expect(presence).toBe("");
+
+    setSource([1]);
+    flush();
+    expect(pending).toBe(false);
+    expect(presence).toBe("present");
+  });
+
+  it("a landing held by a transaction: the parked readers reveal at its commit, not before (PR #3732's open case)", async () => {
+    const [source, setSource] = createSignal<number[] | null>(null);
+    let release!: () => void;
+    let store!: Store<number[]>;
+    const seen: string[] = [];
+    createRoot(() => {
+      [store] = createStore<number[]>(() => source() ?? new Promise(() => {}), [9, 9, 9]);
+      createRenderEffect(
+        () => ("length" in store ? "present" : "missing"),
+        v => {
+          seen.push(`in:${v}`);
+        }
+      );
+      createRenderEffect(
+        () => store.length,
+        v => {
+          seen.push(`length:${v}`);
+        }
+      );
+    });
+    flush();
+    expect(seen).toEqual([]);
+
+    const done = action(function* () {
+      setSource([1]);
+      yield new Promise<void>(r => (release = r));
+    })();
+    flush();
+    // Held: the readers re-ran as the transaction's work; nothing published,
+    // the seed still invisible (A25; A29 — born into the future).
+    expect(seen).toEqual([]);
+    expect(() => untrack(() => [...store])).toThrow(NotReadyError);
+
+    release();
+    await done;
+    await tick();
+    flush();
+    expect(untrack(() => [...store])).toEqual([1]);
+    expect(seen.sort()).toEqual(["in:present", "length:1"]);
+  });
+
+  it("a landing held by a transaction under <Loading>: fallback until the commit, content after", async () => {
+    const [source, setSource] = createSignal<number[] | null>(null);
+    let release!: () => void;
+    let presence = "";
+    let shown: unknown;
+    createRoot(() => {
+      const [store] = createStore<number[]>(() => source() ?? new Promise(() => {}), []);
+      const boundary = createLoadingBoundary(
+        () => {
+          createRenderEffect(
+            () => ("length" in store ? "present" : "missing"),
+            v => {
+              presence = v;
+            }
+          );
+          return "content";
+        },
+        () => "fallback"
+      );
+      createRenderEffect(
+        () => boundary(),
+        v => {
+          shown = v;
+        }
+      );
+    });
+    flush();
+    expect(shown).toBe("fallback");
+
+    const done = action(function* () {
+      setSource([1]);
+      yield new Promise<void>(r => (release = r));
+    })();
+    flush();
+    expect(shown).toBe("fallback");
+    expect(presence).toBe("");
+
+    release();
+    await done;
+    await tick();
+    flush();
+    expect(shown).toBe("content");
+    expect(presence).toBe("present");
+  });
+});
+
+/** GabbeV's board (the #3726 comment), reduced: an async card source behind
+ * a memo → a derived `createStore` → `createOptimisticStore` → a keyed list,
+ * remounted under a loading boundary that has already revealed. Before, the
+ * remounted readers were parked on the derive's first flight under the
+ * boundary's hold and the held synchronous landing never woke them — an
+ * empty lane beside the outside count (PR #3732's open case; red on its base
+ * with and without its fix). On L2 the revealed boundary holds the view
+ * switch (A29: a boundary already showing content holds like any reader)
+ * and the lane reveals with its rows as one frame. The web twin renders the
+ * playground itself (`packages/web/test/derived-presence-async-3726.spec.tsx`). */
+describe("#3726 board shape — a lane remounted under a revealed boundary fills at the held sync landing", () => {
+  type Card = { id: string; title: string };
+  const snapshot: Card[] = [{ id: "1", title: "Review the proposal" }];
+
+  it("async source → derived store → optimistic store → keyed list, remounted", async () => {
+    const [view, setView] = createSignal<"board" | "activity">("board");
+    let shown: unknown;
+    let mounts = 0;
+    createRoot(() => {
+      const boundary = createLoadingBoundary(
+        () => {
+          // The `{view() === 'board' ? <CardList /> : null}` hole.
+          const hole = createMemo(() => {
+            if (view() !== "board") return null;
+            mounts++;
+            const [ready, setReady] = createSignal<Card[]>();
+            const pending = new Promise<Card[]>(resolve =>
+              setTimeout(() => {
+                setReady(snapshot);
+                resolve(snapshot);
+              }, 10)
+            );
+            const source = createMemo(() => ready() ?? pending);
+            const [localCards] = createStore(() => source(), [] as Card[]);
+            const [cards] = createOptimisticStore(localCards);
+            return mapArray(
+              () => cards,
+              card => card().title,
+              { keyed: (c: Card) => c.id }
+            );
+          });
+          return () => {
+            const h = hole();
+            return h === null ? null : h();
+          };
+        },
+        () => "fallback"
+      );
+      createRenderEffect(
+        () => {
+          const b = boundary();
+          return typeof b === "function" ? b() : b;
+        },
+        v => {
+          shown = v;
+        }
+      );
+    });
+    await microtasks();
+    expect(shown).toBe("fallback");
+    await sleep(30);
+    await microtasks();
+    expect(shown).toEqual(["Review the proposal"]);
+    expect(mounts).toBe(1);
+
+    setView("activity");
+    await microtasks();
+    expect(shown).toBe(null);
+
+    setView("board");
+    await microtasks();
+    // Held: the revealed boundary keeps its frame until the remounted
+    // lane's flight lands.
+    expect(shown).toBe(null);
+    expect(mounts).toBe(2);
+    await sleep(30);
+    await microtasks();
+    expect(shown).toEqual(["Review the proposal"]);
+  });
+});
diff --git a/packages/web/test/derived-presence-async-3726.spec.tsx b/packages/web/test/derived-presence-async-3726.spec.tsx
new file mode 100644
index 000000000..f0c4ca3eb
--- /dev/null
+++ b/packages/web/test/derived-presence-async-3726.spec.tsx
@@ -0,0 +1,145 @@
+/**
+ * @jsxImportSource @solidjs/web
+ * @vitest-environment jsdom
+ */
+// #3726 — the report's two playgrounds, verbatim in shape. The signals-side
+// pins are `packages/signals/tests/store/derived-presence-async-3726.test.ts`.
+import { describe, expect, test } from "vitest";
+import {
+  createMemo,
+  createOptimisticStore,
+  createSignal,
+  createStore,
+  For,
+  Loading,
+  Show
+} from "solid-js";
+import { render } from "../src/index.js";
+
+const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
+const microtasks = async () => {
+  for (let i = 0; i < 5; i++) await Promise.resolve();
+};
+
+describe("presence read on an async derived store (#3726)", () => {
+  // A derived `createStore` whose first run returns a pending promise, read
+  // by presence (`"length" in data`) inside `<Loading>`; a timer writes the
+  // source (the derive lands synchronously) and resolves the superseded
+  // promise in the same tick. The presence hole stayed blank while the
+  // source hole outside the boundary updated.
+  test("shows `present` after the source lands the derive synchronously", async () => {
+    const div = document.createElement("div");
+    const dispose = render(() => {
+      const [ready, setReady] = createSignal<number[]>();
+      const pending = new Promise<number[]>(resolve =>
+        setTimeout(() => {
+          setReady([1]);
+          resolve([1]);
+        }, 10)
+      );
+      const [data] = createStore(() => ready() ?? pending, []);
+      return (
+        <>
+          <p>Source: {ready() ? "resolved" : "pending"}</p>
+          <Loading fallback={<p>Loading…</p>}>
+            <p>Presence: {"length" in data ? "present" : "missing"}</p>
+          </Loading>
+        </>
+      );
+    }, div);
+    await microtasks();
+    expect(div.innerHTML).toBe("<p>Source: pending</p><p>Loading…</p>");
+
+    await sleep(30);
+    await microtasks();
+    expect(div.innerHTML).toBe("<p>Source: resolved</p><p>Presence: present</p>");
+    dispose();
+  });
+
+  // GabbeV's board (issue comment): an async card source behind a memo, a
+  // derived `createStore`, a `createOptimisticStore` over it and a keyed
+  // `<For>`, remounted under a `<Loading>` that has already revealed; a
+  // count outside the view. Before: after Activity → Board the count read
+  // "All cards: 1" beside an empty lane — the remounted readers were parked
+  // on the derive's first flight under the boundary's hold, and the held
+  // synchronous landing never woke them (the case PR #3732 left open). On
+  // L2 the revealed boundary holds the view switch (A29: a boundary already
+  // showing content holds like any reader) and the lane reveals with its
+  // card as one frame; the count and the list never disagree.
+  test("a lane remounted under a revealed <Loading> fills beside the outside count", async () => {
+    type Card = { id: string; title: string };
+    const snapshot: Card[] = [{ id: "1", title: "Review the proposal" }];
+    const div = document.createElement("div");
+    let setView!: (v: "board" | "activity") => void;
+    let mounts = 0;
+
+    function CardList() {
+      mounts++;
+      const [ready, setReady] = createSignal<Card[]>();
+      const pending = new Promise<Card[]>(resolve =>
+        setTimeout(() => {
+          setReady(snapshot);
+          resolve(snapshot);
+        }, 10)
+      );
+      const source = createMemo(() => ready() ?? pending);
+      const [localCards] = createStore(() => source(), [] as Card[]);
+      const [cards] = createOptimisticStore(localCards);
+      return (
+        <For each={cards} keyed={card => card.id}>
+          {card => <article>{card().title}</article>}
+        </For>
+      );
+    }
+
+    function App() {
+      const [view, set] = createSignal<"board" | "activity">("board");
+      setView = set;
+      const [allCards] = createSignal(snapshot);
+      return (
+        <main>
+          <p>All cards: {allCards().length}</p>
+          <section hidden={view() === "activity"}>
+            <h2>To do</h2>
+            <Loading fallback={<p>Loading lane…</p>}>
+              {view() === "board" ? <CardList /> : null}
+            </Loading>
+          </section>
+          <Show when={view() === "activity"}>
+            <p>Activity view</p>
+          </Show>
+        </main>
+      );
+    }
+
+    const board =
+      "<main><p>All cards: 1</p><section><h2>To do</h2><article>Review the proposal</article></section></main>";
+    const activity =
+      '<main><p>All cards: 1</p><section hidden=""><h2>To do</h2></section><p>Activity view</p></main>';
+
+    const dispose = render(() => <App />, div);
+    await microtasks();
+    expect(div.innerHTML).toBe(
+      "<main><p>All cards: 1</p><section><h2>To do</h2><p>Loading lane…</p></section></main>"
+    );
+    await sleep(30);
+    await microtasks();
+    expect(div.innerHTML).toBe(board);
+    expect(mounts).toBe(1);
+
+    setView("activity");
+    await microtasks();
+    expect(div.innerHTML).toBe(activity);
+
+    setView("board");
+    await microtasks();
+    // Held: the revealed boundary keeps its frame until the remounted lane's
+    // flight lands — no fallback, no empty lane beside the count.
+    expect(div.innerHTML).toBe(activity);
+    expect(mounts).toBe(2);
+    await sleep(30);
+    await microtasks();
+    expect(div.innerHTML).toBe(board);
+    dispose();
+  });
+});