@solidjs/signals 2.0.0-rc.0 → 2.0.0-rc.10

package/dist/prod/core/heap.js

@@ -1,104 +1,111 @@
-import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, EFFECT_TRACKED, EFFECT_USER, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_ZOMBIE, REACTIVE_CHECK, REACTIVE_DIRTY } from "./constants.js";
+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.se & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    return e.oe & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
 }
 
 /**
- * Schedule one subscriber to re-run on the next flush: tracked effects bypass
- * the heap and go directly to their effect queue; everything else is inserted
- * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
+ * 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) {
-    if (e.Re === EFFECT_TRACKED) {
-        const E = e;
-        if (!E.Je) {
-            E.Je = true;
-            E.C.enqueue(EFFECT_USER, E.Ft);
-        }
-        return;
-    }
     const E = queueFor(e);
-    if (E.Ve > e.xe) E.Ve = e.xe;
+    if (E.ln > e.rn) E.ln = e.rn;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.ke?.Nt ? e.ke.dt?.xe : e.ke?.xe) ?? -1;
-    if (t >= e.xe) e.xe = t + 1;
-    const n = e.xe;
+    const t = (e._parent?.Wn ? e._parent.qn?.rn : e._parent?.rn) ?? -1;
+    if (t >= e.rn) e.rn = t + 1;
+    const n = e.rn;
     const I = E.eE[n];
     if (I === undefined) E.eE[n] = e; else {
-        const E = I.st;
-        E.ot = e;
-        e.st = E;
-        I.st = e;
+        const E = I.Fn;
+        E.Pn = e;
+        e.Fn = E;
+        I.Fn = e;
     }
     if (n > E.EE) E.EE = n;
 }
 
 function insertIntoHeap(e, E) {
-    let t = e.se;
-    if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
+    let t = e.oe;
+    // 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.se = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+        e.oe = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
     } else {
-        e.se = t | REACTIVE_IN_HEAP;
-        // An unmarked node entering a marked heap invalidates the markHeap memo:
-        // `_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).
-                if (E.tE && !(t & REACTIVE_DIRTY)) E.tE = false;
+        e.oe = 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.se;
+    let t = e.oe;
     if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
-    e.se = t | REACTIVE_IN_HEAP_HEIGHT;
+    e.oe = t | REACTIVE_IN_HEAP_HEIGHT;
     actualInsertIntoHeap(e, E);
 }
 
 function deleteFromHeap(e, E) {
-    const t = e.se;
+    const t = e.oe;
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-    e.se = t & -25;
-    const n = e.xe;
-    if (e.st === e) E.eE[n] = undefined; else {
-        const t = e.ot;
+    e.oe = t & -25;
+    const n = e.rn;
+    if (e.Fn === e) E.eE[n] = undefined; else {
+        const t = e.Pn;
         const I = E.eE[n];
         const o = t ?? I;
-        if (e === I) E.eE[n] = t; else e.st.ot = t;
-        o.st = e.st;
+        if (e === I) E.eE[n] = t; else e.Fn.Pn = t;
+        o.Fn = e.Fn;
     }
-    e.st = e;
-    e.ot = undefined;
+    e.Fn = e;
+    e.Pn = 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.ot) {
-            if (t.se & REACTIVE_IN_HEAP) markNode(t);
+        for (let t = e.eE[E]; t !== undefined; t = t.Pn) {
+            if (t.oe & REACTIVE_IN_HEAP) markNode(t);
         }
     }
 }
 
 function markNode(e, E = REACTIVE_DIRTY) {
-    const t = e.se;
+    const t = e.oe;
     if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
-    e.se = t & -4 | E;
-    for (let E = e.o; E !== null; E = E.le) {
-        markNode(E.fe, REACTIVE_CHECK);
+    e.oe = t & -4 | E;
+    for (let E = e.u; E !== null; E = E.Ae) {
+        markNode(E.ge, REACTIVE_CHECK);
     }
-    if (e.u !== null) {
-        for (let E = e.u; E !== null; E = E.ae) {
-            for (let e = E.o; e !== null; e = e.le) {
-                markNode(e.fe, 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.Ae) {
+                markNode(e.ge, REACTIVE_CHECK);
             }
         }
     }
@@ -106,11 +113,11 @@ function markNode(e, E = REACTIVE_DIRTY) {
 
 function runHeap(e, E) {
     e.tE = false;
-    for (e.Ve = 0; e.Ve <= e.EE; e.Ve++) {
-        let t = e.eE[e.Ve];
+    for (e.ln = 0; e.ln <= e.EE; e.ln++) {
+        let t = e.eE[e.ln];
         while (t !== undefined) {
-            if (t.se & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.Ve];
+            if (t.oe & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
+            t = e.eE[e.ln];
         }
     }
     e.EE = 0;
@@ -118,21 +125,21 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.xe;
-    for (let E = e.tt; E; E = E.nt) {
-        const e = E.it;
-        const n = e.lt || e;
-        if (n.ce && n.xe >= t) t = n.xe + 1;
+    let t = e.rn;
+    for (let E = e.Ie; E; E = E.Ne) {
+        const e = E.Oe;
+        const n = e.De || e;
+        if (n.he && n.rn >= t) t = n.rn + 1;
     }
-    if (e.xe !== t) {
-        e.xe = t;
-        for (let E = e.o; E !== null; E = E.le) {
+    if (e.rn !== t) {
+        e.rn = t;
+        for (let E = e.u; E !== null; E = E.Ae) {
             // 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.fe, queueFor(E.fe));
+            insertIntoHeapHeight(E.ge, queueFor(E.ge));
         }
     }
 }

package/dist/prod/core/invariants.js

@@ -1,3 +1,5 @@
+import "./core.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
@@ -6,8 +8,7 @@
  * (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) {
+ */ function devCheckActiveOverrides(e) {
     return;
 }
 

