@solidjs/signals 2.0.0-rc.15 → 2.0.0-rc.17

package/dist/prod/core/truth.js

@@ -0,0 +1,45 @@
+import { CONFIG_GUESS, NOT_PENDING, CONFIG_AUTHORITATIVE, CONFIG_OVERRIDE } from "./constants.js";
+
+import { NotReadyError } from "./error.js";
+
+import { enqueueSub } from "./heap.js";
+
+// Truth reads (`until`, `refresh`; CONFIG_AUTHORITATIVE) over lane nodes.
+// Side-effect free and apart from lanes.ts so a truth reader alone does not
+// retain the lane engine: its reads reach these only through `laneRead`,
+// which exists once something installs lanes (`createOptimistic`, verdicts).
+/** A lane node's current value: its guess, or the latest it derived — the
+ * staging a shown lane holds for its next reveal, else its slot; the
+ * committed value while it has none (its first lane pass in flight). */
+function laneValueOf(r) {
+    if (!(r.l & CONFIG_GUESS) && r.se !== NOT_PENDING) return r.se;
+    const t = r.T.v;
+    return t !== NOT_PENDING ? t : r.Ie;
+}
+
+/** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
+ * the first one installs these on GlobalQueue (signals.ts `watch`).
+ *
+ * A truth reader's read of a lane node: the lane's value when it is the
+ * truth (#3943), else the truth staged beneath a guess, else the committed
+ * value. */ function truthRead(r) {
+    if (truth(r)) return laneValueOf(r);
+    if (!(r.l & CONFIG_GUESS)) throw new NotReadyError(null);
+    return r.se !== NOT_PENDING ? r.se : r.Ie;
+}
+
+/** A guess confirmed: its lane's truth readers re-read — of the lane's
+ * derivations too, which may be the truth now (#3943). */ function truthConfirmed(r) {
+    for (let t = 0; t < r.tn.length; t++) for (let e = r.tn[t].o; e !== null; e = e.t) if (e.u.l & CONFIG_AUTHORITATIVE) enqueueSub(e.u);
+}
+
+/** A lane node's value is the truth when every guess beneath it is
+ * confirmed — its source staged a value equal to the guess — and nothing
+ * beneath it is held in the parent: same inputs, same value. */ function truth(r) {
+    if (r.l & CONFIG_GUESS) return r.se !== NOT_PENDING && r.xe && r.xe(r.T.v, r.se);
+    if (r.se !== NOT_PENDING) return;
+    if (r.l & CONFIG_OVERRIDE) for (let t = r.C; t; t = t.G) if (!truth(t.S)) return;
+    return 1;
+}
+
+export { laneValueOf, truthConfirmed, truthRead };

package/dist/prod/core/verdict.js

@@ -1,14 +1,16 @@
-import { CONFIG_VERDICT, REACTIVE_PROBED, CONFIG_INPUTS_PUBLISHED, CONFIG_HELD, REACTIVE_JOINED, REACTIVE_STAGED_READ, REACTIVE_LANE_READ, CONFIG_CHILDREN_FORBIDDEN, CONFIG_OVERRIDE, STATUS_PENDING, CONFIG_GUESS, NOT_PENDING, STATUS_UNINITIALIZED, EFFECT_RENDER, STATUS_ERROR, REACTIVE_PROBE_UNANSWERED } from "./constants.js";
+import { CONFIG_VERDICT, REACTIVE_PROBED, CONFIG_CHILDREN_FORBIDDEN, CONFIG_OVERRIDE, STATUS_ERROR, CONFIG_GUESS, STATUS_PENDING, NOT_PENDING, STATUS_UNINITIALIZED, CONFIG_HELD, EFFECT_RENDER, CONFIG_STAGED_ERROR, REACTIVE_STAGED_READ, REACTIVE_PROBE_UNANSWERED, CONFIG_INPUTS_PUBLISHED, REACTIVE_JOINED, REACTIVE_LANE_READ } from "./constants.js";
 
