@solidjs/signals 2.0.0-beta.19 → 2.0.0-beta.20

package/dist/prod/core/core.js

@@ -1,18 +1,18 @@
 import { handleAsync, clearStatus, notifyStatus } from "./async.js";
 
-import { $REFRESH, REACTIVE_DISPOSED, REACTIVE_MANUAL_WRITE, REACTIVE_DIRTY, REACTIVE_CHECK, REACTIVE_IN_HEAP, REACTIVE_REASK, REACTIVE_LAZY, REACTIVE_NONE, defaultContext, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_AUTO_DISPOSE, CONFIG_SYNC, CONFIG_NO_SNAPSHOT, CONFIG_IN_SNAPSHOT_SCOPE, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_PENDING, NO_SNAPSHOT, REACTIVE_SNAPSHOT_STALE, EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_RECOMPUTING_DEPS, STATUS_ERROR, REACTIVE_IN_HEAP_HEIGHT, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
+import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, STATUS_UNINITIALIZED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, STATUS_PENDING, STATUS_ERROR, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, OVERRIDE_UNDEFINED, CONFIG_AUTO_DISPOSE, REACTIVE_LAZY, REACTIVE_DISPOSED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, $REFRESH, REACTIVE_MANUAL_WRITE, NO_SNAPSHOT, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 
 import { trimStaleDeps, link, unobserved } from "./graph.js";
 
-import { insertIntoHeap, queueFor, deleteFromHeap, insertIntoHeapHeight, markNode, markHeap } from "./heap.js";
+import { deleteFromHeap, queueFor, insertIntoHeapHeight, markNode, markHeap, insertIntoHeap } from "./heap.js";
 
-import { schedule, GlobalQueue, globalQueue, clock, activeTransition, queuePendingNode, insertSubs, dirtyQueue, activeAffectsMarks, runInTransition, projectionWriteActive, armReaskClear } from "./scheduler.js";
+import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, queuePendingNode, activeAffectsMarks, runInTransition, schedule, dirtyQueue, projectionWriteActive, armReaskClear } from "./scheduler.js";
 
 import "./invariants.js";
 
-import { inheritId, disposeChildren, markDisposal } from "./owner.js";
+import { disposeChildren, markDisposal, inheritId } from "./owner.js";
 
 GlobalQueue.Ce = recompute;
 
@@ -60,7 +60,7 @@ let snapshotSources = null;
 function ownerInSnapshotScope(e) {
     while (e) {
         if (e.ke) return true;
-        e = e.He;
+        e = e.Fe;
     }
     return false;
 }
