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

package/dist/prod/core/optimistic.js

@@ -1,6 +1,6 @@
-import { NOT_PENDING, STATUS_UNINITIALIZED, STATUS_PENDING, CONFIG_OWNED_WRITE, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_RENDER, EFFECT_USER } from "./constants.js";
+import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, OVERRIDE_UNDEFINED, STATUS_PENDING, CONFIG_OWNED_WRITE, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_RENDER, EFFECT_USER } from "./constants.js";
 
-import { latestReadActive, stale, currentOptimisticLane } from "./core.js";
+import { latestReadActive, currentOptimisticLane, stale } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -29,33 +29,40 @@ import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule
 // committed-view rerun. Keep that override local to the stash flush.
 let stashedOptimisticReads = null;
 
-/** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, t) {
-    const n = e.be !== NOT_PENDING;
-    const i = n ? e.be : e.Ue;
-    if (typeof t === "function") t = t(i);
-    const u = !!(e.i & STATUS_UNINITIALIZED) || !e.Ge || !e.Ge(i, t);
+/** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
+    const t = e.be !== NOT_PENDING;
+    const i = t ? unwrapOverride(e.be) : e.Ue;
+    if (typeof n === "function") n = n(i);
+    const u = !!(e.i & STATUS_UNINITIALIZED) || !e.Ge || !e.Ge(i, n);
     if (!u) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
-        if (n) {
-            const t = resolveTransition(e);
-            if (t && activeTransition !== t) globalQueue.initTransition(t);
+        if (t) {
+            const n = resolveTransition(e);
+            if (n && activeTransition !== n) globalQueue.initTransition(n);
         }
-        return t;
+        return n;
     }
-    if (n) globalQueue.initTransition(resolveTransition(e));
+    if (t) globalQueue.initTransition(resolveTransition(e));
     // No revert target is stashed: while the override is active every reader
     // sees it (A17), so authoritative arrivals commit silently into _value and
     // reverting is just dropping the override — _value is already correct.
-     else globalQueue.Be.push(e);
+     else globalQueue.N.Be.push(e);
+    // Stamp ownership on the node (post-merge, so entangled writers share the
+    // joint root). resolveTransition prefers this over the lane's _transition,
+    // which a shared subscriber can merge across transactions (#2912).
+        e.fn = activeTransition;
     const s = getOrCreateLane(e);
     e.Je = s;
-    e.be = t;
-    GlobalQueue._e !== null && GlobalQueue._e(e, t);
+    // Literal undefined must not land raw: the slot doubles as the optimistic
+    // brand, and erasing it makes the write invisible and routes follow-up
+    // writes off the optimistic path into permanent commits (#2898).
+        e.be = n === undefined ? OVERRIDE_UNDEFINED : n;
+    GlobalQueue._e !== null && GlobalQueue._e(e, n);
     e.Ie = clock;
     insertSubs(e, true);
     schedule();
-    return t;
+    return n;
 }
 
 function readStashed(e) {
@@ -63,8 +70,8 @@ function readStashed(e) {
 }
 
 function queueStashedOptimisticEffects(e) {
-    for (let t = e.p; t !== null; t = t.de) {
-        const e = t.Ee;
+    for (let n = e.p; n !== null; n = n.de) {
+        const e = n.Ee;
         if (!e.De) continue;
         enqueueSub(e);
     }
@@ -75,11 +82,11 @@ function queueStashedOptimisticEffects(e) {
  * optimistic nodes: give plain optimistic signals one committed-view rerun.
  */ function stashOptimistic(e) {
     stashedOptimisticReads = new Set;
-    for (let t = 0; t < e.Be.length; t++) {
-        const n = e.Be[t];
-        if (n.xe || n.U & CONFIG_OWNED_WRITE) continue;
-        stashedOptimisticReads.add(n);
-        queueStashedOptimisticEffects(n);
+    for (let n = 0; n < e.Be.length; n++) {
+        const t = e.Be[n];
+        if (t.xe || t.U & CONFIG_OWNED_WRITE) continue;
+        stashedOptimisticReads.add(t);
+        queueStashedOptimisticEffects(t);
     }
     try {
         finalizePureQueue(null, true);
@@ -93,13 +100,13 @@ function queueStashedOptimisticEffects(e) {
  * while one of its optimistic nodes holds an active override that is still
  * pending on real (non-affects-sentinel) async.
  */ function transitionBlocked(e) {
-    for (let t = 0; t < e.Be.length; t++) {
-        const n = e.Be[t];
-        if (hasActiveOverride(n) && "i" in n && n.i & STATUS_PENDING && n.k instanceof NotReadyError && 
+    for (let n = 0; n < e.Be.length; n++) {
+        const t = e.Be[n];
+        if (hasActiveOverride(t) && "i" in t && t.i & STATUS_PENDING && t.k instanceof NotReadyError && 
         // Mark-sourced pending never blocks settlement: affects() releases AT
         // settle, so counting its sentinel here would deadlock the window it
         // is scoped to.
-        !n.k.source?.l) {
+        !t.k.source?.l) {
             return true;
         }
     }
@@ -110,62 +117,63 @@ function resolveOptimisticNodes(e) {
     // Settlement writes below (snapCompanionsToState → updatePendingSignal-style
     // notifications) may push fresh optimistic nodes; only this batch settles
     // now, so iterate a fixed window and splice it out at the end.
-    const t = e.length;
-    for (let n = 0; n < t; n++) {
-        const t = e[n];
-        t.Je = undefined;
+    const n = e.length;
+    for (let t = 0; t < n; t++) {
+        const n = e[t];
+        n.Je = undefined;
         // Revert is a pure drop: there is no revert target to commit —
         // override-covered authoritative values hold in _pendingValue and
         // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
-                if (!(t.i & STATUS_PENDING)) t.i &= ~STATUS_UNINITIALIZED;
-        const i = t.be;
-        t.be = NOT_PENDING;
-        if (i !== NOT_PENDING && t.Ue !== i) insertSubs(t, true);
-        t.ve = null;
+                if (!(n.i & STATUS_PENDING)) n.i &= ~STATUS_UNINITIALIZED;
+        const i = n.be;
+        n.be = NOT_PENDING;
+        if (i !== NOT_PENDING && n.Ue !== unwrapOverride(i)) insertSubs(n, true);
+        n.ve = null;
+        n.fn = null;
     }
     // Settlement checkpoint (#2838): companions caught in this batch (or owned
     // by a node in it) re-derive from committed state, so verdicts survive the
     // transition that produced them (A19 — pending is a property of the data).
-        for (let n = 0; n < t; n++) {
-        const t = e[n];
-        if (t.ye || t.pe) GlobalQueue.R(t);
-        const i = t.en;
-        if (i && (i.ye === t || i.pe === t)) GlobalQueue.R(i);
+        for (let t = 0; t < n; t++) {
+        const n = e[t];
+        if (n.ye || n.pe) GlobalQueue.R(n);
+        const i = n.en;
+        if (i && (i.ye === n || i.pe === n)) GlobalQueue.R(i);
     }
-    e.splice(0, t);
+    e.splice(0, n);
 }
 
-function runQueue(e, t) {
-    for (let n = 0; n < e.length; n++) e[n](t);
+function runQueue(e, n) {
+    for (let t = 0; t < e.length; t++) e[t](n);
 }
 
 /**
  * Run effects from all lanes that are ready (no pending async).
  */ function runLaneEffects(e) {
-    for (const t of activeLanes) {
-        if (t.rn || t.Pe.size > 0) continue;
-        const n = t.tn[e - 1];
-        if (n.length) {
-            t.tn[e - 1] = [];
-            runQueue(n, e);
+    for (const n of activeLanes) {
+        if (n.an || n.Pe.size > 0) continue;
+        const t = n.tn[e - 1];
+        if (t.length) {
+            n.tn[e - 1] = [];
+            runQueue(t, e);
         }
     }
 }
 
 function cleanupCompletedLanes(e) {
-    for (const t of activeLanes) {
-        const n = e ? t.ve === e : !t.ve;
-        if (!n) continue;
-        if (!t.rn) {
-            if (t.tn[0].length) runQueue(t.tn[0], EFFECT_RENDER);
-            if (t.tn[1].length) runQueue(t.tn[1], EFFECT_USER);
+    for (const n of activeLanes) {
+        const t = e ? n.ve === e : !n.ve;
+        if (!t) continue;
+        if (!n.an) {
+            if (n.tn[0].length) runQueue(n.tn[0], EFFECT_RENDER);
+            if (n.tn[1].length) runQueue(n.tn[1], EFFECT_USER);
         }
-        if (t.an.Je === t) t.an.Je = undefined;
-        t.Pe.clear();
-        t.tn[0].length = 0;
-        t.tn[1].length = 0;
-        activeLanes.delete(t);
-        signalLanes.delete(t.an);
+        if (n.rn.Je === n) n.rn.Je = undefined;
+        n.Pe.clear();
+        n.tn[0].length = 0;
+        n.tn[1].length = 0;
+        activeLanes.delete(n);
+        signalLanes.delete(n.rn);
     }
 }
 
@@ -173,44 +181,44 @@ function cleanupCompletedLanes(e) {
     // Per-lane suspension: only throw if in same lane as pending async
     // AND the node doesn't have an active override (overrides are the visible value,
     // downstream in the lane should read the override, not throw)
-    const t = e.Je;
-    if (!t) return false;
-    return findLane(t) === findLane(currentOptimisticLane) && !hasActiveOverride(e);
+    const n = e.Je;
+    if (!n) return false;
+    return findLane(n) === findLane(currentOptimisticLane) && !hasActiveOverride(e);
 }
 
 /**
  * read()'s entanglement gate: a reader recomputing under an optimistic lane
  * that reads a pending mid-transition write sees the committed value; the sub
  * is recorded for replay at commit.
- */ function gatedRead(e, t, n) {
-    if (latestReadActive || e.ge === NOT_PENDING || e.xe || t !== e && !(t.u & REACTIVE_MANUAL_WRITE)) {
+ */ function gatedRead(e, n, t) {
+    if (latestReadActive || e.ge === NOT_PENDING || e.xe || n !== e && !(n.u & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
-    activeTransition.Qt.add(n);
+    activeTransition.un.add(t);
     return true;
 }
 
 /**
  * read()'s value selection under a lane: return the committed `_value` for
  * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
- */ function laneReadsCommitted(e, t, n) {
-    return e.be !== undefined || !!e.Je || t === e && stale && n.en !== e || !!(t.i & STATUS_PENDING);
+ */ function laneReadsCommitted(e, n, t) {
+    return e.be !== undefined || !!e.Je || n === e && stale && t.en !== e || !!(n.i & STATUS_PENDING);
 }
 
 /**
  * recompute()'s lane posture: resolve the node's own lane (own=true), or adopt
  * a dependency's optimistic lane (own=false — parent-deeper-than-owned-child
  * can run before its OPT-dirty child propagates).
- */ function recomputeLane(e, t) {
-    if (t) return resolveLane(e) ?? null;
-    for (let t = e.S; t; t = t.st) {
-        const n = t.ot;
-        if (n.u & REACTIVE_OPTIMISTIC_DIRTY) {
-            const t = resolveLane(n);
-            if (t) {
+ */ function recomputeLane(e, n) {
+    if (n) return resolveLane(e) ?? null;
+    for (let n = e.S; n; n = n.st) {
+        const t = n.ot;
+        if (t.u & REACTIVE_OPTIMISTIC_DIRTY) {
+            const n = resolveLane(t);
+            if (n) {
                 e.u |= REACTIVE_OPTIMISTIC_DIRTY;
-                assignOrMergeLane(e, t);
-                return t;
+                assignOrMergeLane(e, n);
+                return n;
             }
         }
     }
@@ -218,25 +226,25 @@ function cleanupCompletedLanes(e) {
 }
 
 /** recompute()'s catch path: track pending async in the current lane. */ function laneAsyncPending(e) {
-    const t = findLane(currentOptimisticLane);
-    if (t.an !== e) {
-        t.Pe.add(e);
-        e.Je = t;
-        GlobalQueue._ !== null && GlobalQueue._(t.an);
+    const n = findLane(currentOptimisticLane);
+    if (n.rn !== e) {
+        n.Pe.add(e);
+        e.Je = n;
+        GlobalQueue.P !== null && GlobalQueue.P(n.rn);
     }
 }
 
 /** recompute()'s success path: the node's async settled, clear it from its lane. */ function laneAsyncSettled(e) {
-    const t = resolveLane(e);
-    if (t) {
-        t.Pe.delete(e);
-        GlobalQueue._ !== null && GlobalQueue._(t.an);
+    const n = resolveLane(e);
+    if (n) {
+        n.Pe.delete(e);
+        GlobalQueue.P !== null && GlobalQueue.P(n.rn);
     }
 }
 
 function trackOptimisticStore(e) {
-    // After initTransition, globalQueue._optimisticStores IS activeTransition._optimisticStores (same reference)
-    globalQueue.Lt.add(e);
+    // After initTransition, globalQueue._batch IS activeTransition (same reference)
+    globalQueue.N.dn.add(e);
     schedule();
 }
 
@@ -247,19 +255,19 @@ function trackOptimisticStore(e) {
  */ function installOptimisticEngine() {
     if (GlobalQueue.bt !== null) return;
     GlobalQueue.bt = optimisticWrite;
-    GlobalQueue.Ut = resolveOptimisticNodes;
-    GlobalQueue.yt = stashOptimistic;
-    GlobalQueue.Wt = transitionBlocked;
-    GlobalQueue.jt = cleanupCompletedLanes;
-    GlobalQueue.Mt = runLaneEffects;
-    GlobalQueue.gt = readStashed;
-    GlobalQueue.Dt = gatedRead;
+    GlobalQueue.En = resolveOptimisticNodes;
+    GlobalQueue.Tn = stashOptimistic;
+    GlobalQueue.In = transitionBlocked;
+    GlobalQueue.Nn = cleanupCompletedLanes;
+    GlobalQueue.On = runLaneEffects;
+    GlobalQueue.Dt = readStashed;
+    GlobalQueue.gt = gatedRead;
     GlobalQueue.ht = laneSuspends;
-    GlobalQueue.kt = laneReadsCommitted;
+    GlobalQueue.vt = laneReadsCommitted;
     GlobalQueue.$e = recomputeLane;
     GlobalQueue.et = laneAsyncPending;
     GlobalQueue.Xe = laneAsyncSettled;
-    GlobalQueue.Vt = trackOptimisticStore;
+    GlobalQueue.mn = trackOptimisticStore;
 }
 
 export { installOptimisticEngine };

package/dist/prod/core/owner.js

@@ -1,4 +1,4 @@
-import { defaultContext, CONFIG_TRANSPARENT, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT } from "./constants.js";
+import { REACTIVE_DISPOSED, REACTIVE_ZOMBIE, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, CONFIG_TRANSPARENT, defaultContext } from "./constants.js";
 
 import { context, runWithOwner, pendingCheckActive, latestReadActive, tracking } from "./core.js";
 
@@ -6,13 +6,13 @@ import { unlinkSubs } from "./graph.js";
 
 import { deleteFromHeap, queueFor, insertIntoHeap, insertIntoHeapHeight } from "./heap.js";
 
-import { globalQueue, GlobalQueue, zombieQueue, dirtyQueue } from "./scheduler.js";
+import { GlobalQueue, zombieQueue, dirtyQueue, globalQueue } from "./scheduler.js";
 
 const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let n = e.Fe;
+    let n = e.He;
     while (n) {
         const e = n.u;
         n.u = e | REACTIVE_ZOMBIE;
@@ -54,7 +54,7 @@ function disposeChildren(e, n = false, t) {
         if (n.ye || n.pe) GlobalQueue.R(n);
     }
     if (n && e.xe) e.Ae = null;
-    let l = t ? e.Ze : e.Fe;
+    let l = t ? e.Ze : e.He;
     while (l) {
         const e = l.Ve;
         if (l.S) {
@@ -73,26 +73,26 @@ function disposeChildren(e, n = false, t) {
     if (t) {
         e.Ze = null;
     } else {
-        e.Fe = null;
+        e.He = null;
         e.je = 0;
     }
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // batch dispose (parent already disposed) and zombie disposal (node sits on
     // parent's _pendingFirstChild). We leave node._nextSibling intact so outer
     // walks that already advanced past us still reach later siblings.
-        if (n && !t && !(i & REACTIVE_ZOMBIE) && e.He !== null && !(e.He.u & REACTIVE_DISPOSED)) {
-        const n = e.Tt;
+        if (n && !t && !(i & REACTIVE_ZOMBIE) && e.Fe !== null && !(e.Fe.u & REACTIVE_DISPOSED)) {
+        const n = e.Nt;
         const t = e.Ve;
-        if (n !== null) n.Ve = t; else e.He.Fe = t;
-        if (t !== null) t.Tt = n;
-        e.Tt = null;
+        if (n !== null) n.Ve = t; else e.Fe.He = t;
+        if (t !== null) t.Nt = n;
+        e.Nt = null;
     }
     runDisposal(e, t);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (n && e.At) {
-        const n = e.At;
-        e.At = undefined;
+        if (n && e.dt) {
+        const n = e.dt;
+        e.dt = undefined;
         n();
     }
 }
@@ -113,7 +113,7 @@ function runDisposal(e, n) {
 
 function childId(e, n) {
     let t = e;
-    while (t.U & CONFIG_TRANSPARENT && t.He) t = t.He;
+    while (t.U & CONFIG_TRANSPARENT && t.Fe) t = t.Fe;
     if (t.id != null) return formatId(t.id, n ? t.je++ : t.je);
     throw new Error("");
 }
@@ -235,28 +235,28 @@ function disposeRootSelf(e = true) {
     const i = {
         id: inheritId(e, t, n),
         U: t ? CONFIG_TRANSPARENT : 0,
-        dt: true,
-        Ct: n?.dt ? n.Ct : n,
-        Fe: null,
+        At: true,
+        Ct: n?.At ? n.Ct : n,
+        He: null,
         Ve: null,
-        Tt: null,
+        Nt: null,
         Me: null,
         v: n?.v ?? globalQueue,
         we: n?.we || defaultContext,
         je: 0,
         We: null,
         Ze: null,
-        He: n,
+        Fe: n,
         dispose: disposeRootSelf
     };
     if (n) {
-        const e = n.Fe;
+        const e = n.He;
         if (e === null) {
-            n.Fe = i;
+            n.He = i;
         } else {
             i.Ve = e;
-            e.Tt = i;
-            n.Fe = i;
+            e.Nt = i;
+            n.He = i;
         }
     }
     return i;