@solidjs/signals 2.0.0-rc.6 → 2.0.0-rc.8

package/dist/prod/core/async.js

@@ -1,4 +1,4 @@
-import { STATUS_UNINITIALIZED, CONFIG_CHILD_COMPANIONS, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTHORITATIVE_OBSERVED, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_DISPOSED } from "./constants.js";
+import { STATUS_UNINITIALIZED, CONFIG_CHILD_COMPANIONS, STATUS_ERROR, STATUS_PENDING, CONFIG_INPUTS_PUBLISHED, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_DISPOSED } from "./constants.js";
 
 import { untrack, ext, statusNotifierOf, setSignal, context } from "./core.js";
 
@@ -14,7 +14,7 @@ import { hasActiveOverride, assignOrMergeLane, resolveLane, resolveTransition }
 
 import { cleanup } from "./owner.js";
 
-import { GlobalQueue, schedule, flush, queuePendingNode, insertSubs, clock, currentTransition, globalQueue } from "./scheduler.js";
+import { GlobalQueue, schedule, flush, queuePendingNode, insertSubs, clock, waitingTransition, currentTransition, globalQueue, setOrigin, origin } from "./scheduler.js";
 
 // The lazily-created Set is the ONE container for pending sources. Its
 // predecessor — a singular slot promoted to a Set on the second source —
@@ -40,6 +40,19 @@ function clearPendingSources(e) {
     if (e.o !== null) e.o.le = undefined;
 }
 
