@solidjs/signals 2.0.0-rc.7 → 2.0.0-rc.9

package/dist/observe/core/external.js

@@ -0,0 +1,98 @@
+import { signal, setSignal, read } from "./core.js";
+
+import { cleanup } from "./owner.js";
+
+import { GlobalQueue } from "./scheduler.js";
+
+let externalSourceConfig = null;
+
+/**
+ * Registers a factory that bridges external reactive systems (e.g. MobX, Vue refs)
+ * into Solid's tracking graph. Every computation will be wrapped so that the
+ * external library can track its own dependencies alongside Solid's.
+ *
+ * Multiple calls pipe together: each new factory wraps the previous one.
+ *
+ * @param config.factory receives `(fn, trigger)` — wrap fn execution in external tracking,
+ *   call trigger when external deps change. Return `{ track, dispose }`.
+ * @param config.untrack optional wrapper for `untrack` — disables external tracking too.
+ *
+ * @example
+ * ```ts
+ * // Bridge an external "subscribe / notify" library into Solid's graph.
+ * // `factory` wraps every Solid compute so the external library can attach
+ * // its own dependency tracker; `trigger` re-runs the compute on external
+ * // change. `untrack` mirrors Solid's `untrack()` into the external library
+ * // so that reads inside `untrack(...)` don't get tracked twice.
+ * enableExternalSource({
+ *   factory: (compute, trigger) => {
+ *     const sub = externalLib.subscribe(trigger);
+ *     return {
+ *       track: prev => externalLib.run(() => compute(prev)),
+ *       dispose: () => sub.unsubscribe()
+ *     };
+ *   },
+ *   untrack: fn => externalLib.untracked(fn)
+ * });
+ * ```
+ */
+// Wires a freshly created computed through the active external-source bridge.
+// Lives here (installed on GlobalQueue while a config is active) rather than
+// inline in core: esbuild cannot literal-track the mutable config binding the
+// way rollup does, so an inline `if (externalSourceConfig)` block ships in
+// every bundle even though only enableExternalSource() can make it reachable.
+function wireExternalSource(e) {
+    const n = signal(undefined, {
+        equals: false,
+        ownedWrite: true
+    });
+    const r = externalSourceConfig.factory(e.ht, () => {
+        setSignal(n, undefined);
+    });
+    cleanup(() => r.dispose());
+    e.ht = e => {
+        read(n);
+        return r.track(e);
+    };
+}
+
+function externalUntrack(e) {
+    return externalSourceConfig.untrack(e);
+}
+
+// The hooks mirror the config's liveness exactly (installed on enable,
+// removed on reset) so core's null checks stay equivalent to the old
+// `externalSourceConfig` truthiness checks.
+function syncExternalHooks() {
+    GlobalQueue._n = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.In = externalSourceConfig ? externalUntrack : null;
+}
+
+function enableExternalSource(e) {
+    const {factory: n, untrack: r = e => e()} = e;
+    if (externalSourceConfig) {
+        const {factory: e, untrack: o} = externalSourceConfig;
+        externalSourceConfig = {
+            factory: (r, o) => {
+                const t = e(r, o);
+                const a = n(e => t.track(e), o);
+                return {
+                    track: e => a.track(e),
+                    dispose() {
+                        a.dispose();
+                        t.dispose();
+                    }
+                };
+            },
+            untrack: e => o(() => r(e))
+        };
+    } else {
+        externalSourceConfig = {
+            factory: n,
+            untrack: r
+        };
+    }
+    syncExternalHooks();
+}
+
+export { enableExternalSource, externalSourceConfig };

package/dist/observe/core/graph.js

