@solidjs/signals 2.0.0-rc.7 → 2.0.0-rc.9

package/dist/prod/attribution.js

@@ -0,0 +1,41 @@
+const EMPTY = Object.freeze([]);
+
+const noop = () => {};
+
+const attribution = {
+    enable: noop,
+    disable: noop,
+    subscribe: () => noop,
+    history: () => EMPTY,
+    waterfalls: () => EMPTY,
+    holds: () => EMPTY,
+    navigations: () => EMPTY,
+    interactions: () => EMPTY,
+    markFlight: noop
+};
+
+// The named surface, inert: every fold empty, every query empty, every
+// formatter blank. Typed against the real entry's exports so the two cannot
+// drift.
+const costs = () => ({
+    scopes: [],
+    writes: []
+});
+
+const feedback = () => ({
+    sources: [],
+    interactions: [],
+    navigations: [],
+    flights: [],
+    fallbacks: []
+});
+
+const why = () => [];
+
+const subscriptions = () => [];
+
+const formatRerun = () => "";
+
+const formatOrigin = () => "";
+
+export { attribution, costs, feedback, formatOrigin, formatRerun, subscriptions, why };

package/dist/prod/boundaries.js

@@ -1,14 +1,14 @@
-import { runWithOwner, signal, untrack, read, computed, setSignal, ext, recompute } from "./core/core.js";
+import { runWithOwner, signal, untrack, read, computed, spectate, setSignal, ext, recompute } from "./core/core.js";
 
 import { NotReadyError, unwrapStatusError } from "./core/error.js";
 
 import { createOwner, cleanup } from "./core/owner.js";
 
-import { Queue, haltReactivity, schedule } from "./core/scheduler.js";
+import { Queue, transitions, wakeParked, haltReactivity, schedule } from "./core/scheduler.js";
 
 import { getContext, setContext, createContext } from "./core/context.js";
 
-import { STATUS_PENDING, STATUS_ERROR, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE } from "./core/constants.js";
+import { STATUS_PENDING, STATUS_ERROR, REACTIVE_ZOMBIE, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE } from "./core/constants.js";
 
 import "./core/invariants.js";
 
@@ -16,6 +16,8 @@ import "./core/verdict.js";
 
 import "./core/effect.js";
 
