@solidjs/signals 2.0.0-rc.3 → 2.0.0-rc.5

package/dist/prod/core/async.js

@@ -1,6 +1,6 @@
-import { STATUS_UNINITIALIZED, CONFIG_CHILD_COMPANIONS, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_DISPOSED } from "./constants.js";
+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 { untrack, ext, setSignal, context } from "./core.js";
+import { untrack, ext, statusNotifierOf, setSignal, context } from "./core.js";
 
 import "./invariants.js";
 
@@ -45,7 +45,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).ue = true;
+    ext(e).fe = 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
@@ -70,10 +70,10 @@ function setPendingError(e, n, t) {
 }
 
 function forEachDependent(e, n) {
-    for (let t = e.u; t !== null; t = t.fe) n(t.ae, t);
+    for (let t = e.u; t !== null; t = t.ae) n(t.ce, t);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-        for (let t = e.o?.l ?? null; t !== null; t = t.ce) {
-        for (let e = t.u; e !== null; e = e.fe) n(e.ae, e);
+        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);
     }
 }
 
@@ -88,7 +88,7 @@ function forEachDependent(e, n) {
 // callbacks handle their own release (settleAutodispose in handleAsync); this
 // covers derivatively-pending dependents, which have no callbacks of their own.
 function releaseIfSettledUnobserved(e) {
-    e.Se && e.T & CONFIG_AUTO_DISPOSE && !e.u && !(e.ie & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+    e.oe && e.T & CONFIG_AUTO_DISPOSE && !e.u && !(e.ie & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
 }
 
 // Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
@@ -145,35 +145,35 @@ function settlePendingSource(e) {
     const r = new Set;
     // Companion updates no-op without the verdict layer (null hook).
         const o = GlobalQueue.de;
-    const settle = l => {
-        if (r.has(l) || !removePendingSource(l, e)) return;
-        r.add(l);
-        l.Te = clock;
-        const u = l.o?.le?.values().next().value;
+    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;
         // 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 i = l.S & STATUS_ERROR;
-        if (u) {
-            if (!i) setPendingError(l, u);
-            o !== null && o(l);
+                const s = i.S & STATUS_ERROR;
+        if (l) {
+            if (!s) setPendingError(i, l);
+            o?.(i);
         } else {
-            l.S &= ~STATUS_PENDING;
-            if (!i) setPendingError(l);
-            o !== null && o(l);
-            if (l.o?.ue) {
-                enqueueSub(l);
+            i.S &= ~STATUS_PENDING;
+            if (!s) setPendingError(i);
+            o?.(i);
+            if (i.o?.fe) {
+                enqueueSub(i);
                 n = true;
             }
-            if (l.o !== null) l.o.ue = false;
+            if (i.o !== null) i.o.fe = 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 (!l.u && l.T & CONFIG_AUTO_DISPOSE) (t ??= []).push(l);
+                        if (!i.u && i.T & CONFIG_AUTO_DISPOSE) (t ??= []).push(i);
         }
-        forEachDependent(l, settle);
+        forEachDependent(i, settle);
     };
     forEachDependent(e, settle);
     // Release before the flush schedule below: unobserved() pulls the node back
@@ -187,6 +187,14 @@ function isThenable(e) {
     return e != null && typeof e === "object" && typeof e.then === "function";
 }
 
+/** Fire and clear a node's iterator-flight cancellation hook (#3122). */ function releaseFlightTeardown(e) {
+    const n = e.o?.Ee;
+    if (n != null) {
+        e.o.Ee = null;
+        n();
+    }
+}
+
 function handleAsync(e, n, t) {
     let r = false;
     let o = false;
@@ -197,13 +205,18 @@ function handleAsync(e, n, t) {
         });
     }
     if (!o && !r) {
-        if (e.o !== null) e.o.Ee = null;
+        if (e.o !== null) e.o.Ie = null;
         // A sync landing is the first real answer for a loadingValue node.
-                e.Ie = false;
+                e.Ne = false;
         return n;
     }
-    ext(e).Ee = n;
-    let l;
+    // Flight replacement relies on recompute's supersede release for iterator
+    // teardown (#3122): every handleAsync call — including the projection
+    // 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;
     // 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
@@ -216,24 +229,24 @@ function handleAsync(e, n, t) {
     // are the transaction's reveal machinery and always re-enter.
         const settleTransition = () => {
         const n = resolveTransition(e);
-        if (n && e.S & STATUS_UNINITIALIZED && !currentTransition(n).Ne.has(e)) {
+        if (n && e.S & STATUS_UNINITIALIZED && !currentTransition(n)._e.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._e = null;
+            e.Ae = null;
             return;
         }
         globalQueue.initTransition(n);
     };
     const handleError = t => {
-        if (e.o?.Ee !== n) return;
+        if (e.o?.Ie !== n) return;
         // NotReadyError from rejected promises should be treated as pending, not error
                 let r = t instanceof NotReadyError;
-        if (r && e.Ie) {
+        if (r && e.Ne) {
             // 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.Ee = null;
+            if (e.o !== null) e.o.Ie = null;
             parkLoadingWindow(e, t);
             e.Te = clock;
             return;
@@ -247,21 +260,21 @@ function handleAsync(e, n, t) {
                 if (!r) releaseSettledDependents(e);
     };
     const asyncWrite = (r, o) => {
-        if (e.o?.Ee !== n) return;
+        if (e.o?.Ie !== 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;
         settleTransition();
-        const l = !!(e.S & STATUS_UNINITIALIZED);
+        const i = !!(e.S & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
-        const u = resolveLane(e);
-        if (u) u.Ae.delete(e);
+        const l = resolveLane(e);
+        if (l) l.De.delete(e);
         if (t) {
             t(r);
-            if (l) clearStatus(e, true);
-        } else if (e.o?.De !== undefined) {
+            if (i) clearStatus(e, true);
+        } else if (e.o?.Oe !== 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
@@ -280,24 +293,35 @@ 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.Oe !== null && GlobalQueue.Oe(e, r);
+                        GlobalQueue.Re?.(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.Ue?.(e);
             }
             e.Te = clock;
-        } else if (u) {
+        } else if (l) {
             // Route through lane's effect queue for independent flushing
-            const n = e.Re;
+            const n = e.he;
             const t = e.be;
-            const o = e.Ue;
+            const o = e.ge;
             try {
-                if (!n && l || !o || !o(r, t)) {
+                if (!n && i || !o || !o(r, t)) {
                     e.be = r;
                     e.Te = 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.Oe !== null && GlobalQueue.Oe(e, r);
+                                        GlobalQueue.Re?.(e, r);
                     insertSubs(e, true);
                 }
             } catch (n) {
@@ -322,7 +346,7 @@ function handleAsync(e, n, t) {
         // held-value branch is window-gated, and commitPendingNode closes the
         // window when the hold commits, so no one-frame isPending pulse can leak
         // to live observers between the landing and its commit (#2990).
-                if (e.Pe === NOT_PENDING) e.Ie = false;
+                if (e.Pe === NOT_PENDING) e.Ne = false;
         settlePendingSource(e);
         schedule();
         flush();
@@ -355,18 +379,23 @@ function handleAsync(e, n, t) {
     // meaningful only in the live posture.
         const consumeIterator = (t, r) => {
         const o = t[Symbol.asyncIterator]();
-        let u = false;
-        let i = false;
-        let s = !r;
+        let l = false;
+        let s = false;
+        let u = !r;
         const close = () => {
-            if (i) return;
-            i = true;
+            if (s) return;
+            s = true;
             try {
                 const e = o.return?.();
                 if (isThenable(e)) e.then(undefined, () => {});
             } catch {}
         };
         r ? r(close) : cleanup(close);
+        // Flight-identity cancellation (#3122): the registration above is the
+        // 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;
         // 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).
@@ -392,18 +421,18 @@ function handleAsync(e, n, t) {
                 // stash: it must write through the async path or the value is
                 // silently dropped. (The deferred posture never has a caller, so
                 // initialRead starts false there and everything writes through.)
-                if (c && s) {
+                if (c && u) {
                     t = r;
                     f = true;
-                    if (r.done) i = true;
-                } else if (e.o?.Ee !== n) {
+                    if (r.done) s = true;
+                } else if (e.o?.Ie !== n) {
                     return;
                 } else if (!r.done) {
-                    u = true;
+                    l = true;
                     asyncWrite(r.value, iterateOrRelease);
                 } else {
-                    i = true;
-                    if (u) {
+                    s = true;
+                    if (l) {
                         schedule();
                         flush();
                     } else {
@@ -413,11 +442,11 @@ function handleAsync(e, n, t) {
                     settleAutodispose();
                 }
             }, t => {
-                if (c && s) {
+                if (c && u) {
                     r = t;
                     a = true;
-                } else if (e.o?.Ee === n) {
-                    i = true;
+                } else if (e.o?.Ie === n) {
+                    s = true;
                     handleError(t);
                     settleAutodispose();
                 }
@@ -425,27 +454,27 @@ function handleAsync(e, n, t) {
             c = false;
             if (a) {
                 // Match the promise branch, but only rethrow during the initial read.
-                i = true;
+                s = true;
                 handleError(r);
-                if (s) throw r;
+                if (u) throw r;
                 return true;
             }
             if (f && !t.done) {
-                l = t.value;
-                u = true;
+                i = t.value;
+                l = true;
                 return iterate();
             }
             return f && t.done;
         };
         const f = iterate();
         // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
-                s = false;
-        return u || f;
+                u = false;
+        return l || f;
     };
     // Landed-synchronously verdict for a LIVE iterator drain; null when no live
     // drain ran (plain promise flight, or a deferred flatten). Drives the
     // shared NotReady/loading tail below.
-        let u = null;
+        let l = null;
     // Flatten one async level: a thenable that RESOLVES to an AsyncIterable —
     // the shape every async stub returning a stream produces — consumes as the
     // stream itself rather than settling on the iterable object. One level
@@ -460,11 +489,11 @@ function handleAsync(e, n, t) {
         }
         if (!t) return false;
         const r = consumeIterator(e, n);
-        if (!n) u = r;
+        if (!n) l = r;
         return true;
     };
     if (o) {
-        let t = false, r = false, o, u = true;
+        let t = false, r = false, o, l = 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
@@ -476,18 +505,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.he) e.he = n; else if (Array.isArray(e.he)) e.he.push(n); else e.he = [ e.he, n ];
+            if (!e.pe) e.pe = n; else if (Array.isArray(e.pe)) e.pe.push(n); else e.pe = [ e.pe, n ];
         };
         n.then(r => {
-            if (u) {
-                l = r;
+            if (l) {
+                i = r;
                 t = true;
-            } else if (e.o?.Ee === n && !(e.ie & REACTIVE_DISPOSED) && flattenIfIterable(r, registerDeferredClose)) ; else {
+            } else if (e.o?.Ie === n && !(e.ie & REACTIVE_DISPOSED) && flattenIfIterable(r, registerDeferredClose)) ; else {
                 asyncWrite(r);
                 settleAutodispose();
             }
         }, e => {
-            if (u) {
+            if (l) {
                 o = e;
                 r = true;
             } else {
@@ -495,7 +524,7 @@ function handleAsync(e, n, t) {
                 settleAutodispose();
             }
         });
-        u = false;
+        l = 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
@@ -507,103 +536,105 @@ 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.Ie) return e.be;
+            if (e.Ne) return e.be;
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
-        } else if (!flattenIfIterable(l)) {
+        } else if (!flattenIfIterable(i)) {
             // Synchronously-resolved promise: the first real answer landed.
-            e.Ie = false;
+            e.Ne = false;
         }
         // A sync-resolved promise holding an AsyncIterable flattened LIVE (we
         // are still inside the synchronous read): full initial-drain semantics
         // apply and the shared tail below settles the verdict.
         }
     if (r) flattenIfIterable(n);
-    if (u !== null) {
-        if (!u) {
+    if (l !== null) {
+        if (!l) {
             // Loading window: serve commit #0 (see the promise branch above).
-            if (e.Ie) return e.be;
+            if (e.Ne) return e.be;
             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.Ie = false;
+                e.Ne = false;
     }
-    return l;
+    return i;
 }
 
 function clearStatus(e, n = false) {
     if (e.o?.le) clearPendingSources(e);
-    if (e.o?.ue) if (e.o !== null) e.o.ue = false;
+    if (e.o?.fe) if (e.o !== null) e.o.fe = 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.pe = false;
+        if (e.o !== null) e.o.Ge = 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?.Ge || e.o?.ge) GlobalQueue.de(e);
-    if (e.o?.l && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
-    if (e.o?.A) e.o.A.call(e);
+        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);
+    const t = statusNotifierOf(e);
+    if (t) t.call(e);
 }
 
 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 l = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
-    const u = l === e;
-    const i = n === STATUS_PENDING && e.o?.De !== undefined && !u;
-    const s = i && hasActiveOverride(e);
+    const i = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
+    const l = i === e;
+    const s = n === STATUS_PENDING && e.o?.Oe !== undefined && !l;
+    const u = s && hasActiveOverride(e);
     if (!r) {
-        if (n === STATUS_PENDING && l) {
-            addPendingSource(e, l);
+        if (n === STATUS_PENDING && i) {
+            addPendingSource(e, i);
             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.
-                        setPendingError(e, l, t);
+                        setPendingError(e, i, t);
         } else {
             clearPendingSources(e);
             e.S = n | (n !== STATUS_ERROR ? e.S & STATUS_UNINITIALIZED : 0);
             ext(e)._ = t;
         }
-        GlobalQueue.de !== null && GlobalQueue.de(e);
-        if (e.o?.l && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
+        GlobalQueue.de?.(e);
+        if (e.o?.i && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.me !== null) GlobalQueue.me(e);
     }
     if (o && !r) {
         assignOrMergeLane(e, o);
     }
-    const f = r || s;
-    const a = r || i ? undefined : o;
-    if (e.o?.A) {
+    const f = r || u;
+    const a = r || s ? undefined : o;
+    const c = statusNotifierOf(e);
+    if (c) {
         if (r && n === STATUS_PENDING) {
             return;
         }
         if (f) {
-            e.o.A.call(e, n, t);
+            c.call(e, n, t);
         } else {
-            e.o.A.call(e);
+            c.call(e);
         }
         return;
     }
     forEachDependent(e, (e, r) => {
         e.Te = clock;
-        if (n === STATUS_PENDING && l && !e.o?.le?.has(l) || n !== STATUS_PENDING && (e.o?._ !== t || e.o?.le)) {
+        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.me && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
+            if (r.ve && n !== STATUS_PENDING && !(t instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
             }
-            if (!f && !e._e) queuePendingNode(e);
+            if (!f && !e.Ae) queuePendingNode(e);
             notifyStatus(e, n, t, f, a);
         }
     });
 }
 
-export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, parkLoadingWindow, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource };
+export { addPendingSource, clearStatus, forEachDependent, handleAsync, isThenable, notifyStatus, parkLoadingWindow, releaseFlightTeardown, releaseSettledDependents, setPendingError, settleErroredDependents, settlePendingSource };

package/dist/prod/core/constants.js

@@ -83,6 +83,60 @@ const CONFIG_HAS_LANE = 1 << 10;
  * moved into the cold extension (§12), and an unconditional `_x` deref per
  * marked node measurably taxed the propagation hot path (diamond -22%). */ const CONFIG_FW_CHILDREN = 1 << 12;
 
+/** Authoritative-view reader (`until()`): while this node computes, reads
+ * dodge active optimistic OVERRIDES only — the predicate must observe
+ * arriving truth, never the caller's own tentative writes (which would
+ * trivially satisfy it). Everything else reads normally, INCLUDING
+ * transition-staged `_pendingValue`: staged data is authoritative (optimism
+ * lives only in override slots), and a hold that refused staged reads would
+ * deadlock on data the open transaction itself is holding (a refresh the
+ * action issued lands staged and cannot commit until the hold releases).
+ * read() checks the bit on the reading computation (`context`) directly — no
+ * ambient flag — so a shared computed the predicate pulls recomputes as
+ * itself (no bit) under the normal view, and its cache never forks. */ const CONFIG_AUTHORITATIVE_READ = 1 << 13;
+
+/** Sticky mark: an authoritative-view reader read this node PAST an active
+ * override. The ack shape — an authoritative arrival EQUAL to the override —
+ * rides paths that are deliberately silent under A17 (every ordinary reader
+ * sees the override, so an equal landing changes nothing for them). A marked
+ * node notifies those readers on such paths anyway, so the landed truth is
+ * seen without re-firing ordinary subscribers. Never cleared — only nodes an
+ * until() predicate observed mid-override pay. */ const CONFIG_AUTHORITATIVE_OBSERVED = 1 << 14;
+
+/** Promise-delivery effect (resolve()/until()): commits its computed value
+ * directly even when recomputing under its own held transition. These
+ * effects deliver applies on a microtask (#2930) instead of the stashed
+ * effect queues, so the value must ride the same immediate schedule — a
+ * staged value with an immediate apply delivers stale state (resolve) or
+ * deadlocks the hold (until). Safe because the node is a private leaf: no
+ * subscriber reads an effect's value, only its own apply does. */ const CONFIG_DIRECT_COMMIT = 1 << 15;
+
+/** Fresh-pull reader (awaitable `refresh()`'s waiter effect): a read of a
+ * dirty source recomputes it inline even when the height gate defers to the
+ * flush. Closes the same-flush ordering race where a waiter created
+ * alongside a refresh() mark read the PRE-re-ask value as settled and
+ * delivered stale; with the pull, the waiter either parks on the re-ask's
+ * pending window (async — woken by the settle walk, which runs on every
+ * landing including equal-value ones) or serves its sync answer. resolve()
+ * deliberately keeps that race — its contract is "first settled value"
+ * (#2930), not "next quiescent state". */ const CONFIG_FRESH_READ = 1 << 16;
+
+/** HELD truth (#3164): this node's staged `_pendingValue` is confirming
+ * truth riding a transaction that retains optimism, revealed only at that
+ * transaction's settle. Two arming sites, one meaning: the store fold
+ * (a landing staged into the retaining transaction) and until()'s
+ * flip-entanglement (a foreign carrier's staged write, stolen when it
+ * flipped the awaited predicate truthy). Until the reveal, ordinary
+ * readers — lane and speculative recomputes included — keep committed:
+ * the staging notified subscribers as a plain write, so without the mask
+ * a mid-hold recompute composes live optimism with the confirming truth,
+ * a frame no timeline contains (GabbeV's union tear). Authoritative
+ * readers (until()'s predicate) and latest() tunnel through — the
+ * exemption that keeps holds deadlock-free. Override-covered nodes never
+ * arm: the override is their display and its revert their notification
+ * (A17). Cleared at commit (the commit IS the reveal); subscribers masked
+ * during the hold are woken by finalizePureQueue's post-revert pass. */ const CONFIG_HELD_TRUTH = 1 << 17;
+
 const STATUS_PENDING = 1 << 0;
 
 const STATUS_ERROR = 1 << 1;
@@ -127,4 +181,4 @@ const defaultContext = {};
  * @internal
  */ const $REFRESH = Symbol("refresh");
 
-export { $REFRESH, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_CHILD_COMPANIONS, CONFIG_FW_CHILDREN, CONFIG_HAS_COMPANIONS, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_NO_SNAPSHOT, CONFIG_OPTIMISTIC, CONFIG_OWNED_WRITE, CONFIG_SYNC, CONFIG_TRANSPARENT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, OVERRIDE_UNDEFINED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SNAPSHOT_STALE, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, STORE_SNAPSHOT_PROPS, SUPPORTS_PROXY, defaultContext, unwrapOverride };
+export { $REFRESH, CONFIG_AUTHORITATIVE_OBSERVED, CONFIG_AUTHORITATIVE_READ, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_CHILD_COMPANIONS, CONFIG_DIRECT_COMMIT, CONFIG_FRESH_READ, CONFIG_FW_CHILDREN, CONFIG_HAS_COMPANIONS, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, CONFIG_HELD_TRUTH, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_NO_SNAPSHOT, CONFIG_OPTIMISTIC, CONFIG_OWNED_WRITE, CONFIG_SYNC, CONFIG_TRANSPARENT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, OVERRIDE_UNDEFINED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SNAPSHOT_STALE, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, STORE_SNAPSHOT_PROPS, SUPPORTS_PROXY, defaultContext, unwrapOverride };