@@ -81,7 +81,7 @@ function releaseSnapshotScope(e) {
 }
 
 function releaseSubtree(e) {
-    let t = e.Fe;
+    let t = e.He;
     while (t) {
         if (t.ke) {
             t = t.Ve;
@@ -120,12 +120,12 @@ function recompute(e, t = false) {
         deleteFromHeap(e, queueFor(e));
         e.Ae = null;
         // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
-                if (e.ve || n === EFFECT_TRACKED) disposeChildren(e); else if (e.Fe !== null || e.Me !== null) {
+                if (e.ve || n === EFFECT_TRACKED) disposeChildren(e); else if (e.He !== null || e.Me !== null) {
             markDisposal(e);
             e.We = e.Me;
-            e.Ze = e.Fe;
+            e.Ze = e.He;
             e.Me = null;
-            e.Fe = null;
+            e.He = null;
             e.je = 0;
         } else ;
     }
@@ -165,9 +165,9 @@ function recompute(e, t = false) {
             currentOptimisticLane = t;
         }
     }
-    const T = n && n !== EFFECT_USER;
-    const N = stale;
-    if (T) stale = true;
+    const N = n && n !== EFFECT_USER;
+    const T = stale;
+    if (N) stale = true;
     try {
         if (!false && e.U & CONFIG_SYNC) {
             a = e.xe(a);
@@ -201,7 +201,7 @@ function recompute(e, t = false) {
         if (n) GlobalQueue.nt(e);
     } finally {
         tracking = c;
-        if (T) stale = N;
+        if (N) stale = T;
         e.u = REACTIVE_NONE | (t ? e.u & REACTIVE_SNAPSHOT_STALE : 0);
         context = o;
         f = affectsReads;
@@ -209,7 +209,7 @@ function recompute(e, t = false) {
     }
     if (!e.k) {
         trimStaleDeps(e);
-        const s = l ? e.be : e.ge === NOT_PENDING ? e.Ue : e.ge;
+        const s = l ? unwrapOverride(e.be) : e.ge === NOT_PENDING ? e.Ue : e.ge;
         let o = false;
         try {
             o = !n && u || !e.Ge || !e.Ge(s, a);
@@ -240,7 +240,7 @@ function recompute(e, t = false) {
                 // own reveal schedule; drop any superseded older hold so its queued
                 // commit can't clobber the fresh value.
                                 if (l && i) {
-                    e.be = a;
+                    e.be = a === undefined ? OVERRIDE_UNDEFINED : a;
                     e.ge = NOT_PENDING;
                 }
             } else {
@@ -279,13 +279,13 @@ function recompute(e, t = false) {
     // action's transaction onto it — freezing unrelated writes that share it.
     // (Single mask test up front keeps the mark-free hot path at original cost.)
         const I = e.i & (STATUS_PENDING | STATUS_UNINITIALIZED);
-    const S = e.ge !== NOT_PENDING || e.Ze !== null || e.We !== null || I !== 0 && (I !== STATUS_PENDING || activeAffectsMarks === 0 || !GlobalQueue.$(e));
+    const p = e.ge !== NOT_PENDING || e.Ze !== null || e.We !== null || I !== 0 && (I !== STATUS_PENDING || activeAffectsMarks === 0 || !GlobalQueue.$(e));
     // 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.
-        S && (!t || e.i & STATUS_PENDING) && (!e.ve || l) && queuePendingNode(e);
+        p && (!t || e.i & STATUS_PENDING) && (!e.ve || l) && queuePendingNode(e);
     e.ve && n && activeTransition !== e.ve && runInTransition(e.ve, () => recompute(e));
 }
 
@@ -330,10 +330,10 @@ function computed(e, t) {
         ze: 0,
         p: null,
         Et: null,
-        He: context,
+        Fe: context,
         Ve: null,
-        Tt: null,
-        Fe: null,
+        Nt: null,
+        He: null,
         u: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         i: STATUS_UNINITIALIZED,
         Ie: clock,
@@ -375,10 +375,10 @@ function computed(e, t) {
         ze: 0,
         p: null,
         Et: null,
-        He: context,
+        Fe: context,
         Ve: null,
-        Tt: null,
-        Fe: null,
+        Nt: null,
+        He: null,
         u: REACTIVE_LAZY,
         i: STATUS_UNINITIALIZED,
         Ie: clock,
@@ -389,10 +389,10 @@ function computed(e, t) {
         ve: null,
         A: false,
         it: false,
-        Nt: undefined,
+        Tt: undefined,
         It: t,
         St: n,
-        At: undefined,
+        dt: undefined,
         De: i,
         C: l
     };
@@ -406,15 +406,15 @@ const lazyOptions = {
 
 function setupComputedNode(e, t) {
     e.ft = e;
-    const n = context?.dt ? context.Ct : context;
+    const n = context?.At ? context.Ct : context;
     if (context) {
-        const t = context.Fe;
+        const t = context.He;
         if (t === null) {
-            context.Fe = e;
+            context.He = e;
         } else {
             e.Ve = t;
-            t.Tt = e;
-            context.Fe = e;
+            t.Nt = e;
+            context.He = e;
         }
     }
     if (n) e.qe = n.qe + 1;
@@ -520,7 +520,7 @@ function read(e) {
     // than the original node (which stays "pending" while held in a transition).
     if (latestReadActive) return GlobalQueue.Gt(e);
     let t = context;
-    if (t?.dt) t = t.Ct;
+    if (t?.At) t = t.Ct;
     const n = e;
     const i = e.rt;
     const l = i || e;
@@ -538,7 +538,7 @@ function read(e) {
             // A live mark on a read source flows to the reader (probe reads are
             // excluded: the probe's own collection owns that verdict, and marking
             // the enclosing memo would make an `isPending` wrapper itself pending).
-                        if (activeAffectsMarks !== 0 && e.P && !pendingCheckActive) (affectsReads ??= []).push(e);
+                        if (activeAffectsMarks !== 0 && e.M && !pendingCheckActive) (affectsReads ??= []).push(e);
         }
         return !t || e.ge === NOT_PENDING ? e.Ue : e.ge;
     }
@@ -550,7 +550,7 @@ function read(e) {
         // to re-establish through, so without this a mid-window recompute sheds
         // pendingness permanently past one derivation level.
                 if (activeAffectsMarks !== 0 && !pendingCheckActive) {
-            if (e.P) (affectsReads ??= []).push(e);
+            if (e.M) (affectsReads ??= []).push(e);
             if (l.i & STATUS_PENDING) GlobalQueue.I(l, affectsReads ??= []);
         }
         if (l.xe) {
@@ -562,7 +562,7 @@ function read(e) {
             }
             const i = l.qe;
             // parent check is shallow, might need to be recursive
-                        if (i >= t.qe && e.He !== t) {
+                        if (i >= t.qe && e.Fe !== t) {
                 t.qe = i + 1;
             }
         }
@@ -611,8 +611,8 @@ function read(e) {
     if (e.be !== undefined && e.be !== NOT_PENDING) {
         // An active override means the engine is installed (A17: the override IS
         // the value for every reader — that check itself stays right here).
-        if (t && stale && GlobalQueue.gt(e)) return e.Ue;
-        return e.be;
+        if (t && stale && GlobalQueue.Dt(e)) return e.Ue;
+        return unwrapOverride(e.be);
     }
     // Entanglement gate: a reader recomputing under an optimistic lane that reads
     // a pending mid-transition write sees the committed value. Projection-store
@@ -621,17 +621,17 @@ function read(e) {
     // _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.Dt(e, l, t)) {
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.gt(e, l, t)) {
         return e.Ue;
     }
     // 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.)
-        const u = !t || currentOptimisticLane !== null && GlobalQueue.kt(e, l, t) || e.ge === NOT_PENDING || stale && e.ve && activeTransition !== e.ve ? e.Ue : e.ge;
+        const u = !t || currentOptimisticLane !== null && GlobalQueue.vt(e, l, t) || e.ge === NOT_PENDING || stale && e.ve && activeTransition !== e.ve ? e.Ue : e.ge;
     // 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.vt(e, u);
+        if (pendingCheckActive) GlobalQueue.kt(e, u);
     if (!t && l === e && typeof n.xe === "function" && e.U & CONFIG_AUTO_DISPOSE && !(l.i & STATUS_PENDING) && !e.p) {
         unobserved(e);
     }

package/dist/prod/core/effect.js

@@ -1,10 +1,10 @@
-import { EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, STATUS_ERROR, STATUS_PENDING, EFFECT_RENDER, REACTIVE_DISPOSED } from "./constants.js";
+import { REACTIVE_DISPOSED, STATUS_ERROR, EFFECT_USER, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_TRACKED, STATUS_PENDING, EFFECT_RENDER } from "./constants.js";
 
 import { createEffectNode, recompute, computed, staleValues } from "./core.js";
 
 import { unwrapStatusError, StatusError } from "./error.js";
 
-import { haltReactivity, GlobalQueue } from "./scheduler.js";
+import { GlobalQueue, haltReactivity } from "./scheduler.js";
 
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
@@ -62,12 +62,12 @@ function runEffect(t) {
     // same flush must not be hijacked by a later-arriving error status.
         if (t.i & STATUS_ERROR && t.De === EFFECT_USER) {
         const E = unwrapStatusError(t.k);
-        t.Nt = t.Ue;
+        t.Tt = t.Ue;
         t.it = false;
         try {
             t.St ? t.St(E, () => {
-                const E = t.At;
-                t.At = undefined;
+                const E = t.dt;
+                t.dt = undefined;
                 E?.();
             }) : console.error(E);
         } catch (E) {
@@ -78,14 +78,14 @@ function runEffect(t) {
         }
         return;
     }
-    const E = t.At;
-    t.At = undefined;
+    const E = t.dt;
+    t.dt = undefined;
     try {
         E?.();
-        const e = t.It(t.Ue, t.Nt);
+        const e = t.It(t.Ue, t.Tt);
         if (false && e !== undefined && typeof e !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                t.At = e;
+                t.dt = e;
     } catch (E) {
         t.k = new StatusError(t, E);
         t.i |= STATUS_ERROR;
@@ -94,7 +94,7 @@ function runEffect(t) {
             throw E;
         }
     } finally {
-        t.Nt = t.Ue;
+        t.Tt = t.Ue;
         t.it = false;
     }
 }
@@ -114,16 +114,16 @@ GlobalQueue.ut = runEffect;
         } finally {}
     };
     const e = computed(() => {
-        const E = e.At;
-        e.At = undefined;
+        const E = e.dt;
+        e.dt = undefined;
         E?.();
         const R = staleValues(t);
-        e.At = R;
+        e.dt = R;
     }, {
         ...E,
         lazy: true
     });
-    e.At = undefined;
+    e.dt = undefined;
     e.U = e.U & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
     e.it = true;
     e.De = EFFECT_TRACKED;

package/dist/prod/core/graph.js

@@ -1,4 +1,4 @@
-import { REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE } from "./constants.js";
+import { CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
 
 import { deleteFromHeap, queueFor } from "./heap.js";
 

package/dist/prod/core/heap.js

@@ -1,4 +1,4 @@
-import { REACTIVE_IN_HEAP, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_ZOMBIE, EFFECT_TRACKED, EFFECT_USER } from "./constants.js";
+import { REACTIVE_IN_HEAP, EFFECT_TRACKED, EFFECT_USER, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_ZOMBIE, REACTIVE_CHECK, REACTIVE_DIRTY } from "./constants.js";
 
 import { zombieQueue, dirtyQueue } from "./scheduler.js";
 
@@ -25,7 +25,7 @@ import { zombieQueue, dirtyQueue } from "./scheduler.js";
 }
 
 function actualInsertIntoHeap(e, E) {
-    const t = (e.He?.dt ? e.He.Ct?.qe : e.He?.qe) ?? -1;
+    const t = (e.Fe?.At ? e.Fe.Ct?.qe : e.Fe?.qe) ?? -1;
     if (t >= e.qe) e.qe = t + 1;
     const n = e.qe;
     const I = E.eE[n];

package/dist/prod/core/lanes.js

@@ -1,6 +1,6 @@
 import { NOT_PENDING } from "./constants.js";
 
-import { activeTransition } from "./scheduler.js";
+import { currentTransition, activeTransition } from "./scheduler.js";
 
 // Map from optimistic signal to its lane (reused for multiple writes to same signal)
 const signalLanes = new WeakMap;
@@ -19,14 +19,14 @@ 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.en;
-    const a = i?.Je ? findLane(i.Je) : null;
+    const r = i?.Je ? findLane(i.Je) : null;
     e = {
-        an: n,
+        rn: n,
         Pe: new Set,
         tn: [ [], [] ],
-        rn: null,
+        an: null,
         ve: activeTransition,
-        sn: a
+        sn: r
     };
     signalLanes.set(n, e);
     activeLanes.add(e);
@@ -45,16 +45,16 @@ function adoptCompanionLane(n, e) {
     if (!n) return;
     const i = signalLanes.get(n);
     if (!i) return;
-    const a = findLane(i);
+    const r = 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 (a !== e && a.an === n && !a.sn) a.sn = e;
+        if (r !== e && r.rn === n && !r.sn) r.sn = e;
 }
 
 /**
  * Union-find: find the root lane.
  */ function findLane(n) {
-    while (n.rn) n = n.rn;
+    while (n.an) n = n.an;
     return n;
 }
 
@@ -64,7 +64,7 @@ function adoptCompanionLane(n, e) {
     n = findLane(n);
     e = findLane(e);
     if (n === e) return n;
-    e.rn = n;
+    e.an = 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).
@@ -89,6 +89,16 @@ function adoptCompanionLane(n, e) {
 }
 
 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.fn) {
+        const e = n.fn = currentTransition(n.fn);
+        if (e.cn !== true) return e;
+        n.fn = null;
+    }
     return resolveLane(n)?.ve ?? n.ve;
 }
 
@@ -103,16 +113,16 @@ function resolveTransition(n) {
  * a different active lane), merge unless the node has an active override.
  */ function assignOrMergeLane(n, e) {
     const i = findLane(e);
-    const a = n.Je;
-    if (a) {
+    const r = n.Je;
+    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 (a.rn) {
+        if (r.an) {
             n.Je = e;
             return;
         }
-        const t = findLane(a);
+        const t = findLane(r);
         if (activeLanes.has(t)) {
             if (t !== i && !hasActiveOverride(n)) {
                 // Parent-child lanes stay independent so isPending resolves without