@solidjs/signals 2.0.0-rc.15 → 2.0.0-rc.16

package/dist/prod/reveal.js

@@ -32,124 +32,124 @@ const SEQUENTIAL_ACCESSOR = () => "sequential";
 
 const isController = t => t instanceof RevealController;
 
-const slotReady = t => isController(t) ? t.Rt() : ready(t);
+const slotReady = t => isController(t) ? t.St() : ready(t);
 
-const slotMinReady = t => isController(t) ? t.Ct() : ready(t);
+const slotMinReady = t => isController(t) ? t.Rt() : ready(t);
 
 /** Force a slot's state. A boundary re-derives its output when it changes;
  * a nested controller passes the state on to its own slots. Released
  * (`!gated`), a nested controller leaves its parent's ownership and runs its
  * own order; a boundary leaves when it has shown content (boundaries.ts). */ function setSlotState(t, e, s, r) {
     if (isController(t)) {
-        t.ne = s;
-        t.re = r;
-        t.vt();
+        t.$ = s;
+        t.ee = r;
+        t._t();
         // Released and ready — every slot of its own has shown — it graduates,
         // as a boundary does when it shows content. Released at the frontier
         // but not ready, it stays the parent's frontier.
-                if (!s && t.Lt && t._parent === e) t._parent = null;
+                if (!s && t.Ct && t._parent === e) t._parent = null;
         return;
     }
-    if (t.ne !== s || t.re !== r) {
-        t.ne = s;
-        t.re = r;
+    if (t.$ !== s || t.ee !== r) {
+        t.$ = s;
+        t.ee = r;
         redraw(t);
     }
 }
 
 class RevealController {
-    qt;
-    Vt;
-    Ft=[];
+    yt;
+    Et;
+    At=[];
     /** The controller gating this one, until it releases this one. */
     _parent=null;
     /** The state a parent forces on this whole group. */
-    ne=false;
-    re=false;
-    Lt=true;
-    Qt=true;
-    Tt=false;
+    $=false;
+    ee=false;
+    Ct=true;
+    kt=true;
+    vt=false;
     constructor(t, e) {
-        this.qt = t;
-        this.Vt = e;
+        this.yt = t;
+        this.Et = e;
     }
     /** A slot that has left this controller's ownership: a boundary that has
      * shown content, a nested group that is ready. Shown is shown — it counts
-     * as ready whatever happens to it later (a re-arm gates nobody else). */    Ut(t) {
-        return (isController(t) ? t._parent : t.H) !== this;
+     * as ready whatever happens to it later (a re-arm gates nobody else). */    gt(t) {
+        return (isController(t) ? t._parent : t.V) !== this;
     }
     /** The slots this controller still owns, in registration order — the
-     * ones the order's state is forced on. */    Wt(t) {
-        for (let e = 0; e < this.Ft.length; e++) {
-            const s = this.Ft[e];
-            if (!this.Ut(s) && t(s) === false) return false;
+     * ones the order's state is forced on. */    Lt(t) {
+        for (let e = 0; e < this.At.length; e++) {
+            const s = this.At[e];
+            if (!this.gt(s) && t(s) === false) return false;
         }
         return true;
     }
-    /** Readiness is judged over every slot, done ones as ready. */    Rt() {
-        for (let t = 0; t < this.Ft.length; t++) {
-            const e = this.Ft[t];
-            if (!this.Ut(e) && !slotReady(e)) return false;
+    /** Readiness is judged over every slot, done ones as ready. */    St() {
+        for (let t = 0; t < this.At.length; t++) {
+            const e = this.At[t];
+            if (!this.gt(e) && !slotReady(e)) return false;
         }
         return true;
     }
     /** Something visible to show under its own order — what an enclosing
      * `together` waits for: `together` — every slot minimally ready;
-     * `sequential` — the first slot; `natural` — any. */    Ct() {
-        const t = untrack(this.qt);
-        const e = this.Ft;
+     * `sequential` — the first slot; `natural` — any. */    Rt() {
+        const t = untrack(this.yt);
+        const e = this.At;
         if (e.length === 0) return true;
-        if (t === "sequential") return this.Ut(e[0]) || slotMinReady(e[0]);
+        if (t === "sequential") return this.gt(e[0]) || slotMinReady(e[0]);
         for (let s = 0; s < e.length; s++) {
-            const r = this.Ut(e[s]) || slotMinReady(e[s]);
+            const r = this.gt(e[s]) || slotMinReady(e[s]);
             if (t === "natural" ? r : !r) return t === "natural";
         }
         return t !== "natural";
     }
-    ue(t) {
-        if (this.Ft.includes(t)) return;
-        this.Ft.push(t);
+    oe(t) {
+        if (this.At.includes(t)) return;
+        this.At.push(t);
         // Gated from the start (collapsed in a collapsed sequential tail); the
         // evaluation releases what the order allows.
-                const e = untrack(this.qt) === "sequential" && !!untrack(this.Vt);
+                const e = untrack(this.yt) === "sequential" && !!untrack(this.Et);
         if (isController(t)) {
             t._parent = this;
-            t.ne = true;
-            t.re = e;
-            t.vt();
+            t.$ = true;
+            t.ee = e;
+            t._t();
         } else {
-            t.H = this;
-            t.ne = true;
-            t.re = e;
+            t.V = this;
+            t.$ = true;
+            t.ee = e;
         }
-        untrack(() => this.vt());
+        untrack(() => this._t());
     }
-    oe(t) {
-        const e = this.Ft.indexOf(t);
-        if (e >= 0) this.Ft.splice(e, 1);
-        untrack(() => this.vt());
+    te(t) {
+        const e = this.At.indexOf(t);
+        if (e >= 0) this.At.splice(e, 1);
+        untrack(() => this._t());
     }
     /** Apply the order to the owned slots — or, gated by a parent, its state
-     * to all of them. */    vt() {
-        if (this.Tt) return;
-        this.Tt = true;
-        const t = this.Lt;
-        const e = this.Qt;
+     * to all of them. */    _t() {
+        if (this.vt) return;
+        this.vt = true;
+        const t = this.Ct;
+        const e = this.kt;
         try {
-            const t = untrack(this.qt);
-            const e = t === "sequential" && !!untrack(this.Vt);
-            if (this.ne) {
-                this.Wt(t => setSlotState(t, this, true, this.re));
+            const t = untrack(this.yt);
+            const e = t === "sequential" && !!untrack(this.Et);
+            if (this.$) {
+                this.Lt(t => setSlotState(t, this, true, this.ee));
             } else if (t === "natural") {
-                this.Wt(t => {
+                this.Lt(t => {
                     if (isController(t)) setSlotState(t, this, false, false); else setSlotState(t, this, !ready(t), false);
                 });
             } else if (t === "together") {
-                const t = this.Wt(slotMinReady);
-                this.Wt(e => setSlotState(e, this, !t, false));
+                const t = this.Lt(slotMinReady);
+                this.Lt(e => setSlotState(e, this, !t, false));
             } else {
                 let t = false;
-                this.Wt(s => {
+                this.Lt(s => {
                     if (t) return setSlotState(s, this, true, e);
                     if (slotReady(s)) return setSlotState(s, this, false, false);
                     t = true;
@@ -159,11 +159,11 @@ class RevealController {
                 });
             }
         } finally {
-            this.Lt = this.Rt();
-            this.Qt = this.Ct();
-            this.Tt = false;
+            this.Ct = this.St();
+            this.kt = this.Rt();
+            this.vt = false;
         }
-        if (this._parent !== null && (t !== this.Lt || e !== this.Qt)) this._parent.vt();
+        if (this._parent !== null && (t !== this.Ct || e !== this.kt)) this._parent._t();
     }
 }
 
@@ -179,23 +179,23 @@ class RevealController {
  *   slots behind the frontier render nothing instead of their fallbacks
  */ function createRevealOrder(t, e) {
     const s = createOwner();
-    const r = s.D[REVEAL];
+    const r = s.A[REVEAL];
     const i = new RevealController(e?.order || SEQUENTIAL_ACCESSOR, e?.collapsed || FALSE_ACCESSOR);
-    s.D = {
-        ...s.D,
+    s.A = {
+        ...s.A,
         [REVEAL]: i
     };
     return runWithOwner(s, () => {
         const e = t();
         const s = computed(() => {
-            i.qt();
-            i.Vt();
-            i.vt();
+            i.yt();
+            i.Et();
+            i._t();
         });
         if (false) ;
         if (r) {
-            r.ue(i);
-            cleanup(() => r.oe(i));
+            r.oe(i);
+            cleanup(() => r.te(i));
         }
         return e;
     });
@@ -204,9 +204,9 @@ class RevealController {
 // Installed at module evaluation — present exactly when something imports
 // `createRevealOrder`; a Loading boundary without one pays a null check.
 setRevealHooks({
-    ue: (t, e) => t.ue(e),
     oe: (t, e) => t.oe(e),
-    P: t => t.vt()
+    te: (t, e) => t.te(e),
+    P: t => t._t()
 });
 
 export { createRevealOrder };

package/dist/prod/signals.js

@@ -10,9 +10,13 @@ import { globalQueue, flushTransaction, dirtyQueue, GlobalQueue, resolveTx, pass
 
 import { cleanup, createRoot, getOwner, dispose } from "./core/owner.js";
 
+import { signalHook } from "./core/identities.js";
+
 import { effect, trackedEffect } from "./core/effect.js";
 
-import { optimisticWrite, truthRead, truthConfirmed } from "./core/lanes.js";
+import { optimisticWrite } from "./core/lanes.js";
+
+import { truthRead, truthConfirmed } from "./core/truth.js";
 
 /**
  * Low-level reactive-cleanup primitive. Registers a callback that runs when
@@ -71,17 +75,18 @@ function accessor(e) {
 function createSignal(e, t) {
     if (typeof e === "function") {
         const r = computed(e, t);
-        r.i &= ~CONFIG_AUTO_DISPOSE;
+        r.l &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(r), setMemo.bind(null, r) ];
     }
     const r = signal(e, t);
+    if (signalHook !== null) signalHook(r);
     return [ accessor(r), setSignal.bind(null, r) ];
 }
 
 function createOptimistic(e, t) {
     if (typeof e === "function") {
         const r = computed(e, t);
-        r.i &= ~CONFIG_AUTO_DISPOSE;
+        r.l &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(r), optimisticWrite.bind(null, r) ];
     }
     const r = signal(e, t);
@@ -158,7 +163,7 @@ function createMemo(e, t) {
  * );
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-effect
  */ function createEffect(e, t, r) {
     effect(e, t.effect || t, t.error, {
         user: true,
@@ -193,7 +198,7 @@ function createMemo(e, t) {
  * }
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-render-effect
  */ function createRenderEffect(e, t, r) {
     effect(e, t, undefined, r);
 }
@@ -241,7 +246,7 @@ function createMemo(e, t) {
  * });
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-tracked-effect
  */ function createTrackedEffect(e, t) {
     trackedEffect(e, t);
 }
@@ -270,7 +275,7 @@ function createMemo(e, t) {
  * setCount(1); // logs once, reaction re-armed for next change
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-reaction
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-reaction
  */ function createReaction(e, t) {
     let r = undefined;
     cleanup(() => r?.());
@@ -321,34 +326,40 @@ function createMemo(e, t) {
  *   joined it (L2, born held — A29) and delivers at that commit: the
  *   committed view, never a foreign hold's unrevealed frame. */ function watch(e, t, r, n = 0, o, c = flushTransaction) {
     if (n & CONFIG_AUTHORITATIVE) {
-        GlobalQueue.En = truthRead;
-        GlobalQueue.un = truthConfirmed;
+        GlobalQueue.rn = truthRead;
+        GlobalQueue.sn = truthConfirmed;
     }
     // `config` is on the node for its first pass too (the pass runs inside
     // `computed()`): `until`'s predicate is authoritative from its first read,
     // or an already-displayed guess would satisfy it in a later slice. (REDERIVE
     // after: the first pass's own error is the promise's rejection.)
         computed(() => {
-        let n;
+        let i, u = false;
         try {
-            n = e();
+            i = e();
         } catch (e) {
             if (e instanceof NotReadyError) throw e;
-            queueMicrotask(() => r(unwrapStatusError(e)));
-            return;
+            // An error is an answer (D-41): delivered by the same frame rule.
+                        i = unwrapStatusError(e);
+            u = true;
         }
-        const u = getOwner();
+        const s = getOwner();
+        // A truth reader waits out a `createDeferred` flight its value derives
+        // from, which serves everyone else the stale answer (D-40).
+                const f = n & CONFIG_AUTHORITATIVE && GlobalQueue.er?.(s);
+        if (f) throw new NotReadyError(f);
         // (Outside a flush a mainline pass joins through `passTx`.)
-                const i = flushTransaction ?? passTx;
-        if (u.R & REACTIVE_JOINED && i !== null && (c === null || resolveTx(c) !== resolveTx(i))) {
-            staleReader(u, resolveTx(i));
+                const a = flushTransaction ?? passTx;
+        if (s.R & REACTIVE_JOINED && a !== null && (c === null || resolveTx(c) !== resolveTx(a))) {
+            staleReader(s, resolveTx(a));
             return;
         }
-        o?.(n);
-        queueMicrotask(() => t(n));
+        if (u) return void queueMicrotask(() => r(i));
+        o?.(i);
+        queueMicrotask(() => t(i));
     }, {
-        Me: n
-    }).i |= CONFIG_REDERIVE;
+        Le: n
+    }).l |= CONFIG_REDERIVE;
 }
 
 /**
@@ -447,7 +458,7 @@ function createMemo(e, t) {
                 // guessed node's own re-ask is not answered by it (#3895): park
                 // on that flight, or reject with its error.
                                 const e = read(t);
-                if (t.i & CONFIG_GUESS && t.S & (STATUS_PENDING | STATUS_ERROR)) throw t.m?.F;
+                if (t.l & CONFIG_GUESS && t.m & (STATUS_PENDING | STATUS_ERROR)) throw t.T?.F;
                 return e;
             }, t => {
                 n(typeof e === "function" ? t : e);
@@ -505,14 +516,14 @@ function createMemo(e, t) {
         // (`saving=true` beside the confirmed `version=1` is a tear no timeline
         // contains). Updates that do not flip the predicate reveal freely.
                 const c = flushTransaction;
-        createRoot(u => {
-            let i;
+        createRoot(i => {
+            let u;
             let s;
             const settle = e => {
-                if (i !== undefined) clearTimeout(i);
+                if (u !== undefined) clearTimeout(u);
                 if (s !== undefined) o.removeEventListener("abort", s);
                 e();
-                u();
+                i();
             };
             // Authoritative: the predicate sees the truth, never the action's own
             // optimistic guess — a guess cannot satisfy the wait for its own
@@ -525,9 +536,9 @@ function createMemo(e, t) {
                 // The flip, inside the pass of the flush carrying it: the flush
                 // joins the action's transaction, and what it staged is held and
                 // revealed with the action.
-                if (e && c !== null && globalQueue.X && resolveTx(c).tt !== 0) joinFuture(c);
+                if (e && c !== null && globalQueue.q && resolveTx(c).tt !== 0) joinFuture(c);
             });
-            if (t?.timeout !== undefined) i = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
+            if (t?.timeout !== undefined) u = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
             if (o !== undefined) {
                 s = () => settle(() => n(o.reason));
                 o.addEventListener("abort", s, {
@@ -633,7 +644,7 @@ function createMemo(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.i & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, function fire() {
+    t && !(t.l & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, function fire() {
         // Settled means derived. A settle that reverts optimism (or replays
         // gated reads) only enqueues the affected subscribers; the pass after
         // the commit re-derives them. Fired in the commit pass, the callback
@@ -641,7 +652,7 @@ function createMemo(e, t) {
         // still holding the optimistic value — reads do not pull (#3411). Fall
         // to the next pass while the heap has work; `run` swapped the queue,
         // so this lands there, and `enqueue` keeps the drain alive.
-        if (dirtyQueue.ft >= dirtyQueue.Ue) return globalQueue.enqueue(EFFECT_USER, fire);
+        if (dirtyQueue.et >= dirtyQueue.Ge) return globalQueue.enqueue(EFFECT_USER, fire);
         // Unowned, out-of-band fire (no owner, or a children-forbidden one this
         // one-shot must not bind to): a returned cleanup has no lifecycle to
         // attach to. Reject it in dev; in production the return is simply

package/dist/prod/store/affects.js

@@ -1,4 +1,4 @@
-import { GlobalQueue } from "../core/scheduler.js";
+import { GlobalQueue, releaseMarksHook } from "../core/scheduler.js";
 
 import { optHooks, installAffectsHooks } from "./hooks.js";
 
@@ -40,7 +40,7 @@ function scopeOf(e, o) {
     if (n === undefined) scopes.set(e, n = {
         eo: new Set,
         oo: [],
-        ot: o
+        ze: o
     });
     return n;
 }
@@ -94,7 +94,7 @@ function scopeOf(e, o) {
  * backings (§7b): a view's backing is another store's proxy — marks cover
  * the BASE raw, so every identity along the chain is checked. */ function covering(e, o, n) {
     for (const [t, s] of scopes) {
-        if (t === n || s.ot !== undefined && s.ot !== o) continue;
+        if (t === n || s.ze !== undefined && s.ze !== o) continue;
         for (let o = e.v; ;) {
             if (s.eo.has(o)) return t;
             const e = o?.[$TARGET];
@@ -116,14 +116,14 @@ function scopeOf(e, o) {
         if (scopes.size === 0 || n === $AFFECTS) return;
         const t = covering(e, n, o);
         if (!t) return;
-        GlobalQueue.O(o);
+        GlobalQueue.N(o);
         scopes.get(t).oo.push(o);
     },
     // An untracked probe (`isPending(() => s.x)` with no observer) reading a
     // record a live mark covers: no node carries the mark for it — the
     // verdict is told directly.
     ro(e, o) {
-        if (e.n?.[$AFFECTS]?.m?.T || covering(e, o)) GlobalQueue.ct();
+        if (e.n?.[$AFFECTS]?.T?.I || covering(e, o)) GlobalQueue.rt();
     }
 };
 
@@ -136,7 +136,7 @@ function scopeOf(e, o) {
     const o = scopes.get(e);
     if (o === undefined) return;
     scopes.delete(e);
-    GlobalQueue.k(o.oo);
+    releaseMarksHook(o.oo);
 }
 
 export { installStoreAffects, releaseMarkScope, storeMarks };

package/dist/prod/store/edges.js

@@ -0,0 +1,39 @@
+import { CONFIG_SLOT_NODE } from "../core/constants.js";
+
+import { signalName } from "../core/identities.js";
+
+import { $TARGET } from "./types.js";
+
+/**
+ * Deferred hydration, dependency edges for stores. Only the frames client
+ * imports this module, so nothing here ships without it.
+ *
+ * A plain store root (`createStore` over an object) is named like a plain
+ * signal (core/identities.ts: `<owner id>~<n>`, on the same count), and the
+ * whole store goes by that one name: the server records it for any read of
+ * the store, at any depth, and a setter call on the store — on its root or
+ * on a proxy nested in it — is a write to it. Its readers mount at the
+ * setter's entry, before the draft runs, as a plain signal's do.
+ */
+/**
+ * @internal The name of the store `x` belongs to — `x` a store proxy (a
+ * setter's entry) or one of its property nodes (the setter notifying it) —
+ * or undefined when it has none or it cannot be placed: a projection or
+ * optimistic family, a store chained over another store's proxy, a root
+ * named twice, or a proxy reached through a store other than the one it
+ * was named as the root of.
+ */ function storeName(e) {
+    if (e === undefined) return undefined;
+    let n = e.l & CONFIG_SLOT_NODE ? e.O : e[$TARGET];
+    if (n === undefined) return undefined;
+    // Up to the root; a target on the way named as a root of its own is one
+    // object in two stores.
+        while (n.u !== null) {
+        if (n.fam !== null || n.ch || signalName(n) !== undefined) return undefined;
+        n = n.u;
+    }
+    if (n.fam !== null || n.ch) return undefined;
+    return signalName(n) || undefined;
+}
+
+export { storeName };