@solidjs/signals 2.0.0-rc.18 → 2.0.0-rc.19

package/dist/observe/core/scheduler.js

@@ -130,7 +130,7 @@ function setExternalHooks(e, o) {
 
 /** A transaction (listed here) or a lane (lanes.ts lists its own). */ function newTransaction(e, o = null) {
     const n = {
-        je: [],
+        Ye: [],
         un: [ [], [] ],
         En: [],
         eo: null,
@@ -232,7 +232,7 @@ function resolveTx(e) {
     e.eo = o;
     o.tt += e.tt;
     o.nt ||= e.nt;
-    append(o.je, e.je);
+    append(o.Ye, e.Ye);
     append(o.un[0], e.un[0]);
     append(o.un[1], e.un[1]);
     append(o.En, e.En);
@@ -262,7 +262,7 @@ function resolveTx(e) {
     judge ??= e;
     // An action still running in it holds it open (action.ts). Its lanes
     // (lanes.ts): a lane under `t` blocks it while blocked itself.
-        const n = e.tt !== 0 || blockedBy(e.je, e) || !!lanesBlockedHook?.(e);
+        const n = e.tt !== 0 || blockedBy(e.Ye, e) || !!lanesBlockedHook?.(e);
     judge = o;
     return n;
 }
@@ -273,8 +273,8 @@ let judge = null;
  * frame reader observes (`blockedBy`'s predicate, collected; the readers
  * themselves are not sources). */ function blockersOf(e) {
     const o = [];
-    for (let n = 0; n < e.je.length; n++) {
-        const t = e.je[n];
+    for (let n = 0; n < e.Ye.length; n++) {
+        const t = e.Ye[n];
         if (!t.i && t.m & STATUS_PENDING && !(t.R & REACTIVE_DISPOSED) && (t.T.Je === null || txOf(t) === e) && blockedBy([ t ], e)) o.push(t);
     }
     return o;
@@ -285,7 +285,7 @@ let judge = null;
  * not (lanes.ts, the body-end corollary). A pending reader counts only if
  * one of the sources it waits on is `t`'s (a render effect marked pending
  * by a lane flight, never re-run, is the lane's wait, not the frame's). */ function ownFlights(e) {
-    return blockedBy(e.je, e, true);
+    return blockedBy(e.Ye, e, true);
 }
 
 /** A source the pending node waits on that is `t`'s (held by it, or by no
@@ -323,7 +323,7 @@ function blockedBy(e, o, n = false) {
             // lane-membership ruling, 2026-10-05). An output that never committed
             // shows nothing — a mount the frame has not revealed — and holds
             // nothing.
-                        if ((n.i === EFFECT_RENDER && n.m & STATUS_PENDING || n.R & REACTIVE_FRAME_READ || n.l & CONFIG_REDERIVE && n.m === STATUS_PENDING) && (e.Te === n.Ne || n.T?.F != null) && !(n.R & REACTIVE_DISPOSED) && onScreen(n, judge ?? o)) return true;
+                        if ((n.i === EFFECT_RENDER && n.m & STATUS_PENDING || n.R & REACTIVE_FRAME_READ || n.l & CONFIG_REDERIVE && n.m === STATUS_PENDING) && (e.Ie === n.Ne || n.T?.F != null) && !(n.R & REACTIVE_DISPOSED) && onScreen(n, judge ?? o)) return true;
         }
     }
     return false;
@@ -385,7 +385,7 @@ function deferZombie(e) {
     const n = ext(e);
     if (n.Je === o) return;
     n.Je = o;
-    o.je.push(e);
+    o.Ye.push(e);
 }
 
 /** Hold the (uncommitted) frame under a held pass: every computed in the
@@ -427,7 +427,7 @@ function deferZombie(e) {
 const dirtyQueue = {
     gt: new Array(2e3).fill(undefined),
     p: false,
-    st: 0,
+    lt: 0,
     jt: 0
 };
 
@@ -509,12 +509,14 @@ function schedule() {
  * hook machinery (pay-for-use).
  */ const ROOT_ERROR_HOOK = Symbol.for("solid-js/root-error-hook");
 
+const HALTED = "[REACTIVITY_HALTED]";
+
 function haltReactivity(e) {
     if (halted) return;
     halted = true;
     // A cleanup error collected before the halt is dropped (owner.ts).
         rethrowCleanupError(true);
-    let o = "[REACTIVITY_HALTED]";
+    let o = HALTED;
     // Surface the cause here too: callers rethrow it, but a creation-time throw
     // unwinds through ancestor recomputes that convert it to status instead of
     // surfacing it (#2884), so the rethrow alone cannot guarantee visibility.
@@ -542,7 +544,7 @@ function haltReactivity(e) {
 function notifyHalted() {
     if (haltNotified) return;
     haltNotified = true;
-    console.error("[REACTIVITY_HALTED]");
+    console.error(HALTED);
 }
 
 /** @internal Test/dev-reload hook. Revives scheduling after a halt. */ function resetErrorHalt() {
@@ -573,7 +575,7 @@ class GlobalQueue {
             clock++;
             // A write the commit sweep staged with no subscriber to dirty is work
             // too — the next round commits it.
-                        scheduled = dirtyQueue.jt >= dirtyQueue.st || pendingNodes.length !== 0;
+                        scheduled = dirtyQueue.jt >= dirtyQueue.lt || pendingNodes.length !== 0;
             this.run(EFFECT_RENDER);
             this.run(EFFECT_USER);
             if (true && holding) {
@@ -627,18 +629,18 @@ class GlobalQueue {
                     // stale stamp was the bridge that entangled unrelated updates
                     // with a never-resolving flight). Its observers are held and
                     // wait on its flight (`blocked`).
-                    if (e.ue === NOT_PENDING && e.m & STATUS_UNINITIALIZED && e.i !== EFFECT_RENDER) continue;
+                    if (e.ie === NOT_PENDING && e.m & STATUS_UNINITIALIZED && e.i !== EFFECT_RENDER) continue;
                     // A34 (2): a tick whose writes net to the committed value made no
                     // proposal (`setShow(false); setShow(true)` on a committed true) —
                     // not staged, not held, pends nothing; a later write to it is
                     // plain mainline. (A node already held stays held when written
                     // back: A34 (1).)
-                                        if (e.ue !== NOT_PENDING && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) && e.T?.Nt == null && e.T?.ft == null && 
+                                        if (e.ie !== NOT_PENDING && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) && e.T?.ft == null && e.T?.Nt == null && 
                     // The comparator last: a pass that created children (an object
                     // owning a fresh async memo, #4111) must not have it read them.
                     // A NotReady read there is a change (`isSame`).
-                    isSame(e, e.Ie, e.ue)) {
-                        e.ue = NOT_PENDING;
+                    isSame(e, e.le, e.ie)) {
+                        e.ie = NOT_PENDING;
                         e.l &= ~CONFIG_STAGED;
                         continue;
                     }
@@ -692,11 +694,12 @@ class GlobalQueue {
         // This flush's own runs, the lanes' reveals, and the landings' held runs
         // are collected apart and ordered below.
                 const n = this.un;
-        const t = this.un = [ [], [] ];
+        const t = [ [], [] ];
         // The passes that read this frame's stagings as the screen read held
         // writes if it parked: the lane seam re-derives them on the committed
         // world (a lane's runs wait this round).
                 if (laneSeamsHook) {
+            this.un = t;
             laneSeamsHook(o !== null ? stagedReaders : null);
             if (stagedReaders.length) stagedReaders.length = 0;
         }
@@ -847,12 +850,12 @@ class GlobalQueue {
     // (`_nodes` still lists them).
     if (attrHooks !== null) attrHooks.transitionSettled(e);
     const o = reruns(e);
-    if (e.I !== null) releaseMarksHook(e.I);
+    if (releaseMarksHook && e.I !== null) releaseMarksHook(e.I);
     // Old children die in the commits (cleanups first), then the stashed
     // effects run ahead of this flush's own. A node a lane took over since
     // (a guess written over the staged truth) is the lane's to land.
-        for (let o = 0; o < e.je.length; o++) {
-        const n = e.je[o];
+        for (let o = 0; o < e.Ye.length; o++) {
+        const n = e.Ye[o];
         if (n.T.Je === null || txOf(n) !== e) continue;
         n.T.Je = null;
         commitPendingNode(n);
@@ -925,7 +928,7 @@ function insertSubs(e) {
     // masked read of the always-present _config instead of missing-property
     // lookups in the hottest notify loop.
         const o = e.l;
-    const n = (o & CONFIG_HAS_SNAPSHOT) !== 0 && e.T?.lt !== undefined;
+    const n = (o & CONFIG_HAS_SNAPSHOT) !== 0 && e.T?.st !== undefined;
     // Observe-tier fan-out: this walk visits every subscriber edge anyway, so
     // the graph-size count is one local increment here and no field anywhere.
         let t = 0;
@@ -940,7 +943,7 @@ function insertSubs(e) {
         // pass either re-reads them fresh or trims them), and neither does the
         // tail link: it is the read IN FLIGHT — read() links before it pulls, so
         // this very commit is what that read returns.
-                if (e.R & REACTIVE_RECOMPUTING_DEPS && o.Te === e.Ne && o !== e._) e.R |= REACTIVE_MISSED_WAKE;
+                if (e.R & REACTIVE_RECOMPUTING_DEPS && o.Ie === e.Ne && o !== e._) e.R |= REACTIVE_MISSED_WAKE;
         if (n && e.l & CONFIG_IN_SNAPSHOT_SCOPE) {
             e.R |= REACTIVE_SNAPSHOT_STALE;
             continue;
@@ -977,32 +980,32 @@ function commitPendingNode(e) {
     // commits a value.
         if (!o.X) {
         e.l &= -385;
-        if (e.ue !== NOT_PENDING) {
-            e.Ie = e.ue;
-            e.ue = NOT_PENDING;
+        if (e.ie !== NOT_PENDING) {
+            e.le = e.ie;
+            e.ie = NOT_PENDING;
         }
         return;
     }
     // Computeds only from here (`_statusFlags` is not a signal field). A
     // commit beneath a flight publishes its inputs (A15 reveal corollary,
     // #3305): a reveal of it must observe, not show the pre-flight value.
-        const n = e.ue === NOT_PENDING && (o.m & STATUS_PENDING) !== 0;
+        const n = e.ie === NOT_PENDING && (o.m & STATUS_PENDING) !== 0;
     const t = e.l & CONFIG_STAGED_ERROR;
     // An answer commits: the error it replaces leaves the display (D-41).
-        if (!n && o.T) o.T.de = undefined;
+        if (!n && o.T) o.T.Te = undefined;
     e.l = n ? e.l & -1048833 | CONFIG_INPUTS_PUBLISHED : e.l & -3147137;
     // D-41: the staged answer is an error — published now, when a value would
     // show, through the ordinary error path (`stageError`). Its readers first
     // see it in the cycle after this seam: a tracked re-read there is not a
     // retry (`read`), or a boundary re-derived by it would retry it forever.
         if (t) {
-        const n = e.ue;
-        e.ue = NOT_PENDING;
-        e.ie = clock + 1;
+        const n = e.ie;
+        e.ie = NOT_PENDING;
+        e.ae = clock + 1;
         notifyStatus(o, STATUS_ERROR, n);
-    } else if (e.ue !== NOT_PENDING) {
-        e.Ie = e.ue;
-        e.ue = NOT_PENDING;
+    } else if (e.ie !== NOT_PENDING) {
+        e.le = e.ie;
+        e.ie = NOT_PENDING;
         // A node born staged (recompute) initializes at this commit.
                 o.m &= ~STATUS_UNINITIALIZED;
         // A quiet re-ask's classification survives its landing and dies with
@@ -1032,7 +1035,7 @@ function commitPendingNode(e) {
     if (!(o.m & STATUS_PENDING)) o.m &= ~STATUS_UNINITIALIZED;
     // L2: the children this commit publishes are the frame's now — the frame
     // they replace, parked by the pass (`recompute`), goes.
-        if (!n && o.T != null && (o.T.Nt !== null || o.T.ft !== null)) GlobalQueue.et(o, false, true);
+        if (!n && o.T != null && (o.T.ft !== null || o.T.Nt !== null)) GlobalQueue.et(o, false, true);
 }
 
 function commitPendingNodes() {
@@ -1096,4 +1099,4 @@ function runQueue(e, o) {
     for (let n = 0; n < e.length; n++) e[n](o);
 }
 
-export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, blocked, blockersOf, boundarySeamHook, bumpNotifyEpoch, catchHook, clock, commitPendingNode, deferZombie, dirtyQueue, endLanesHook, enforceLoadingBoundary, enterAction, exitAction, externalUntrackHook, flush, flushTransaction, freshHook, globalQueue, haltReactivity, haltReactivityAt, heldRunHook, heldTrim, heldUnder, hiddenHook, holdNode, insertSubs, installBoundaryHooks, installLaneHooks, installMarkHooks, installStoreHooks, installVerdictHooks, joinFuture, joinPassTx, laneCorrectionsHook, laneDirty, laneOutcomeHook, laneReadHook, laneSeamsHook, laneStageHook, laneWriteHook, lanesBlockedHook, list, liveTx, merge, newTransaction, nextQuestion, notifyEpoch, observeFlightHook, ownFlights, passLane, passTx, question, queuePendingNode, releaseAmbientMarksHook, releaseMarksHook, releaseQueues, reruns, resetErrorHalt, resolveTx, sameLane, schedule, setExternalHooks, setPassLane, setQuestion, stagedReaders, staleReader, storeCommitHook, storeParkHook, txOf, unhold, wireExternalSourceHook };
+export { GlobalQueue, MAINLINE_QUESTION, ROOT_ERROR_HOOK, actionDepth, applyGuessesHook, blocked, blockersOf, boundarySeamHook, bumpNotifyEpoch, catchHook, clock, commitPendingNode, deferZombie, dirtyQueue, endLanesHook, enforceLoadingBoundary, enterAction, exitAction, externalUntrackHook, flush, flushTransaction, freshHook, globalQueue, haltReactivity, haltReactivityAt, heldRunHook, heldTrim, heldUnder, hiddenHook, holdNode, insertSubs, installBoundaryHooks, installLaneHooks, installMarkHooks, installStoreHooks, installVerdictHooks, joinFuture, joinPassTx, laneCorrectionsHook, laneDirty, laneOutcomeHook, laneReadHook, laneSeamsHook, laneStageHook, laneWriteHook, lanesBlockedHook, list, liveTx, merge, newTransaction, nextQuestion, notifyEpoch, observeFlightHook, ownFlights, passLane, passTx, pendingNodes, question, queuePendingNode, releaseAmbientMarksHook, releaseMarksHook, releaseQueues, reruns, resetErrorHalt, resolveTx, sameLane, schedule, setExternalHooks, setPassLane, setQuestion, stagedReaders, staleReader, storeCommitHook, storeParkHook, txOf, unhold, wireExternalSourceHook };

package/dist/observe/core/truth.js

@@ -12,9 +12,9 @@ import { enqueueSub } from "./heap.js";
  * 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.ue !== NOT_PENDING) return r.ue;
+    if (!(r.l & CONFIG_GUESS) && r.ie !== NOT_PENDING) return r.ie;
     const t = r.T.V;
-    return t !== NOT_PENDING ? t : r.Ie;
+    return t !== NOT_PENDING ? t : r.le;
 }
 
 /** Truth readers (`until`, `refresh`; CONFIG_AUTHORITATIVE) — pay-for-use:
@@ -25,19 +25,19 @@ function laneValueOf(r) {
  * value. */ function truthRead(r) {
     if (truth(r)) return laneValueOf(r);
     if (!(r.l & CONFIG_GUESS)) throw new NotReadyError(null);
-    return r.ue !== NOT_PENDING ? r.ue : r.Ie;
+    return r.ie !== NOT_PENDING ? r.ie : r.le;
 }
 
 /** 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.je.length; t++) for (let e = r.je[t].o; e !== null; e = e.t) if (e.u.l & CONFIG_AUTHORITATIVE) enqueueSub(e.u);
+    for (let t = 0; t < r.Ye.length; t++) for (let e = r.Ye[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.ue !== NOT_PENDING && r.Ye && r.Ye(r.T.V, r.ue);
-    if (r.ue !== NOT_PENDING) return;
+    if (r.l & CONFIG_GUESS) return r.ie !== NOT_PENDING && r.je && r.je(r.T.V, r.ie);
+    if (r.ie !== NOT_PENDING) return;
     if (r.l & CONFIG_OVERRIDE) for (let t = r.C; t; t = t.G) if (!truth(t.S)) return;
     return 1;
 }

package/dist/observe/core/verdict.js

@@ -159,7 +159,7 @@ let probeFound = false;
  * flight — a staging equal to what is displayed changes nothing when it
  * lands: final now (maintainer, 2026-10-02). */ function heldNotFinal(e) {
     if ((e.m & STATUS_PENDING) !== 0 && !quietPending(e)) return true;
-    return e.ue !== NOT_PENDING && !latestActive && !e.T.ut && !(e.m & STATUS_UNINITIALIZED) && (!!e.T.de || !e.Ye || !e.Ye(e.Ie, e.ue));
+    return e.ie !== NOT_PENDING && !latestActive && !e.T.ut && !(e.m & STATUS_UNINITIALIZED) && (!!e.T.Te || !e.je || !e.je(e.le, e.ie));
 }
 
 /** `isPending`'s answer for an unheld node whose flight is up (cause ii). */ function pendingVerdict(e, t) {
@@ -177,7 +177,7 @@ 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?.Pt) t = t.Ht;
+    if (t?.Pt) t = t.ht;
     if (t !== null && tracking) {
         t.l |= CONFIG_VERDICT;
         t.R |= REACTIVE_PROBED;
@@ -261,8 +261,8 @@ let probeFound = false;
 }
 
 /** The staging, or the staged error thrown (D-41). */ function staged(e) {
-    if (e.l & CONFIG_STAGED_ERROR) throw e.ue;
-    return e.ue;
+    if (e.l & CONFIG_STAGED_ERROR) throw e.ie;
+    return e.ie;
 }
 
 /** `latest()` of a held node: the flushed staging — the proposal — and, for
@@ -322,7 +322,7 @@ let probeFound = false;
         if (i) verdictRead(t, r._parent ?? r);
         const u = (n.m & STATUS_PENDING) !== 0 && !quietPending(n);
         if (e.l & CONFIG_GUESS) {
-            if (probing && (u || e.ue !== NOT_PENDING && (!e.Ye || !e.Ye(e.T.V, e.ue)))) probeFound = true;
+            if (probing && (u || e.ie !== NOT_PENDING && (!e.je || !e.je(e.T.V, e.ie)))) 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);
@@ -342,28 +342,28 @@ let probeFound = false;
             // `isPending` is answered below either way.
                         if (i && !probing && t.i === EFFECT_RENDER && passLane === null && r.it !== null && r.it.ln && flushTransaction !== r) {
                 staleReader(t, r.it);
-                return e.Ie;
+                return e.le;
             }
             if (i) verdictRead(t, r);
             if (probing && heldNotFinal(n)) probeFound = true;
-            if (latestActive && e.ue !== NOT_PENDING) {
+            if (latestActive && e.ie !== 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.q) joinFuture(txOf(e));
                 return heldLatest(e, i ? t : null);
             }
-            return e.Ie;
+            return e.le;
         }
         // 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.ue !== NOT_PENDING && !(n.m & STATUS_PENDING)) {
+                if (e.ie !== NOT_PENDING && !(n.m & STATUS_PENDING)) {
             if (probing && r) joinPass(t, e);
             return staged(e);
         }
-    } else if (e.ue !== NOT_PENDING) {
+    } else if (e.ie !== 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
@@ -378,12 +378,12 @@ let probeFound = false;
             if (globalQueue.q) return staged(e);
             if (t !== null) markLateLinker(t);
         }
-        return e.Ie;
+        return e.le;
     }
     if (n.m & STATUS_PENDING) {
         if (!u) {
             pendingVerdict(i ? t : null, n);
-            return e.Ie;
+            return e.le;
         }
         // 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
@@ -392,7 +392,7 @@ let probeFound = false;
         throw n.T?.F;
     }
     if (n.X !== undefined && n.m & STATUS_ERROR) throw n.T.F;
-    return e.Ie;
+    return e.le;
 }
 
 // Installed at module evaluation — present exactly when something imports

package/dist/observe/deferred.js

@@ -123,7 +123,7 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
      * 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.ue !== NOT_PENDING ? t.ue : r;
+        return t.l & CONFIG_HELD && t.ie !== NOT_PENDING ? t.ie : r;
     };
     const end = () => t.R & REACTIVE_DISPOSED && land(o);
     return accessor(computed(r => {
@@ -135,52 +135,51 @@ GlobalQueue.er = e => lagging.size !== 0 ? lagOf(e, new Set) : undefined;
         // 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 s;
         try {
-            s = e(r);
+            const t = e(r);
+            if (n && typeof t === "object" && t !== null) {
+                if (isThenable(t)) {
+                    ask(t);
+                    const done = () => land(t, true);
+                    t.then(done, done);
+                    return serve(t);
+                }
+                const e = t[Symbol.asyncIterator];
+                if (e) {
+                    // A stream's flight ends at its first yield (or its end).
+                    const r = e.call(t);
+                    let o = true;
+                    const done = () => land(n, true);
+                    const n = {
+                        // 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 t = r.next(e);
+                            if (o) {
+                                o = false;
+                                if (isThenable(t)) t.then(done, done); else done();
+                            }
+                            return t;
+                        },
+                        return: e => r.return?.(e) ?? Promise.resolve({
+                            done: true,
+                            value: e
+                        })
+                    };
+                    ask(n);
+                    return serve({
+                        [Symbol.asyncIterator]: () => n
+                    });
+                }
+            }
+            land(o);
+            return t;
         } 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); else land(o);
             throw e;
         }
-        if (n && typeof s === "object" && s !== null) {
-            if (isThenable(s)) {
-                ask(s);
-                const done = () => land(s, true);
-                s.then(done, done);
-                return serve(s);
-            }
-            const e = s[Symbol.asyncIterator];
-            if (e) {
-                // A stream's flight ends at its first yield (or its end).
-                const r = e.call(s);
-                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;
-                            if (isThenable(o)) o.then(done, done); else done();
-                        }
-                        return o;
-                    },
-                    return: e => r.return?.(e) ?? Promise.resolve({
-                        done: true,
-                        value: e
-                    })
-                };
-                ask(o);
-                return serve({
-                    [Symbol.asyncIterator]: () => o
-                });
-            }
-        }
-        land(o);
-        return s;
     }, r));
 }
 

package/dist/observe/index.js

@@ -20,7 +20,7 @@ import { OBSERVE as OBSERVE$1 } from "./core/dev.js";
 
 export { setConsoleFooter } from "./core/dev.js";
 
-export { ROOT_ERROR_HOOK, enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
+export { ROOT_ERROR_HOOK, clock, enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
 
 import "./core/effect.js";
 
@@ -28,7 +28,7 @@ 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 { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onFlush, onSettled, refresh, resolve, until } from "./signals.js";
 
 export { mapArray, repeat } from "./map.js";
 

package/dist/observe/map.js

@@ -29,7 +29,7 @@ function mapArray(t, e, i) {
         Mt: [],
         Wt: r,
         vt: [],
-        je: [],
+        Ye: [],
         Vt: s,
         Kt: s || i?.keyed === false ? [] : undefined,
         xt: n && i?.keyed !== false ? [] : undefined,
@@ -157,7 +157,7 @@ function trySmallMove(t, e, i, s) {
         }
     }
     const a = t.vt;
-    const l = t.je;
+    const l = t.Ye;
     const u = a.slice(0, i);
     const d = l.slice(0, i);
     for (let t = 0; t < r.length; t += 3) {
@@ -177,7 +177,7 @@ function trySmallMove(t, e, i, s) {
         d[t] = l[e];
     }
     t.vt = u;
-    t.je = d;
+    t.Ye = d;
     t.wt = i;
     t.Mt = e.slice(0);
     // Dispose unmatched sources LAST (general-path ordering).
@@ -197,7 +197,7 @@ function trySmallMove(t, e, i, s) {
  * needs the reset). The stage arrays are scratch — nothing live is touched. */ function stageRemoval(t, e, i, s, n, r, o, f, h) {
     const c = t.Vt;
     const a = t.Mt;
-    const l = t.je;
+    const l = t.Ye;
     const u = [];
     let d = i;
     for (let p = i; p <= n; d++, p++) {
@@ -222,7 +222,7 @@ function trySmallMove(t, e, i, s) {
  * index signals. Its own function so the general path's body stays under
  * the JIT's optimization budget — the inlined commit measured ~10% slower on
  * full-window reorders (the small-move note has the same finding). */ function commitWindow(t, e, i, s, n, r, o, f, h) {
-    const c = t.je;
+    const c = t.Ye;
     const a = t.Kt;
     const l = t.xt;
     const u = t.wt;
@@ -267,7 +267,7 @@ function updateKeyedMap() {
     // the flight's reader (pending tracking + post-settle retry) instead of
     // vanishing. Set per pass: the first pass runs inside `computed()`, before
     // the node exists to the caller.
-    this.H.Ht = getOwner();
+    this.H.ht = getOwner();
     const t = this.yt() || [], e = t.length;
     t[$TRACK];
  // top level tracking (a store array's container node)
@@ -298,7 +298,7 @@ function updateKeyedMap() {
                 if (e === 0) {
             if (this.wt !== 0) {
                 this.H.dispose(false);
-                this.je = [];
+                this.Ye = [];
                 this.Mt = [];
                 this.vt = [];
                 this.wt = 0;
@@ -308,8 +308,8 @@ function updateKeyedMap() {
             if (this.L && !this.vt.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.je[0]?.dispose();
-                this.vt[0] = runWithOwner(this.je[0] = createOwner(), this.L);
+                this.Ye[0]?.dispose();
+                this.vt[0] = runWithOwner(this.Ye[0] = createOwner(), this.L);
             }
         }
         // fast path for new create
@@ -328,10 +328,10 @@ function updateKeyedMap() {
                 throw t;
             }
             // commit
-                        if (this.je[0]) this.je[0].dispose();
+                        if (this.Ye[0]) this.Ye[0].dispose();
  // previous fallback
                         this.vt = h;
-            this.je = c;
+            this.Ye = c;
             r && (this.Kt = r);
             o && (this.xt = o);
             this.Mt = t.slice(0);
@@ -447,13 +447,13 @@ function updateKeyedMap() {
                     s = d.get(u);
                     if (s !== undefined && s !== -1) {
                         S[s] = this.vt[i];
-                        M[s - h] = this.je[i];
+                        M[s - h] = this.Ye[i];
                         r && (r[s - h] = this.Kt[i]);
                         o && (o[s - h] = this.xt[i]);
                         s = p[s - h];
                         d.set(u, s);
                     } else {
-                        (w ??= []).push(this.je[i]);
+                        (w ??= []).push(this.Ye[i]);
                         if (true && attrHooks !== null) (O ??= []).push(l);
                     }
                 }
@@ -483,7 +483,7 @@ function updateKeyedMap() {
             // save a copy of the mapped items for the next update
                         this.Mt = t.slice(0);
             if (w) for (i = 0; i < w.length; i++) w[i].dispose();
-            if (true && attrHooks !== null && O !== undefined && _ !== undefined) attrHooks.listChurn(this.H.Ht, O, _, e, this.Vt !== undefined);
+            if (true && attrHooks !== null && O !== undefined && _ !== undefined) attrHooks.listChurn(this.H.ht, O, _, e, this.Vt !== undefined);
         }
     });
     return this.vt;
@@ -511,7 +511,7 @@ function updateKeyedMap() {
         $t: 0,
         qt: t,
         Wt: s,
-        je: [],
+        Ye: [],
         vt: [],
         zt: i?.from,
         L: i?.fallback
@@ -530,14 +530,14 @@ function updateKeyedMap() {
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
     // As in updateKeyedMap: the node is the row callbacks' reader, per pass.
-    this.H.Ht = getOwner();
+    this.H.ht = getOwner();
     const t = this.qt();
     const e = this.zt?.() || 0;
     runWithOwner(this.H, () => {
         if (t === 0) {
             if (this.wt !== 0) {
                 this.H.dispose(false);
-                this.je = [];
+                this.Ye = [];
                 this.vt = [];
                 this.wt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
@@ -546,8 +546,8 @@ function updateRepeat() {
             if (this.L && !this.vt.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.je[0]?.dispose();
-                this.vt[0] = runWithOwner(this.je[0] = createOwner(), this.L);
+                this.Ye[0]?.dispose();
+                this.vt[0] = runWithOwner(this.Ye[0] = createOwner(), this.L);
             }
             return;
         }
@@ -560,7 +560,7 @@ function updateRepeat() {
         const o = new Array(t);
         const f = new Array(t);
         for (let t = n; t < r; t++) {
-            f[t - e] = this.je[t - this.$t];
+            f[t - e] = this.Ye[t - this.$t];
             o[t - e] = this.vt[t - this.$t];
         }
         try {
@@ -573,9 +573,9 @@ function updateRepeat() {
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.wt === 0) this.je[0]?.dispose(); else for (let t = this.$t; t < s; t++) if (t < e || t >= i) this.je[t - this.$t].dispose();
+                if (this.wt === 0) this.Ye[0]?.dispose(); else for (let t = this.$t; t < s; t++) if (t < e || t >= i) this.Ye[t - this.$t].dispose();
         this.vt = o;
-        this.je = f;
+        this.Ye = f;
         this.$t = e;
         this.wt = t;
     });