@solidjs/signals 2.0.0-rc.3 → 2.0.0-rc.5

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));
         }
@@ -556,7 +561,10 @@ function flattenArray(e, t = [], r) {
                 } while (typeof n === "function" && !n.length);
             }
             if (Array.isArray(n)) {
-                s = flattenArray(n, t, r);
+                // OR, don't overwrite: an accessor already pushed under doNotUnwrap
+                // still needs the resolving wrapper even when a later sibling
+                // fragment contains no functions (#3133).
+                s = flattenArray(n, t, r) || s;
             } else if (r?.skipNonRendered && (n == null || n === true || n === false || n === "")) {
                 // skip
             } else t.push(n);

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