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

package/dist/prod/boundaries.js

@@ -22,23 +22,23 @@ function boundaryComputed(e, t) {
     const r = computed(e, {
         lazy: true
     });
-    r.C = (e, t) => {
+    r.i = (e, t) => {
         // Use passed values if provided, otherwise read from node
-        const n = e !== undefined ? e : r.i;
-        const s = t !== undefined ? t : r.k;
+        const n = e !== undefined ? e : r.S;
+        const s = t !== undefined ? t : r._;
         // 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.
-                r.i &= ~r.O;
-        const i = r.v.notify(r, STATUS_PENDING | STATUS_ERROR, n, s);
+                r.S &= ~r.R;
+        const i = r.C.notify(r, STATUS_PENDING | STATUS_ERROR, n, s);
         // The queue is the only propagation channel: a foreign status must not stay
         // reader-visible on the tree, or reads re-throw it across the boundary and
         // link unrelated ambient contexts (the #2809 nested-boundary loop). Deps are
         // untouched, so the tree still recomputes when the foreign source settles.
-                const o = n & ~r.O & (STATUS_PENDING | STATUS_ERROR);
+                const o = n & ~r.R & (STATUS_PENDING | STATUS_ERROR);
         if (o) {
-            r.i &= ~o;
-            if (r.k === s && !(r.i & (STATUS_PENDING | STATUS_ERROR))) r.k = undefined;
+            r.S &= ~o;
+            if (r._ === s && !(r.S & (STATUS_PENDING | STATUS_ERROR))) r._ = 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
@@ -49,16 +49,16 @@ function boundaryComputed(e, t) {
             throw s;
         }
     };
-    r.O = t;
-    r.U &= ~CONFIG_AUTO_DISPOSE;
+    r.R = t;
+    r.T &= ~CONFIG_AUTO_DISPOSE;
     recompute(r, true);
     return r;
 }
 
 function createBoundChildren(e, t, r, n) {
-    const s = e.v;
-    s.addChild(e.v = r);
-    cleanup(() => s.removeChild(e.v));
+    const s = e.C;
+    s.addChild(e.C = r);
+    cleanup(() => s.removeChild(e.C));
     return runWithOwner(e, () => {
         const e = computed(t);
         return boundaryComputed(() => flatten(read(e)), n);
@@ -80,53 +80,53 @@ function isRevealController(e) {
 }
 
 function isSlotReady(e) {
-    return isRevealController(e) ? e.B() : e.W.size === 0 && !e.L;
+    return isRevealController(e) ? e.O() : e.v.size === 0 && !e.N;
 }
 
 function isSlotMinimallyReady(e) {
-    return isRevealController(e) ? e.q() : isSlotReady(e);
+    return isRevealController(e) ? e.U() : isSlotReady(e);
 }
 
 function setSlotState(e, t, r, n) {
-    setSignal(e.V, r);
-    setSignal(e.H, n);
+    setSignal(e.I, r);
+    setSignal(e.D, n);
     if (isRevealController(e)) {
-        if (!r && e.J === t) e.J = undefined;
-        return e.K(r, n);
+        if (!r && e.P === t) e.P = undefined;
+        return e.j(r, n);
     }
-    if (!r && e.X === t && e.Y) e.X = undefined;
+    if (!r && e.B === t && e.W) e.B = undefined;
 }
 
 class RevealController {
-    Z;
-    ee;
-    te=[];
-    J;
-    V=signal(false, {
+    L;
+    F;
+    q=[];
+    P;
+    I=signal(false, {
         ownedWrite: true,
-        re: true
+        V: true
     });
-    H=signal(false, {
+    D=signal(false, {
         ownedWrite: true,
-        re: true
+        V: true
     });
-    ne=true;
-    se=true;
-    ie=false;
+    H=true;
+    J=true;
+    K=false;
     constructor(e, t) {
-        this.Z = e;
-        this.ee = t;
+        this.L = e;
+        this.F = t;
     }
-    oe(e) {
-        for (let t = 0; t < this.te.length; t++) {
-            const r = this.te[t];
-            if ((isRevealController(r) ? r.J : r.X) !== this) continue;
+    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;
             if (e(r) === false) return false;
         }
         return true;
     }
-    B() {
-        return this.oe(isSlotReady);
+    O() {
+        return this.X(isSlotReady);
     }
     /**
      * "Minimally ready" = this group has something visible to show under its own policy.
@@ -134,13 +134,13 @@ 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.
-     */    q() {
-        const e = untrack(this.Z);
-        if (e === "together") return this.oe(isSlotMinimallyReady);
+     */    U() {
+        const e = untrack(this.L);
+        if (e === "together") return this.X(isSlotMinimallyReady);
         if (e === "natural") {
             let e = false;
             let t = false;
-            this.oe(r => {
+            this.X(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.oe(e => {
+        this.X(e => {
             t = isSlotMinimallyReady(e);
             return false;
         });
         return t;
     }
-    le(e) {
-        if (this.te.includes(e)) return;
-        this.te.push(e);
-        const t = untrack(this.Z);
-        setSignal(e.V, true), setSignal(e.H, t === "sequential" ? !!untrack(this.ee) : false);
-        untrack(() => this.K());
+    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());
     }
-    ae(e) {
-        const t = this.te.indexOf(e);
-        if (t >= 0) this.te.splice(t, 1);
-        untrack(() => this.K());
+    Z(e) {
+        const t = this.q.indexOf(e);
+        if (t >= 0) this.q.splice(t, 1);
+        untrack(() => this.j());
     }
-    K(e, t) {
-        if (this.ie) return;
-        this.ie = true;
-        const r = this.ne;
-        const n = this.se;
+    j(e, t) {
+        if (this.K) return;
+        this.K = true;
+        const r = this.H;
+        const n = this.J;
         try {
-            const r = e ?? read(this.V), n = untrack(this.Z), s = n === "sequential" && !!untrack(this.ee), i = t ?? s;
+            const r = e ?? read(this.I), n = untrack(this.L), s = n === "sequential" && !!untrack(this.F), 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.oe(e => setSlotState(e, this, true, i));
+                this.X(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.oe(e => {
+                this.X(e => {
                     if (isRevealController(e)) {
-                        setSignal(e.H, false);
-                        setSignal(e.V, false);
-                        e.K(false, false);
+                        setSignal(e.D, false);
+                        setSignal(e.I, false);
+                        e.j(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.oe(isSlotMinimallyReady);
-                this.oe(t => setSlotState(t, this, !e, false));
+                const e = this.X(isSlotMinimallyReady);
+                this.X(t => setSlotState(t, this, !e, false));
             } else {
                 let e = false;
-                this.oe(t => {
+                this.X(t => {
                     if (e) return setSlotState(t, this, true, s);
                     if (isSlotReady(t)) return setSlotState(t, this, false, false);
                     e = true;
@@ -215,63 +215,63 @@ class RevealController {
                     // advancing past this slot, and we bypass setSlotState so the parent
                     // backpointer survives for upward readiness notifications.
                                         if (isRevealController(t)) {
-                        setSignal(t.H, false);
-                        setSignal(t.V, false);
-                        t.K(false, false);
+                        setSignal(t.D, false);
+                        setSignal(t.I, false);
+                        t.j(false, false);
                     } else {
                         setSlotState(t, this, true, false);
                     }
                 });
             }
         } finally {
-            this.ne = this.B();
-            this.se = this.q();
-            this.ie = false;
+            this.H = this.O();
+            this.J = this.U();
+            this.K = false;
         }
-        if (this.J && (r !== this.ne || n !== this.se)) this.J.K();
+        if (this.P && (r !== this.H || n !== this.J)) this.P.j();
     }
 }
 
 class CollectionQueue extends Queue {
-    ue;
-    W=new Set;
-    ce;
-    L=true;
-    V=signal(false, {
+    $;
+    v=new Set;
+    ee;
+    N=true;
+    I=signal(false, {
         ownedWrite: true,
-        re: true
+        V: true
     });
-    k;
-    H=signal(false, {
+    _;
+    D=signal(false, {
         ownedWrite: true,
-        re: true
+        V: true
     });
-    X;
-    Y=false;
-    fe;
-    he=ON_INIT;
+    B;
+    W=false;
+    te;
+    re=ON_INIT;
     constructor(e) {
         super();
-        this.ue = e;
+        this.$ = e;
     }
     run(e) {
-        if (!e || read(this.V) && (!_revealUsed || read(this.H))) return;
+        if (!e || read(this.I) && (!_revealUsed || read(this.D))) return;
         return super.run(e);
     }
     notify(e, t, r, n) {
-        if (!(t & this.ue)) return super.notify(e, t, r, n);
-        if (this.Y && this.fe) {
+        if (!(t & this.$)) return super.notify(e, t, r, n);
+        if (this.W && this.te) {
             const e = untrack(() => {
                 try {
-                    return this.fe();
+                    return this.te();
                 } catch {
                     return ON_INIT;
                 }
             });
-            if (e !== this.he) {
-                this.he = e;
-                this.Y = false;
-                this.W.clear();
+            if (e !== this.re) {
+                this.re = e;
+                this.W = false;
+                this.v.clear();
             }
         }
         // Routing is dimension-independent: each boundary consumes only its own
@@ -284,43 +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.ue & STATUS_PENDING && this.Y) return super.notify(e, t, r, n);
-        if (r & this.ue) {
-            this.L = true;
-            const t = n?.source || e.k?.source;
+                if (this.$ & STATUS_PENDING && this.W) return super.notify(e, t, r, n);
+        if (r & this.$) {
+            this.N = true;
+            const t = n?.source || e._?.source;
             if (t) {
-                const e = this.W.size === 0;
-                this.W.add(t);
-                if (e) setSignal(this.V, true);
-                if (this.ue & STATUS_ERROR) {
-                    setSignal(this.k, unwrapStatusError(t.k));
+                const e = this.v.size === 0;
+                this.v.add(t);
+                if (e) setSignal(this.I, true);
+                if (this.$ & STATUS_ERROR) {
+                    setSignal(this._, unwrapStatusError(t._));
                 }
             }
         }
-        t &= ~this.ue;
+        t &= ~this.$;
         return t ? super.notify(e, t, r, n) : true;
     }
-    Se() {
-        for (const e of this.W) {
-            if (e.u & REACTIVE_DISPOSED || !(e.i & this.ue) && !(this.ue & STATUS_ERROR && e.i & STATUS_PENDING)) this.W.delete(e);
+    ne() {
+        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 (!this.W.size) {
-            if (this.ue & STATUS_PENDING && this.L && !this.Y && this.ce) {
-                this.L = !!(this.ce.i & this.ue);
+        if (!this.v.size) {
+            if (this.$ & STATUS_PENDING && this.N && !this.W && this.ee) {
+                this.N = !!(this.ee.S & this.$);
             } else {
-                this.L = false;
+                this.N = false;
             }
-            if (!this.L) {
-                setSignal(this.V, false);
-                if (this.fe) {
+            if (!this.N) {
+                setSignal(this.I, false);
+                if (this.te) {
                     try {
-                        this.he = untrack(() => this.fe());
+                        this.re = untrack(() => this.te());
                     } catch {
                         /* value not yet committed — _prevOn stays stale, next notify will reset */}
                 }
             }
         }
-        if (_revealUsed) this.X?.K();
+        if (_revealUsed) this.B?.j();
     }
 }
 
@@ -328,12 +332,12 @@ function createCollectionBoundary(e, t, r, n) {
     const s = createOwner();
     if (_revealUsed) setContext(RevealControllerContext, null, s);
     const i = new CollectionQueue(e);
-    if (e === STATUS_ERROR) i.k = signal(undefined, {
+    if (e === STATUS_ERROR) i._ = signal(undefined, {
         ownedWrite: true,
-        re: true
+        V: true
     });
-    if (n) i.fe = n;
-    const o = i.ce = createBoundChildren(s, t, i, e);
+    if (n) i.te = n;
+    const o = i.ee = createBoundChildren(s, t, i, e);
     // Prime source tracking so reveal registration sees pending sources.
         untrack(() => {
         let t = false;
@@ -342,23 +346,23 @@ function createCollectionBoundary(e, t, r, n) {
         } catch (e) {
             if (e instanceof NotReadyError) t = true; else throw e;
         }
-        i.L = t || !!(o.i & e) || o.k instanceof NotReadyError;
+        i.N = t || !!(o.S & e) || o._ instanceof NotReadyError;
     });
     const l = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (l) {
-        i.X = l;
-        l.le(i);
-        cleanup(() => l.ae(i));
+        i.B = l;
+        l.Y(i);
+        cleanup(() => l.Z(i));
     }
     return accessor(computed(() => {
-        if (!read(i.V)) {
+        if (!read(i.I)) {
             const e = read(o);
-            if (!untrack(() => read(i.V))) return i.Y = true, e;
+            if (!untrack(() => read(i.I))) return i.W = 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.H)) return undefined;
+                if (_revealUsed && read(i.D)) return undefined;
         return r(i);
     }, 
     // Boundary structure, not a user source: its value is fallback-or-content and
@@ -366,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.
     {
-        re: true
+        V: true
     }));
 }
 
@@ -419,8 +423,8 @@ function createCollectionBoundary(e, t, r, n) {
  * }
  * ```
  */ function createErrorBoundary(e, t) {
-    return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e.k), () => {
-        for (const t of e.W) recompute(t);
+    return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e._), () => {
+        for (const t of e.v) recompute(t);
         schedule();
     }));
 }
@@ -477,12 +481,12 @@ function createCollectionBoundary(e, t, r, n) {
         computed(() => {
             s();
             i();
-            o.K();
+            o.j();
         });
         if (n) {
-            o.J = n;
-            n.le(o);
-            cleanup(() => n.ae(o));
+            o.P = n;
+            n.Y(o);
+            cleanup(() => n.Z(o));
         }
         return t;
     });

package/dist/prod/core/action.js

@@ -4,14 +4,30 @@ import { isThenable } from "./async.js";
 
 import "./core.js";
 
-function restoreTransition(e, n) {
+function restoreTransition(e, r) {
     globalQueue.initTransition(e);
-    const t = n();
+    const t = r();
     flush();
     return t;
 }
 
 /**
+ * The primitive for mutations: imperative async workflows whose *writes span
+ * an async gap* — optimistic write, server round-trip, reconciling write —
+ * where intermediate state must not leak and failure must revert cleanly
+ * (pair with `createOptimistic` / `createOptimisticStore`).
+ *
+ * Navigation-shaped updates do not need an action. A plain setter call is
+ * enough: reads pull the async, and downstream async computeds hold their
+ * previous values per-node until the new ones are ready (`isPending` /
+ * `latest` expose the in-flight state). Reach for `action` only when writes
+ * happen *after* async work, not merely upstream of it.
+ *
+ * Framework-level actions (router form actions, server actions) are
+ * specializations of this primitive: they are actions in exactly this sense —
+ * the same transactional semantics — with form binding, serialization, and
+ * submission tracking layered on top. The shared name is deliberate.
+ *
  * Wraps a generator function so each invocation runs as a single transaction
  * (a "transition") that batches every signal/store write between yields. The
  * surrounding UI sees one atomic update per yielded step; nothing is committed
@@ -58,23 +74,23 @@ function restoreTransition(e, n) {
  * await addTodo("buy milk");
  * ```
  */ function action(e) {
-    return (...n) => new Promise((t, r) => {
-        const i = e(...n);
+    return (...r) => new Promise((t, n) => {
+        const i = e(...r);
         globalQueue.initTransition();
         let o = activeTransition;
-        o.Te.push(i);
-        const done = (e, n, s = false) => {
+        o.ie.push(i);
+        const done = (e, r, s = false) => {
             o = currentTransition(o);
-            const u = o.Te.indexOf(i);
-            if (u >= 0) o.Te.splice(u, 1);
+            const u = o.ie.indexOf(i);
+            if (u >= 0) o.ie.splice(u, 1);
             setActiveTransition(o);
             schedule();
-            s ? r(n) : t(e);
+            s ? n(r) : t(e);
         };
-        const step = (e, n) => {
+        const step = (e, r) => {
             let t;
             try {
-                t = n ? i.throw(e) : i.next(e);
+                t = r ? i.throw(e) : i.next(e);
             } catch (e) {
                 return done(undefined, e, true);
             }
@@ -86,7 +102,29 @@ function restoreTransition(e, n) {
         };
         const run = e => {
             if (e.done) return done(e.value);
-            if (isThenable(e.value)) return void e.value.then(e => restoreTransition(o, () => step(e)), e => restoreTransition(o, () => step(e, true)));
+            // Thenable assimilation can itself throw synchronously (a `then`
+            // getter, or a `then()` method that throws — #2918). Match `await`
+            // semantics: the failure is thrown back into the generator at the
+            // yield point (catchable there); if uncaught, step()'s guard settles
+            // the action so its iterator never leaks in the transition. The
+            // settled flag implements A+ 2.3.3.3.4.1: a throw after the thenable
+            // already called a callback is ignored.
+                        let r = false;
+            try {
+                if (isThenable(e.value)) return void e.value.then(e => {
+                    if (r) return;
+                    r = true;
+                    restoreTransition(o, () => step(e));
+                }, e => {
+                    if (r) return;
+                    r = true;
+                    restoreTransition(o, () => step(e, true));
+                });
+            } catch (e) {
+                if (r) return;
+                r = true;
+                return void restoreTransition(o, () => step(e, true));
+            }
             restoreTransition(o, () => step(e.value));
         };
         step();