package/dist/prod/core/lanes.js

@@ -1,6 +1,10 @@
-import { NOT_PENDING } from "./constants.js";
+import { CONFIG_DERIVED_OVERRIDE, CONFIG_HAS_LANE, REACTIVE_DISPOSED } from "./constants.js";
 
-import { currentTransition, activeTransition } from "./scheduler.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;
@@ -18,15 +22,16 @@ const activeLanes = new Set;
     }
     // Detect parent lane: _parentSource chains from pendingSignal → pendingValueComputed → original.
     // The child lane should not merge with the parent lane.
-        const i = n.nn;
-    const r = i?.Ke ? findLane(i.Ke) : null;
+        const i = n.o?.kn;
+    const t = i?.o?.me;
+    const r = t ? findLane(t) : null;
     e = {
-        en: n,
-        Ae: new Set,
-        rn: [ [], [] ],
-        tn: null,
-        Ne: activeTransition,
-        an: r
+        ni: n,
+        Qe: new Set,
+        dn: [ [], [] ],
+        ei: null,
+        we: activeTransition,
+        ii: r
     };
     signalLanes.set(n, e);
     activeLanes.add(e);
@@ -36,8 +41,8 @@ const activeLanes = new Set;
     // 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.ge, e);
-    adoptCompanionLane(n.pe, e);
+        adoptCompanionLane(n.o?.Ze, e);
+    adoptCompanionLane(n.o?.He, e);
     return e;
 }
 
@@ -45,46 +50,108 @@ function adoptCompanionLane(n, e) {
     if (!n) return;
     const i = signalLanes.get(n);
     if (!i) return;
-    const r = findLane(i);
+    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 (r !== e && r.en === n && !r.an) r.an = e;
+        if (t !== e && t.ni === n && !t.ii) t.ii = e;
 }
 
 /**
  * Union-find: find the root lane.
  */ function findLane(n) {
-    while (n.tn) n = n.tn;
+    while (n.ei) n = n.ei;
     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.we) return false;
+    for (const e of n.Qe) 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.dn[0].push(() => e.oe & 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.tn = n;
+    e.ei = 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.Ae) n.Ae.add(i);
-    e.Ae.clear();
-    n.rn[0].push(...e.rn[0]);
-    n.rn[1].push(...e.rn[1]);
-    e.rn[0].length = 0;
-    e.rn[1].length = 0;
+        for (const i of e.Qe) n.Qe.add(i);
+    e.Qe.clear();
+    n.dn[0].push(...e.dn[0]);
+    n.dn[1].push(...e.dn[1]);
+    e.dn[0].length = 0;
+    e.dn[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.Ke;
+    const e = n.o?.me;
     if (!e) return undefined;
     const i = findLane(e);
     if (activeLanes.has(i)) return i;
-    n.Ke = undefined;
+    if (n.o !== null) n.o.me = undefined;
     return undefined;
 }
 
@@ -94,18 +161,12 @@ function resolveTransition(n) {
     // 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.sn) {
-        const e = n.sn = currentTransition(n.sn);
-        if (e.fn !== true) return e;
-        n.sn = null;
+    if (hasActiveOverride(n) && n.o?.Ln) {
+        const e = ext(n).Ln = currentTransition(n.o?.Ln);
+        if (e.Rn !== true) return e;
+        if (n.o !== null) n.o.Ln = null;
     }
-    return resolveLane(n)?.Ne ?? n.Ne;
-}
-
-/**
- * Check if a node has an active optimistic override.
- */ function hasActiveOverride(n) {
-    return !!(n._e !== undefined && n._e !== NOT_PENDING);
+    return resolveLane(n)?.we ?? n.we;
 }
 
 /**
@@ -113,28 +174,32 @@ function resolveTransition(n) {
  * a different active lane), merge unless the node has an active override.
  */ function assignOrMergeLane(n, e) {
     const i = findLane(e);
-    const r = n.Ke;
-    if (r) {
-        // If the subscriber's lane was merged into another lane, it's stale —
-        // replace it with the new source lane instead of following the merge chain
-        // (which would incorrectly merge the new lane into the old group)
-        if (r.tn) {
-            n.Ke = e;
-            return;
-        }
-        const t = findLane(r);
-        if (activeLanes.has(t)) {
-            if (t !== i && !hasActiveOverride(n)) {
+    const t = n.o?.me;
+    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.an && findLane(i.an) === t) {
-                    n.Ke = e;
-                } else if (t.an && findLane(t.an) === i) ; else mergeLanes(i, t);
+                if (i.ii && findLane(i.ii) === r) {
+                    ext(n).me = e;
+                    n.C |= CONFIG_HAS_LANE;
+                } else if (r.ii && findLane(r.ii) === i) ; else mergeLanes(i, r);
             }
             return;
         }
     }
-    n.Ke = e;
+    ext(n).me = e;
+    n.C |= CONFIG_HAS_LANE;
 }
 
-export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane, resolveTransition, signalLanes };
+export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, laneHeld, mergeLanes, ownsLane, readsHeldCommitted, resolveLane, resolveTransition, signalLanes };