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

package/dist/prod/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, 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 t = n.o?.St;
-    const i = t?.o?.$e;
-    const r = i ? findLane(i) : null;
+        const i = n.o?.Ht;
+    const t = i?.o?.Ue;
+    const r = t ? findLane(t) : null;
     e = {
-        nn: n,
-        Oe: new Set,
-        tn: [ [], [] ],
-        rn: null,
-        Ae: activeTransition,
-        an: r
+        an: n,
+        ye: new Set,
+        fn: [ [], [] ],
+        cn: null,
+        Ge: activeTransition,
+        Ln: r
     };
     signalLanes.set(n, e);
     activeLanes.add(e);
@@ -39,69 +41,117 @@ 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?.ye, e);
-    adoptCompanionLane(n.o?.Ce, e);
+        adoptCompanionLane(n.o?.je, e);
+    adoptCompanionLane(n.o?.xe, e);
     return e;
 }
 
 function adoptCompanionLane(n, e) {
     if (!n) return;
-    const t = signalLanes.get(n);
-    if (!t) return;
-    const i = findLane(t);
+    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 (i !== e && i.nn === n && !i.an) i.an = e;
+        if (t !== e && t.an === n && !t.Ln) t.Ln = e;
 }
 
 /**
  * Union-find: find the root lane.
  */ function findLane(n) {
-    while (n.rn) n = n.rn;
+    while (n.cn) n = n.cn;
     return n;
 }
 
 /**
  * Is the lane held? `_pendingAsync` records the async the lane OWNS (derived
- * under it); the transaction's reporter map records the async a render effect
+ * 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) {
-    const e = n.Ae;
-    if (e) for (const t of n.Oe) if (currentTransition(e)._e.has(t)) return true;
+    if (!n.Ge) return false;
+    for (const e of n.ye) 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.fn[0].push(() => e.ue & 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.rn = n;
+    e.cn = 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 t of e.Oe) n.Oe.add(t);
-    e.Oe.clear();
-    n.tn[0].push(...e.tn[0]);
-    n.tn[1].push(...e.tn[1]);
-    e.tn[0].length = 0;
-    e.tn[1].length = 0;
+        for (const i of e.ye) n.ye.add(i);
+    e.ye.clear();
+    n.fn[0].push(...e.fn[0]);
+    n.fn[1].push(...e.fn[1]);
+    e.fn[0].length = 0;
+    e.fn[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?.$e;
+    const e = n.o?.Ue;
     if (!e) return undefined;
-    const t = findLane(e);
-    if (activeLanes.has(t)) return t;
-    if (n.o !== null) n.o.$e = undefined;
+    const i = findLane(e);
+    if (activeLanes.has(i)) return i;
+    if (n.o !== null) n.o.Ue = undefined;
     return undefined;
 }
 
@@ -111,51 +161,45 @@ 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?.Tt) {
-        const e = ext(n).Tt = currentTransition(n.o?.Tt);
-        if (e.sn !== true) return e;
-        if (n.o !== null) n.o.Tt = null;
+    if (hasActiveOverride(n) && n.o?.Ft) {
+        const e = ext(n).Ft = currentTransition(n.o?.Ft);
+        if (e.Tt !== true) return e;
+        if (n.o !== null) n.o.Ft = null;
     }
-    return resolveLane(n)?.Ae ?? n.Ae;
-}
-
-/**
- * Check if a node has an active optimistic override.
- */ function hasActiveOverride(n) {
-    const e = n.o;
-    return e !== null && e.Pe !== undefined && e.Pe !== NOT_PENDING;
+    return resolveLane(n)?.Ge ?? n.Ge;
 }
 
 /**
  * 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 t = findLane(e);
-    const i = n.o?.$e;
-    if (i) {
-        // 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 (i.rn) {
-            ext(n).$e = e;
-            n.T |= CONFIG_HAS_LANE;
-            return;
-        }
-        const r = findLane(i);
+    const i = findLane(e);
+    const t = n.o?.Ue;
+    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)) {
-            if (r !== t && !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.T & CONFIG_DERIVED_OVERRIDE)) {
                 // Parent-child lanes stay independent so isPending resolves without
                 // waiting for the parent's async. The child keeps ownership.
-                if (t.an && findLane(t.an) === r) {
-                    ext(n).$e = e;
+                if (i.Ln && findLane(i.Ln) === r) {
+                    ext(n).Ue = e;
                     n.T |= CONFIG_HAS_LANE;
-                } else if (r.an && findLane(r.an) === t) ; else mergeLanes(t, r);
+                } else if (r.Ln && findLane(r.Ln) === i) ; else mergeLanes(i, r);
             }
             return;
         }
     }
-    ext(n).$e = e;
+    ext(n).Ue = e;
     n.T |= 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 };