-import { context, tracking, setVerdict, bornInto, verdict, pullComputed, joinPass, markLateLinker, spectating, unflushedValue } from "./core.js";
+import { context, tracking, setVerdict, verdict, pullComputed, joinPass, markLateLinker, spectating, unflushedValue, bornInto } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
 import { link } from "./graph.js";
 
-import { verdictLane, laneValueOf, display } from "./lanes.js";
+import { display, verdictLane } from "./lanes.js";
 
-import { GlobalQueue, txOf, globalQueue, joinFuture, queuePendingNode, staleReader, passLane, setPassLane, flushTransaction, stagedReaders } from "./scheduler.js";
+import { installVerdictHooks, GlobalQueue, flushTransaction, txOf, passLane, staleReader, globalQueue, joinFuture, stagedReaders, queuePendingNode, setPassLane } from "./scheduler.js";
+
+import { laneValueOf } from "./truth.js";
 
 // Verdicts (plan sec. 28 replay, 2026-10-02; maintainer, 2026-10-01: verdicts are
 // optimistic state the system supplies). `isPending(fn)` asks whether what
@@ -62,10 +64,10 @@ function watchVerdict(e, t = false) {
  * reveal observes the flight. Nor for a reader born into the flight's
  * transaction (`bornInto`, #4010): it has no screen — it waits on the flight
  * with the rest of its frame. */ function observeFlight(e, t) {
-    if (t.i & CONFIG_INPUTS_PUBLISHED || t.i & CONFIG_HELD && bornInto(e, txOf(t))) return false;
-    if (globalQueue.X) {
+    if (t.l & CONFIG_INPUTS_PUBLISHED || t.l & CONFIG_HELD && bornInto(e, txOf(t))) return false;
+    if (globalQueue.q) {
         joinFuture(null);
-        if (!(t.i & CONFIG_HELD)) queuePendingNode(t);
+        if (!(t.l & CONFIG_HELD)) queuePendingNode(t);
         verdictRead(e, flushTransaction, true);
     }
     return true;
@@ -90,7 +92,7 @@ let probeFound = false;
  * rewrite or a landing reaches its reader through the link it holds — so a
  * re-run would only repeat the frame. */ function verdictRead(e, t, n) {
     route(e, t);
-    if (n) staleReader(e, t); else if (probing && t.fn[t.fn.length - 1] !== e) t.fn.push(e);
+    if (n) staleReader(e, t); else if (probing && t.En[t.En.length - 1] !== e) t.En.push(e);
 }
 
 /** A verdict read of a node staged or in flight but not held yet: whether it
@@ -133,13 +135,13 @@ let probeFound = false;
 /** A19 exc. 2 / A24: a flight that re-asks the question already answered
  * (a `refresh()`, a poll) is quiet; a node pending through others is quiet
  * when every flight it waits on is. */ function quietPending(e) {
-    const t = e.m;
+    const t = e.T;
     if (t === null) return false;
-    if (t.Se !== undefined) {
-        for (const e of t.Se) if (!e.m?.ke) return false;
+    if (t.fe !== undefined) {
+        for (const e of t.fe) if (!e.T?.Ve) return false;
         return true;
     }
-    return t.ke;
+    return t.Ve;
 }
 
 /** `isPending`'s answer for a held node (A19), relative to what the reader
@@ -154,15 +156,15 @@ let probeFound = false;
  * frame with neither is final. A24: pending iff a value change is in
  * flight — a staging equal to what is displayed changes nothing when it
  * lands: final now (maintainer, 2026-10-02). */ function heldNotFinal(e) {
-    if ((e.S & STATUS_PENDING) !== 0 && !quietPending(e)) return true;
-    return e.Oe !== NOT_PENDING && !latestActive && !e.m.ke && !(e.S & STATUS_UNINITIALIZED) && (!e.ye || !e.ye(e.Ae, e.Oe));
+    if ((e.m & STATUS_PENDING) !== 0 && !quietPending(e)) return true;
+    return e.se !== NOT_PENDING && !latestActive && !e.T.Ve && !(e.m & STATUS_UNINITIALIZED) && (!!e.T.de || !e.xe || !e.xe(e.Ie, e.se));
 }
 
 /** `isPending`'s answer for an unheld node whose flight is up (cause ii). */ function pendingVerdict(e, t) {
-    if (t.S & STATUS_UNINITIALIZED) return;
+    if (t.m & STATUS_UNINITIALIZED) return;
     if (probing && !quietPending(t)) probeFound = true;
     if (e !== null && tracking) {
-        if (t.i & CONFIG_HELD) verdictRead(e, txOf(t)); else if (globalQueue.X) provisionalVerdict(e, false);
+        if (t.l & CONFIG_HELD) verdictRead(e, txOf(t)); else if (globalQueue.q) provisionalVerdict(e, false);
  // decided above
         }
 }
@@ -173,9 +175,9 @@ let probeFound = false;
  * a router's link claim probing inside the computation that creates the
  * anchor). A throw still reaches the pass through `untrack`. */ function markVerdictReader(e) {
     let t = context;
-    if (t?.$e) t = t.et;
+    if (t?.Qe) t = t.Ye;
     if (t !== null && tracking) {
-        t.i |= CONFIG_VERDICT;
+        t.l |= CONFIG_VERDICT;
         t.R |= REACTIVE_PROBED;
     }
 }
@@ -195,7 +197,38 @@ let probeFound = false;
     }
 }
 
-function isPending(e) {
+/**
+ * Reports whether what `fn` reads is still waiting on an update. Read the
+ * values in question inside `fn`: the probe answers `true` while any of
+ * them depends on a change that is in flight — a write or an async source
+ * that has started producing a new value whose result has not landed yet —
+ * and `false` once the latest value is the one on screen. The answer is
+ * tracked like any read, so a memo or effect that calls `isPending` re-runs
+ * when it flips.
+ *
+ * A read that has no value yet is loading, not pending: inside `fn` it
+ * follows the surrounding `Loading` path like any other read, and the probe
+ * reports only updates to a value that already exists. A bare `refresh()`
+ * does not flip `isPending`; pair it with `affects()` to make the re-ask
+ * visible.
+ *
+ * @param fn expression to probe; read the values in question inside it
+ *
+ * @returns `true` while a read inside `fn` depends on a change that has not committed yet
+ *
+ * @example
+ * ```ts
+ * const [query, setQuery] = createSignal("");
+ * const results = createMemo(() => searchProducts(query()));
+ * const stale = createMemo(() => isPending(results));
+ *
+ * setQuery("shoes");
+ * // stale() is true until the new results land, while results() keeps
+ * // serving the previous list — dim it instead of showing a spinner.
+ * ```
+ *
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/is-pending
+ */ function isPending(e) {
     markVerdictReader();
     const t = probing;
     const n = probeFound;
@@ -222,11 +255,16 @@ function isPending(e) {
     }
 }
 
+/** The staging, or the staged error thrown (D-41). */ function staged(e) {
+    if (e.l & CONFIG_STAGED_ERROR) throw e.se;
+    return e.se;
+}
+
 /** `latest()` of a held node: the flushed staging — the proposal — and, for
  * a tracked reader of a rewrite not yet flushed, the late-linker re-run in
  * the flush that carries it. */ function heldLatest(e, t) {
     const n = unflushedValue(e);
-    if (n === NOT_PENDING) return e.Oe;
+    if (n === NOT_PENDING) return staged(e);
     if (t !== null) markLateLinker(t);
     return n;
 }
@@ -253,11 +291,11 @@ function isPending(e) {
  *   uninitialized one throws NotReady: loading, not pending (A19 exc. 1);
  * - an errored derivation throws for every reader (#2897). */ function verdictValue(e, t) {
     const n = e;
-    const r = t !== null && !(t.i & CONFIG_CHILDREN_FORBIDDEN);
+    const r = t !== null && !(t.l & CONFIG_CHILDREN_FORBIDDEN);
     const i = r && tracking;
     if (t !== null && tracking) {
         link(e, t);
-        if (n.ee !== undefined) {
+        if (n.X !== undefined) {
             // A31: the pulled memo's pass is its own, not the probe's — it reads
             // outside the window, and the probe's read below answers for what
             // the pass produced.
@@ -270,23 +308,26 @@ function isPending(e) {
     // final by declaration — the value itself is read as below. The verdict is
     // display-ahead like any: in a transaction's flush (the declaring action's
     // body) the reader is its verdict lane's, not a staging the frame parks.
-        if (probing && GlobalQueue.N !== undefined && GlobalQueue.N(n)) {
+        if (probing && GlobalQueue.p !== undefined && GlobalQueue.p(n)) {
         probeFound = true;
         if (i && flushTransaction !== null) verdictRead(t, flushTransaction);
     }
-    if (e.i & CONFIG_OVERRIDE) {
+    if (e.l & CONFIG_OVERRIDE && !(n.m & STATUS_ERROR && !(e.l & CONFIG_GUESS))) {
         const r = txOf(e);
         if (i) verdictRead(t, r._parent ?? r);
-        const u = (n.S & STATUS_PENDING) !== 0 && !quietPending(n);
-        if (e.i & CONFIG_GUESS) {
-            if (probing && (u || e.Oe !== NOT_PENDING && (!e.ye || !e.ye(e.m.B, e.Oe)))) probeFound = true;
-            return e.m.B;
+        const u = (n.m & STATUS_PENDING) !== 0 && !quietPending(n);
+        if (e.l & CONFIG_GUESS) {
+            if (probing && (u || e.se !== NOT_PENDING && (!e.xe || !e.xe(e.T.v, e.se)))) probeFound = true;
+            // A lane a correction folded under (D-34): `latest()` shows the hold's
+            // world whole — the truth beneath each guess, else what it covered.
+                        if (latestActive && r.folded) return r.folded(null, e);
+            return e.T.v;
         }
         if (probing && u) probeFound = true;
         return latestActive && !u ? laneValueOf(e) : display(e);
     }
-    const u = (n.S & STATUS_UNINITIALIZED) !== 0;
-    if (e.i & CONFIG_HELD) {
+    const u = (n.m & STATUS_UNINITIALIZED) !== 0;
+    if (e.l & CONFIG_HELD) {
         if (!u) {
             const r = txOf(e);
             // A render effect re-run (or mounted) outside the verdict lane's flush
@@ -294,31 +335,31 @@ function isPending(e) {
             // in flight — is a stale reader of the lane (#3460, as `laneRead`): the
             // committed value now, re-derived at the reveal. Not inside a probe:
             // `isPending` is answered below either way.
-                        if (i && !probing && t.u === EFFECT_RENDER && passLane === null && r.xe !== null && r.xe.sn && flushTransaction !== r) {
-                staleReader(t, r.xe);
-                return e.Ae;
+                        if (i && !probing && t.i === EFFECT_RENDER && passLane === null && r.he !== null && r.he.ln && flushTransaction !== r) {
+                staleReader(t, r.he);
+                return e.Ie;
             }
             if (i) verdictRead(t, r);
             if (probing && heldNotFinal(n)) probeFound = true;
-            if (latestActive && e.Oe !== NOT_PENDING) {
+            if (latestActive && e.se !== NOT_PENDING) {
                 // An action body reading another transaction's proposal derives
                 // from it: the two settle as one (A15; posture C, 2026-09-15). An
                 // untracked read elsewhere has no transaction to entangle.
-                if (!i && flushTransaction !== null && !globalQueue.X) joinFuture(txOf(e));
+                if (!i && flushTransaction !== null && !globalQueue.q) joinFuture(txOf(e));
                 return heldLatest(e, i ? t : null);
             }
-            return e.Ae;
+            return e.Ie;
         }
         // Born into the future: its staging is its only value. It has no
         // committed value, so no verdict: `isPending` reads it as its read does —
         // the owner joins the hold (held with it, or caught by a boundary that
         // has not shown content) and answers for the commit, where it is final.
-                if (e.Oe !== NOT_PENDING && !(n.S & STATUS_PENDING)) {
+                if (e.se !== NOT_PENDING && !(n.m & STATUS_PENDING)) {
             if (probing && r) joinPass(t, e);
-            return e.Oe;
+            return staged(e);
         }
-    } else if (e.Oe !== NOT_PENDING) {
-        if (n.S & STATUS_PENDING && !u) pendingVerdict(i ? t : null, n); else if (i && globalQueue.X) provisionalVerdict(t, !latestActive && !u);
+    } else if (e.se !== NOT_PENDING) {
+        if (n.m & STATUS_PENDING && !u) pendingVerdict(i ? t : null, n); else if (i && globalQueue.q) provisionalVerdict(t, !latestActive && !u);
         // Outside a flush, the staging is an unflushed write (A28): the probe
         // answers for the flushed world, and watches the seam of the flush that
         // carries the write — a memo of `isPending(x)` created after the write
@@ -329,33 +370,33 @@ function isPending(e) {
             // A28: an unflushed write is not what `latest` serves; a tracked
             // reader derived from the flushed world runs again in the carrying
             // flush.
-            if (globalQueue.X) return e.Oe;
+            if (globalQueue.q) return staged(e);
             if (t !== null) markLateLinker(t);
         }
-        return e.Ae;
+        return e.Ie;
     }
-    if (n.S & STATUS_PENDING) {
+    if (n.m & STATUS_PENDING) {
         if (!u) {
             pendingVerdict(i ? t : null, n);
-            return e.Ae;
+            return e.Ie;
         }
         // As `read()`: an untracked read of a pending node still re-runs its
         // reader when the node settles (a projection's pull reads its firewall
         // untracked, store/store.ts).
                 if (t !== null && !tracking && !spectating && e !== t) link(e, t);
-        throw n.m?.F;
+        throw n.T?.F;
     }
-    if (n.ee !== undefined && n.S & STATUS_ERROR) throw n.m.F;
-    return e.Ae;
+    if (n.X !== undefined && n.m & STATUS_ERROR) throw n.T.F;
+    return e.Ie;
 }
 
 // Installed at module evaluation — present exactly when something imports
 // `latest` or `isPending`. (`read` dispatches to `verdictValue` through
 // `verdict`, set while a window is open.)
-GlobalQueue.It = observeFlight;
+installVerdictHooks(observeFlight);
 
 /** A store read inside an untracked `isPending` probe found a live mark on
- * a record with no node to carry it (store/affects.ts): not final. */ GlobalQueue.ct = () => {
+ * a record with no node to carry it (store/affects.ts): not final. */ GlobalQueue.rt = () => {
     if (probing) probeFound = true;
 };
 

package/dist/prod/deferred.js

@@ -0,0 +1,182 @@
+import { CONFIG_REDERIVE, STATUS_UNINITIALIZED, CONFIG_LAGS, CONFIG_SLOT_NODE, REACTIVE_RECOMPUTING_DEPS, REACTIVE_DISPOSED, REACTIVE_REASK, CONFIG_HELD, NOT_PENDING } from "./core/constants.js";
+
+import { isThenable, handleAsync } from "./core/async.js";
+
+import { NotReadyError } from "./core/error.js";
+
+import "./core/verdict.js";
+
+import { computed } from "./core/core.js";
+
+import { cleanup, getOwner } from "./core/owner.js";
+
+import { GlobalQueue, holdNode, txOf, schedule } from "./core/scheduler.js";
+
+import "./core/effect.js";
+
+import { mark, repoll, unmark } from "./affects-marks.js";
+
+import { accessor } from "./signals.js";
+
+// `createDeferred` — an async memo that may lag, but never leads (D-40,
+// docs/create-deferred.md).
+// Once the node has a committed value, its own non-final work is invisible
+// to the graph: its readers keep the committed value and hold nothing, its
+// landings are changes of their own, and only the verdict (`isPending`) and
+// the truth readers (`until`, `refresh`'s waiter) see the flight.
+// Built from parts the engine already has, so core pays nothing for it:
+// - **Read side: the loading window** (`_loading`, async.ts). Every pass of
+//   a node with a committed value opens the window before it asks, so a
+//   flight serves the committed value instead of throwing, and an unready
+//   source parks the node instead of pending it. `CONFIG_REDERIVE` makes a
+//   source going pending a question for the node's pass (which parks) rather
+//   than a status pushed through it to its readers.
+// - **Verdict: a mark** (affects-marks.ts) whose lifetime is the flight —
+//   started when a pass asks a new question (a `refresh()` re-ask is quiet, F-9),
+//   dropped at the landing, the rejection, a sync answer or the node's death.
+// - **Never leads:** a flight that lands while an input it read is held
+//   derived from that hold's world, so it lands into the hold (`holdNode`;
+//   `setSignal` stages it there). An input that changed after the pass
+//   would have superseded the flight, so a held input at the landing is one
+//   the pass read held.
+// - **Truth readers** wait the flight out (`GlobalQueue._lagging`, signals.ts
+//   `watch`): `await refresh(d)` delivers the landing, `until` sees only
+//   settled values.
+/** Deferred nodes with a flight up. */
+const lagging = new Set;
+
+/** The deferred node with a flight up that `c`'s value derives from, if
+ * any: `c` itself, or one reached through its current dependencies. */ function lagOf(e, r) {
+    if (lagging.has(e)) return e;
+    if (r.has(e)) return;
+    r.add(e);
+    if (e.l & CONFIG_SLOT_NODE) return lagOf(e.O?.fam?.node ?? e, r);
+    const t = e.R & REACTIVE_RECOMPUTING_DEPS ? e._ : undefined;
+    if (t !== null) for (let o = e.C ?? null; o !== null; o = o.G) {
+        const e = lagOf(o.S, r);
+        if (e) return e;
+        if (o === t) break;
+    }
+}
+
+GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
+
+/**
+ * Creates an async memo that may lag, but never leads. Before its first
+ * answer it is an ordinary async memo: readers suspend to the nearest
+ * `<Loading>`. After it, a refetch holds nothing: readers keep the last
+ * committed value until the new one lands, and the rest of the screen moves
+ * on without it. `isPending` reports the refetch, on the node and on what
+ * derives from it. Use it for independent widgets (dashboards, feeds,
+ * search results) where the previous answer with a "refreshing" indicator is
+ * better than waiting with everything else.
+ *
+ * - It never shows a value ahead of a held change: a refetch that read a
+ *   held value lands with that hold.
+ * - A rejected refetch errors like any memo; the stale value never masks it.
+ * - `refresh(d)` is a quiet re-ask, and `await refresh(d)` and `until`
+ *   wait for the landing rather than the stale value.
+ * - Combine with `loadingValue` for a node that never suspends at all.
+ *
+ * @example
+ * ```tsx
+ * const rows = createDeferred(() => fetchRows(store.period));
+ *
+ * <section class={{ stale: isPending(() => rows()) }}>
+ *   <For each={rows()}>{row => <Row row={row} />}</For>
+ * </section>
+ * ```
+ */ function createDeferred(e, r) {
+    let t;
+    /** The flight in force: a promise, a stream, or the error an unready
+     * source parked the node with. */    let o = null;
+    let n = false;
+    let l = false;
+    /** The flight `r` is over. An async answer (`held`) arriving while an
+     * input is held lands into that hold first. */    const land = (e, r) => {
+        if (e === null || o !== e) return;
+        o = null;
+        lagging.delete(t);
+        if (r) for (let e = t.C; e !== null; e = e.G) if (e.S.l & CONFIG_HELD) {
+            holdNode(t, txOf(e.S));
+            break;
+        }
+        if (n) {
+            n = false;
+            unmark(t);
+            schedule();
+        }
+    };
+    const ask = e => {
+        o = e;
+        lagging.add(t);
+        if (!n && !(t.R & REACTIVE_REASK)) {
+            n = true;
+            mark(t);
+            repoll(t);
+        }
+    };
+    /** Registers the flight and serves the pass's value: the committed one,
+     * or over a held landing the landing itself, which a lagging question
+     * does not replace (D-40) — restaged as the committed value, the hold's
+     * readers would re-derive against the old input. */    const serve = e => {
+        const r = handleAsync(t, e);
+        return t.l & CONFIG_HELD && t.se !== NOT_PENDING ? t.se : r;
+    };
+    const end = () => t.R & REACTIVE_DISPOSED && land(o);
+    return accessor(computed(r => {
+        t = getOwner();
+        t.l |= CONFIG_REDERIVE;
+        cleanup(end);
+        // Answered: the node has a real committed answer — not a first load,
+        // not a `loadingValue` window still open (both are loading, F-9).
+        // Sticky, and read before this wrapper ever opens the window itself.
+                const n = l ||= !(t.m & STATUS_UNINITIALIZED) && !t.ce;
+        if (n) t.ce = true, t.l |= CONFIG_LAGS;
+        let c;
+        try {
+            c = e(r);
+        } catch (e) {
+            // The wrapping form: an unready source parks the node in the window,
+            // and the wait is its flight until the source's settle re-runs it.
+            if (n && e instanceof NotReadyError) ask(e);
+            throw e;
+        }
+        if (n && typeof c === "object" && c !== null) {
+            if (isThenable(c)) {
+                ask(c);
+                const done = () => land(c, true);
+                c.then(done, done);
+                return serve(c);
+            }
+            const e = c[Symbol.asyncIterator];
+            if (e) {
+                // A stream's flight ends at its first yield (or its end).
+                const r = e.call(c);
+                let t = true;
+                const done = () => land(o, true);
+                const o = {
+                    // Registered ahead of the engine's own reaction to the same
+                    // promise, as for a plain flight: verdict and value in one flush.
+                    next: e => {
+                        const o = r.next(e);
+                        if (t) t = false, o.then(done, done);
+                        return o;
+                    },
+                    return: e => r.return?.(e) ?? Promise.resolve({
+                        done: true,
+                        value: e
+                    })
+                };
+                ask(o);
+                return serve({
+                    [Symbol.asyncIterator]: () => o
+                });
+            }
+        }
+        land(o);
+        return c;
+    }, r));
+}
+
+export { createDeferred };

package/dist/prod/index.js

@@ -4,12 +4,14 @@ export { isPending, latest } from "./core/verdict.js";
 
 export { action } from "./core/action.js";
 
-export { clearSnapshots, isEqual, markSnapshotScope, releaseSnapshotScope, runWithOwner, setSnapshotCapture, untrack } from "./core/core.js";
+export { clearSnapshots, isEqual, markSnapshotScope, releaseSnapshotScope, runWithOwner, setSnapshotCapture, setWriteHook, untrack } from "./core/core.js";
 
 export { enableExternalSource } from "./core/external.js";
 
 export { createOwner, createRoot, getNextChildId, getObserver, getOwner, isDisposed, peekNextChildId } from "./core/owner.js";
 
+export { setReadWatch, setSignalIdentities, signalName } from "./core/identities.js";
+
 export { createContext, getContext, setContext } from "./core/context.js";
 
 export { $REFRESH, SUPPORTS_PROXY } from "./core/constants.js";
@@ -22,6 +24,8 @@ import "./core/effect.js";
 
 export { configureClientErrors } from "./core/error-hooks.js";
 
+export { storeName } from "./store/edges.js";
+
 export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, refresh, resolve, until } from "./signals.js";
 
 export { mapArray, repeat } from "./map.js";
@@ -30,6 +34,8 @@ export { createStore, deep, reconcile, snapshot } from "./store/index.js";
 
 export { affects } from "./affects.js";
 
+export { createDeferred } from "./deferred.js";
+
 export { flatten } from "./flatten.js";
 
 export { createErrorBoundary, createLoadingBoundary } from "./boundaries.js";