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

package/dist/prod/affects.js

@@ -1,11 +1,11 @@
 import { forEachDependent } from "./core/async.js";
 
+import { ext } from "./core/core.js";
+
 import { $REFRESH, STATUS_PENDING } from "./core/constants.js";
 
 import { NotReadyError } from "./core/error.js";
 
-import "./core/core.js";
-
 import { GlobalQueue, globalQueue, schedule, shiftAffectsMarks } from "./core/scheduler.js";
 
 import "./core/verdict.js";
@@ -24,7 +24,7 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
  * nothing is stored downstream and nothing can be stranded or stripped by
  * mid-window recomputes.
  */ function markAffects(e) {
-    e.t = (e.t || 0) + 1;
+    ext(e).t = (e.o?.t || 0) + 1;
     shiftAffectsMarks(1);
 }
 
@@ -40,17 +40,17 @@ 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.o && !e.u) return;
+    if (!e.u && !e.o?.l) return;
     const r = new NotReadyError(e);
-    r.l = true;
+    r.i = 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.i) {
-            e.i(STATUS_PENDING, r);
+                if (e.o?.A) {
+            e.o.A.call(e, STATUS_PENDING, r);
             return;
         }
         forEachDependent(e, visit);
@@ -68,10 +68,10 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
  * earlier overlapping registration get covered, and dedup stops re-descent.
  */ function registerAffectsMark(e) {
     markAffects(e);
-    globalQueue.m.A.push(e);
+    globalQueue.k.m.push(e);
     // Companions only exist once the verdict layer (isPending/latest) loaded;
     // without them there is no materialized verdict to poke.
-        GlobalQueue.k !== null && GlobalQueue.k(e);
+        GlobalQueue.p !== null && GlobalQueue.p(e);
     notifyMarkBoundaries(e);
     schedule();
 }
@@ -83,10 +83,10 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
  * setSignal would open a fresh override window that nothing settles).
  */ function releaseAffectsMark(e) {
     shiftAffectsMarks(-1);
-    e.t--;
-    if (!e.t) {
-        GlobalQueue.k !== null && GlobalQueue.k(e, true);
-        GlobalQueue.p?.(e);
+    e.o.t--;
+    if (!e.o.t) {
+        GlobalQueue.p !== null && GlobalQueue.p(e, true);
+        GlobalQueue.G?.(e);
     }
 }
 
@@ -103,11 +103,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.G = releaseAffectsMarks;
+GlobalQueue.M = releaseAffectsMarks;
 
-GlobalQueue.M = markAffects;
+GlobalQueue.h = markAffects;
 
-GlobalQueue.h = releaseAffectsMark;
+GlobalQueue.j = releaseAffectsMark;
 
 function affects(e, r) {
     const t = e?.[$TARGET];

package/dist/prod/boundaries.js

@@ -1,4 +1,4 @@
-import { runWithOwner, signal, untrack, read, computed, setSignal, recompute } from "./core/core.js";
+import { runWithOwner, signal, untrack, read, computed, setSignal, ext, recompute } from "./core/core.js";
 
 import { NotReadyError, unwrapStatusError } from "./core/error.js";
 
@@ -22,10 +22,10 @@ function boundaryComputed(e, t) {
     const r = computed(e, {
         lazy: true
     });
-    r.i = (e, t) => {
+    ext(r).A = (e, t) => {
         // Use passed values if provided, otherwise read from node
         const n = e !== undefined ? e : r.S;
-        const s = t !== undefined ? t : r._;
+        const s = t !== undefined ? t : r.o?._;
         // Notify both status dimensions like a render effect does; the queue chain
         // consumes this boundary's own type and forwards the remainder upward until
         // a boundary that handles it is found.
@@ -38,7 +38,7 @@ function boundaryComputed(e, t) {
                 const o = n & ~r.R & (STATUS_PENDING | STATUS_ERROR);
         if (o) {
             r.S &= ~o;
-            if (r._ === s && !(r.S & (STATUS_PENDING | STATUS_ERROR))) r._ = undefined;
+            if (r.o?._ === s && !(r.S & (STATUS_PENDING | STATUS_ERROR))) if (r.o !== null) r.o._ = undefined;
         }
         // An ERROR the chain could not deliver to any boundary is uncaught. The
         // scrub above already removed it from reader-visible state, so without
@@ -92,41 +92,41 @@ function setSlotState(e, t, r, n) {
     setSignal(e.D, n);
     if (isRevealController(e)) {
         if (!r && e.P === t) e.P = undefined;
-        return e.j(r, n);
+        return e.B(r, n);
     }
-    if (!r && e.B === t && e.W) e.B = undefined;
+    if (!r && e.W === t && e.L) e.W = undefined;
 }
 
 class RevealController {
-    L;
     F;
-    q=[];
+    q;
+    V=[];
     P;
     I=signal(false, {
         ownedWrite: true,
-        V: true
+        H: true
     });
     D=signal(false, {
         ownedWrite: true,
-        V: true
+        H: true
     });
-    H=true;
     J=true;
-    K=false;
+    K=true;
+    X=false;
     constructor(e, t) {
-        this.L = e;
-        this.F = t;
+        this.F = e;
+        this.q = t;
     }
-    X(e) {
-        for (let t = 0; t < this.q.length; t++) {
-            const r = this.q[t];
-            if ((isRevealController(r) ? r.P : r.B) !== this) continue;
+    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 (e(r) === false) return false;
         }
         return true;
     }
     O() {
-        return this.X(isSlotReady);
+        return this.Y(isSlotReady);
     }
     /**
      * "Minimally ready" = this group has something visible to show under its own policy.
@@ -135,12 +135,12 @@ class RevealController {
      * - `sequential`: the first owned slot is minimally ready (frontier can advance).
      * - `natural`: any owned slot is minimally ready.
      */    U() {
-        const e = untrack(this.L);
-        if (e === "together") return this.X(isSlotMinimallyReady);
+        const e = untrack(this.F);
+        if (e === "together") return this.Y(isSlotMinimallyReady);
         if (e === "natural") {
             let e = false;
             let t = false;
-            this.X(r => {
+            this.Y(r => {
                 e = true;
                 if (isSlotMinimallyReady(r)) {
                     t = true;
@@ -151,45 +151,45 @@ class RevealController {
         }
         // sequential: only the first owned slot matters.
                 let t = true;
-        this.X(e => {
+        this.Y(e => {
             t = isSlotMinimallyReady(e);
             return false;
         });
         return t;
     }
-    Y(e) {
-        if (this.q.includes(e)) return;
-        this.q.push(e);
-        const t = untrack(this.L);
-        setSignal(e.I, true), setSignal(e.D, t === "sequential" ? !!untrack(this.F) : false);
-        untrack(() => this.j());
-    }
     Z(e) {
-        const t = this.q.indexOf(e);
-        if (t >= 0) this.q.splice(t, 1);
-        untrack(() => this.j());
+        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);
+        untrack(() => this.B());
+    }
+    $(e) {
+        const t = this.V.indexOf(e);
+        if (t >= 0) this.V.splice(t, 1);
+        untrack(() => this.B());
     }
-    j(e, t) {
-        if (this.K) return;
-        this.K = true;
-        const r = this.H;
-        const n = this.J;
+    B(e, t) {
+        if (this.X) return;
+        this.X = true;
+        const r = this.J;
+        const n = this.K;
         try {
-            const r = e ?? read(this.I), n = untrack(this.L), s = n === "sequential" && !!untrack(this.F), i = t ?? s;
+            const r = e ?? read(this.I), 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
                 // held; it resumes once the outer releases us.
-                this.X(e => setSlotState(e, this, true, i));
+                this.Y(e => setSlotState(e, this, true, i));
             } else if (n === "natural") {
                 // Each child reveals based on its own readiness. A nested controller slot
                 // is released to run its own order locally — we bypass setSlotState for it
                 // so the parent backpointer survives for upward readiness notifications.
-                this.X(e => {
+                this.Y(e => {
                     if (isRevealController(e)) {
                         setSignal(e.D, false);
                         setSignal(e.I, false);
-                        e.j(false, false);
+                        e.B(false, false);
                     } else {
                         setSlotState(e, this, !isSlotReady(e), false);
                     }
@@ -200,11 +200,11 @@ class RevealController {
                 // sequential's first slot being ready is minimally ready; natural having any
                 // ready child is minimally ready. This lets `together` guarantee a single
                 // cohesive reveal without waiting for every grandchild.
-                const e = this.X(isSlotMinimallyReady);
-                this.X(t => setSlotState(t, this, !e, false));
+                const e = this.Y(isSlotMinimallyReady);
+                this.Y(t => setSlotState(t, this, !e, false));
             } else {
                 let e = false;
-                this.X(t => {
+                this.Y(t => {
                     if (e) return setSlotState(t, this, true, s);
                     if (isSlotReady(t)) return setSlotState(t, this, false, false);
                     e = true;
@@ -217,60 +217,60 @@ class RevealController {
                                         if (isRevealController(t)) {
                         setSignal(t.D, false);
                         setSignal(t.I, false);
-                        t.j(false, false);
+                        t.B(false, false);
                     } else {
                         setSlotState(t, this, true, false);
                     }
                 });
             }
         } finally {
-            this.H = this.O();
-            this.J = this.U();
-            this.K = false;
+            this.J = this.O();
+            this.K = this.U();
+            this.X = false;
         }
-        if (this.P && (r !== this.H || n !== this.J)) this.P.j();
+        if (this.P && (r !== this.J || n !== this.K)) this.P.B();
     }
 }
 
 class CollectionQueue extends Queue {
-    $;
-    v=new Set;
     ee;
+    v=new Set;
+    te;
     N=true;
     I=signal(false, {
         ownedWrite: true,
-        V: true
+        H: true
     });
     _;
     D=signal(false, {
         ownedWrite: true,
-        V: true
+        H: true
     });
-    B;
-    W=false;
-    te;
-    re=ON_INIT;
+    W;
+    L=false;
+    re;
+    ne=ON_INIT;
     constructor(e) {
         super();
-        this.$ = e;
+        this.ee = e;
     }
     run(e) {
         if (!e || read(this.I) && (!_revealUsed || read(this.D))) return;
         return super.run(e);
     }
     notify(e, t, r, n) {
-        if (!(t & this.$)) return super.notify(e, t, r, n);
-        if (this.W && this.te) {
+        if (!(t & this.ee)) return super.notify(e, t, r, n);
+        if (this.L && this.re) {
             const e = untrack(() => {
                 try {
-                    return this.te();
+                    return this.re();
                 } catch {
                     return ON_INIT;
                 }
             });
-            if (e !== this.re) {
-                this.re = e;
-                this.W = false;
+            if (e !== this.ne) {
+                this.ne = e;
+                this.L = false;
                 this.v.clear();
             }
         }
@@ -284,47 +284,47 @@ class CollectionQueue extends Queue {
         // dimension, while a status already caught by an inner boundary arrives with
         // its dimension consumed from the mask and is correctly not re-routed
         // (the Loading > Errored > content composition escape, #2856).
-                if (this.$ & STATUS_PENDING && this.W) return super.notify(e, t, r, n);
-        if (r & this.$) {
+                if (this.ee & STATUS_PENDING && this.L) return super.notify(e, t, r, n);
+        if (r & this.ee) {
             this.N = true;
-            const t = n?.source || e._?.source;
+            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 (this.$ & STATUS_ERROR) {
-                    setSignal(this._, unwrapStatusError(t._));
+                if (this.ee & STATUS_ERROR) {
+                    setSignal(this._, unwrapStatusError(t.o?._));
                 }
             }
         }
-        t &= ~this.$;
+        t &= ~this.ee;
         return t ? super.notify(e, t, r, n) : true;
     }
-    ne() {
+    se() {
         for (const e of this.v) {
             // A source with a live affects() mark holds display state for the
             // mark's lifetime (the visual channel): the marked node carries no
             // status of its own, so the count is the liveness test. The release
             // sweep (finalizePureQueue after mark release) re-runs this check.
-            if (e.se & REACTIVE_DISPOSED || !e.t && !(e.S & this.$) && !(this.$ & STATUS_ERROR && e.S & STATUS_PENDING)) this.v.delete(e);
+            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.$ & STATUS_PENDING && this.N && !this.W && this.ee) {
-                this.N = !!(this.ee.S & this.$);
+            if (this.ee & STATUS_PENDING && this.N && !this.L && this.te) {
+                this.N = !!(this.te.S & this.ee);
             } else {
                 this.N = false;
             }
             if (!this.N) {
                 setSignal(this.I, false);
-                if (this.te) {
+                if (this.re) {
                     try {
-                        this.re = untrack(() => this.te());
+                        this.ne = untrack(() => this.re());
                     } catch {
                         /* value not yet committed — _prevOn stays stale, next notify will reset */}
                 }
             }
         }
-        if (_revealUsed) this.B?.j();
+        if (_revealUsed) this.W?.B();
     }
 }
 
@@ -334,10 +334,10 @@ function createCollectionBoundary(e, t, r, n) {
     const i = new CollectionQueue(e);
     if (e === STATUS_ERROR) i._ = signal(undefined, {
         ownedWrite: true,
-        V: true
+        H: true
     });
-    if (n) i.te = n;
-    const o = i.ee = createBoundChildren(s, t, i, e);
+    if (n) i.re = n;
+    const o = i.te = createBoundChildren(s, t, i, e);
     // Prime source tracking so reveal registration sees pending sources.
         untrack(() => {
         let t = false;
@@ -346,18 +346,18 @@ function createCollectionBoundary(e, t, r, n) {
         } catch (e) {
             if (e instanceof NotReadyError) t = true; else throw e;
         }
-        i.N = t || !!(o.S & e) || o._ instanceof NotReadyError;
+        i.N = t || !!(o.S & e) || o.o?._ instanceof NotReadyError;
     });
     const l = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (l) {
-        i.B = l;
-        l.Y(i);
-        cleanup(() => l.Z(i));
+        i.W = l;
+        l.Z(i);
+        cleanup(() => l.$(i));
     }
     return accessor(computed(() => {
         if (!read(i.I)) {
             const e = read(o);
-            if (!untrack(() => read(i.I))) return i.W = true, e;
+            if (!untrack(() => read(i.I))) 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
@@ -370,7 +370,7 @@ function createCollectionBoundary(e, t, r, n) {
     // by snapshot capture. The tree no longer carries foreign status flags, so
     // capture can't rely on PENDING to skip this node the way it used to.
     {
-        V: true
+        H: true
     }));
 }
 
@@ -481,12 +481,12 @@ function createCollectionBoundary(e, t, r, n) {
         computed(() => {
             s();
             i();
-            o.j();
+            o.B();
         });
         if (n) {
             o.P = n;
-            n.Y(o);
-            cleanup(() => n.Z(o));
+            n.Z(o);
+            cleanup(() => n.$(o));
         }
         return t;
     });

package/dist/prod/core/action.js

@@ -78,11 +78,11 @@ function restoreTransition(e, r) {
         const i = e(...r);
         globalQueue.initTransition();
         let o = activeTransition;
-        o.ie.push(i);
+        o.oe.push(i);
         const done = (e, r, u = false) => {
             o = currentTransition(o);
-            const s = o.ie.indexOf(i);
-            if (s >= 0) o.ie.splice(s, 1);
+            const s = o.oe.indexOf(i);
+            if (s >= 0) o.oe.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