@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.4

package/dist/prod/affects.js

@@ -1,6 +1,6 @@
 import { forEachDependent } from "./core/async.js";
 
-import { ext } from "./core/core.js";
+import { ext, statusNotifierOf } from "./core/core.js";
 
 import { $REFRESH, STATUS_PENDING } from "./core/constants.js";
 
@@ -40,17 +40,18 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
  * flush that would surface them, before effects run — verdict-only, netting
  * no visual change.
  */ function notifyMarkBoundaries(e) {
-    if (!e.u && !e.o?.l) return;
+    if (!e.u && !e.o?.i) return;
     const r = new NotReadyError(e);
-    r.i = true;
+    r.l = true;
     const t = new Set;
     const visit = e => {
         if (t.has(e)) return;
         t.add(e);
         // Display consumers (render effects, boundary computeds) act on the
         // notification; descent stops there, exactly like the status rails.
-                if (e.o?.A) {
-            e.o.A.call(e, STATUS_PENDING, r);
+                const o = statusNotifierOf(e);
+        if (o) {
+            o.call(e, STATUS_PENDING, r);
             return;
         }
         forEachDependent(e, visit);
@@ -68,10 +69,10 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
  * earlier overlapping registration get covered, and dedup stops re-descent.
  */ function registerAffectsMark(e) {
     markAffects(e);
-    globalQueue.k.m.push(e);
+    globalQueue.m.A.push(e);
     // Companions only exist once the verdict layer (isPending/latest) loaded;
     // without them there is no materialized verdict to poke.
-        GlobalQueue.p !== null && GlobalQueue.p(e);
+        GlobalQueue.k !== null && GlobalQueue.k(e);
     notifyMarkBoundaries(e);
     schedule();
 }
@@ -85,8 +86,8 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
     shiftAffectsMarks(-1);
     e.o.t--;
     if (!e.o.t) {
-        GlobalQueue.p !== null && GlobalQueue.p(e, true);
-        GlobalQueue.G?.(e);
+        GlobalQueue.k !== null && GlobalQueue.k(e, true);
+        GlobalQueue.p?.(e);
     }
 }
 
@@ -103,11 +104,11 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
 // Each call site is gated by state only this module creates (a non-empty
 // `_affectsNodes` batch, a live scope in the store's `affectsScopes`), so the
 // hooks are installed before the first time any of them can fire.
-GlobalQueue.M = releaseAffectsMarks;
+GlobalQueue.G = releaseAffectsMarks;
 
-GlobalQueue.h = markAffects;
+GlobalQueue.M = markAffects;
 
-GlobalQueue.j = releaseAffectsMark;
+GlobalQueue.N = releaseAffectsMark;
 
 function affects(e, r) {
     const t = e?.[$TARGET];

package/dist/prod/boundaries.js

@@ -22,7 +22,7 @@ function boundaryComputed(e, t) {
     const r = computed(e, {
         lazy: true
     });
-    ext(r).A = (e, t) => {
+    ext(r).h = (e, t) => {
         // Use passed values if provided, otherwise read from node
         const n = e !== undefined ? e : r.S;
         const s = t !== undefined ? t : r.o?._;
@@ -80,18 +80,18 @@ function isRevealController(e) {
 }
 
 function isSlotReady(e) {
-    return isRevealController(e) ? e.O() : e.v.size === 0 && !e.N;
+    return isRevealController(e) ? e.O() : e.v.size === 0 && !e.U;
 }
 
 function isSlotMinimallyReady(e) {
-    return isRevealController(e) ? e.U() : isSlotReady(e);
+    return isRevealController(e) ? e.I() : isSlotReady(e);
 }
 
 function setSlotState(e, t, r, n) {
-    setSignal(e.I, r);
-    setSignal(e.D, n);
+    setSignal(e.D, r);
+    setSignal(e.P, n);
     if (isRevealController(e)) {
-        if (!r && e.P === t) e.P = undefined;
+        if (!r && e.j === t) e.j = undefined;
         return e.B(r, n);
     }
     if (!r && e.W === t && e.L) e.W = undefined;
@@ -101,12 +101,12 @@ class RevealController {
     F;
     q;
     V=[];
-    P;
-    I=signal(false, {
+    j;
+    D=signal(false, {
         ownedWrite: true,
         H: true
     });
-    D=signal(false, {
+    P=signal(false, {
         ownedWrite: true,
         H: true
     });
@@ -120,7 +120,7 @@ class RevealController {
     Y(e) {
         for (let t = 0; t < this.V.length; t++) {
             const r = this.V[t];
-            if ((isRevealController(r) ? r.P : r.W) !== this) continue;
+            if ((isRevealController(r) ? r.j : r.W) !== this) continue;
             if (e(r) === false) return false;
         }
         return true;
@@ -134,7 +134,7 @@ class RevealController {
      * - `together`: every direct slot is minimally ready.
      * - `sequential`: the first owned slot is minimally ready (frontier can advance).
      * - `natural`: any owned slot is minimally ready.
-     */    U() {
+     */    I() {
         const e = untrack(this.F);
         if (e === "together") return this.Y(isSlotMinimallyReady);
         if (e === "natural") {
@@ -161,7 +161,7 @@ class RevealController {
         if (this.V.includes(e)) return;
         this.V.push(e);
         const t = untrack(this.F);
-        setSignal(e.I, true), setSignal(e.D, t === "sequential" ? !!untrack(this.q) : false);
+        setSignal(e.D, true), setSignal(e.P, t === "sequential" ? !!untrack(this.q) : false);
         untrack(() => this.B());
     }
     $(e) {
@@ -175,7 +175,7 @@ class RevealController {
         const r = this.J;
         const n = this.K;
         try {
-            const r = e ?? read(this.I), n = untrack(this.F), s = n === "sequential" && !!untrack(this.q), i = t ?? s;
+            const r = e ?? read(this.D), n = untrack(this.F), s = n === "sequential" && !!untrack(this.q), i = t ?? s;
             if (r) {
                 // Held by an outer group. Propagate the hold (and whatever collapsed policy
                 // the outer asked for) down the whole subtree. Inner order is ignored while
@@ -187,8 +187,8 @@ class RevealController {
                 // so the parent backpointer survives for upward readiness notifications.
                 this.Y(e => {
                     if (isRevealController(e)) {
+                        setSignal(e.P, false);
                         setSignal(e.D, false);
-                        setSignal(e.I, false);
                         e.B(false, false);
                     } else {
                         setSlotState(e, this, !isSlotReady(e), false);
@@ -215,8 +215,8 @@ class RevealController {
                     // advancing past this slot, and we bypass setSlotState so the parent
                     // backpointer survives for upward readiness notifications.
                                         if (isRevealController(t)) {
+                        setSignal(t.P, false);
                         setSignal(t.D, false);
-                        setSignal(t.I, false);
                         t.B(false, false);
                     } else {
                         setSlotState(t, this, true, false);
@@ -225,10 +225,10 @@ class RevealController {
             }
         } finally {
             this.J = this.O();
-            this.K = this.U();
+            this.K = this.I();
             this.X = false;
         }
-        if (this.P && (r !== this.J || n !== this.K)) this.P.B();
+        if (this.j && (r !== this.J || n !== this.K)) this.j.B();
     }
 }
 
@@ -236,13 +236,13 @@ class CollectionQueue extends Queue {
     ee;
     v=new Set;
     te;
-    N=true;
-    I=signal(false, {
+    U=true;
+    D=signal(false, {
         ownedWrite: true,
         H: true
     });
     _;
-    D=signal(false, {
+    P=signal(false, {
         ownedWrite: true,
         H: true
     });
@@ -255,7 +255,7 @@ class CollectionQueue extends Queue {
         this.ee = e;
     }
     run(e) {
-        if (!e || read(this.I) && (!_revealUsed || read(this.D))) return;
+        if (!e || read(this.D) && (!_revealUsed || read(this.P))) return;
         return super.run(e);
     }
     notify(e, t, r, n) {
@@ -286,12 +286,12 @@ class CollectionQueue extends Queue {
         // (the Loading > Errored > content composition escape, #2856).
                 if (this.ee & STATUS_PENDING && this.L) return super.notify(e, t, r, n);
         if (r & this.ee) {
-            this.N = true;
+            this.U = true;
             const t = n?.source || e.o?._?.source;
             if (t) {
                 const e = this.v.size === 0;
                 this.v.add(t);
-                if (e) setSignal(this.I, true);
+                if (e) setSignal(this.D, true);
                 if (this.ee & STATUS_ERROR) {
                     setSignal(this._, unwrapStatusError(t.o?._));
                 }
@@ -309,13 +309,13 @@ class CollectionQueue extends Queue {
             if (e.ie & REACTIVE_DISPOSED || !e.o?.t && !(e.S & this.ee) && !(this.ee & STATUS_ERROR && e.S & STATUS_PENDING)) this.v.delete(e);
         }
         if (!this.v.size) {
-            if (this.ee & STATUS_PENDING && this.N && !this.L && this.te) {
-                this.N = !!(this.te.S & this.ee);
+            if (this.ee & STATUS_PENDING && this.U && !this.L && this.te) {
+                this.U = !!(this.te.S & this.ee);
             } else {
-                this.N = false;
+                this.U = false;
             }
-            if (!this.N) {
-                setSignal(this.I, false);
+            if (!this.U) {
+                setSignal(this.D, false);
                 if (this.re) {
                     try {
                         this.ne = untrack(() => this.re());
@@ -346,7 +346,7 @@ function createCollectionBoundary(e, t, r, n) {
         } catch (e) {
             if (e instanceof NotReadyError) t = true; else throw e;
         }
-        i.N = t || !!(o.S & e) || o.o?._ instanceof NotReadyError;
+        i.U = t || !!(o.S & e) || o.o?._ instanceof NotReadyError;
     });
     const l = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (l) {
@@ -355,14 +355,14 @@ function createCollectionBoundary(e, t, r, n) {
         cleanup(() => l.$(i));
     }
     return accessor(computed(() => {
-        if (!read(i.I)) {
+        if (!read(i.D)) {
             const e = read(o);
-            if (!untrack(() => read(i.I))) return i.L = true, e;
+            if (!untrack(() => read(i.D))) return i.L = true, e;
         }
         // Collapsed reveal slots suppress their own output entirely; the
         // renderer treats the hole as empty, so the cast never leaks to users
         // outside a `createRevealOrder` scope.
-                if (_revealUsed && read(i.D)) return undefined;
+                if (_revealUsed && read(i.P)) return undefined;
         return r(i);
     }, 
     // Boundary structure, not a user source: its value is fallback-or-content and
@@ -424,7 +424,12 @@ function createCollectionBoundary(e, t, r, n) {
  * ```
  */ function createErrorBoundary(e, t) {
     return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e._), () => {
-        for (const t of e.v) recompute(t);
+        for (const t of e.v) {
+            // Non-computed sources (patch-channel registrations under plain
+            // owners) are not recomputable — their reset is the record's next
+            // transition re-applying the patch (re-audit 2, P1-4).
+            if (t.oe !== undefined) recompute(t);
+        }
         schedule();
     }));
 }
@@ -484,7 +489,7 @@ function createCollectionBoundary(e, t, r, n) {
             o.B();
         });
         if (n) {
-            o.P = n;
+            o.j = n;
             n.Z(o);
             cleanup(() => n.$(o));
         }

package/dist/prod/core/action.js

@@ -78,11 +78,11 @@ function restoreTransition(e, r) {
         const i = e(...r);
         globalQueue.initTransition();
         let o = activeTransition;
-        o.oe.push(i);
+        o.ue.push(i);
         const done = (e, r, u = false) => {
             o = currentTransition(o);
-            const s = o.oe.indexOf(i);
-            if (s >= 0) o.oe.splice(s, 1);
+            const s = o.ue.indexOf(i);
+            if (s >= 0) o.ue.splice(s, 1);
             // Re-adopt through initTransition like every other resumption site:
             // a bare setActiveTransition leaves globalQueue._batch as a detached
             // ambient batch, and anything registered before the scheduled flush

package/dist/prod/core/async.js

@@ -1,6 +1,6 @@
 import { STATUS_UNINITIALIZED, CONFIG_CHILD_COMPANIONS, STATUS_ERROR, STATUS_PENDING, REACTIVE_DIRTY, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_DISPOSED } from "./constants.js";
 
-import { untrack, ext, setSignal, context } from "./core.js";
+import { untrack, ext, statusNotifierOf, setSignal, context } from "./core.js";
 
 import "./invariants.js";
 
@@ -45,7 +45,7 @@ function clearPendingSources(e) {
  * with NO read-visible pending status, no downstream propagation, no
  * transition, no lane registration. Commit #0 keeps serving.
  */ function parkLoadingWindow(e, n) {
-    ext(e).ue = true;
+    ext(e).fe = true;
     if (n.source) addPendingSource(e, n.source);
     // A settled error is the node's answer ("the error stays the answer until
     // this retry can actually run") — the park must not replace it: reads
@@ -70,10 +70,10 @@ function setPendingError(e, n, t) {
 }
 
 function forEachDependent(e, n) {
-    for (let t = e.u; t !== null; t = t.fe) n(t.ae, t);
+    for (let t = e.u; t !== null; t = t.ae) n(t.ce, t);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-        for (let t = e.o?.l ?? null; t !== null; t = t.ce) {
-        for (let e = t.u; e !== null; e = e.fe) n(e.ae, e);
+        for (let t = e.o?.i ?? null; t !== null; t = t.Se) {
+        for (let e = t.u; e !== null; e = e.ae) n(e.ce, e);
     }
 }
 
@@ -88,7 +88,7 @@ function forEachDependent(e, n) {
 // callbacks handle their own release (settleAutodispose in handleAsync); this
 // covers derivatively-pending dependents, which have no callbacks of their own.
 function releaseIfSettledUnobserved(e) {
-    e.Se && e.T & CONFIG_AUTO_DISPOSE && !e.u && !(e.ie & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+    e.oe && e.T & CONFIG_AUTO_DISPOSE && !e.u && !(e.ie & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
 }
 
 // Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
@@ -149,25 +149,25 @@ function settlePendingSource(e) {
         if (r.has(l) || !removePendingSource(l, e)) return;
         r.add(l);
         l.Te = clock;
-        const u = l.o?.le?.values().next().value;
+        const i = l.o?.le?.values().next().value;
         // STATUS_ERROR + pending sources only coexist via an errored loading
         // window's park (notifyStatus(STATUS_ERROR) clears pending sources
         // otherwise): the settled error stays the answer through the settle —
         // nulling it here would have reads throw `null` until the re-enqueued
         // retry lands, or lose it entirely if that retry parks again (#2989).
-                const i = l.S & STATUS_ERROR;
-        if (u) {
-            if (!i) setPendingError(l, u);
+                const u = l.S & STATUS_ERROR;
+        if (i) {
+            if (!u) setPendingError(l, i);
             o !== null && o(l);
         } else {
             l.S &= ~STATUS_PENDING;
-            if (!i) setPendingError(l);
+            if (!u) setPendingError(l);
             o !== null && o(l);
-            if (l.o?.ue) {
+            if (l.o?.fe) {
                 enqueueSub(l);
                 n = true;
             }
-            if (l.o !== null) l.o.ue = false;
+            if (l.o !== null) l.o.fe = false;
             // Fully settled with nobody watching: release candidate (#2934). Checked
             // again at release time — deferred so unobserved() can't unlink subs
             // lists this walk is still iterating.
@@ -256,8 +256,8 @@ function handleAsync(e, n, t) {
         const l = !!(e.S & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
-        const u = resolveLane(e);
-        if (u) u.Ae.delete(e);
+        const i = resolveLane(e);
+        if (i) i.Ae.delete(e);
         if (t) {
             t(r);
             if (l) clearStatus(e, true);
@@ -285,7 +285,7 @@ function handleAsync(e, n, t) {
                 insertSubs(e);
             }
             e.Te = clock;
-        } else if (u) {
+        } else if (i) {
             // Route through lane's effect queue for independent flushing
             const n = e.Re;
             const t = e.be;
@@ -355,12 +355,12 @@ function handleAsync(e, n, t) {
     // meaningful only in the live posture.
         const consumeIterator = (t, r) => {
         const o = t[Symbol.asyncIterator]();
-        let u = false;
         let i = false;
+        let u = false;
         let s = !r;
         const close = () => {
-            if (i) return;
-            i = true;
+            if (u) return;
+            u = true;
             try {
                 const e = o.return?.();
                 if (isThenable(e)) e.then(undefined, () => {});
@@ -395,15 +395,15 @@ function handleAsync(e, n, t) {
                 if (c && s) {
                     t = r;
                     f = true;
-                    if (r.done) i = true;
+                    if (r.done) u = true;
                 } else if (e.o?.Ee !== n) {
                     return;
                 } else if (!r.done) {
-                    u = true;
+                    i = true;
                     asyncWrite(r.value, iterateOrRelease);
                 } else {
-                    i = true;
-                    if (u) {
+                    u = true;
+                    if (i) {
                         schedule();
                         flush();
                     } else {
@@ -417,7 +417,7 @@ function handleAsync(e, n, t) {
                     r = t;
                     a = true;
                 } else if (e.o?.Ee === n) {
-                    i = true;
+                    u = true;
                     handleError(t);
                     settleAutodispose();
                 }
@@ -425,14 +425,14 @@ function handleAsync(e, n, t) {
             c = false;
             if (a) {
                 // Match the promise branch, but only rethrow during the initial read.
-                i = true;
+                u = true;
                 handleError(r);
                 if (s) throw r;
                 return true;
             }
             if (f && !t.done) {
                 l = t.value;
-                u = true;
+                i = true;
                 return iterate();
             }
             return f && t.done;
@@ -440,12 +440,12 @@ function handleAsync(e, n, t) {
         const f = iterate();
         // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
                 s = false;
-        return u || f;
+        return i || f;
     };
     // Landed-synchronously verdict for a LIVE iterator drain; null when no live
     // drain ran (plain promise flight, or a deferred flatten). Drives the
     // shared NotReady/loading tail below.
-        let u = null;
+        let i = null;
     // Flatten one async level: a thenable that RESOLVES to an AsyncIterable —
     // the shape every async stub returning a stream produces — consumes as the
     // stream itself rather than settling on the iterable object. One level
@@ -460,11 +460,11 @@ function handleAsync(e, n, t) {
         }
         if (!t) return false;
         const r = consumeIterator(e, n);
-        if (!n) u = r;
+        if (!n) i = r;
         return true;
     };
     if (o) {
-        let t = false, r = false, o, u = true;
+        let t = false, r = false, o, i = true;
         // Close registration for the flattening path. Consumption starts in a
         // microtask where the ambient owner is gone (or worse, someone else's),
         // so `cleanup()` can't be used — the close targets el's disposal list
@@ -479,7 +479,7 @@ function handleAsync(e, n, t) {
             if (!e.he) e.he = n; else if (Array.isArray(e.he)) e.he.push(n); else e.he = [ e.he, n ];
         };
         n.then(r => {
-            if (u) {
+            if (i) {
                 l = r;
                 t = true;
             } else if (e.o?.Ee === n && !(e.ie & REACTIVE_DISPOSED) && flattenIfIterable(r, registerDeferredClose)) ; else {
@@ -487,7 +487,7 @@ function handleAsync(e, n, t) {
                 settleAutodispose();
             }
         }, e => {
-            if (u) {
+            if (i) {
                 o = e;
                 r = true;
             } else {
@@ -495,7 +495,7 @@ function handleAsync(e, n, t) {
                 settleAutodispose();
             }
         });
-        u = false;
+        i = false;
         if (r) {
             // Settle through the same status path an async rejection uses, then
             // unwind the in-progress synchronous read so the errored node isn't
@@ -519,8 +519,8 @@ function handleAsync(e, n, t) {
         // apply and the shared tail below settles the verdict.
         }
     if (r) flattenIfIterable(n);
-    if (u !== null) {
-        if (!u) {
+    if (i !== null) {
+        if (!i) {
             // Loading window: serve commit #0 (see the promise branch above).
             if (e.Ie) return e.be;
             globalQueue.initTransition(resolveTransition(e));
@@ -535,7 +535,7 @@ function handleAsync(e, n, t) {
 
 function clearStatus(e, n = false) {
     if (e.o?.le) clearPendingSources(e);
-    if (e.o?.ue) if (e.o !== null) e.o.ue = false;
+    if (e.o?.fe) if (e.o !== null) e.o.fe = false;
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
@@ -545,17 +545,18 @@ function clearStatus(e, n = false) {
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
         if (e.o?.Ge || e.o?.ge) GlobalQueue.de(e);
-    if (e.o?.l && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
-    if (e.o?.A) e.o.A.call(e);
+    if (e.o?.i && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
+    const t = statusNotifierOf(e);
+    if (t) t.call(e);
 }
 
 function notifyStatus(e, n, t, r, o) {
     // Wrap regular errors to track source node
     if (n === STATUS_ERROR && !(t instanceof StatusError) && !(t instanceof NotReadyError)) t = new StatusError(e, t);
     const l = n === STATUS_PENDING && t instanceof NotReadyError ? t.source : undefined;
-    const u = l === e;
-    const i = n === STATUS_PENDING && e.o?.De !== undefined && !u;
-    const s = i && hasActiveOverride(e);
+    const i = l === e;
+    const u = n === STATUS_PENDING && e.o?.De !== undefined && !i;
+    const s = u && hasActiveOverride(e);
     if (!r) {
         if (n === STATUS_PENDING && l) {
             addPendingSource(e, l);
@@ -569,21 +570,22 @@ function notifyStatus(e, n, t, r, o) {
             ext(e)._ = t;
         }
         GlobalQueue.de !== null && GlobalQueue.de(e);
-        if (e.o?.l && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
+        if (e.o?.i && e.T & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
     }
     if (o && !r) {
         assignOrMergeLane(e, o);
     }
     const f = r || s;
-    const a = r || i ? undefined : o;
-    if (e.o?.A) {
+    const a = r || u ? undefined : o;
+    const c = statusNotifierOf(e);
+    if (c) {
         if (r && n === STATUS_PENDING) {
             return;
         }
         if (f) {
-            e.o.A.call(e, n, t);
+            c.call(e, n, t);
         } else {
-            e.o.A.call(e);
+            c.call(e);
         }
         return;
     }