+import { reportClientError } from "./core/error-hooks.js";
+
 import { accessor } from "./signals.js";
 
 function boundaryComputed(e, t) {
@@ -80,11 +82,11 @@ function isRevealController(e) {
 }
 
 function isSlotReady(e) {
-    return isRevealController(e) ? e.O() : e.v.size === 0 && !e.U;
+    return isRevealController(e) ? e.O() : e.I.size === 0 && !e.v;
 }
 
 function isSlotMinimallyReady(e) {
-    return isRevealController(e) ? e.I() : isSlotReady(e);
+    return isRevealController(e) ? e.U() : isSlotReady(e);
 }
 
 function setSlotState(e, t, r, n) {
@@ -99,34 +101,34 @@ function setSlotState(e, t, r, n) {
 
 class RevealController {
     F;
-    q;
-    V=[];
+    V;
+    q=[];
     j;
     D=signal(false, {
         ownedWrite: true,
-        H: true
+        Z: true
     });
     P=signal(false, {
         ownedWrite: true,
-        H: true
+        Z: true
     });
+    H=true;
     J=true;
-    K=true;
-    X=false;
+    K=false;
     constructor(e, t) {
         this.F = e;
-        this.q = t;
+        this.V = t;
     }
-    Y(e) {
-        for (let t = 0; t < this.V.length; t++) {
-            const r = this.V[t];
+    X(e) {
+        for (let t = 0; t < this.q.length; t++) {
+            const r = this.q[t];
             if ((isRevealController(r) ? r.j : r.W) !== this) continue;
             if (e(r) === false) return false;
         }
         return true;
     }
     O() {
-        return this.Y(isSlotReady);
+        return this.X(isSlotReady);
     }
     /**
      * "Minimally ready" = this group has something visible to show under its own policy.
@@ -134,13 +136,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.
-     */    I() {
+     */    U() {
         const e = untrack(this.F);
-        if (e === "together") return this.Y(isSlotMinimallyReady);
+        if (e === "together") return this.X(isSlotMinimallyReady);
         if (e === "natural") {
             let e = false;
             let t = false;
-            this.Y(r => {
+            this.X(r => {
                 e = true;
                 if (isSlotMinimallyReady(r)) {
                     t = true;
@@ -151,41 +153,41 @@ class RevealController {
         }
         // sequential: only the first owned slot matters.
                 let t = true;
-        this.Y(e => {
+        this.X(e => {
             t = isSlotMinimallyReady(e);
             return false;
         });
         return t;
     }
-    Z(e) {
-        if (this.V.includes(e)) return;
-        this.V.push(e);
+    Y(e) {
+        if (this.q.includes(e)) return;
+        this.q.push(e);
         const t = untrack(this.F);
-        setSignal(e.D, true), setSignal(e.P, t === "sequential" ? !!untrack(this.q) : false);
+        setSignal(e.D, true), setSignal(e.P, t === "sequential" ? !!untrack(this.V) : false);
         untrack(() => this.B());
     }
     $(e) {
-        const t = this.V.indexOf(e);
-        if (t >= 0) this.V.splice(t, 1);
+        const t = this.q.indexOf(e);
+        if (t >= 0) this.q.splice(t, 1);
         untrack(() => this.B());
     }
     B(e, t) {
-        if (this.X) return;
-        this.X = true;
-        const r = this.J;
-        const n = this.K;
+        if (this.K) return;
+        this.K = true;
+        const r = this.H;
+        const n = this.J;
         try {
-            const r = e ?? read(this.D), 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.V), 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.Y(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.Y(e => {
+                this.X(e => {
                     if (isRevealController(e)) {
                         setSignal(e.P, false);
                         setSignal(e.D, false);
@@ -200,11 +202,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.Y(isSlotMinimallyReady);
-                this.Y(t => setSlotState(t, this, !e, false));
+                const e = this.X(isSlotMinimallyReady);
+                this.X(t => setSlotState(t, this, !e, false));
             } else {
                 let e = false;
-                this.Y(t => {
+                this.X(t => {
                     if (e) return setSlotState(t, this, true, s);
                     if (isSlotReady(t)) return setSlotState(t, this, false, false);
                     e = true;
@@ -224,32 +226,34 @@ class RevealController {
                 });
             }
         } finally {
-            this.J = this.O();
-            this.K = this.I();
-            this.X = false;
+            this.H = this.O();
+            this.J = this.U();
+            this.K = false;
         }
-        if (this.j && (r !== this.J || n !== this.K)) this.j.B();
+        if (this.j && (r !== this.H || n !== this.J)) this.j.B();
     }
 }
 
 class CollectionQueue extends Queue {
     ee;
-    v=new Set;
+    I=new Set;
     te;
-    U=true;
+    v=true;
     D=signal(false, {
         ownedWrite: true,
-        H: true
+        Z: true
     });
     _;
     P=signal(false, {
         ownedWrite: true,
-        H: true
+        Z: true
     });
     W;
     L=false;
     re;
     ne=ON_INIT;
+    /** The boundary's owner — where a `caught` report locates itself, set before the children are built (a creation-time throw arrives before `_tree`). */
+    se;
     constructor(e) {
         super();
         this.ee = e;
@@ -258,20 +262,41 @@ class CollectionQueue extends Queue {
         if (!e || read(this.D) && (!_revealUsed || read(this.P))) return;
         return super.run(e);
     }
+    /** The `on` key, or ON_INIT when it throws. Evaluated mid-propagation,
+     * inside the pending node's own pass: read as a spectator so the key's
+     * sources never become that node's dependencies (#3528). */    ie() {
+        return spectate(() => {
+            try {
+                return this.re();
+            } catch {
+                return ON_INIT;
+            }
+        });
+    }
     notify(e, t, r, n) {
         if (!(t & this.ee)) return super.notify(e, t, r, n);
         if (this.L && this.re) {
-            const e = untrack(() => {
-                try {
-                    return this.re();
-                } catch {
-                    return ON_INIT;
-                }
-            });
+            const e = this.ie();
             if (e !== this.ne) {
                 this.ne = e;
                 this.L = false;
-                this.v.clear();
+                this.I.clear();
+                // Readers forwarded while this boundary showed content are behind the
+                // fallback now: they stop blocking (`reporterBlocksSource`), and the
+                // transactions they were holding must be re-judged for it (A33, #3375).
+                // What those readers still wait on is this boundary's to wait on now:
+                // they never re-notify (status propagation dedupes on the reader's
+                // `_pendingSources`), so the reset collects it from their registrations
+                // — the one place a forwarded reader is recorded (INV-3) — or a sibling
+                // reader's flight that lands first reveals them stale (A33, #3459).
+                                for (const e of transitions) for (const [t, r] of e.oe) for (const e of r) if (this.le(e)) {
+                    this.I.add(t);
+                    e.o?.ae?.forEach(e => this.I.add(e));
+                }
+                if (this.I.size) {
+                    setSignal(this.D, true);
+                }
+                wakeParked();
             }
         }
         // Routing is dimension-independent: each boundary consumes only its own
@@ -286,43 +311,69 @@ 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.U = true;
+            this.v = true;
             const t = n?.source || e.o?._?.source;
             if (t) {
-                const e = this.v.size === 0;
-                this.v.add(t);
-                if (e) {
+                const r = this.I.size === 0;
+                this.I.add(t);
+                // A collecting boundary waits on everything the effect is pending on,
+                // not only the source this notification carries. Status propagation
+                // dedupes on the effect's `_pendingSources`: a source it already
+                // carries (a flight that started before an `on` reset cleared the
+                // set) is never re-reported, and that source's later re-flight
+                // stays invisible — the boundary revealed when its one collected
+                // source settled while the effect was still pending (#3375).
+                                if (this.ee & STATUS_PENDING) e.o?.ae?.forEach(e => this.I.add(e));
+                if (r) {
                     setSignal(this.D, true);
                 }
                 if (this.ee & STATUS_ERROR) {
-                    setSignal(this._, unwrapStatusError(t.o?._));
+                    const e = unwrapStatusError(t.o?._);
+                    setSignal(this._, e);
+                    // The client error hook: this boundary renders its fallback for
+                    // it — the one road a rendered failure took that no global handler
+                    // ever saw. `source` is the computation that threw (the status
+                    // wrapper's, made at the first landing and kept downstream), so the
+                    // hook hears where it broke as well as where it was met. Once per
+                    // error object; a `reset()` re-collecting the same failure says
+                    // nothing new.
+                                        reportClientError(e, this.se, t);
                 }
             }
         }
         t &= ~this.ee;
         return t ? super.notify(e, t, r, n) : true;
     }
-    se() {
-        for (const e of this.v) {
+    /** Is `reporter` live and routed to this boundary — under it, with no
+     * collecting pending-type boundary in between (`reporterBlocksSource`'s test)? */    le(e) {
+        if (e.ue & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+        for (let t = e.C; t; t = t._parent) {
+            if (t === this) return true;
+            if (t.ee & STATUS_PENDING && !t.L) return false;
+        }
+        return false;
+    }
+    fe() {
+        for (const e of this.I) {
             // 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.ie & REACTIVE_DISPOSED || !e.o?.t && !(e.S & this.ee) && !(this.ee & STATUS_ERROR && e.S & STATUS_PENDING)) this.v.delete(e);
+            if (e.ue & REACTIVE_DISPOSED || !e.o?.t && !(e.S & this.ee) && !(this.ee & STATUS_ERROR && e.S & STATUS_PENDING)) this.I.delete(e);
         }
-        if (!this.v.size) {
-            if (this.ee & STATUS_PENDING && this.U && !this.L && this.te) {
-                this.U = !!(this.te.S & this.ee);
+        if (!this.I.size) {
+            if (this.ee & STATUS_PENDING && this.v && !this.L && this.te) {
+                this.v = !!(this.te.S & this.ee);
             } else {
-                this.U = false;
+                this.v = false;
             }
-            if (!this.U) {
+            if (!this.v) {
                 setSignal(this.D, false);
                 if (this.re) {
-                    try {
-                        this.ne = untrack(() => this.re());
-                    } catch {
-                        /* value not yet committed — _prevOn stays stale, next notify will reset */}
+                    // A throw (value not yet committed) leaves _prevOn stale; the next
+                    // notify then resets.
+                    const e = this.ie();
+                    if (e !== ON_INIT) this.ne = e;
                 }
             }
         }
@@ -334,9 +385,10 @@ function createCollectionBoundary(e, t, r, n) {
     const s = createOwner();
     if (_revealUsed) setContext(RevealControllerContext, null, s);
     const i = new CollectionQueue(e);
+    i.se = s;
     if (e === STATUS_ERROR) i._ = signal(undefined, {
         ownedWrite: true,
-        H: true
+        Z: true
     });
     if (n) i.re = n;
     const o = i.te = createBoundChildren(s, t, i, e);
@@ -348,12 +400,12 @@ function createCollectionBoundary(e, t, r, n) {
         } catch (e) {
             if (e instanceof NotReadyError) t = true; else throw e;
         }
-        i.U = t || !!(o.S & e) || o.o?._ instanceof NotReadyError;
+        i.v = t || !!(o.S & e) || o.o?._ instanceof NotReadyError;
     });
     const l = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (l) {
         i.W = l;
-        l.Z(i);
+        l.Y(i);
         cleanup(() => l.$(i));
     }
     return accessor(computed(() => {
@@ -372,7 +424,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.
     {
-        H: true
+        Z: true
     }));
 }
 
@@ -426,11 +478,11 @@ 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) {
+        for (const t of e.I) {
             // 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);
+            if (t.ce !== undefined) recompute(t);
         }
         schedule();
     }));
@@ -492,7 +544,7 @@ function createCollectionBoundary(e, t, r, n) {
         });
         if (n) {
             o.j = n;
-            n.Z(o);
+            n.Y(o);
             cleanup(() => n.$(o));
         }
         return t;

package/dist/prod/core/action.js

@@ -1,14 +1,25 @@
-import { globalQueue, activeTransition, currentTransition, schedule, flush } from "./scheduler.js";
+import { setOrigin, globalQueue, activeTransition, currentTransition, schedule, actionStepDepth, flush, enterActionStep, exitActionStep } from "./scheduler.js";
 
 import { isThenable } from "./async.js";
 
 import "./core.js";
 
-function restoreTransition(e, r) {
-    globalQueue.initTransition(e);
-    const t = r();
-    flush();
-    return t;
+/** Invocation order across all actions — the provenance every slice of an
+ * action runs under (scheduler `origin`): the flights and overrides its
+ * ambient windows issue are stamped with it, so a later action's override
+ * can tell this action's late answer from its own (#3331). */ let actionSeq = 0;
+
+function restoreTransition(e, t, n) {
+    const r = setOrigin(e);
+    globalQueue.initTransition(t);
+    const i = n();
+    // A nested action resuming synchronously (its body yielded a non-thenable)
+    // runs this inside the OUTER action's slice: draining here would park the
+    // shared transaction and detach the outer body's remaining writes (the
+    // flush() rule, scheduler.ts). The outer step's own return drains.
+        if (actionStepDepth === 0) flush();
+    setOrigin(r);
+    return i;
 }
 
 /**
@@ -36,15 +47,22 @@ function restoreTransition(e, r) {
  * `yield` is the transaction-safe suspension point: the action waits for a
  * yielded promise and re-enters the transaction before running the code after
  * it. A plain `await` does NOT — the runtime has no hook into an async
- * generator's internal await continuations, so writes to fresh signals
- * between an `await` and the next `yield` escape the transaction and commit
- * immediately. `await` is still the ergonomic choice for typed results; just
- * put a bare `yield` before any writes that follow it:
+ * generator's internal await continuations, so code between an `await` and
+ * the next `yield` runs OUTSIDE the transaction: writes to fresh signals
+ * commit immediately, and anything that creates a reader there — `until()`,
+ * `latest()`, a memo or effect, a mount — is created mainline, where a read of
+ * this action's held state makes it born held (A29): staged with the
+ * transaction and replayed at its commit. For `until()` that commit is the
+ * settle its own promise holds open (#3482). `await` is still the ergonomic
+ * choice for typed results; just put a bare `yield` before any write or
+ * reader creation that follows it — including the expression of the next
+ * `yield`, which is evaluated before the step re-enters:
  *
  * ```ts
  * const saved = await api.createTodo(text); // typed result
- * yield; // re-enter the transaction before writing
+ * yield; // re-enter the transaction before writing or reading
  * setTodos(t => { ... });
+ * yield until(() => todos.some(t => t.id === saved.id));
  * ```
  *
  * (For the same reason, don't call `flush()` inside an action body — it
@@ -74,36 +92,46 @@ function restoreTransition(e, r) {
  * await addTodo("buy milk");
  * ```
  */ function action(e) {
-    return (...r) => new Promise((t, n) => {
-        const i = e(...r);
+    return (...t) => new Promise((n, r) => {
+        const i = e(...t);
+        const o = ++actionSeq;
+        // The first slice's window runs to the scheduled flush, which clears
+        // the provenance with the window — no restore here.
+                setOrigin(o);
         globalQueue.initTransition();
-        let o = activeTransition;
-        o.ue.push(i);
-        const done = (e, r, u = false) => {
-            o = currentTransition(o);
-            const s = o.ue.indexOf(i);
-            if (s >= 0) o.ue.splice(s, 1);
+        let s = activeTransition;
+        s.pe.push(i);
+        s.he = true;
+        const done = (e, t, o = false) => {
+            s = currentTransition(s);
+            const u = s.pe.indexOf(i);
+            if (u >= 0) s.pe.splice(u, 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
             // (held writes on a merging transition, optimistic overrides,
             // affects() marks) lands there with nothing to ever finalize it.
-                        globalQueue.initTransition(o);
+                        globalQueue.initTransition(s);
             schedule();
-            u ? n(r) : t(e);
+            o ? r(t) : n(e);
         };
-        const step = (e, r) => {
-            let t;
+        const step = (e, t) => {
+            let n;
+            // The body is on the stack between these brackets: flush() is
+            // refused inside (FLUSH_IN_ACTION, scheduler.ts).
+                        enterActionStep();
             try {
-                t = r ? i.throw(e) : i.next(e);
+                n = t ? i.throw(e) : i.next(e);
             } catch (e) {
+                exitActionStep();
                 return done(undefined, e, true);
             }
+            exitActionStep();
             // A rejected iterator result (async generators) means the error already
             // escaped the generator body — it is completed, and throwing back in
             // would just reject again forever. Settle instead.
-                        if (isThenable(t)) return void t.then(run, e => done(undefined, e, true));
-            run(t);
+                        if (isThenable(n)) return void n.then(run, e => done(undefined, e, true));
+            run(n);
         };
         const run = e => {
             if (e.done) return done(e.value);
@@ -114,23 +142,23 @@ function restoreTransition(e, r) {
             // 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;
+                        let t = false;
             try {
                 if (isThenable(e.value)) return void e.value.then(e => {
-                    if (r) return;
-                    r = true;
-                    restoreTransition(o, () => step(e));
+                    if (t) return;
+                    t = true;
+                    restoreTransition(o, s, () => step(e));
                 }, e => {
-                    if (r) return;
-                    r = true;
-                    restoreTransition(o, () => step(e, true));
+                    if (t) return;
+                    t = true;
+                    restoreTransition(o, s, () => step(e, true));
                 });
             } catch (e) {
-                if (r) return;
-                r = true;
-                return void restoreTransition(o, () => step(e, true));
+                if (t) return;
+                t = true;
+                return void restoreTransition(o, s, () => step(e, true));
             }
-            restoreTransition(o, () => step(e.value));
+            restoreTransition(o, s, () => step(e.value));
         };
         step();
     });