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

package/dist/observe/core/heap.js

@@ -5,7 +5,7 @@ import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_ZOMBIE, REACTIVE_RE
 import { zombieQueue, dirtyQueue } from "./scheduler.js";
 
 /** The queue a node belongs to, picked from its own zombie flag. */ function queueFor(e) {
-    return e.it & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    return e.ft & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
 }
 
 /**
@@ -16,34 +16,34 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
  * (see GlobalQueue._update, #3291).
  */ function enqueueSub(e) {
     const E = queueFor(e);
-    if (E.St > e.At) E.St = e.At;
+    if (E.Ct > e.Rt) E.Ct = e.Rt;
     insertIntoHeap(e, E);
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.Nt?.$t ? e.Nt.ln?.At : e.Nt?.At) ?? -1;
-    if (t >= e.At) e.At = t + 1;
-    const n = e.At;
+    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.Qt;
-        E.yt = e;
-        e.Qt = E;
-        I.Qt = e;
+        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.it;
+    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.it = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+        e.ft = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
     } else {
-        e.it = t | REACTIVE_IN_HEAP;
+        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 +
@@ -60,52 +60,52 @@ function insertIntoHeap(e, E) {
 }
 
 function insertIntoHeapHeight(e, E) {
-    let t = e.it;
+    let t = e.ft;
     if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
-    e.it = t | REACTIVE_IN_HEAP_HEIGHT;
+    e.ft = t | REACTIVE_IN_HEAP_HEIGHT;
     actualInsertIntoHeap(e, E);
 }
 
 function deleteFromHeap(e, E) {
-    const t = e.it;
+    const t = e.ft;
     if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-    e.it = t & -25;
-    const n = e.At;
-    if (e.Qt === e) E.eE[n] = undefined; else {
-        const t = e.yt;
+    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.Qt.yt = t;
-        o.Qt = e.Qt;
+        if (e === I) E.eE[n] = t; else e.Mt.Wt = t;
+        o.Mt = e.Mt;
     }
-    e.Qt = e;
-    e.yt = undefined;
+    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.yt) {
-            if (t.it & REACTIVE_IN_HEAP) markNode(t);
+        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.it;
+    const t = e.ft;
     if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
-    e.it = t & -4 | E;
-    for (let E = e.u; E !== null; E = E.se) {
-        markNode(E.le, REACTIVE_CHECK);
+    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.T & CONFIG_FW_CHILDREN) {
+        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.se) {
-                markNode(e.le, REACTIVE_CHECK);
+            for (let e = E.u; e !== null; e = e.ie) {
+                markNode(e.se, REACTIVE_CHECK);
             }
         }
     }
@@ -113,11 +113,11 @@ function markNode(e, E = REACTIVE_DIRTY) {
 
 function runHeap(e, E) {
     e.tE = false;
-    for (e.St = 0; e.St <= e.EE; e.St++) {
-        let t = e.eE[e.St];
+    for (e.Ct = 0; e.Ct <= e.EE; e.Ct++) {
+        let t = e.eE[e.Ct];
         while (t !== undefined) {
-            if (t.it & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.St];
+            if (t.ft & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
+            t = e.eE[e.Ct];
         }
     }
     e.EE = 0;
@@ -125,21 +125,21 @@ function runHeap(e, E) {
 
 function adjustHeight(e, E) {
     deleteFromHeap(e, E);
-    let t = e.At;
-    for (let E = e.te; E; E = E.ne) {
-        const e = E.oe;
-        const n = e.re || e;
-        if (n.ot && n.At >= t) t = n.At + 1;
+    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.At !== t) {
-        e.At = t;
-        for (let E = e.u; E !== null; E = E.se) {
+    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.le, queueFor(E.le));
+            insertIntoHeapHeight(E.se, queueFor(E.se));
         }
     }
 }

package/dist/observe/core/invariants.js

@@ -1,5 +1,7 @@
 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

package/dist/observe/core/lanes.js

@@ -1,8 +1,10 @@
-import { CONFIG_HAS_LANE, NOT_PENDING } from "./constants.js";
+import { CONFIG_DERIVED_OVERRIDE, CONFIG_HAS_LANE, REACTIVE_DISPOSED } from "./constants.js";
 
-import { ext } from "./core.js";
+import { hasActiveOverride, ext, ownsHold, currentOptimisticLane } from "./core.js";
 
-import { currentTransition, waitingTransition, activeTransition } from "./scheduler.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;
@@ -20,16 +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.o?.Qe;
-    const t = i?.o?.Te;
+        const i = n.o?.nn;
+    const t = i?.o?.de;
     const r = t ? findLane(t) : null;
     e = {
         Ln: n,
-        _e: new Set,
+        Ie: new Set,
         vn: [ [], [] ],
-        gn: null,
-        Ee: activeTransition,
-        hn: r
+        wn: null,
+        Te: activeTransition,
+        Hn: r
     };
     signalLanes.set(n, e);
     activeLanes.add(e);
@@ -39,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.o?.be, e);
-    adoptCompanionLane(n.o?.pe, e);
+        adoptCompanionLane(n.o?.he, e);
+    adoptCompanionLane(n.o?.Ge, e);
     return e;
 }
 
@@ -51,13 +53,13 @@ function adoptCompanionLane(n, e) {
     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;
+        if (t !== e && t.Ln === n && !t.Hn) t.Hn = e;
 }
 
 /**
  * Union-find: find the root lane.
  */ function findLane(n) {
-    while (n.gn) n = n.gn;
+    while (n.wn) n = n.wn;
     return n;
 }
 
@@ -77,23 +79,64 @@ function adoptCompanionLane(n, e) {
  * 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.Ee) return false;
-    for (const e of n._e) if (waitingTransition(e) !== null) return true;
+    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.gn = 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._e) n._e.add(i);
-    e._e.clear();
+        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;
@@ -104,11 +147,11 @@ function adoptCompanionLane(n, e) {
 /**
  * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
  */ function resolveLane(n) {
-    const e = n.o?.Te;
+    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.Te = undefined;
+    if (n.o !== null) n.o.de = undefined;
     return undefined;
 }
 
@@ -118,19 +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.o?.Yt) {
-        const e = ext(n).Yt = currentTransition(n.o?.Yt);
-        if (e.Ut !== true) return e;
-        if (n.o !== null) n.o.Yt = null;
+    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)?.Ee ?? n.Ee;
-}
-
-/**
- * Check if a node has an active optimistic override.
- */ function hasActiveOverride(n) {
-    const e = n.o;
-    return e !== null && e.De !== undefined && e.De !== NOT_PENDING;
+    return resolveLane(n)?.Te ?? n.Te;
 }
 
 /**
@@ -138,31 +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 t = n.o?.Te;
+    const t = n.o?.de;
     if (t) {
-        // 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 (t.gn) {
-            ext(n).Te = e;
-            n.T |= CONFIG_HAS_LANE;
-            return;
-        }
+        // 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)) {
-            if (r !== i && !hasActiveOverride(n)) {
+            // 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).Te = e;
-                    n.T |= CONFIG_HAS_LANE;
-                } else if (r.hn && findLane(r.hn) === i) ; else mergeLanes(i, r);
+                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).Te = e;
-    n.T |= CONFIG_HAS_LANE;
+    ext(n).de = e;
+    n.C |= CONFIG_HAS_LANE;
 }
 
-export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, laneHeld, mergeLanes, resolveLane, resolveTransition, signalLanes };
+export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, laneHeld, mergeLanes, ownsLane, readsHeldCommitted, resolveLane, resolveTransition, signalLanes };