+// A rejection-pending only resolves through the settle sweep over the
+// SOURCE's subscribers, so it is retryable iff a tracked read created that
+// edge: a dep that IS the source, or one whose own pending chain carries it
+// (pending sources propagate the origin node, so this covers any depth).
+// Also guards branch-local recovery: another dependency may still need the source.
+function retryReaches(e, n) {
+    for (let t = e.fe; t; t = t.ae) {
+        const e = t.Se.ce || t.Se;
+        if (e === n || e.o?.le?.has(n)) return true;
+    }
+    return false;
+}
+
 /**
  * A loading-window node hit an unready source (sync throw in recompute, or a
  * NotReadyError-rejected flight): register for the source's settle — the
@@ -47,7 +60,7 @@ function clearPendingSources(e) {
  * with NO read-visible pending status, no downstream propagation, no
  * transition, no lane registration. Commit #0 keeps serving.
  */ function parkLoadingWindow(e, n) {
-    ext(e).fe = true;
+    ext(e).de = true;
     if (n.source) addPendingSource(e, n.source);
     // A settled error is the node's answer ("the error stays the answer until
     // this retry can actually run") — the park must not replace it: reads
@@ -72,10 +85,10 @@ function setPendingError(e, n, t) {
 }
 
 function forEachDependent(e, n) {
-    for (let t = e.u; t !== null; t = t.ae) n(t.ce, t);
+    for (let t = e.u; t !== null; t = t.Te) n(t.Ie, t);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-        for (let t = e.o?.i ?? null; t !== null; t = t.Se) {
-        for (let e = t.u; e !== null; e = e.ae) n(e.ce, e);
+        for (let t = e.o?.i ?? null; t !== null; t = t.Ee) {
+        for (let e = t.u; e !== null; e = e.Te) n(e.Ie, e);
     }
 }
 
@@ -119,9 +132,9 @@ function releaseSettledDependents(e) {
 // object identity down the whole dependent tree, and holding it is exactly
 // the "blocked on this error" marker — re-enqueue those holders so they
 // re-run: fresh values commit and flow, and a dependent with another
-// still-broken source simply re-errors. The async dimension needs no twin of
-// its own: recovery there passes through a pending window whose re-runners
-// set _blocked and ride settlePendingSource. Walks the full dependent graph
+// still-broken source simply re-errors. Pending recovery uses
+// settlePendingSource to clear inherited status and retry blocked readers.
+// Walks the full dependent graph
 // (releaseSettledDependents shape): identity holders can sit below an
 // intermediate whose own error state has since been scrubbed or replaced
 // (e.g. an error boundary's tree node).
@@ -141,51 +154,63 @@ function settleErroredDependents(e, n) {
     if (t) schedule();
 }
 
-function settlePendingSource(e) {
-    // The normal landing path already cleared the source's own set. Superseded
-    // re-parks arrive here with an abandoned self entry, which must retire in
-    // the same walk as its propagated copies.
-    removePendingSource(e, e);
-    let n = false;
-    let t;
-    const r = new Set;
+// Retire `source` from pending state along the dependent graph rooted at `el`.
+// By default, `el` is the source whose flight settled or was superseded.
+// With a distinct `source`, `el` is a recovered computation that dropped it:
+// the source may still be pending, so dependents with another path to it stay pending.
+function settlePendingSource(e, n = e) {
+    // Landing and branch recovery already cleared el's own set. Superseded
+    // re-parks can retain an abandoned self entry (source === el), which must
+    // retire in the same walk as its propagated copies.
+    removePendingSource(e, n);
+    let t = false;
+    let r;
+    const o = new Set;
     // Companion updates no-op without the verdict layer (null hook).
-        const o = GlobalQueue.de;
-    const settle = i => {
-        if (r.has(i) || !removePendingSource(i, e)) return;
-        r.add(i);
-        i.Te = clock;
-        const l = i.o?.le?.values().next().value;
+        const i = GlobalQueue.Ne;
+    const settle = s => {
+        if (o.has(s)) return;
+        // A conditional dropped this source, but another dependency can still
+        // carry it. Only retire pending state inherited through the recovered
+        // branch. Deliberately NOT marked visited on this early return: the
+        // carrying dependency may itself be a later branch of this same walk
+        // (two unchanged memos converging), and its visit must be free to
+        // re-examine this node once that branch has retired the source.
+                if (n !== e && retryReaches(s, n)) return;
+        if (!removePendingSource(s, n)) return;
+        o.add(s);
+        s._e = clock;
+        const l = s.o?.le?.values().next().value;
         // STATUS_ERROR + pending sources only coexist via an errored loading
         // window's park (notifyStatus(STATUS_ERROR) clears pending sources
         // otherwise): the settled error stays the answer through the settle —
         // nulling it here would have reads throw `null` until the re-enqueued
         // retry lands, or lose it entirely if that retry parks again (#2989).
-                const s = i.S & STATUS_ERROR;
+                const u = s.S & STATUS_ERROR;
         if (l) {
-            if (!s) setPendingError(i, l);
-            o?.(i);
+            if (!u) setPendingError(s, l);
+            i?.(s);
         } else {
-            i.S &= ~STATUS_PENDING;
-            if (!s) setPendingError(i);
-            o?.(i);
-            if (i.o?.fe) {
-                enqueueSub(i);
-                n = true;
+            s.S &= ~STATUS_PENDING;
+            if (!u) setPendingError(s);
+            i?.(s);
+            if (s.o?.de) {
+                enqueueSub(s);
+                t = true;
             }
-            if (i.o !== null) i.o.fe = false;
+            if (s.o !== null) s.o.de = false;
             // Fully settled with nobody watching: release candidate (#2934). Checked
             // again at release time — deferred so unobserved() can't unlink subs
             // lists this walk is still iterating.
-                        if (!i.u && i.T & CONFIG_AUTO_DISPOSE) (t ??= []).push(i);
+                        if (!s.u && s.T & CONFIG_AUTO_DISPOSE) (r ??= []).push(s);
         }
-        forEachDependent(i, settle);
+        forEachDependent(s, settle);
     };
     forEachDependent(e, settle);
     // Release before the flush schedule below: unobserved() pulls the node back
     // out of the heap, so the enqueueSub above never recomputes a released node.
-        if (t) for (const e of t) releaseIfSettledUnobserved(e);
-    if (n) schedule();
+        if (r) for (const e of r) releaseIfSettledUnobserved(e);
+    if (t) schedule();
 }
 
 // Object-thenable detection (Promises/A+ shape).
@@ -194,9 +219,9 @@ function isThenable(e) {
 }
 
 /** Fire and clear a node's iterator-flight cancellation hook (#3122). */ function releaseFlightTeardown(e) {
-    const n = e.o?.Ee;
+    const n = e.o?.De;
     if (n != null) {
-        e.o.Ee = null;
+        e.o.De = null;
         n();
     }
 }
@@ -211,9 +236,9 @@ function handleAsync(e, n, t) {
         });
     }
     if (!o && !r) {
-        if (e.o !== null) e.o.Ie = null;
+        if (e.o !== null) e.o.Pe = null;
         // A sync landing is the first real answer for a loadingValue node.
-                e.Ne = false;
+                e.Ae = false;
         return n;
     }
     // Flight replacement relies on recompute's supersede release for iterator
@@ -221,8 +246,13 @@ function handleAsync(e, n, t) {
     // self-registration — runs during a recompute of `el`, which has already
     // fired _flightTeardown. A future non-recompute registration path must
     // release it here before overwriting _inFlight.
-        ext(e).Ie = n;
-    let i;
+        ext(e).Pe = n;
+    // Provenance of the question this flight asks (#3331): the action whose
+    // window is registering it, or the flight whose landing is. Its landings
+    // propagate under it (asyncWrite) so an override downstream can tell a
+    // stale answer from its own.
+        const i = origin;
+    let s;
     // Settle-time transition re-entry. The loading rail is invisible to
     // transactions (#2933): a boundary-caught first load never registers as an
     // async reporter, so its settle — the boundary's fallback -> content
@@ -234,27 +264,35 @@ function handleAsync(e, n, t) {
     // keeps transition scheduling; initialized (value-holding) pending settles
     // are the transaction's reveal machinery and always re-enter.
         const settleTransition = () => {
-        const n = resolveTransition(e);
-        if (n && e.S & STATUS_UNINITIALIZED && !currentTransition(n)._e.has(e)) {
+        let n = resolveTransition(e);
+        // A lane-routed node's landing is revealed by its lane, ahead of the
+        // transaction that owns the lane (whose own commit is only the override's
+        // confirm/revert). Entering that owner here would fold every transaction
+        // waiting on this flight into it at the landing — a reveal that
+        // discovered the flight (#3305) would then wait on the owner's action
+        // instead of on the flight (#3334). Enter the waiter: the transaction
+        // whose blocker this landing clears.
+                if (e.o?.Oe) n = waitingTransition(e) ?? n;
+        if (n && e.S & STATUS_UNINITIALIZED && !currentTransition(n).Re.has(e)) {
             // Drop the stale stamp too: the plain settle write (setSignal) and the
             // stash-path restamp both re-enter the transaction through it.
-            e.Ae = null;
+            e.ge = null;
             return;
         }
         globalQueue.initTransition(n);
     };
     const handleError = t => {
-        if (e.o?.Ie !== n) return;
+        if (e.o?.Pe !== n) return;
         // NotReadyError from rejected promises should be treated as pending, not error
                 let r = t instanceof NotReadyError;
-        if (r && e.Ne) {
+        if (r && e.Ae) {
             // Loading window: the flight died waiting on an unready source. Keep
             // serving commit #0 — same parking as recompute's catch for sync
             // dependency throws. The dead flight is released so the clock-gated
             // error-retry pull (updateIfNecessary) can also re-ask.
-            if (e.o !== null) e.o.Ie = null;
+            if (e.o !== null) e.o.Pe = null;
             parkLoadingWindow(e, t);
-            e.Te = clock;
+            e._e = clock;
             return;
         }
         settleTransition();
@@ -263,36 +301,44 @@ function handleAsync(e, n, t) {
         // rejected flight will never settle its self entry, so transfer ownership
         // after notifyStatus has propagated the replacement source.
                 if (r) settlePendingSource(e);
-        e.Te = clock;
+        e._e = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
         // cleared their pending sources), so stranded lazy ones release here —
         // the error twin of settlePendingSource's release (#2934).
                 if (!r) releaseSettledDependents(e);
     };
     const asyncWrite = (r, o) => {
-        if (e.o?.Ie !== n) return;
+        if (e.o?.Pe !== n) return;
         // If the node was dirtied by a newer write (optimistic override or regular),
         // skip this stale async result — the upcoming flush will recompute the node
         // with the new value, creating a fresh Promise that supersedes this one.
                 if (e.ie & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+        // The landing propagates under the flight's provenance (#3331) — through
+        // the flush below, which clears it.
+                setOrigin(i);
         settleTransition();
-        const i = !!(e.S & STATUS_UNINITIALIZED);
+        const s = !!(e.S & STATUS_UNINITIALIZED);
         // Captured before clearStatus wipes it: a quiet re-ask's landing may be
         // transition-held below, and the displayed value keeps answering the same
         // question until the hold commits — the classification must survive to
         // that reveal or companion synchronization briefly classifies the held
         // old value as pending, a one-frame pulse to direct observers (#3178).
         // A truthy capture implies `_x` exists, so the restore writes it directly.
-                const l = e.o?.De;
+                const l = e.o?.Ue;
         trimStaleDeps(e);
         clearStatus(e);
-        if (l) e.o.De = true;
-        const s = resolveLane(e);
-        if (s) s.Oe.delete(e);
+        if (l) e.o.Ue = true;
+        const u = resolveLane(e);
+        if (u) u.he.delete(e);
         if (t) {
-            t(r);
-            if (i) clearStatus(e, true);
-        } else if (e.o?.Pe !== undefined) {
+            try {
+                t(r);
+            } catch (e) {
+                handleError(e);
+                return;
+            }
+            if (s) clearStatus(e, true);
+        } else if (e.o?.be !== undefined) {
             // Optimistic node — resting OR covered by an active override — holds
             // through the shared pending-node path, exactly like a plain async memo,
             // so the commit clears STATUS_UNINITIALIZED (#2806) and elevation to
@@ -302,8 +348,8 @@ function handleAsync(e, n, t) {
             // (A17 — every reader sees the override); the revert reveals whatever
             // has committed by then, so corrections reveal atomically with their
             // transition rather than escaping it.
-            if (e.Re === NOT_PENDING) queuePendingNode(e);
-            e.Re = r;
+            if (e.Ge === NOT_PENDING) queuePendingNode(e);
+            e.Ge = r;
             // The hold is a companion-visible write like any other (A13/A19): the
             // clearStatus() above computed its verdict before the hold existed, so
             // isPending must re-derive (the value is not final until commit — V1)
@@ -311,35 +357,34 @@ function handleAsync(e, n, t) {
             // only notified when the hold is visible to them: under an active
             // override every reader sees the override (A17), so waking subs would
             // re-show an unchanged view — the revert is the notification point.
-                        GlobalQueue.Ue?.(e, r);
+            // Under an override the landing is handed to the engine's
+            // supersedeOverride (A18 supersession, #3331): own-source truth that
+            // differs from the override ends the optimism for the graph now (plain
+            // channel, lane demoted); a matching arrival is silent except to an
+            // authoritative-view reader (until()'s predicate) waiting on exactly
+            // this staged truth (#3164 — without the wake the hold deadlocks: the
+            // landing waits on the transaction, the transaction on the action, the
+            // action on an until() never re-notified). The hook is installed with
+            // the engine, which an active override implies. The propagation runs
+            // under this flight's provenance (setOrigin above).
+                        GlobalQueue.pe?.(e, r);
             if (!hasActiveOverride(e)) {
                 insertSubs(e);
-            } else if (e.T & CONFIG_AUTHORITATIVE_OBSERVED) {
-                // A17 silence is stated over ordinary readers; an authoritative-view
-                // reader (until()'s predicate) observed this node PAST its override
-                // and is waiting for exactly this staged truth. Without the wake the
-                // hold deadlocks: the landing waits on the transaction, the
-                // transaction on the action, the action on an until() that was never
-                // re-notified (#3164). Same selective wake as the equal-landing
-                // branch in recompute(). Optional call: the bit implies the
-                // optimistic engine WAS consulted, but the hook only installs with
-                // it — a bare-core build must not crash here.
-                GlobalQueue.he?.(e);
-            }
-            e.Te = clock;
-        } else if (s) {
+            } else GlobalQueue.ye(e, r);
+            e._e = clock;
+        } else if (u) {
             // Route through lane's effect queue for independent flushing
-            const n = e.ge;
-            const t = e.be;
-            const o = e.pe;
+            const n = e.Ce;
+            const t = e.me;
+            const o = e.ve;
             try {
-                if (!n && i || !o || !o(r, t)) {
-                    e.be = r;
-                    e.Te = clock;
+                if (!n && s || !o || !o(r, t)) {
+                    e.me = r;
+                    e._e = clock;
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
                     // (computePendingState doesn't read _value).
-                                        GlobalQueue.Ue?.(e, r);
+                                        GlobalQueue.pe?.(e, r);
                     insertSubs(e, true);
                 }
             } catch (n) {
@@ -365,9 +410,9 @@ function handleAsync(e, n, t) {
         // window when the hold commits, so no one-frame isPending pulse can leak
         // to live observers between the landing and its commit (#2990). The
         // quiet re-ask classification follows the same schedule (#3178).
-                if (e.Re === NOT_PENDING) {
-            e.Ne = false;
-            if (l) e.o.De = false;
+                if (e.Ge === NOT_PENDING) {
+            e.Ae = false;
+            if (l) e.o.Ue = false;
         }
         settlePendingSource(e);
         schedule();
@@ -401,12 +446,12 @@ function handleAsync(e, n, t) {
     // meaningful only in the live posture.
         const consumeIterator = (t, r) => {
         const o = t[Symbol.asyncIterator]();
+        let i = false;
         let l = false;
-        let s = false;
         let u = !r;
         const close = () => {
-            if (s) return;
-            s = true;
+            if (l) return;
+            l = true;
             try {
                 const e = o.return?.();
                 if (isThenable(e)) e.then(undefined, () => {});
@@ -417,7 +462,7 @@ function handleAsync(e, n, t) {
         // owner-death backstop, but its disposal list can be zombie-deferred
         // until the SUPERSEDING flight settles. The teardown slot fires at the
         // _inFlight release sites so supersede stops this stream immediately.
-                ext(e).Ee = close;
+                ext(e).De = close;
         // Release check before each next pull: an unobserved lazy node must tear
         // down (its close above runs via disposal, closing the iterator) instead
         // of pumping the stream forever with zero subscribers (#2935).
@@ -446,15 +491,15 @@ function handleAsync(e, n, t) {
                 if (c && u) {
                     t = r;
                     f = true;
-                    if (r.done) s = true;
-                } else if (e.o?.Ie !== n) {
+                    if (r.done) l = true;
+                } else if (e.o?.Pe !== n) {
                     return;
                 } else if (!r.done) {
-                    l = true;
+                    i = true;
                     asyncWrite(r.value, iterateOrRelease);
                 } else {
-                    s = true;
-                    if (l) {
+                    l = true;
+                    if (i) {
                         schedule();
                         flush();
                     } else {
@@ -467,8 +512,8 @@ function handleAsync(e, n, t) {
                 if (c && u) {
                     r = t;
                     a = true;
-                } else if (e.o?.Ie === n) {
-                    s = true;
+                } else if (e.o?.Pe === n) {
+                    l = true;
                     handleError(t);
                     settleAutodispose();
                 }
@@ -476,14 +521,14 @@ function handleAsync(e, n, t) {
             c = false;
             if (a) {
                 // Match the promise branch, but only rethrow during the initial read.
-                s = true;
+                l = true;
                 handleError(r);
                 if (u) throw r;
                 return true;
             }
             if (f && !t.done) {
-                i = t.value;
-                l = true;
+                s = t.value;
+                i = true;
                 return iterate();
             }
             return f && t.done;
@@ -491,7 +536,7 @@ function handleAsync(e, n, t) {
         const f = iterate();
         // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
                 u = false;
-        return l || f;
+        return i || f;
     };
     // Landed-synchronously verdict for a LIVE iterator drain; null when no live
     // drain ran (plain promise flight, or a deferred flatten). Drives the
@@ -515,7 +560,7 @@ function handleAsync(e, n, t) {
         return true;
     };
     if (o) {
-        let t = false, r = false, o, l = true;
+        let t = false, r = false, o, i = true;
         // Close registration for the flattening path. Consumption starts in a
         // microtask where the ambient owner is gone (or worse, someone else's),
         // so `cleanup()` can't be used — the close targets el's disposal list
@@ -527,18 +572,18 @@ function handleAsync(e, n, t) {
         // becomes disposal-bearing, which is exactly the class a directly
         // returned iterable already occupies.
                 const registerDeferredClose = n => {
-            if (!e.Ge) e.Ge = n; else if (Array.isArray(e.Ge)) e.Ge.push(n); else e.Ge = [ e.Ge, n ];
+            if (!e.we) e.we = n; else if (Array.isArray(e.we)) e.we.push(n); else e.we = [ e.we, n ];
         };
         n.then(r => {
-            if (l) {
-                i = r;
+            if (i) {
+                s = r;
                 t = true;
-            } else if (e.o?.Ie === n && !(e.ie & REACTIVE_DISPOSED) && flattenIfIterable(r, registerDeferredClose)) ; else {
+            } else if (e.o?.Pe === n && !(e.ie & REACTIVE_DISPOSED) && flattenIfIterable(r, registerDeferredClose)) ; else {
                 asyncWrite(r);
                 settleAutodispose();
             }
         }, e => {
-            if (l) {
+            if (i) {
                 o = e;
                 r = true;
             } else {
@@ -546,7 +591,7 @@ function handleAsync(e, n, t) {
                 settleAutodispose();
             }
         });
-        l = false;
+        i = false;
         if (r) {
             // Settle through the same status path an async rejection uses, then
             // unwind the in-progress synchronous read so the errored node isn't
@@ -558,12 +603,12 @@ function handleAsync(e, n, t) {
             // is opened — first-flight work on a loadingValue node is loading-class
             // (invisible to boundaries and transitions); the flight itself is
             // already registered in _inFlight and lands through asyncWrite.
-            if (e.Ne) return e.be;
+            if (e.Ae) return e.me;
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
-        } else if (!flattenIfIterable(i)) {
+        } else if (!flattenIfIterable(s)) {
             // Synchronously-resolved promise: the first real answer landed.
-            e.Ne = false;
+            e.Ae = false;
         }
         // A sync-resolved promise holding an AsyncIterable flattened LIVE (we
         // are still inside the synchronous read): full initial-drain semantics
@@ -573,30 +618,30 @@ function handleAsync(e, n, t) {
     if (l !== null) {
         if (!l) {
             // Loading window: serve commit #0 (see the promise branch above).
-            if (e.Ne) return e.be;
+            if (e.Ae) return e.me;
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
         }
         // A sync first yield (or immediate empty completion) is the first real
         // answer; async yields clear inside asyncWrite.
-                e.Ne = false;
+                e.Ae = false;
     }
-    return i;
+    return s;
 }
 
 function clearStatus(e, n = false) {
     if (e.o?.le) clearPendingSources(e);
-    if (e.o?.fe) if (e.o !== null) e.o.fe = false;
+    if (e.o?.de) if (e.o !== null) e.o.de = false;
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
-        if (e.o !== null) e.o.De = false;
+        if (e.o !== null) e.o.Ue = false;
     e.S = n ? 0 : e.S & STATUS_UNINITIALIZED;
     if (e.o?._) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e.o?.ye || e.o?.Ce) GlobalQueue.de(e);
-    if (e.o?.i && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.me !== null) GlobalQueue.me(e);
+        if (e.o?.Le || e.o?.Qe) GlobalQueue.Ne(e);
+    if (e.o?.i && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.ke !== null) GlobalQueue.ke(e);
     const t = statusNotifierOf(e);
     if (t) t.call(e);
 }
@@ -605,12 +650,16 @@ function notifyStatus(e, n, t, r, o) {
     // Wrap regular errors to track source node
     if (n === STATUS_ERROR && !(t instanceof StatusError) && !(t instanceof NotReadyError)) t = new StatusError(e, t);
     const i = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
-    const l = i === e;
-    const s = n === STATUS_PENDING && e.o?.Pe !== undefined && !l;
-    const u = s && hasActiveOverride(e);
+    const s = i === e;
+    const l = n === STATUS_PENDING && e.o?.be !== undefined && !s;
+    const u = l && hasActiveOverride(e);
     if (!r) {
         if (n === STATUS_PENDING && i) {
             addPendingSource(e, i);
+            // A fresh flight from a settled state starts with its inputs unpublished
+            // (a replacement flight while still pending keeps the mark: the first
+            // flight's committed inputs are still the frame).
+                        if (!(e.S & STATUS_PENDING)) e.T &= ~CONFIG_INPUTS_PUBLISHED;
             e.S = STATUS_PENDING | e.S & STATUS_UNINITIALIZED;
             // Preserve the current source on this propagation so render-effect notification
             // can register every distinct pending source with the transition.
@@ -620,14 +669,14 @@ function notifyStatus(e, n, t, r, o) {
             e.S = n | (n !== STATUS_ERROR ? e.S & STATUS_UNINITIALIZED : 0);
             ext(e)._ = t;
         }
-        GlobalQueue.de?.(e);
-        if (e.o?.i && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.me !== null) GlobalQueue.me(e);
+        GlobalQueue.Ne?.(e);
+        if (e.o?.i && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.ke !== null) GlobalQueue.ke(e);
     }
     if (o && !r) {
         assignOrMergeLane(e, o);
     }
     const f = r || u;
-    const a = r || s ? undefined : o;
+    const a = r || l ? undefined : o;
     const c = statusNotifierOf(e);
     if (c) {
         if (r && n === STATUS_PENDING) {
@@ -641,19 +690,19 @@ function notifyStatus(e, n, t, r, o) {
         return;
     }
     forEachDependent(e, (e, r) => {
-        e.Te = clock;
+        e._e = clock;
         if (n === STATUS_PENDING && i && !e.o?.le?.has(i) || n !== STATUS_PENDING && (e.o?._ !== t || e.o?.le)) {
             // A pending-observer link is the subscription an `isPending` read created.
             // It exists so the observer re-runs when the source settles, but it must
             // not carry a real (non-NotReadyError) error — the synchronous `isPending`
             // read swallows those, and the async path must match. Re-run the observer
             // so `isPending` re-evaluates (to not-pending) instead of forwarding.
-            if (r.ve && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
+            if (r.je && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
             }
-            if (!f && !e.Ae) queuePendingNode(e);
+            if (!f && !e.ge) queuePendingNode(e);
             notifyStatus(e, n, t, f, a);
         }
     });

package/dist/prod/core/attribution-hooks.js

@@ -0,0 +1,3 @@
+let attrHooks = null;
+
+export { attrHooks };