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

package/dist/observe/core/core.js

@@ -0,0 +1,1289 @@
+import { releaseFlightTeardown, handleAsync, clearStatus, parkLoadingWindow, notifyStatus, settlePendingSource, settleErroredDependents } from "./async.js";
+
+import { EFFECT_TRACKED, EFFECT_USER, REACTIVE_OPTIMISTIC_DIRTY, CONFIG_OPTIMISTIC, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_ERROR, STATUS_PENDING, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, CONFIG_HAS_LANE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, CONFIG_DIRECT_COMMIT, OVERRIDE_UNDEFINED, CONFIG_HAS_COMPANIONS, REACTIVE_LAZY, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRESH_READ, CONFIG_INPUTS_PUBLISHED, CONFIG_AUTHORITATIVE_READ, CONFIG_OVERRIDE_SUPERSEDED, CONFIG_AUTHORITATIVE_OBSERVED, CONFIG_HELD_TRUTH, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, REACTIVE_MANUAL_WRITE, CONFIG_FW_CHILDREN, CONFIG_SLOT_NODE, STORE_SNAPSHOT_PROPS } from "./constants.js";
+
+import { NotReadyError } from "./error.js";
+
+import { trimStaleDeps, link, dormantNodes } from "./graph.js";
+
+import { deleteFromHeap, queueFor, insertIntoHeapHeight, enqueueSub, markNode, markHeap, insertIntoHeap } from "./heap.js";
+
+import { GlobalQueue, bumpNotifyEpoch, activeTransition, globalQueue, clock, currentTransition, insertSubs, queuePendingNode, runInTransition, schedule, notifyEpoch, dirtyQueue, projectionWriteActive, reaskArmed, armReaskClear } from "./scheduler.js";
+
+import { GRAPH_SIZE_WARN_AT, noteFanIn } from "./dev.js";
+
+import { attrHooks } from "./attribution-hooks.js";
+
+import "./invariants.js";
+
+import { disposeChildren, markDisposal, inheritId } from "./owner.js";
+
+// The heap's per-node step. A tracked effect's heap visit is its compute
+// phase — empty, like a user effect whose compute reads nothing — and hands
+// the callback to the user queue. Routing the wake through the heap, rather
+// than straight into the queue at notify time, is what orders the run after
+// the commit regardless of which phase the write came from: a write in a
+// render-effect callback stages its value for the next pass, but a wake pushed
+// directly into the user queue ran in the SAME pass, read the old value, and
+// nothing re-notified it when the value landed (#3291).
+GlobalQueue.lt = e => {
+    if (e.Re === EFFECT_TRACKED) {
+        deleteFromHeap(e, queueFor(e));
+        e._t = true;
+        e.C.enqueue(EFFECT_USER, e.ct);
+    } else recompute(e);
+};
+
+GlobalQueue.Et = disposeChildren;
+
+let tracking = false;
+
+/** @internal verdict-module glue */ function setPendingCheckActive(e) {
+    pendingCheckActive = e;
+}
+
+/** @internal verdict-module glue */ function setLatestReadActive(e) {
+    latestReadActive = e;
+}
+
+/** @internal verdict-module glue */ function setContextInternal(e) {
+    context = e;
+}
+
+let stale = false;
+
+let pendingCheckActive = false;
+
+let latestReadActive = false;
+
+let context = null;
+
+let currentOptimisticLane = null;
+
+let snapshotCaptureActive = false;
+
+let snapshotSources = null;
+
+function ownerInSnapshotScope(e) {
+    while (e) {
+        if (e.It) return true;
+        e = e.Nt;
+    }
+    return false;
+}
+
+function setSnapshotCapture(e) {
+    snapshotCaptureActive = e;
+    if (e && !snapshotSources) snapshotSources = new Set;
+}
+
+function markSnapshotScope(e) {
+    e.It = true;
+}
+
+function releaseSnapshotScope(e) {
+    e.It = false;
+    releaseSubtree(e);
+    schedule();
+}
+
+function releaseSubtree(e) {
+    let t = e.Tt;
+    while (t) {
+        if (t.It) {
+            t = t.dt;
+            continue;
+        }
+        if (t.ot) {
+            const e = t;
+            e.T &= ~CONFIG_IN_SNAPSHOT_SCOPE;
+            if (e.it & REACTIVE_SNAPSHOT_STALE) {
+                e.it &= ~REACTIVE_SNAPSHOT_STALE;
+                e.it |= REACTIVE_DIRTY;
+                if (dirtyQueue.St > e.At) dirtyQueue.St = e.At;
+                insertIntoHeap(e, dirtyQueue);
+            }
+        }
+        releaseSubtree(t);
+        t = t.dt;
+    }
+}
+
+function clearSnapshots() {
+    if (snapshotSources) {
+        for (const e of snapshotSources) {
+            delete e.o?.Ot;
+            // StoreNode targets share one pre-initialized hidden class (see
+            // createStoreProxy) — assign undefined instead of deleting, and only
+            // when present so signal-node sources don't grow the field.
+                        if (e[STORE_SNAPSHOT_PROPS] !== undefined) e[STORE_SNAPSHOT_PROPS] = undefined;
+        }
+        snapshotSources = null;
+    }
+    snapshotCaptureActive = false;
+}
+
+function recompute(e, t = false) {
+    // §12d: any recompute can clean a marked subscriber — invalidate skips.
+    bumpNotifyEpoch();
+    const n = e.Re;
+    // Attribution hook: fired before this run touches the dep list — `_deps`
+    // still holds the previous run's links (the subscriptions that could have
+    // triggered this run, and the baseline for the engine's subscription diff).
+        let i = false;
+    if (attrHooks !== null) attrHooks.recomputeStart(e, t);
+    if (!t) {
+        if (e.Ee && (!n || activeTransition) && activeTransition !== e.Ee) globalQueue.initTransition(e.Ee);
+        deleteFromHeap(e, queueFor(e));
+        if (e.o !== null) {
+            e.o.Se = null;
+            // Supersede is where an iterator flight dies (#3122): close it now.
+            // Its cleanup(close) registration may sit in a zombie-deferred
+            // disposal list that a held transition only drains when the
+            // SUPERSEDING flight settles — cancellation must not wait for the
+            // work that replaced it. Idempotent with the cleanup-channel close.
+                        releaseFlightTeardown(e);
+        }
+        // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
+                if (e.Ee || n === EFFECT_TRACKED) disposeChildren(e); else if (e.Tt !== null || e.he !== null) {
+            markDisposal(e);
+            const t = ext(e);
+            t.Ct = e.he;
+            t.Rt = e.Tt;
+            e.he = null;
+            e.Tt = null;
+            e.Gt = 0;
+        } else ;
+    }
+    let l = !!(e.it & REACTIVE_OPTIMISTIC_DIRTY);
+    const u = (e.T & CONFIG_OPTIMISTIC) !== 0 && e.o?.De !== NOT_PENDING && e.o?.De !== undefined;
+    const o = !!(e.S & STATUS_UNINITIALIZED);
+    // Capture both error and pending status before the compute clears them.
+    // A conditional can drop its pending source and recover to an unchanged
+    // value, leaving blocked dependents outside that source’s settle walk.
+        const s = e.S & STATUS_ERROR ? e.o?._ : undefined;
+    const a = e.S & STATUS_PENDING ? e.o?.ee : undefined;
+    // Pending SOURCE-hood, captured before the compute clears status: a node
+    // whose own flight parked dependents self-registers in _pendingSources
+    // (notifyStatus, isSource). If this recompute supersedes that flight and
+    // settles synchronously, those dependents settle HERE — asyncWrite's
+    // settlePendingSource walk never runs for a landing that was preempted
+    // (#3181).
+        const r = e.o?.ee?.has(e);
+    // Re-ask classification lives in the verdict module; capture the flag before
+    // the recompute wipes _flags below.
+        const _ = (e.it & REACTIVE_REASK) !== 0;
+    // Captured before the compute clears it on a sync landing: if that landing
+    // is transition-held below, the window must stay open until the hold
+    // commits (commitPendingNode) — a closed window plus a held value reads as
+    // a pending frame to live observers of the verdict (#2990).
+        const c = e.de;
+    const f = context;
+    context = e;
+    e.Dt = null;
+    e.Pt++;
+    e.it = REACTIVE_RECOMPUTING_DEPS;
+    e.ae = clock;
+    let E = e.Pe === NOT_PENDING ? e.ge : e.Pe;
+    let I = e.At;
+    let N = false;
+    let T = tracking;
+    let d = currentOptimisticLane;
+    tracking = true;
+    // A computed's fn establishes its OWN dependencies, so it must never run
+    // inside a latest() read window: read() short-circuits through the
+    // companion path before dependency linking, so a memo created (eagerly
+    // computed) inside latest(fn) came out permanently dependency-less (#2926).
+    // latestRead() already suspends the flag for its pull-recomputes; this
+    // covers creation-time computes and flushes that run inside the window.
+        const S = latestReadActive;
+    latestReadActive = false;
+    // Lane posture lives with the engine: OPTIMISTIC_DIRTY is only ever set by
+    // engine-driven paths, and _optimisticNodes is only pushed by
+    // _optimisticWrite, so the hook is installed whenever either gate holds.
+        if (l) {
+        const t = GlobalQueue.Ft(e, true);
+        if (t) currentOptimisticLane = t;
+        // `false` = wake-only lane demotion: recompute plain so a mid-tick
+        // latest()/isPending() pull stages instead of direct-committing (#3009).
+        // The predicate lives with the engine (recomputeLane).
+         else if (t === false) l = false;
+    } else if (activeTransition && !t && activeTransition.en.length) {
+        // Lane adoption: parent-deeper-than-owned-child can run before its OPT-dirty
+        // child propagates. Walk deps once and inherit the OPT lane so this node
+        // recomputes under the right posture and propagates correctly.
+        const t = GlobalQueue.Ft(e, false);
+        if (t) {
+            l = true;
+            currentOptimisticLane = t;
+        }
+    }
+    const A = n && n !== EFFECT_USER;
+    const O = stale;
+    if (A) stale = true;
+    // An effect recorded for this transaction's commit replay (it once read a
+    // node the transaction held and showed the committed value) and now
+    // recomputing UNDER the transaction sees its staged view: the value this
+    // run produces is applied by the commit itself, and the stale recording
+    // would publish the frame a second time. Drop it; the reads below re-record
+    // if they are served the committed view again (a lane's committed read).
+        if (n && activeTransition !== null && activeTransition.ht.size) activeTransition.ht.delete(e);
+    try {
+        if (!false && e.T & CONFIG_SYNC) {
+            E = e.ot(E);
+            if (e.o !== null) e.o.Se = null;
+            e.de = false;
+        } else {
+            // Snapshot `_inFlight` so we can detect whether `_fn` self-registered an async
+            // subscription (e.g. `createProjection` calls `handleAsync` from inside its body
+            // with a setter callback). In that case, the outer `handleAsync` call below would
+            // clobber the fresh subscription, so we skip it and let the internally-registered
+            // iteration drive updates.
+            const t = e.o?.Se;
+            const n = e.ot(E);
+            const i = typeof n === "object" && n !== null;
+            const l = e.o?.Se !== t;
+            E = l || !i ? n : handleAsync(e, n);
+            if (!l && !i) {
+                if (e.o !== null) e.o.Se = null;
+                // A sync (non-object) return is the first real answer; async-shaped
+                // results clear inside handleAsync at their own landing points, and a
+                // self-registered flight (inFlightChanged — projections) clears when
+                // its internal handleAsync lands.
+                                e.de = false;
+            }
+        }
+        // On a status-free node clearStatus is a guaranteed no-op: every field
+        // its body gates on is either _statusFlags or lives in the cold
+        // extension — no extension, no status to clear. (_x from an unrelated
+        // installer just makes clearStatus a cheap re-verified no-op.)
+                if (e.S !== 0 || e.o !== null) clearStatus(e, t);
+        // _optimisticLane is only ever assigned by engine paths (CONFIG_HAS_LANE
+        // is their sticky presence mark).
+                if (e.T & CONFIG_HAS_LANE && e.o?.Te) GlobalQueue.Ht(e);
+    } catch (t) {
+        const n = t instanceof NotReadyError;
+        if (n && e.de) {
+            // Loading window with an unready sync dependency: register for the
+            // source's settle (the settlePendingSource walk runs off
+            // _pendingSources + _blocked alone) but take NO read-visible pending
+            // status, no downstream propagation, no transition, no lane
+            // registration — the committed loading value keeps serving. If the
+            // node is currently errored the error stays the answer until this
+            // retry can actually run.
+            parkLoadingWindow(e, t);
+        } else {
+            // Track pending async in the lane (not the lane's source — it creates the lane
+            // but doesn't belong to it). Set lane BEFORE notifyStatus for downstream propagation.
+            if (n && currentOptimisticLane) GlobalQueue.vt(e);
+            let i = false;
+            if (n) {
+                ext(e).ie = true;
+                if (GlobalQueue.gt !== null) i = GlobalQueue.gt(e, _);
+            }
+            notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t, undefined, n ? e.o?.Te : undefined);
+            // The replacement source is fully propagated now. If no new flight
+            // re-owned self, retire the superseded flight and its dependent copies.
+                        if (n && r && !e.o?.Se) settlePendingSource(e);
+            if (i) GlobalQueue.k(e);
+        }
+    } finally {
+        tracking = T;
+        latestReadActive = S;
+        if (A) stale = O;
+        // Consume the missed-wake latch (#3037, set by insertSubs): a dep write
+        // landed beneath this pass on a link it had already validated. The wipe
+        // below must not key off DIRTY/CHECK — the read-time pull protocol
+        // (markNode(c) in read()) marks the running node as part of ordinary
+        // bookkeeping, and those marks are correctly discarded here.
+                N = (e.it & REACTIVE_MISSED_WAKE) !== 0;
+        e.it = REACTIVE_NONE | (t ? e.it & REACTIVE_SNAPSHOT_STALE : 0);
+        context = f;
+    }
+    if (!e.o?._) {
+        trimStaleDeps(e);
+        // Observe-tier fan-in (HUGE_FAN_IN): with the stale tail trimmed, the dep
+        // list IS this pass's distinct sources — count it here rather than per
+        // link. A begin/end bracket around the pass plus a per-link increment
+        // measured -5.8% on createRenderEffects:create1to1 (CodSpeed, dev tier)
+        // and cost several points of the shape wins elsewhere; this walk is a
+        // fraction of the reads that built the list and keeps no module state,
+        // so nested pulls need no save/restore.
+                {
+            let t = 0;
+            for (let n = e.te; n !== null; n = n.ne) t++;
+            if (t >= GRAPH_SIZE_WARN_AT) noteFanIn(e, t);
+        }
+        // INV-11 (#3330): the equality gate compares against the slot this run
+        // publishes to. An override-covered node publishes the override; a lane
+        // recompute (OPT-dirty) direct-commits `_value` — the lane's own reveal
+        // schedule — so a transaction-held `_pendingValue` that already equals
+        // the new result is not "unchanged": the screen still shows `_value`.
+        // Only a transaction-staged run compares against `_pendingValue`.
+                const _ = u ? unwrapOverride(e.o?.De) : l || e.Pe === NOT_PENDING ? e.ge : e.Pe;
+        let f = false;
+        try {
+            f = !n && o || !e.Ue || !e.Ue(_, E);
+        } catch (t) {
+            // A throwing user comparator is an error of this node's computation.
+            // Route it through the same status path as a compute-phase throw so
+            // error boundaries contain it; otherwise it unwinds the scheduler
+            // flush, bypassing every boundary and wedging the queue (#2837).
+            notifyStatus(e, STATUS_ERROR, t);
+        }
+        // A committed derived change becomes a cause for this node's subscribers,
+        // chaining their attribution through this node to the root write.
+                if (attrHooks !== null) {
+            i = f && !e.o?._;
+            if (i && !n && !t) attrHooks.derivedChanged(e);
+        }
+        // Effects use `_equals: false` (no per-effect closure). The side effects that
+        // the equals closure used to perform — flagging the effect dirty and enqueueing
+        // its runner — happen here instead. `!create` matches the previous `initialized`
+        // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
+        // effect() can call its runner synchronously for the first run.
+                if (n && f) {
+            e._t = !e.o?._;
+            // Reuse one bound runner per effect — runEffect no-ops on a stale
+            // `_modified`, so re-enqueueing the same function is harmless.
+                        if (!t) {
+                e.C.enqueue(n, e.kt ??= GlobalQueue.bt.bind(null, e));
+                // Contested effect (#3322). Effects don't entangle transactions (a
+                // shared effect is not shared state), yet they have one value slot:
+                // when this write commits under a different transaction
+                // (`activeTransition`, null = mainline) than the one that produced the
+                // previous value (`_valueTransition`), that view is gone. Rather than
+                // merge the two, each commit re-derives the effect against its own
+                // committed world (Transition._contested, re-dirtied by
+                // finalizePureQueue ahead of the heap run). The previous owner always
+                // needs it if still live: its commit is silent (staging already
+                // notified) and the value it computed is gone. The new owner needs it
+                // too, for the same reason, unless it is mainline — mainline publishes
+                // what it computes. A previous owner that was mainline, or already
+                // committed, left nothing to protect.
+                                let t = e.Vt;
+                if (t !== activeTransition) {
+                    e.Vt = activeTransition;
+                    if (t !== null && (t = currentTransition(t)) !== activeTransition && !t.Ut) {
+                        (t.xt ??= []).push(e);
+                        if (activeTransition !== null) (activeTransition.xt ??= []).push(e);
+                    }
+                }
+            }
+        }
+        if (e.o?._) ; else if (f) {
+            const i = u ? e.o?.De : undefined;
+            if (t || 
+            // Plain sync flush (no transition on either side) commits effect
+            // values directly — the pending round-trip (queuePendingNode +
+            // commitPendingNodes) exists to sequence transition reveals, and
+            // paying it per effect on the plain path is pure overhead.
+            // DIRECT_COMMIT effects (resolve/until) commit directly even under
+            // their own held transition: their applies deliver on a microtask,
+            // not the stashed queues, so a staged value would hand the immediate
+            // apply stale state — see CONFIG_DIRECT_COMMIT.
+            n && (activeTransition !== e.Ee || activeTransition === null || e.T & CONFIG_DIRECT_COMMIT) || l) {
+                e.ge = E;
+                // Lane-propagated correction: upstream data is fresh, correct the
+                // override unconditionally. The direct _value commit is the lane's
+                // own reveal schedule; drop any superseded older hold so its queued
+                // commit can't clobber the fresh value.
+                                if (u && l) {
+                    ext(e).De = E === undefined ? OVERRIDE_UNDEFINED : E;
+                    e.Pe = NOT_PENDING;
+                }
+            } else {
+                e.Pe = E;
+                // A window landing that gets held re-opens the window until the hold
+                // commits — the verdict's held-value branch is window-gated (#2990).
+                                if (c) e.de = true;
+                // Transition-held sync recompute is a write path like setSignal/asyncWrite,
+                // so sync derivations of held sources stay visible to isPending()/latest()
+                // (#2831). Both companion writes are transition-scoped (optimistic) and
+                // auto-revert/re-derive at commit. Skipped for plain flushes where the
+                // pending value commits before effects run.
+                                if ((activeTransition || e.Ee) && GlobalQueue.Ae !== null) GlobalQueue.Ae(e, E);
+            }
+            // insertSubs only walks _subs (no scheduling of its own), so a
+            // subscriber-less node has nothing to notify.
+                        if (e.u !== null && (!u || l || e.o?.De !== i)) insertSubs(e, l || u);
+            // A18 supersession, sync twin of asyncWrite's override branch (#3331):
+            // this pass published truth that differs from the override (the gate
+            // compared against it) into the transaction-held slot. Whether the
+            // source is this node's own async or an upstream node it derives from
+            // synchronously makes no difference — "the source recomputed". The
+            // override stays displayed until the commit; the graph moves to the
+            // staged truth now (plain channel, lane demoted). Ordering: "a new
+            // value from the source" postdates the override — an override written
+            // in this same tick (optimisticWrite stamps `_overrideTime`) is the
+            // newer intent over whatever this pass derives from the batch's staged
+            // inputs, and is not superseded by it.
+             else if (u && !l && e.o.Lt !== clock) GlobalQueue.Oe(e, E);
+        } else if (u) {
+            // Unchanged value (equals the override) recomputed while the override
+            // is active: _value may still be stale, so hold the authoritative value
+            // for commit on its own transition's schedule — invisibly (A17/A18).
+            if (e.Pe === NOT_PENDING) queuePendingNode(e);
+            e.Pe = E;
+            if (c) e.de = true;
+ // see the held branch above (#2990)
+            // A confirmation after a supersession restores the override as the
+            // graph's value and notifies; a plain confirmation wakes only an
+            // authoritative-view reader (until()'s predicate, refresh()'s waiter)
+            // that observed this node past its override — "authoritative arrival
+            // equal to the override" is exactly the acknowledgment it waits for;
+            // A17 silence holds for every ordinary subscriber. Both live in the
+            // engine's supersedeOverride.
+                        GlobalQueue.Oe(e, E);
+        } else if (e.At != I) {
+            for (let t = e.u; t !== null; t = t.se) {
+                insertIntoHeapHeight(t.le, queueFor(t.le));
+            }
+        }
+        // Silent recovery: errored → unchanged value fires no notification, but
+        // dependents still holding the propagated error consumed their dirty flag
+        // in an errored run and may sit on stale commits (#2949). Changed-value
+        // recoveries ride insertSubs above; a comparator throw re-errored the node
+        // (el._x?._error re-set), so this only runs on a genuinely clean recovery.
+                if (!f && !e.o?._) {
+            if (s !== undefined) settleErroredDependents(e, s);
+            // Self-registration (this node's own superseded flight) is the #3181
+            // sweep's business below — retiring it here too would walk twice.
+                        if (a) for (const t of a) if (t !== e) settlePendingSource(e, t);
+        }
+        // #3181: a synchronous settle supersedes the old landing callback, so
+        // recompute owns its pending-source sweep. An uninitialized node without
+        // a replacement source still has no truth to reveal and must stay parked.
+                if (r && !(e.S & (STATUS_PENDING | STATUS_UNINITIALIZED))) settlePendingSource(e);
+    }
+    // Attribution hook: fired before the lane restore so `currentOptimisticLane`
+    // still reflects THIS run's posture. The facts distinguish an overlay
+    // recompute (optimistic lane, transition replay, transition-held commit)
+    // from a plain committed one — the engine must not blame overlay runs as
+    // waste or double-count them against plain aggregates.
+        if (attrHooks !== null) attrHooks.recomputeEnd(e, t, i, l || currentOptimisticLane !== null, activeTransition !== null || e.Ee !== null, e.Pe !== NOT_PENDING);
+    currentOptimisticLane = d;
+    const C = e.Pe !== NOT_PENDING || e.o !== null && (e.o.Rt !== null || e.o.Ct !== null) || (e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    // Override-covered holds (hasOverride) always queue: their commit belongs
+    // to their own transition's schedule (A18 re-rule) and is unobservable
+    // under the override (A17). Revert no longer commits anything, so an
+    // unqueued covered hold would leak (INV-7) once the revert clears
+    // _transition.
+        C && (!t || e.S & STATUS_PENDING) && (!e.Ee || u) && queuePendingNode(e);
+    e.Ee && n && activeTransition !== e.Ee && runInTransition(e.Ee, () => recompute(e));
+    // Missed-wake reschedule (see the finally above): values this pass read
+    // before the nested commit are stale, so run again now that the heap will
+    // accept the node. Equality gates stop same-value landings from cascading,
+    // and a re-run only latches again if another nested commit changes a dep
+    // beneath it — convergent unless deps genuinely keep changing.
+        if (N) {
+        enqueueSub(e);
+        schedule();
+    }
+}
+
+function updateIfNecessary(e) {
+    // Never re-enter a node that is currently computing: its dep bookkeeping
+    // (_depsTail/_depGen) is live, and a nested recompute would corrupt it.
+    // A mid-pass mark stays latched for recompute's own tail to reschedule
+    // (#3037); readers meanwhile serve the values the pass has so far.
+    // Never recompute a DISPOSED node either: recompute rewrites _flags and
+    // would resurrect it (#2983) — readers serve its last value.
+    if (e.it & (REACTIVE_RECOMPUTING_DEPS | REACTIVE_DISPOSED)) return;
+    if (e.it & REACTIVE_CHECK) {
+        for (let t = e.te; t; t = t.ne) {
+            const n = t.oe;
+            const i = n.re || n;
+            if (i.ot) {
+                updateIfNecessary(i);
+            }
+            if (e.it & REACTIVE_DIRTY) {
+                break;
+            }
+        }
+    }
+    if (e.it & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.o?._ && e.ae < clock && !e.o?.Se) {
+        recompute(e);
+    }
+    e.it = e.it & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
+}
+
+function computed(e, t) {
+    const n = t?.transparent ?? false;
+    // `in` (not `!== undefined`): an explicit `loadingValue: undefined` on a
+    // `T | undefined` node is a real commit #0. The typeof guard tolerates
+    // non-object option values that older call shapes force through `as any`.
+        const i = t !== null && typeof t === "object" && "loadingValue" in t;
+    // Two literals, one per tier, selected at build time (the observe flag is
+    // a literal after replacement; the untaken branch is dead code). The observe
+    // literal is the prod literal plus its `_name` slot — a slot in the
+    // boilerplate, because a post-construction `self._name = …` forces a
+    // hidden-class transition and an out-of-object property store on EVERY node
+    // (measured: the whole of the observe tier's creation overhead). Keep the
+    // two in sync — the dist artifact test pins observe's key set to prod's
+    // plus `_name`.
+        const l = {
+        id: inheritId(t, n, context),
+        T: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.V ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Ue: t?.equals ?? isEqual,
+        he: null,
+        C: context?.C ?? globalQueue,
+        ft: context?.ft ?? defaultContext,
+        Gt: 0,
+        ot: e,
+        ge: i ? t.loadingValue : undefined,
+        At: 0,
+        yt: undefined,
+        Qt: null,
+        te: null,
+        Dt: null,
+        Pt: 0,
+        u: null,
+        Wt: null,
+        Nt: context,
+        dt: null,
+        wt: null,
+        Tt: null,
+        it: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+        S: i ? 0 : STATUS_UNINITIALIZED,
+        ae: clock,
+        Pe: NOT_PENDING,
+        Ee: null,
+        Mt: -1,
+        de: i,
+        o: null,
+        _name: t?.name ?? "computed"
+    };
+    if (t?.unobserved) ext(l).qt = t.unobserved;
+    setupComputedNode(l, t);
+    return l;
+}
+
+/** Lazily allocate a node's cold extension (ONE shape for signals and
+ * computeds — `_x` access stays monomorphic). Installers write through
+ * this; hot paths read `el._x?._field` gated by the _config presence bits.
+ * Never call ext() just to store a field's default. */ function ext(e) {
+    return e.o ??= {
+        De: undefined,
+        Yt: undefined,
+        Lt: 0,
+        Zt: 0,
+        Te: undefined,
+        be: undefined,
+        pe: undefined,
+        Qe: undefined,
+        t: 0,
+        Se: null,
+        ce: null,
+        _: undefined,
+        ie: undefined,
+        ee: undefined,
+        h: undefined,
+        Ne: false,
+        i: null,
+        qt: undefined,
+        Ot: undefined,
+        Ct: null,
+        Rt: null,
+        jt: undefined
+    };
+}
+
+/**
+ * Build an Effect node with all effect-specific fields baked into a single object literal,
+ * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
+ * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
+ * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
+ */ function createEffectNode(e, t, n, i, l) {
+    const u = l?.transparent ?? false;
+    // Prod and observe boilerplates — see computed() for why the observe tier
+    // gets its `_name` as a literal slot rather than a write after the fact.
+    // The default label is the node kind (tracked effects relabel their computed
+    // in trackedEffect); the wrappers in signals.ts no longer spread a name into
+    // the options to get it.
+        const o = {
+        id: inheritId(l, u, context),
+        T: (u ? CONFIG_TRANSPARENT : 0) | (l?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (l?.sync ? CONFIG_SYNC : 0) | (l?.Kt ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Ue: false,
+        he: null,
+        C: context?.C ?? globalQueue,
+        ft: context?.ft ?? defaultContext,
+        Gt: 0,
+        ot: e,
+        ge: undefined,
+        At: 0,
+        yt: undefined,
+        Qt: null,
+        te: null,
+        Dt: null,
+        Pt: 0,
+        u: null,
+        Wt: null,
+        Nt: context,
+        dt: null,
+        wt: null,
+        Tt: null,
+        it: REACTIVE_LAZY,
+        S: STATUS_UNINITIALIZED,
+        ae: clock,
+        Pe: NOT_PENDING,
+        Ee: null,
+        Mt: -1,
+        de: false,
+        _t: false,
+        Bt: undefined,
+        zt: t,
+        Jt: n,
+        Xt: undefined,
+        Re: i,
+        Vt: null,
+        o: null,
+        _name: l?.name ?? "effect"
+    };
+    // Effects dispatch status through the SHARED notifier (statusNotifierOf,
+    // keyed off _type) — storing it per node forced a full NodeExtension
+    // allocation on EVERY effect at creation (an alloc + 19 field stores,
+    // +23% effect creation, caught by the creation benches). Only genuinely
+    // per-node channels (boundaries) live on _x.
+        if (l?.unobserved) ext(o).qt = l.unobserved;
+    setupComputedNode(o, lazyOptions);
+    return o;
+}
+
+/**
+ * The shared status notifier for effect nodes, installed once by effect.ts
+ * at module evaluation (`this`-dispatched — one function serves every
+ * effect, so nodes never store it). Boundary computeds keep their own
+ * per-node channel on `_x._notifyStatus`, which takes precedence.
+ */ let effectStatusNotify = null;
+
+function setEffectStatusNotify(e) {
+    effectStatusNotify = e;
+}
+
+/** Resolve a node's status notifier: an own `_x` channel (boundaries) wins;
+ * effect nodes (`_type` — EFFECT_PURE is 0, and only effect literals carry
+ * the field) fall back to the shared notifier. Presence doubles as the
+ * "display consumer" membership test in the status walks, exactly as the
+ * per-node field did when every effect carried one. */ function statusNotifierOf(e) {
+    const t = e.o?.h;
+    if (t !== undefined) return t;
+    return e.Re ? effectStatusNotify ?? undefined : undefined;
+}
+
+const lazyOptions = {
+    lazy: true
+};
+
+function setupComputedNode(e, t) {
+    e.Qt = e;
+    const n = context?.$t ? context.ln : context;
+    if (context) {
+        const t = context.Tt;
+        if (t === null) {
+            context.Tt = e;
+        } else {
+            e.dt = t;
+            t.wt = e;
+            context.Tt = e;
+        }
+    }
+    if (n) e.At = n.At + 1;
+    if (GlobalQueue.un !== null) GlobalQueue.un(e);
+    !t?.lazy && recompute(e, true);
+    if (snapshotCaptureActive && !t?.lazy) {
+        if (!(e.S & STATUS_PENDING) && !(e.T & CONFIG_NO_SNAPSHOT)) {
+            ext(e).Ot = e.ge === undefined ? NO_SNAPSHOT : e.ge;
+            e.T |= CONFIG_HAS_SNAPSHOT;
+            snapshotSources.add(e);
+        }
+    }
+}
+
+function signal(e, t, n = null) {
+    // Prod and observe boilerplates — see computed(). The observe literal adds
+    // `_name` and `_owner` (the creating owner, stamped by registerGraph for
+    // createSignal nodes so ownerPath can locate signal subjects; null here,
+    // and staying null on internal signals — one shape either way).
+    const i = {
+        Ue: t?.equals ?? isEqual,
+        T: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.V ? CONFIG_NO_SNAPSHOT : 0),
+        ge: e,
+        u: null,
+        Wt: null,
+        ae: clock,
+        re: n,
+        ue: n?.o?.i || null,
+        sn: null,
+        Pe: NOT_PENDING,
+        Ee: null,
+        Mt: -1,
+        o: null,
+        _name: t?.name ?? "signal",
+        an: null
+    };
+    if (t?.unobserved) ext(i).qt = t.unobserved;
+    if (n) linkFirewallChild(n, i);
+    if (snapshotCaptureActive && !(i.T & CONFIG_NO_SNAPSHOT) && !((n?.S ?? 0) & STATUS_PENDING)) {
+        ext(i).Ot = e === undefined ? NO_SNAPSHOT : e;
+        i.T |= CONFIG_HAS_SNAPSHOT;
+        snapshotSources.add(i);
+    }
+    return i;
+}
+
+// ---------------------------------------------------------------------------
+// SLOT SIGNALS (store leaves) — the create-floor diet. Store mounts
+// materialize one signal per touched leaf (~13 × rows on dbmon), so per-node
+// allocations are mount bytes: the generic path costs an options object, an
+// equals closure, an unobserved closure, a NodeExtension to hold it, and
+// three post-construction expandos (acc/px/pxv → hidden-class transitions).
+// slotSignal bakes everything into ONE literal: `_host`/`_key` backrefs
+// replace the closures (equals is a method call — `this` is the node; the
+// unobserved sweep dispatches CONFIG_SLOT_NODE to one shared hook), and the
+// store's wrap-cache fields are pre-shaped.
+/** The shared slot-node unobserved handler — a live binding read directly by
+ * the sweep sites (no wrapper frame, no null check: a CONFIG_SLOT_NODE node
+ * existing implies the store module loaded and registered the hook). */ let slotUnobservedHook;
+
+/** Install the shared slot-node unobserved handler (store module, once). */ function setSlotUnobserved(e) {
+    slotUnobservedHook = e;
+}
+
+/** Push a new node onto its firewall's child chain (the literal already
+ * points `_nextChild` at the old head). Doubly linked so a released leaf
+ * unlinks in O(1) — the chain is walked per mark of the projection and
+ * would otherwise grow by one node per leaf ever read (#3351). */ function linkFirewallChild(e, t) {
+    const n = t.ue;
+    if (n !== null) n.sn = t;
+    ext(e).i = t;
+    e.T |= CONFIG_FW_CHILDREN;
+}
+
+/** Release a firewall child the store no longer addresses (unobserved sweep
+ * dropped it from its target's cache): unlink it from the chain so the
+ * projection stops retaining it and its last value. The node keeps its own
+ * `_nextChild` so a walk that is mid-chain on it still terminates. Nodes in
+ * `_companionChildren` stay there — companions are permanent by contract
+ * and snap through that set, not the chain. */ function unlinkFirewallChild(e) {
+    const t = e;
+    const n = t.re;
+    if (!n) return;
+    const i = t.sn;
+    const l = t.ue;
+    if (i !== null) i.ue = l; else if (n.o.i === t) n.o.i = l;
+    if (l !== null) l.sn = i;
+    t.sn = null;
+}
+
+function slotSignal(e, t, n, i, l, u = null) {
+    // Prod and observe boilerplates — see computed(). The store relabels the
+    // observe slot (`store.<key>`) when the attribution engine is installed.
+    const o = {
+        Ue: t,
+        T: CONFIG_OWNED_WRITE | CONFIG_SLOT_NODE,
+        ge: e,
+        u: null,
+        Wt: null,
+        ae: clock,
+        re: u,
+        ue: u?.o?.i || null,
+        sn: null,
+        Pe: NOT_PENDING,
+        Ee: null,
+        Mt: -1,
+        o: null,
+        rn: n,
+        _n: i,
+        acc: l,
+        px: undefined,
+        pxv: undefined,
+        _name: "signal"
+    };
+    if (u) linkFirewallChild(u, o);
+    if (snapshotCaptureActive && !((u?.S ?? 0) & STATUS_PENDING)) {
+        ext(o).Ot = e === undefined ? NO_SNAPSHOT : e;
+        o.T |= CONFIG_HAS_SNAPSHOT;
+        snapshotSources.add(o);
+    }
+    return o;
+}
+
+function optimisticSignal(e, t) {
+    const n = signal(e, t);
+    ext(n).De = NOT_PENDING;
+    n.T |= CONFIG_OPTIMISTIC;
+    return n;
+}
+
+function optimisticComputed(e, t) {
+    const n = computed(e, t);
+    ext(n).De = NOT_PENDING;
+    n.T |= CONFIG_OPTIMISTIC;
+    return n;
+}
+
+function isEqual(e, t) {
+    return e === t;
+}
+
+/**
+ * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
+ * subscribe the current scope. Returns whatever `fn` returns.
+ *
+ * Use `untrack` inside a memo or effect when you need to read a signal once
+ * without making the surrounding computation depend on its future changes.
+ *
+ * Pass a `strictReadLabel` string to enable a dev-mode warning: any reactive
+ * read inside `fn` that isn't inside a nested tracking scope will log a
+ * warning naming the label.
+ *
+ * @example
+ * ```ts
+ * createEffect(
+ *   () => trigger(),                 // tracks `trigger` only
+ *   () => {
+ *     const snapshot = untrack(() => state); // read once, untracked
+ *     log(snapshot);
+ *   }
+ * );
+ * ```
+ */ function untrack(e, t) {
+    if (GlobalQueue.cn === null && !tracking && true) return e();
+    const n = tracking;
+    tracking = false;
+    try {
+        if (GlobalQueue.cn !== null) return GlobalQueue.cn(e);
+        return e();
+    } finally {
+        tracking = n;
+    }
+}
+
+/**
+ * Bring a computed to a readable state: lazy/disposed nodes are (re)computed;
+ * an isPending() probe (`refresh`) additionally pulls the node fully up to
+ * date so its status flags reflect the current graph.
+ */ function prepareComputed(e, t) {
+    if (e.it & REACTIVE_LAZY) {
+        e.it &= ~REACTIVE_LAZY;
+        recompute(e, true);
+    } else if (e.it & REACTIVE_DISPOSED) {
+        // Two disposal lifecycles share the flag (#3024). Observation-lifecycle
+        // nodes (CONFIG_AUTO_DISPOSE) are dormant — torn down by unobserved()
+        // when the last subscriber left — and reads reawaken them; that is the
+        // pay-for-use contract. Owner-lifecycle nodes are dead: recomputing would
+        // re-run user code in a torn-down tree (and discard manual writes on
+        // derived-writable signals), so reads return the last committed value.
+        if (e.T & CONFIG_AUTO_DISPOSE) recompute(e, true);
+    } else if (t) {
+        updateIfNecessary(e);
+    }
+}
+
+/**
+ * Sentinel returned by readNodeFast when the plain-signal fast path does not
+ * apply and the caller must fall back to the full read().
+ */ const READ_SLOW = Symbol("read-slow");
+
+/**
+ * read()'s plain-signal fast path as a standalone entry for hot callers
+ * (store traps). Safe to substitute for read() only because the bail
+ * conditions mirror read()'s prelude and fast-path guard exactly: the
+ * latestRead and pendingCheck windows run side-effectful hooks before the
+ * fast path, `_fn` nodes need prepareComputed, and firewall / override /
+ * snapshot / transition / lane / dev-strictRead state all take the full
+ * resolution. Anything slow returns READ_SLOW; the caller then calls read().
+ */
+/**
+ * Wake only authoritative-view readers (until() predicates) subscribed to `el`.
+ * The A17-silent ack paths — an authoritative arrival equal to the active
+ * override — use this so the predicate re-evaluates without re-firing
+ * ordinary subscribers whose visible (override) value did not change.
+ * Pay-for-use: reached through GlobalQueue._notifyAuthoritativeObservers,
+ * installed at first until() call — apps that never use until() shake it.
+ */ function notifyAuthoritativeObservers(e) {
+    for (let t = e.u; t !== null; t = t.se) {
+        const e = t.le;
+        if (!(e.T & CONFIG_AUTHORITATIVE_READ)) continue;
+        // Missed-wake latch (#3037), same contract as insertSubs: the reader may
+        // itself have pulled this recompute (updateIfNecessary from its own
+        // read), and the heap refuses RECOMPUTING nodes — latch so recompute's
+        // tail reschedules it with the staged value visible.
+                if (e.it & REACTIVE_RECOMPUTING_DEPS && t.fn === e.Pt && t !== e.Dt) e.it |= REACTIVE_MISSED_WAKE;
+        enqueueSub(e);
+    }
+    schedule();
+}
+
+/** Installs the authoritative-reader wakeup hook. Idempotent; called by every
+ * creator of a CONFIG_AUTHORITATIVE_READ computation — until() and refresh() —
+ * before its first read (same late-binding contract as the optimistic engine;
+ * the gating bit is only ever set by such a read, so the `!` call sites are
+ * safe once every setter installs, #3303). */ function installAuthoritativeRead() {
+    if (GlobalQueue.En === null) GlobalQueue.En = notifyAuthoritativeObservers;
+}
+
+/**
+ * Stale-reader term of the value selections below: a render effect reading a
+ * node some OTHER live transaction has staged sees the committed value. The
+ * commit is silent — the staging walk was the notification — so a reader
+ * that linked AFTER that walk (an effect created during the hold, a store
+ * key first read under it) would show the old value past the reveal: record
+ * it for the transaction's commit replay (the `_gatedSubs` contract lanes
+ * already use). An effect the transaction itself computed re-derives at its
+ * commit on its own (parked run, or the contested re-derive, #3322) and is
+ * not recorded — replaying it too would publish the frame twice.
+ */ function heldFromStale(e, t) {
+    const n = e.Ee;
+    if (n === null || n === activeTransition) return false;
+    const i = currentTransition(n);
+    const l = t.Vt;
+    if (l == null || currentTransition(l) !== i) i.ht.add(t);
+    return true;
+}
+
+function readNodeFast(e) {
+    if (latestReadActive || pendingCheckActive || e.ot || e.re || e.o?.De !== undefined || e.o?.Ot !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
+    let t = context;
+    if (t?.$t) t = t.ln;
+    if (t && tracking) link(e, t);
+    // Children-forbidden readers (createTrackedEffect / onSettled callbacks) get
+    // committed visibility: like the effect half of createEffect and event
+    // handlers, effect-phase code never observes its own unsettled write — the
+    // write lands in the same flush's continuation (#3006).
+    // A stale reader (render effect) recomputing with no transaction active is
+    // mainline: a write staged by a live transaction (`_transition` stamped —
+    // ambient staging never is) stays masked until that transaction's reveal,
+    // the same rule the slow path applies (#3322). Without it a zombie
+    // recompute, or a commit-time re-derive of a contested effect, published
+    // another transaction's uncommitted value.
+        return !t || e.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && heldFromStale(e, t) ? e.ge : e.Pe;
+}
+
+function read(e) {
+    // Handle latest() mode: read from _latestValueComputed
+    // Checked before isPending so that isPending(() => latest(x)) checks
+    // the _pendingSignal of _latestValueComputed (async in flight) rather
+    // than the original node (which stays "pending" while held in a transition).
+    if (latestReadActive) return GlobalQueue.In(e);
+    let t = context;
+    if (t?.$t) t = t.ln;
+    const n = e;
+    const i = e.re;
+    const l = i || e;
+    // Handle isPending() mode: collect pending state while preserving normal read semantics.
+    // Probe mode is suspended while preparing the node so nested reads during a
+    // recompute don't collect into the probe.
+        if (pendingCheckActive) {
+        GlobalQueue.Nn(e, t, l, i);
+    } else if (typeof n.ot === "function") {
+        prepareComputed(e, false);
+    }
+    if (!n.ot && l === e && e.o?.De === undefined && e.o?.Ot === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+        if (t && tracking) link(e, t);
+        // Committed visibility for children-forbidden readers and for stale
+        // readers of a foreign transaction's staged write — see readNodeFast.
+                return !t || e.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && heldFromStale(e, t) ? e.ge : e.Pe;
+    }
+    if (t && tracking) {
+        link(e, t, pendingCheckActive);
+        if (l.ot) {
+            const n = queueFor(e);
+            if (l.At >= n.St) {
+                markNode(t);
+                markHeap(n);
+                updateIfNecessary(l);
+            }
+            // Fresh-pull readers (awaitable refresh's waiter) recompute a dirty
+            // source inline even when the height gate defers to the flush: the
+            // waiter must park on the re-ask's window (or serve its sync answer),
+            // never read the PRE-re-ask value as settled. Self-guarded: a clean
+            // node no-ops and updateIfNecessary refuses disposed nodes (#2983) —
+            // a dead target serves its last value, which is already quiescent.
+             else if (t.T & CONFIG_FRESH_READ) updateIfNecessary(l);
+            const i = l.At;
+            // parent check is shallow, might need to be recursive
+                        if (i >= t.At && e.Nt !== t) {
+                t.At = i + 1;
+            }
+        }
+    }
+    if (l.S & STATUS_PENDING) {
+        // A reader landing on a pending node throws — the reveal that discovered
+        // the flight holds on it (A15: observed async settles as one unit) — with
+        // one carve-out: a stale (render) reader of a node pending in some OTHER
+        // transaction keeps showing the node's committed value, no entanglement
+        // (parallel transactions; the reader is recorded for that transaction's
+        // commit replay, `heldFromStale`). The carve-out is sound only while the
+        // committed value is coherent with the visible frame, i.e. while the
+        // flight's inputs are themselves unpublished: the stamp alone does not
+        // say so (it is pending-node bookkeeping), so it is refused when the
+        // inputs are on screen — committed by a batch that left the flight in
+        // the air (CONFIG_INPUTS_PUBLISHED, #3305) or revealed through a lane
+        // (optimistic / latest, #3334) — and the reader holds instead. An
+        // UNINITIALIZED node has no committed value to show and holds too
+        // (firewall-backed store reads always did; plain memos since the #3043
+        // port): falling through served `undefined` as if settled and stranded
+        // the reader outside both transactions, so it never re-ran.
+        if (t && !(stale && !(l.S & STATUS_UNINITIALIZED) && !(l.T & CONFIG_INPUTS_PUBLISHED) && !(l.T & CONFIG_HAS_LANE && GlobalQueue.Tn(l)) && heldFromStale(l, t))) {
+            // Per-lane suspension lives with the engine (a non-null lane implies it
+            // is installed): under a lane, only same-lane pending async without an
+            // active override throws — plus uninitialized sources regardless of
+            // lane (#3276); that check rides laneSuspends so floor bundles don't
+            // pay for it.
+            if (currentOptimisticLane === null || GlobalQueue.dn(l)) {
+                if (!tracking && e !== t) link(e, t);
+                throw l.o?._;
+            }
+        } else if (!t && l.S & STATUS_UNINITIALIZED) {
+            throw l.o?._;
+        }
+    }
+    // `owner` is the computed itself, or the firewall behind a store node —
+    // firewall-backed reads follow the same rules (memo parity, #2897 ruling):
+    // an errored derive throws for every late reader instead of silently
+    // serving node values (the seed, or last-good data after a failed refetch).
+        if (l.ot && l.S & STATUS_ERROR) {
+        // Only a genuine reactive re-read may retry an errored async source:
+        // - tracking: owned/tracked scope only (never events / `untrack` / effect side-effect phase)
+        // - !pendingCheckActive: an `isPending` probe observes the error, never refetches
+        // - owner._time < clock: only on a later cycle than the one the error was found
+        if (tracking && !pendingCheckActive && l.ae < clock) {
+            recompute(l);
+            return read(e);
+        } else throw l.o?._;
+    }
+    if (snapshotCaptureActive && t && t.T & CONFIG_IN_SNAPSHOT_SCOPE) {
+        const n = e.o?.Ot;
+        if (n !== undefined) {
+            const i = n === NO_SNAPSHOT ? undefined : n;
+            const l = e.Pe !== NOT_PENDING ? e.Pe : e.ge;
+            if (l !== i) t.it |= REACTIVE_SNAPSHOT_STALE;
+            return i;
+        }
+    }
+    if (e.o?.De !== undefined && e.o?.De !== NOT_PENDING) {
+        // A17: the override IS the value for every reader — except an authoritative
+        // reader (until()'s predicate carries CONFIG_AUTHORITATIVE_READ): it must
+        // observe independently-arriving truth, and serving it the caller's own
+        // tentative write would trivially satisfy the predicate. The bit is checked
+        // on the reading computation itself, so a shared computed the predicate
+        // pulls recomputes as ITSELF (context = the memo, no bit) under the normal
+        // view. Fall through to normal value selection (staged `_pendingValue` is
+        // authoritative — optimism never lives there); the sticky mark makes the
+        // A17-silent "landing equals override" paths notify this node's subs so
+        // the reader re-runs when truth arrives.
+        if (!(t && t.T & CONFIG_AUTHORITATIVE_READ)) {
+            // A18 supersession (#3331): the node's own source answered with a
+            // DIFFERENT value. The optimism is over for the graph — a tracked
+            // reader sees the staged truth — while the override remains the
+            // DISPLAYED value for untracked reads (and for a stale reader of some
+            // other transaction). The selection lives with the engine.
+            if (t && e.T & CONFIG_OVERRIDE_SUPERSEDED) return GlobalQueue.Sn(e);
+            return unwrapOverride(e.o?.De);
+        }
+        e.T |= CONFIG_AUTHORITATIVE_OBSERVED;
+    }
+    // Entanglement gate: a reader recomputing under an optimistic lane that reads
+    // a pending mid-transition write sees the committed value. Projection-store
+    // manual writes use the firewall's manual-write flag to opt into this path.
+    // Async drivers are not under an optimistic lane and so bypass this, reading
+    // _pendingValue for correct fetching. The sub is recorded for replay at commit
+    // so it re-runs with the new committed view. (Gate details live with the
+    // engine — a non-null lane implies it is installed.)
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.An(e, l, t)) {
+        return e.ge;
+    }
+    // In optimistic lane context, return _value for optimistic/lane-assigned signals
+    // and for regular signals in stale mode (render effects). Non-stale readers (user
+    // effects) see _pendingValue so that latest() and direct reads stay consistent.
+    // (The lane-context clause lives with the engine.) Children-forbidden readers
+    // (createTrackedEffect / onSettled callbacks) get committed visibility — see
+    // readNodeFast (#3006).
+        const u = !t || currentOptimisticLane !== null && GlobalQueue.On(e, l, t) || e.Pe === NOT_PENDING || t.T & CONFIG_CHILDREN_FORBIDDEN || stale && heldFromStale(e, t) || 
+    // A17 for HELD truth (#3164, see CONFIG_HELD_TRUTH): staged confirming
+    // truth — fold-staged onto an armed family, or entangle-stolen by an
+    // awaited until() — is masked from ordinary readers until its
+    // transaction's reveal; the retaining transaction's own speculative
+    // recomputes included (partial override coverage would otherwise
+    // compose override + staged truth into a state no timeline contains).
+    // Authoritative readers (until()'s predicate) and latest() see the
+    // staged truth — the tunnel that keeps the hold deadlock-free.
+    e.T & CONFIG_HELD_TRUTH && !latestReadActive && !(t.T & CONFIG_AUTHORITATIVE_READ) ? e.ge : e.Pe;
+    // Record that this isPending() probe observed the fresh pending value, so
+    // the probe doesn't pair "pending" with the new value (#2831).
+        if (pendingCheckActive) GlobalQueue.Cn(e, u);
+    if (!t && l === e && typeof n.ot === "function" && e.T & CONFIG_AUTO_DISPOSE && !(l.S & STATUS_PENDING) && !e.u) {
+        // Deferred, not inline (#3078): an inline unobserved() here made untracked
+        // reads destructive — dispose on this read, full revival recompute on the
+        // next — so consecutive reads could answer differently with no write in
+        // between (the revival samples the ambient transition/lane context).
+        // The sweep at flush finalization re-validates and reclaims; schedule()
+        // guarantees that flush happens even if nothing else is queued.
+        dormantNodes.add(e);
+        schedule();
+    }
+    return u;
+}
+
+function setSignal(e, t) {
+    if (e.Ee && activeTransition !== e.Ee) globalQueue.initTransition(e.Ee);
+    // The optimistic write path lives with the engine: only optimisticSignal /
+    // optimisticComputed callers and optimistic store nodes carry an
+    // _overrideValue slot (flagged by CONFIG_OPTIMISTIC — a masked read of the
+    // always-present config instead of a missing-property probe), and every
+    // module that installs one installs the engine first.
+        if (e.T & CONFIG_OPTIMISTIC) {
+        if (!projectionWriteActive) return GlobalQueue.pn(e, t);
+        // An authoritative store landing on an override-covered node: the store
+        // twin of asyncWrite's override branch, decided by the engine (#3331).
+                const n = e.o?.De;
+        if (n !== undefined && n !== NOT_PENDING) return GlobalQueue.Rn(e, t);
+    }
+    const n = e.Pe === NOT_PENDING ? e.ge : e.Pe;
+    if (typeof t === "function") t = t(n);
+    // Uninitialized check first: the first commit has no previous value, so the
+    // user comparator must not run against `undefined` (matches recompute).
+        const i = !!(e.S & STATUS_UNINITIALIZED) || !e.Ue || !e.Ue(n, t);
+    if (!i) return t;
+    // Attribution hook: this committed write is where a re-run chain begins.
+        if (attrHooks !== null) attrHooks.write(e, n, t);
+    const l = e.Pe !== NOT_PENDING;
+    if (!l) queuePendingNode(e);
+    e.Pe = t;
+    // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
+    // neither companion present the call is a guaranteed no-op (companions are
+    // only ever created, never removed, and creating one installs the hook and
+    // sets CONFIG_HAS_COMPANIONS — one masked read replaces two optional-field
+    // probes on every write).
+        e.T & CONFIG_HAS_COMPANIONS && GlobalQueue.Ae !== null && GlobalQueue.Ae(e, t);
+    // _time is a computed-only slot (§12e): writing it on a signal would fork
+    // the lean shape. Every read site is computed-typed.
+        if (e.ot !== undefined) e.ae = clock;
+    // Staged-rewrite fast path (§12d): a re-write to a node whose subscribers
+    // were already walked — and where nothing has recomputed or linked since
+    // (epoch) — re-stages the value and stops. The walk is idempotent (subs
+    // marked, heap entries flag-guarded, effects queued once); lane and reask
+    // contexts change what a walk MEANS, so they always walk.
+        if (l && e.Mt === notifyEpoch && currentOptimisticLane === null && !reaskArmed) return t;
+    insertSubs(e);
+    schedule();
+    return t;
+}
+
+/**
+ * Suppresses automatic recomputation of `el` until the scheduler drains. Used
+ * when a manual write should win over dependency changes queued in the same
+ * tick. The MANUAL_WRITE flag is cleared by the pending-node drain; projection
+ * computeds don't commit values, but they still need the same end-of-tick
+ * cleanup point.
+ */ function suppressComputedRecompute(e) {
+    deleteFromHeap(e, queueFor(e));
+    if (!(e.it & REACTIVE_MANUAL_WRITE) && e.Pe === NOT_PENDING) {
+        queuePendingNode(e);
+        schedule();
+    }
+    e.it = e.it & -4 | REACTIVE_MANUAL_WRITE;
+    e.Gn = clock;
+}
+
+/**
+ * User-facing setter for the memo form of `createSignal(fn)`. Behaves like
+ * `setSignal`, but also cancels any pending recompute of the memo so the
+ * manual value wins over a value that would otherwise be produced by an
+ * upstream change in the same tick.
+ */ function setMemo(e, t) {
+    const n = setSignal(e, t);
+    suppressComputedRecompute(e);
+    return n;
+}
+
+/**
+ * Executes `fn` with the given `owner` set as the current owner. Any reactive
+ * primitives (`createSignal`, `createMemo`, `createEffect`, `onCleanup`,
+ * `cleanup`, etc.) created inside `fn` are attached to that owner, so they
+ * are disposed when the owner is disposed.
+ *
+ * The classic pattern: capture the current owner with `getOwner()` inside a
+ * component, then re-enter it from a callback (event handler, async resolve,
+ * setTimeout) so disposables created in the callback get cleaned up with the
+ * component.
+ *
+ * @example
+ * ```ts
+ * function delayed<T>(ms: number, fn: () => T) {
+ *   const owner = getOwner();
+ *   setTimeout(() => runWithOwner(owner, fn), ms);
+ * }
+ * ```
+ */ function runWithOwner(e, t) {
+    const n = context;
+    const i = tracking;
+    context = e;
+    tracking = false;
+    try {
+        return t();
+    } finally {
+        context = n;
+        tracking = i;
+    }
+}
+
+function staleValues(e, t = true) {
+    const n = stale;
+    stale = t;
+    try {
+        return e();
+    } finally {
+        stale = n;
+    }
+}
+
+/**
+ * Core marking half of `refresh()` (the public wrapper lives in signals.ts —
+ * it validates the target, marks through here, then builds the quiescence
+ * promise on the resolve()/until() effect machinery). Flags the node's next
+ * recompute as a quiet re-ask and schedules it; no-ops for non-derived or
+ * disposed targets and for same-tick manual writes.
+ */ function markRefresh(e) {
+    if (typeof e.ot === "function" && !(e.it & REACTIVE_DISPOSED)) {
+        if (e.it & REACTIVE_MANUAL_WRITE) {
+            // A manual write in the CURRENT tick wins over the refresh (#2692).
+            // A mask stamped in an earlier tick only survives because a
+            // transaction (action) is holding the pending drain open; there the
+            // refresh is a later, explicit re-ask and lifts the mask — otherwise
+            // any setStore early in an action silently swallows every refresh()
+            // for the rest of the transaction (#3026).
+            if (e.Gn === clock) return;
+            e.it &= ~REACTIVE_MANUAL_WRITE;
+            // The lift falls through to the re-ask classification below. The held
+            // write's value change already rides the transaction; the refetch it
+            // asks for is the same question with unchanged inputs. Skipping the
+            // mark here classified that refetch as a NEW question, which pends
+            // every leaf (3.1) — an action doing setStore + yield + refresh(store)
+            // lit up every sibling row, and affects() could not narrow it (a mark
+            // only turns pending on). Same-question motion stays silent (3.4);
+            // the written slot and any declared mark carry the pending instead.
+                }
+        // A refresh with no value-change dirt already queued is a re-ask of the
+        // same question: mark it so the recompute classifies any resulting
+        // pending window as quiet (not pending). If the node is already dirty
+        // from a real input change, the question changed — don't mark.
+        // REACTIVE_IN_HEAP counts as dirt: insertSubs schedules subscribers by
+        // heap insertion alone (no DIRTY/CHECK flag), so a same-batch value
+        // change followed by refresh() must not be laundered into a quiet re-ask.
+                if (!(e.it & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+            e.it |= REACTIVE_REASK;
+            armReaskClear();
+        }
+        e.it = e.it & ~REACTIVE_CHECK | REACTIVE_DIRTY;
+        // A refresh() self-invalidation is a root cause too — the target's next
+        // run has no changed dep to point at, so it points here instead.
+                if (attrHooks !== null) attrHooks.refreshed(e);
+        insertIntoHeap(e, queueFor(e));
+        schedule();
+    }
+}
+
+export { READ_SLOW, clearSnapshots, computed, context, createEffectNode, currentOptimisticLane, effectStatusNotify, ext, installAuthoritativeRead, isEqual, latestReadActive, markRefresh, markSnapshotScope, notifyAuthoritativeObservers, optimisticComputed, optimisticSignal, pendingCheckActive, prepareComputed, read, readNodeFast, recompute, releaseSnapshotScope, runWithOwner, setContextInternal, setEffectStatusNotify, setLatestReadActive, setMemo, setPendingCheckActive, setSignal, setSlotUnobserved, setSnapshotCapture, signal, slotSignal, slotUnobservedHook, snapshotCaptureActive, snapshotSources, stale, staleValues, statusNotifierOf, suppressComputedRecompute, tracking, unlinkFirewallChild, untrack };