@solidjs/signals 2.0.0-rc.11 → 2.0.0-rc.13

package/dist/observe/core/core.js

@@ -105,10 +105,10 @@ function releaseSnapshotScope(e) {
 }
 
 function releaseSubtree(e) {
-    let t = e._n;
+    let t = e.On;
     while (t) {
         if (t.ot) {
-            t = t.Fn;
+            t = t._n;
             continue;
         }
         if (t.Se) {
@@ -122,7 +122,7 @@ function releaseSubtree(e) {
             }
         }
         releaseSubtree(t);
-        t = t.Fn;
+        t = t._n;
     }
 }
 
@@ -155,8 +155,8 @@ function recompute(e, t = false) {
         let i = false;
     if (attrHooks !== null) attrHooks.recomputeStart(e, t);
     // Lane posture is resolved BEFORE the previous frame is parked below: a
-    // lane pass on an effect direct-commits (#3662, see the parking site), so
-    // the decision must be known there. `lane` is applied to
+    // lane pass parks a lane frame, not a transaction zombie (#3662, #3698;
+    // see the parking site), so the decision must be known there. `lane` is applied to
     // `currentOptimisticLane` further down, once the previous posture is saved.
         let l = !!(e.oe & REACTIVE_OPTIMISTIC_DIRTY);
     let u = null;
@@ -204,29 +204,39 @@ function recompute(e, t = false) {
         // Tracked effects run after finalizePureQueue, so dispose immediately
         // instead of deferring. Children built by an uncommitted recompute
         // (CONFIG_HELD_CHILDREN) die immediately too: no frame ever showed them.
-        // Everything else is the committed frame's and is deferred as zombies
-        // until this node's commit — a transaction-owned node included (#3404):
-        // a parked node's children predate the hold, and tearing them down when
-        // the source lands ran cleanups before the transaction's atomic reveal.
-        // A lane pass on an effect parks a LANE frame instead (CONFIG_LANE_FRAME,
-        // #3662; A15 lanes corollary): the frame it replaces leaves the screen
-        // when the lane's queue applies this run (A30) — not at the action's
-        // commit — and a held lane defers that with the frame still displayed.
-        // The drain is the lane's first render entry for this pass, pushed before
-        // the pass builds the new frame: cleanups before side effects — the
-        // retired frame's `onCleanup`s run ahead of every effect callback of the
-        // new frame. While the frame waits, the live children were never shown:
-        // a superseding pass disposes them here like held children, and the
-        // parked frame stays.
-                if (n === EFFECT_TRACKED || e.C & (CONFIG_HELD_CHILDREN | CONFIG_LANE_FRAME)) disposeChildren(e); else if (e._n !== null || e.Ve !== null) {
+        // Everything else is the committed frame's. Which frame retires it is
+        // decided by who owns the pass, never by the node's kind (A15 lane work
+        // and transaction work, ruled 2026-09-28, #3698). Transaction work — a
+        // pass under a held transaction — defers them as zombies until this
+        // node's commit, a transaction-owned node included (#3404): a parked
+        // node's children predate the hold, and tearing them down when the
+        // source lands ran cleanups before the transaction's atomic reveal.
+        // Lane work — a pass over a lane, effect or memo alike — parks a LANE
+        // frame instead (CONFIG_LANE_FRAME, #3662, #3698): the frame it replaces
+        // leaves the screen when the lane's queue applies this pass (A30) — not
+        // at the action's commit — and a held lane defers that with the frame
+        // still displayed. The drain is the lane's first render entry for this
+        // pass, pushed before the pass builds the new frame: cleanups before
+        // side effects — the retired frame's `onCleanup`s run ahead of every
+        // effect callback of the new frame. While the frame waits, the live
+        // children were never shown: a superseding pass disposes them here like
+        // held children, and the parked frame stays. Zombies exist for
+        // transaction work only: #3662 gated the lane frame on `isEffect`, and a
+        // memo's lane pass (its value a derived override, A17) parked a
+        // transaction zombie that made the memo a pending node of the action,
+        // stamped it, and sent its next mainline recompute through the
+        // stamped-memo arm above — a `Show` whose `when` getter owns a
+        // compiler-emitted memo held an unrelated sync write for the action's
+        // lifetime, against the #3460 ruling that a lane never holds a sync write.
+                if (n === EFFECT_TRACKED || e.C & (CONFIG_HELD_CHILDREN | CONFIG_LANE_FRAME)) disposeChildren(e); else if (e.On !== null || e.Ve !== null) {
             markDisposal(e);
             const t = ext(e);
             t.Et = e.Ve;
-            t.dt = e._n;
+            t.dt = e.On;
             e.Ve = null;
-            e._n = null;
+            e.On = null;
             e.Nt = 0;
-            if (n && u) {
+            if (u) {
                 e.C |= CONFIG_LANE_FRAME;
                 findLane(u).It[0].push(() => {
                     e.C &= ~CONFIG_LANE_FRAME;
@@ -798,9 +808,9 @@ function computed(e, t) {
         u: null,
         Ht: null,
         _parent: context,
-        Fn: null,
-        kt: null,
         _n: null,
+        kt: null,
+        On: null,
         oe: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         S: i ? 0 : STATUS_UNINITIALIZED,
         Ge: clock,
@@ -880,9 +890,9 @@ function computed(e, t) {
         u: null,
         Ht: null,
         _parent: context,
-        Fn: null,
-        kt: null,
         _n: null,
+        kt: null,
+        On: null,
         oe: REACTIVE_LAZY,
         S: STATUS_UNINITIALIZED,
         Ge: clock,
@@ -1398,7 +1408,7 @@ function enterStagedRead(e, t = e.me) {
  * False means the reader derives from the staged value and enters its
  * transaction (enterStagedRead, A29).
  */ function readerSeesCommitted(e, t, n, i) {
-    return !!(!t || currentOptimisticLane !== null && GlobalQueue.On(e, n, t) || e._e === NOT_PENDING || t.C & CONFIG_CHILDREN_FORBIDDEN || stale && !i && heldFromStale(e, t) || e.C & CONFIG_HELD_TRUTH && currentOptimisticLane !== null && !latestReadActive && !(t.C & CONFIG_AUTHORITATIVE_READ));
+    return !!(!t || currentOptimisticLane !== null && GlobalQueue.An(e, n, t) || e._e === NOT_PENDING || t.C & CONFIG_CHILDREN_FORBIDDEN || stale && !i && heldFromStale(e, t) || e.C & CONFIG_HELD_TRUTH && currentOptimisticLane !== null && !latestReadActive && !(t.C & CONFIG_AUTHORITATIVE_READ));
 }
 
 /** A28 — set when a node is staged (queuePendingNode) or a held node rewritten
@@ -1522,7 +1532,7 @@ function read(e) {
     // Checked before isPending so that isPending(() => latest(x)) checks
     // the _pendingSignal of _latestValueComputed (async in flight) rather
     // than the original node (which stays "pending" while held in a transition).
-    if (latestReadActive) return GlobalQueue.An(e);
+    if (latestReadActive) return GlobalQueue.Cn(e);
     let t = context;
     if (t?.Zt) t = t.Yt;
     const n = e;
@@ -1532,7 +1542,7 @@ function read(e) {
     // Probe mode is suspended while preparing the node so nested reads during a
     // recompute don't collect into the probe.
         if (pendingCheckActive) {
-        GlobalQueue.Cn(e, t, l, i);
+        GlobalQueue.Rn(e, t, l, i);
     } else if (typeof n.Se === "function") {
         prepareComputed(e, false);
     }
@@ -1584,13 +1594,13 @@ function read(e) {
         // (firewall-backed store reads always did; plain memos since the #3043
         // port): falling through served `undefined` as if settled and stranded
         // the reader outside both transactions, so it never re-ran.
-        if (t && !(stale && !(l.S & STATUS_UNINITIALIZED) && !(l.C & CONFIG_INPUTS_PUBLISHED) && !(l.C & CONFIG_HAS_LANE && GlobalQueue.Rn(l)) && heldFromStale(l, t))) {
+        if (t && !(stale && !(l.S & STATUS_UNINITIALIZED) && !(l.C & CONFIG_INPUTS_PUBLISHED) && !(l.C & CONFIG_HAS_LANE && GlobalQueue.Gn(l)) && heldFromStale(l, t))) {
             // Per-lane suspension lives with the engine (a non-null lane implies it
             // is installed): under a lane, only same-lane pending async without an
             // active override throws — plus uninitialized sources regardless of
             // lane (#3276); that check rides laneSuspends so floor bundles don't
             // pay for it.
-            if (currentOptimisticLane === null || GlobalQueue.Gn(l)) {
+            if (currentOptimisticLane === null || GlobalQueue.Dn(l)) {
                 // An untracked read of a pending node still re-runs its reader when
                 // the node settles — unless nobody is reading (`spectating`, #3528)
                 // or the reader is the node itself.
@@ -1694,7 +1704,7 @@ function read(e) {
             // a node whose own source answered with a DIFFERENT value hands a
             // tracked reader the staged truth (A18 supersession, #3331). Untracked
             // reads display the override.
-            if (t && e.C & (CONFIG_HAS_LANE | CONFIG_OVERRIDE_SUPERSEDED)) return GlobalQueue.Dn(e, t);
+            if (t && e.C & (CONFIG_HAS_LANE | CONFIG_OVERRIDE_SUPERSEDED)) return GlobalQueue.Pn(e, t);
             return unwrapOverride(e.o?.we);
         }
         e.C |= CONFIG_AUTHORITATIVE_OBSERVED;
@@ -1706,7 +1716,7 @@ 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.Pn(e, n, t)) {
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Fn(e, n, t)) {
         return i;
     }
     // In optimistic lane context, return _value for optimistic/lane-assigned signals

package/dist/observe/core/dev.js

@@ -68,20 +68,31 @@ function recordsChannel() {
     const e = globalThis;
     if (e[RECORDS]) return e[RECORDS];
     const n = new Map;
+    const t = new Map;
     return e[RECORDS] = {
-        subscribe(e, t) {
-            const o = n.get(e);
-            // Set semantics: one entry per function, however often it is passed.
-                        if (o === undefined) n.set(e, [ t ]); else if (!o.includes(t)) n.set(e, [ ...o, t ]);
+        subscribe(e, o, r) {
+            const i = n.get(e);
+            // Set semantics: one entry per function, however often it is passed —
+            // the first subscription's options stand for it.
+                        if (i === undefined || !i.includes(o)) {
+                n.set(e, i === undefined ? [ o ] : [ ...i, o ]);
+                if (r !== undefined && r.bodies) {
+                    let n = t.get(e);
+                    if (n === undefined) t.set(e, n = new Set);
+                    n.add(o);
+                }
+            }
             return () => {
-                const o = n.get(e);
-                if (o === undefined) return;
-                const r = o.filter(e => e !== t);
-                if (r.length > 0) n.set(e, r); else n.delete(e);
+                const r = n.get(e);
+                if (r === undefined || !r.includes(o)) return;
+                const i = r.filter(e => e !== o);
+                if (i.length > 0) n.set(e, i); else n.delete(e);
+                const s = t.get(e);
+                if (s !== undefined && s.delete(o) && s.size === 0) t.delete(e);
             };
         },
-        observed(e) {
-            return n.has(e);
+        observed(e, o) {
+            return o === "bodies" ? t.has(e) : n.has(e);
         },
         emit(e, t, o) {
             const r = n.get(e);
@@ -108,9 +119,14 @@ const OBSERVE = {
     // empty HERE and gains its members by augmentation downstream.
     server: {},
     exclude(e) {
-        excludedOwners.add(e);
+        markedOwners.set(e, true);
         hasExclusions = true;
     },
+    include(e) {
+        // No flag flip: with nothing excluded there is nothing to re-admit,
+        // and the walk stays short-circuited.
+        markedOwners.set(e, false);
+    },
     isExcluded: isExcluded,
     ownerPath: ownerPath
 };
@@ -119,9 +135,13 @@ const OBSERVE = {
 
 // An observer that lives inside the observed app (an adapter's panel,
 // devtools) marks its root; both channels check the subject's owner chain —
-// the same walk `ownerPath` already makes — and stay silent under it. The
-// flag short-circuits the walk for the common case of no exclusions.
-const excludedOwners = new WeakSet;
+// the same walk `ownerPath` already makes — and stay silent under it. An
+// observer that WRAPS the app (a toolbar around it) excludes its own root
+// and includes the app's back: one map, `true` excluded / `false` included,
+// and the nearest marker up the chain decides. The flag short-circuits the
+// walk for the common case of no exclusions (an include with nothing
+// excluded changes no verdict, so it does not flip it).
+const markedOwners = new WeakMap;
 
 let hasExclusions = false;
 
@@ -130,7 +150,10 @@ let hasExclusions = false;
 function isExcluded(e) {
     if (!hasExclusions || !e) return false;
     let n = "_parent" in e ? e : e.ie ?? null;
-    for (;n !== null; n = n._parent) if (excludedOwners.has(n)) return true;
+    for (;n !== null; n = n._parent) {
+        const e = markedOwners.get(n);
+        if (e !== undefined) return e;
+    }
     return false;
 }
 

package/dist/observe/core/optimistic.js

@@ -653,13 +653,13 @@ function trackOptimisticStore(e) {
     GlobalQueue.Kn = runLaneEffects;
     GlobalQueue.Qe = supersedeOverride;
     GlobalQueue.zn = endOptimism;
-    GlobalQueue.Dn = overrideRead;
+    GlobalQueue.Pn = overrideRead;
     GlobalQueue.je = laneOverride;
     GlobalQueue.Vn = landOnOverride;
-    GlobalQueue.Pn = gatedRead;
-    GlobalQueue.Gn = laneSuspends;
-    GlobalQueue.Rn = laneLive;
-    GlobalQueue.On = laneReadsCommitted;
+    GlobalQueue.Fn = gatedRead;
+    GlobalQueue.Dn = laneSuspends;
+    GlobalQueue.Gn = laneLive;
+    GlobalQueue.An = laneReadsCommitted;
     GlobalQueue._t = recomputeLane;
     GlobalQueue.Ot = laneAsyncPending;
     GlobalQueue.St = laneAsyncSettled;

package/dist/observe/core/owner.js

@@ -14,7 +14,7 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let n = e._n;
+    let n = e.On;
     while (n) {
         const e = n.oe;
         n.oe = e | REACTIVE_ZOMBIE;
@@ -28,7 +28,7 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(n, zombieQueue); else insertIntoHeapHeight(n, zombieQueue);
         }
         markDisposal(n);
-        n = n.Fn;
+        n = n._n;
     }
 }
 
@@ -76,8 +76,8 @@ function disposeChildren(e, n = false, t) {
         schedule();
     }
     if (n && e.Se && e.o !== null) e.o.pe = null;
-    let o = t ? e.o?.dt ?? null : e._n;
-    if (!t) e._n = null;
+    let o = t ? e.o?.dt ?? null : e.On;
+    if (!t) e.On = null;
     while (o) {
         const e = o;
         // Owner teardown is death regardless of the child's own lifecycle
@@ -107,7 +107,7 @@ function disposeChildren(e, n = false, t) {
         // itself out of the detached chain, and a cleanup may then have linked
         // it at the fresh head, which rewrote the `_nextSibling` a pre-read
         // would still be holding.
-                o = o.Fn;
+                o = o._n;
     }
     if (t) {
         if (e.o !== null) e.o.dt = null;
@@ -118,8 +118,8 @@ function disposeChildren(e, n = false, t) {
     // walks that already advanced past us still reach later siblings.
         if (n && !t && !(i & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.oe & REACTIVE_DISPOSED)) {
         const n = e.kt;
-        const t = e.Fn;
-        if (n !== null) n.Fn = t; else e._parent._n = t;
+        const t = e._n;
+        if (n !== null) n._n = t; else e._parent.On = t;
         if (t !== null) t.kt = n;
         e.kt = null;
     }
@@ -134,11 +134,11 @@ function disposeChildren(e, n = false, t) {
 }
 
 function linkChild(e, n) {
-    const t = e._n;
+    const t = e.On;
     n.kt = null;
-    n.Fn = t;
+    n._n = t;
     if (t !== null) t.kt = n;
-    e._n = n;
+    e.On = n;
 }
 
 function runDisposal(e, n) {
@@ -295,8 +295,8 @@ function disposeRootSelf(e = true) {
         C: t ? CONFIG_TRANSPARENT : 0,
         Zt: true,
         Yt: n?.Zt ? n.Yt : n,
+        On: null,
         _n: null,
-        Fn: null,
         kt: null,
         Ve: null,
         T: n?.T ?? globalQueue,

package/dist/observe/core/scheduler.js

@@ -554,8 +554,8 @@ class GlobalQueue extends Queue {
     static Ue=null;
     static qe=null;
     static Qn=null;
-    static An=null;
     static Cn=null;
+    static Rn=null;
     static Hn=null;
     static At=null;
     static k=null;
@@ -579,14 +579,14 @@ class GlobalQueue extends Queue {
      * apply at lane-effect timing — visible in flight, unlike the regular
      * effect queues an action stashes. Injected; null when unused. */
     static Zn=null;
-    static Pn=null;
-    static Gn=null;
+    static Fn=null;
+    static Dn=null;
     /** Is the node routed through a LIVE lane (`resolveLane`)? read()'s reveal
      * carve-out asks before showing a foreign-held pending node's committed
      * value: a lane-derived flight's inputs are already revealed through the
      * lane (#3334). Gated on CONFIG_HAS_LANE, which only the engine sets. */
-    static Rn=null;
-    static On=null;
+    static Gn=null;
+    static An=null;
     static _t=null;
     static Ot=null;
     /** Authoritative-view reader wakeup: installed by until() and refresh() before
@@ -618,7 +618,7 @@ class GlobalQueue extends Queue {
      * transaction's committed value over its staged write. */
     /** A tracked read of an active override: the lane outside-view rule
      * (#3460) and the A18 supersession selection (#3331) — see optimistic.ts. */
-    static Dn=null;
+    static Pn=null;
     /** A lane pass's publish for a memo (#3479, lanes stage): the speculative
      * result becomes a DERIVED override, `_value` stays committed — see
      * optimistic.ts laneOverride. Set with the engine, which a lane implies. */

package/dist/observe/core/verdict.js

@@ -657,9 +657,9 @@ GlobalQueue.qe = updateChildCompanions;
 
 GlobalQueue.Qn = snapCompanionsToState;
 
-GlobalQueue.An = latestRead;
+GlobalQueue.Cn = latestRead;
 
-GlobalQueue.Cn = pendingCheckRead;
+GlobalQueue.Rn = pendingCheckRead;
 
 GlobalQueue.Hn = recordFreshRead;