@@ -0,0 +1,155 @@
+import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
+
+import { slotUnobservedHook } from "./core.js";
+
+import { deleteFromHeap, queueFor } from "./heap.js";
+
+import { disposeChildren } from "./owner.js";
+
+import { bumpNotifyEpoch } from "./scheduler.js";
+
+// https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
+function unlinkSubs(e) {
+    const n = e.re;
+    const l = e.te;
+    const o = e.ie;
+    const s = e.bn;
+    if (o !== null) o.bn = s; else n.qt = s;
+    if (s !== null) s.ie = o; else {
+        n.u = o;
+        if (o === null) {
+            // Slot nodes (store leaves) dispatch to the ONE shared hook — no
+            // per-node unobserved closure, no NodeExtension to hold it.
+            if (n.C & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.o?.Kt?.();
+            // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
+            // A pending node is exempt: its in-flight async work (or the
+            // transition holding it) is an observer — tearing down would orphan
+            // the work and re-execute it on the next read. The settle path runs
+            // this same last-one-out check when that observer releases (the
+            // untracked-read dormancy sweep guards on pending identically).
+                        const e = n;
+            e.ht && e.C & CONFIG_AUTO_DISPOSE && !(e.ft & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+        }
+    }
+    return l;
+}
+
+function trimStaleDeps(e) {
+    const n = e.Fe;
+    let l = n !== null ? n.te : e.ee;
+    if (l !== null) {
+        do {
+            l = unlinkSubs(l);
+        } while (l !== null);
+        if (n !== null) n.te = null; else e.ee = null;
+    }
+}
+
+// Shared by unobserved() and the disposeChildren child loop. The truthy guard
+// (not `!== null`) matters: plain Owners in a child chain have no _deps field,
+// and skipping early also avoids adding one (hidden-class churn) via the
+// null-out below.
+function clearDeps(e) {
+    let n = e.ee;
+    if (!n) return;
+    do {
+        n = unlinkSubs(n);
+    } while (n !== null);
+    e.ee = null;
+    e.Fe = null;
+}
+
+function unobserved(e) {
+    deleteFromHeap(e, queueFor(e));
+    clearDeps(e);
+    disposeChildren(e, true);
+}
+
+/**
+ * Deferred dormancy for never-observed auto-dispose computeds (#3078).
+ *
+ * An untracked top-level read of a subscriber-less observation-lifecycle memo
+ * used to call unobserved() inline at the end of read(). That kept the leak
+ * closed (the compute links the memo into its deps' sub lists — without a
+ * teardown point a never-observed memo is retained by its sources forever;
+ * upstream alien-signals has exactly this retention), but it made reads
+ * destructive: each read disposed the node, the next read revived it with a
+ * full recompute in whatever ambient transition/lane context happened to be
+ * current, so consecutive reads could return different answers with no write
+ * in between.
+ *
+ * Instead, reads queue the node here and the scheduler sweeps at the top of
+ * the next flush (before runHeap, so a same-tick dirtying is reclaimed
+ * instead of recomputed). Reads become idempotent within a tick (the node
+ * stays alive and serves its cache, uniform with observed memos) while
+ * reclamation still happens within one microtask — the enqueue site arms
+ * schedule(), so a flush is guaranteed even when no other work is queued.
+ */ const dormantNodes = new Set;
+
+function sweepDormant() {
+    if (dormantNodes.size === 0) return;
+    for (const e of dormantNodes) {
+        // Re-validate at sweep time: the node may have gained a subscriber (its
+        // lifecycle is the unlinkSubs cascade now), gone pending (in-flight async
+        // is an observer; the settle path re-runs last-one-out), lost its
+        // AUTO_DISPOSE bit (owner teardown strips it, #3024), or already been
+        // torn down.
+        if (!e.u && e.C & CONFIG_AUTO_DISPOSE && !(e.S & STATUS_PENDING) && !(e.ft & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+            unobserved(e);
+        }
+    }
+    dormantNodes.clear();
+}
+
+// https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
+function link(e, n, l = false) {
+    // Repeat touches within one pass AND-combine `_pendingObserver`: a probe
+    // read (`isPending(() => x())`) beside a value read of the same dep must
+    // not relabel the value dependency as probe-only — the value read is what
+    // real-error propagation and affects() coverage key off, regardless of
+    // read order within the computation.
+    const o = n.Fe;
+    if (o !== null && o.re === e) {
+        o.Ce &&= l;
+        return;
+    }
+    let s = null;
+    const t = n.ft & REACTIVE_RECOMPUTING_DEPS;
+    if (t) {
+        s = o !== null ? o.te : n.ee;
+        if (s !== null && s.re === e) {
+            s.pe = n.ye;
+            n.Fe = s;
+            // First touch of this pass: the previous pass's label is stale.
+                        s.Ce = l;
+            return;
+        }
+    }
+    // A link stamped with the current pass generation was created or reused
+    // in-order during this recompute, i.e. it already sits in the validated
+    // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
+    // (the old alien-signals `isValidLink` walk, O(n²) when a computation
+    // re-reads earlier deps non-consecutively, e.g. store leaf reads).
+        const r = e.qt;
+    if (r !== null && r.se === n && (!t || r.pe === n.ye)) {
+        // Gen-matched during a recompute = repeat touch this pass (AND); outside
+        // a recompute there is no pass boundary, so the latest read labels it.
+        if (t) r.Ce &&= l; else r.Ce = l;
+        return;
+    }
+    const u = n.Fe = e.qt = {
+        re: e,
+        se: n,
+        te: s,
+        bn: r,
+        ie: null,
+        pe: n.ye,
+        Ce: l
+    };
+    if (o !== null) o.te = u; else n.ee = u;
+    if (r !== null) r.ie = u; else e.u = u;
+    // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
+        bumpNotifyEpoch();
+}
+
+export { clearDeps, dormantNodes, link, sweepDormant, trimStaleDeps, unlinkSubs, unobserved };

package/dist/observe/core/heap.js

@@ -0,0 +1,147 @@
+import "./core.js";
+
+import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_ZOMBIE, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_CHECK, REACTIVE_DIRTY, CONFIG_FW_CHILDREN } from "./constants.js";
+
+import { zombieQueue, dirtyQueue } from "./scheduler.js";
+
+/** The queue a node belongs to, picked from its own zombie flag. */ function queueFor(e) {
+    return e.ft & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+}
+
+/**
+ * Schedule one subscriber to re-run on the next flush: inserted into its own
+ * (zombie-flag-routed) heap with the `_min` cursor pulled down. Tracked
+ * effects ride the heap too — the heap visit is their (empty) compute phase,
+ * which hands the callback to the user queue once the pass has committed
+ * (see GlobalQueue._update, #3291).
+ */ function enqueueSub(e) {
+    const E = queueFor(e);
+    if (E.Ct > e.Rt) E.Ct = e.Rt;
+    insertIntoHeap(e, E);
+}
+
+function actualInsertIntoHeap(e, E) {
+    const t = (e._parent?.cn ? e._parent.fn?.Rt : e._parent?.Rt) ?? -1;
+    if (t >= e.Rt) e.Rt = t + 1;
+    const n = e.Rt;
+    const I = E.eE[n];
+    if (I === undefined) E.eE[n] = e; else {
+        const E = I.Mt;
+        E.Wt = e;
+        e.Mt = E;
+        I.Mt = e;
+    }
+    if (n > E.EE) E.EE = n;
+}
+
+function insertIntoHeap(e, E) {
+    let t = e.ft;
+    // RECOMPUTING refusals are not always losses: a genuinely missed wake (a
+    // write to a link this pass already validated) is latched link-side in
+    // insertSubs as REACTIVE_MISSED_WAKE for recompute's tail (#3037).
+        if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
+    if (t & REACTIVE_CHECK) {
+        e.ft = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+    } else {
+        e.ft = t | REACTIVE_IN_HEAP;
+        // An unmarked node entering an already-marked heap is marked on the
+        // spot, keeping the markHeap memo valid. `_marked` is only reset by
+        // runHeap, so a write between two mid-tick pulls (read-time markHeap +
+        // updateIfNecessary) would otherwise leave this node unmarked and every
+        // downstream pull stale until the next flush (#2922: the second
+        // `latest()` returned the first write's value). Invalidating the memo
+        // instead re-walked the WHOLE heap on the next pull — with N effects
+        // parked in the heap for a synchronous mount (each row writing a ref
+        // signal its effect subscribes to), mounting N rows was O(N²) (#3350).
+        // markNode's own guard skips an already-DIRTY node.
+                if (E.tE) markNode(e);
+    }
+    if (!(t & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, E);
+}
+
+function insertIntoHeapHeight(e, E) {
+    let t = e.ft;
+    if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
+    e.ft = t | REACTIVE_IN_HEAP_HEIGHT;
+    actualInsertIntoHeap(e, E);
+}
+
+function deleteFromHeap(e, E) {
+    const t = e.ft;
+    if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
+    e.ft = t & -25;
+    const n = e.Rt;
+    if (e.Mt === e) E.eE[n] = undefined; else {
+        const t = e.Wt;
+        const I = E.eE[n];
+        const o = t ?? I;
+        if (e === I) E.eE[n] = t; else e.Mt.Wt = t;
+        o.Mt = e.Mt;
+    }
+    e.Mt = e;
+    e.Wt = undefined;
+}
+
+function markHeap(e) {
+    if (e.tE) return;
+    e.tE = true;
+    for (let E = 0; E <= e.EE; E++) {
+        for (let t = e.eE[E]; t !== undefined; t = t.Wt) {
+            if (t.ft & REACTIVE_IN_HEAP) markNode(t);
+        }
+    }
+}
+
+function markNode(e, E = REACTIVE_DIRTY) {
+    const t = e.ft;
+    if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
+    e.ft = t & -4 | E;
+    for (let E = e.u; E !== null; E = E.ie) {
+        markNode(E.se, REACTIVE_CHECK);
+    }
+    // Firewall children (projection machinery only): gate the cold-extension
+    // deref on the config bit — markNode runs per sub edge per write, and an
+    // unconditional _x chase here taxed every propagation (diamond -22%).
+        if (e.C & CONFIG_FW_CHILDREN) {
+        for (let E = e.o.i; E !== null; E = E.ue) {
+            for (let e = E.u; e !== null; e = e.ie) {
+                markNode(e.se, REACTIVE_CHECK);
+            }
+        }
+    }
+}
+
+function runHeap(e, E) {
+    e.tE = false;
+    for (e.Ct = 0; e.Ct <= e.EE; e.Ct++) {
+        let t = e.eE[e.Ct];
+        while (t !== undefined) {
+            if (t.ft & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
+            t = e.eE[e.Ct];
+        }
+    }
+    e.EE = 0;
+}
+
+function adjustHeight(e, E) {
+    deleteFromHeap(e, E);
+    let t = e.Rt;
+    for (let E = e.ee; E; E = E.te) {
+        const e = E.re;
+        const n = e.ne || e;
+        if (n.ht && n.Rt >= t) t = n.Rt + 1;
+    }
+    if (e.Rt !== t) {
+        e.Rt = t;
+        for (let E = e.u; E !== null; E = E.ie) {
+            // Route each subscriber by its own zombie flag, mirroring the
+            // post-recompute height-adjust path. Inserting into the running `heap`
+            // unconditionally can park a zombie in `dirtyQueue` (or a live node in
+            // `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap`
+            // relies on — the same corruption class as #2759.
+            insertIntoHeapHeight(E.se, queueFor(E.se));
+        }
+    }
+}
+
+export { deleteFromHeap, enqueueSub, insertIntoHeap, insertIntoHeapHeight, markHeap, markNode, queueFor, runHeap };

package/dist/observe/core/invariants.js

@@ -0,0 +1,45 @@
+import "./core.js";
+
+import "./dev.js";
+
+/**
+ * INV-2: a node with an *active* override must be registered for reversion in
+ * the queue's or a transition's `_optimisticNodes`. An unregistered active
+ * override would survive transition completion forever. Runs at the end of
+ * every flush (not just quiescence — the invariant holds mid-transition).
+ * (There is no revert-target requirement: authoritative values commit
+ * silently into `_value` under the override mask — A17 — so reverting is
+ * just dropping the override.)
+ */ function devCheckActiveOverrides(e) {
+    return;
+}
+
+/** INV-1: an isPending() probe must never leak past its own call. */ function devCheckFlushStart() {
+    return;
+}
+
+/**
+ * Companion-vs-oracle census (#2838 pre-work). A NON-ASSERTING diff logger:
+ * at the end of every flush it compares each live companion's cached state
+ * against a fresh oracle and logs every distinct divergence fingerprint once
+ * (console, `[census]` prefix). Legit lane-scoped windows will show up too —
+ * the census exists to enumerate the full taxonomy of mid-flight divergence
+ * so the write-driven redesign knows every case it must produce, not to
+ * judge them. Enabled only when the COMPANION_CENSUS env var is set (in
+ * addition to `false`), so normal test runs pay one boolean check.
+ */ typeof globalThis !== "undefined" && !!globalThis.process?.env?.COMPANION_CENSUS;
+
+function devCensusCompanions(e) {
+    return;
+}
+
+/**
+ * Quiescence checks. Run only when the system is fully drained: nothing
+ * scheduled, no active/stashed transitions, no live lanes. At that point no
+ * transition-scoped state may survive, and the lazily-created companions must
+ * agree with a fresh computation of their owner's state.
+ */ function devCheckQuiescent(e) {
+    return;
+}
+
+export { devCensusCompanions, devCheckActiveOverrides, devCheckFlushStart, devCheckQuiescent };

package/dist/observe/core/lanes.js

@@ -0,0 +1,205 @@
+import { CONFIG_DERIVED_OVERRIDE, CONFIG_HAS_LANE, REACTIVE_DISPOSED } from "./constants.js";
+
+import { hasActiveOverride, ext, ownsHold, currentOptimisticLane } from "./core.js";
+
+import { enqueueSub } from "./heap.js";
+
+import { currentTransition, activeTransition, waitingTransition } from "./scheduler.js";
+
+// Map from optimistic signal to its lane (reused for multiple writes to same signal)
+const signalLanes = new WeakMap;
+
+// All active lanes (for cleanup on transition completion)
+const activeLanes = new Set;
+
+/**
+ * Get an existing lane for a signal or create a new one.
+ * Reuses lane for multiple writes to the same signal.
+ */ function getOrCreateLane(n) {
+    let e = signalLanes.get(n);
+    if (e) {
+        return findLane(e);
+    }
+    // Detect parent lane: _parentSource chains from pendingSignal → pendingValueComputed → original.
+    // The child lane should not merge with the parent lane.
+        const i = n.o?.nn;
+    const t = i?.o?.de;
+    const r = t ? findLane(t) : null;
+    e = {
+        Ln: n,
+        Ie: new Set,
+        vn: [ [], [] ],
+        wn: null,
+        Te: activeTransition,
+        Hn: r
+    };
+    signalLanes.set(n, e);
+    activeLanes.add(e);
+    // A companion may have written before the owner's first optimistic write
+    // (affects() as an action's first statement pokes the verdict companion of a
+    // still lane-less node, #2887), leaving its lane parentless. Adopt it now:
+    // parent-child is a property of the nodes, not of write order — otherwise
+    // the owner's write merges the companion's subscribers into this lane and
+    // their effects wait on its async instead of flushing immediately.
+        adoptCompanionLane(n.o?.he, e);
+    adoptCompanionLane(n.o?.Ge, e);
+    return e;
+}
+
+function adoptCompanionLane(n, e) {
+    if (!n) return;
+    const i = signalLanes.get(n);
+    if (!i) return;
+    const t = findLane(i);
+    // Only the companion's own unmerged root is safely re-parentable: a root
+    // that absorbed other lanes carries work that is not a child of this owner.
+        if (t !== e && t.Ln === n && !t.Hn) t.Hn = e;
+}
+
+/**
+ * Union-find: find the root lane.
+ */ function findLane(n) {
+    while (n.wn) n = n.wn;
+    return n;
+}
+
+/**
+ * Is the lane held? `_pendingAsync` records the async the lane OWNS (derived
+ * under it); a transaction's reporter map records the async a render effect
+ * OBSERVED pending with no boundary taking it (INV-3, the one registration
+ * site). A hold needs both — the same rule the transaction itself uses, so a
+ * memo nobody renders, or one a fallback-showing boundary caught, cannot tear
+ * a frame and holds nothing (#3289). An orphan lane has no observation record
+ * and never holds.
+ *
+ * The observation is looked up per NODE, in whichever live transaction
+ * recorded it — not in this lane's transaction. Lanes merge across
+ * transactions (#2912: ownership never travels through lanes), so after a
+ * merge the root's transaction holds the observations of only one member;
+ * the async the other member's transaction observed must hold the merged
+ * reveal just the same (A15 for lanes, #3335).
+ */ function laneHeld(n) {
+    if (!n.Te) return false;
+    for (const e of n.Ie) if (waitingTransition(e) !== null) return true;
+    return false;
+}
+
+/**
+ * Lanes mirror transitions (#3460): a render effect OFF a HELD lane that reads
+ * a value the lane is revealing — an override, a `latest()` shadow — sees the
+ * committed value, exactly as a stale reader of a held transaction does
+ * (A15 reveal corollary): it publishes now, with the frame that is on screen
+ * (the lane defers its own readers' runs, so the committed value is what is
+ * visible), entangles nothing — a sync write is never held by a lane — and
+ * re-derives at the release. The release re-run rides the lane's own render
+ * queue, which runs when the lane reveals (runLaneEffects) or its transaction
+ * commits (cleanupCompletedLanes). A reader ON the lane computes the lane's
+ * reveal and takes the value as before.
+ *
+ * OFF the lane is provenance, not membership — the transaction mirror
+ * exactly: a stale reader of a transaction is a pass that runs outside it. A
+ * pass under the lane's own transaction is the lane's work — its write (lane
+ * posture), or the landing of its async, which re-enters the transaction
+ * (#3334) and runs a member with no ambient lane. Read as an outsider, that
+ * pass published the committed view and queued a replay that revealed the
+ * override beside its unready derivation at the release (`1:0` for an
+ * optimistic frame that never became ready; #3479 review). Membership is the
+ * wrong test the other way: a member re-run by a sibling's sync write is a
+ * mainline pass and shows the committed view.
+ */ function readsHeldCommitted(n, e) {
+    const i = resolveLane(n);
+    if (!i || !laneHeld(i)) return false;
+    if (ownsLane(i, n)) return false;
+    i.vn[0].push(() => e.ft & REACTIVE_DISPOSED || enqueueSub(e));
+    return true;
+}
+
+/** The ownership relation for a lane hold (core `ownsHold`, §6 ruling 2): the
+ * running pass owns `lane`'s hold if it runs under the transition that owns
+ * the lane (the node's, resolved through override ownership and merges) or
+ * inside the lane itself. */ function ownsLane(n, e) {
+    if (activeTransition !== null) {
+        const n = resolveTransition(e);
+        if (n && ownsHold(n)) return true;
+    }
+    return currentOptimisticLane !== null && findLane(currentOptimisticLane) === n;
+}
+
+/**
+ * Merge two lanes when their dependency graphs overlap.
+ */ function mergeLanes(n, e) {
+    n = findLane(n);
+    e = findLane(e);
+    if (n === e) return n;
+    e.wn = n;
+    // Move (not copy) the merged lane's work: after the merge all routing goes
+    // through findLane() to the root, so anything left behind here is dead —
+    // and anything *added* here later is a routing bug (INV-5).
+        for (const i of e.Ie) n.Ie.add(i);
+    e.Ie.clear();
+    n.vn[0].push(...e.vn[0]);
+    n.vn[1].push(...e.vn[1]);
+    e.vn[0].length = 0;
+    e.vn[1].length = 0;
+    return n;
+}
+
+/**
+ * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
+ */ function resolveLane(n) {
+    const e = n.o?.de;
+    if (!e) return undefined;
+    const i = findLane(e);
+    if (activeLanes.has(i)) return i;
+    if (n.o !== null) n.o.de = undefined;
+    return undefined;
+}
+
+function resolveTransition(n) {
+    // An active override answers with its owner, not its lane: lanes are
+    // scheduling affinity and a shared subscriber merges them across
+    // transactions (#2912) — the merged root's _transition would hand this
+    // node's override to whichever action wrote last through the shared
+    // reader. Chase merge chains; a dead owner settled through another path.
+    if (hasActiveOverride(n) && n.o?.jt) {
+        const e = ext(n).jt = currentTransition(n.o?.jt);
+        if (e.yt !== true) return e;
+        if (n.o !== null) n.o.jt = null;
+    }
+    return resolveLane(n)?.Te ?? n.Te;
+}
+
+/**
+ * Assign or merge a lane onto a node. At convergence points (node already has
+ * a different active lane), merge unless the node has an active override.
+ */ function assignOrMergeLane(n, e) {
+    const i = findLane(e);
+    const t = n.o?.de;
+    if (t) {
+        // A merged lane is followed to its root like any other: the root is where
+        // the subscriber's affinity lives now. Replacing it with the source lane
+        // outright (as this once did) skipped the parent/child check below — an
+        // isPending reader of two async siblings had their two companion lanes
+        // merge, and the next parent-lane notification then moved it onto the
+        // held parent, where its verdict waited on the async it reports (#3409).
+        const r = findLane(t);
+        if (activeLanes.has(r)) {
+            // A WRITTEN override is its own lane's source and merges nothing
+            // through it; a derived one (lanes stage, #3479) is a plain member —
+            // the shared reader that merges two writers' lanes carries one.
+            if (r !== i && (!hasActiveOverride(n) || n.C & CONFIG_DERIVED_OVERRIDE)) {
+                // Parent-child lanes stay independent so isPending resolves without
+                // waiting for the parent's async. The child keeps ownership.
+                if (i.Hn && findLane(i.Hn) === r) {
+                    ext(n).de = e;
+                    n.C |= CONFIG_HAS_LANE;
+                } else if (r.Hn && findLane(r.Hn) === i) ; else mergeLanes(i, r);
+            }
+            return;
+        }
+    }
+    ext(n).de = e;
+    n.C |= CONFIG_HAS_LANE;
+}
+
+export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, laneHeld, mergeLanes, ownsLane, readsHeldCommitted, resolveLane, resolveTransition, signalLanes };