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

package/dist/prod/signals.js

@@ -4,7 +4,7 @@ import { computed, optimisticComputed, setSignal, optimisticSignal, runWithOwner
 
 import { cleanup, createRoot, getOwner, dispose, getObserver } from "./core/owner.js";
 
-import { globalQueue, Queue, entangleConfirmingTransitions, activeTransition } from "./core/scheduler.js";
+import { globalQueue, dirtyQueue, Queue, entangleConfirmingTransitions, activeTransition } from "./core/scheduler.js";
 
 import { CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH, CONFIG_DIRECT_COMMIT, CONFIG_AUTHORITATIVE_READ, CONFIG_FRESH_READ } from "./core/constants.js";
 
@@ -281,10 +281,7 @@ function createMemo(e, t) {
                 n = r;
                 dispose(t);
             }, e.error, {
-                ...false ? {
-                    ...t,
-                    name: t?.name ?? "effect"
-                } : t,
+                ...t,
                 user: true,
                 defer: true
             });
@@ -330,7 +327,7 @@ function createMemo(e, t) {
             // route through the inherited queue.
             const i = getOwner();
             const o = new MicrotaskQueue;
-            o.Le = i.C;
+            o._parent = i.C;
  // notify() forwards up the normal chain
                         i.C = o;
             // A user effect rather than a bare computed: computeds are pull-based and
@@ -352,7 +349,7 @@ function createMemo(e, t) {
             // stale mainline value and resolves with old data.
             {
                 user: true,
-                At: CONFIG_DIRECT_COMMIT
+                kt: CONFIG_DIRECT_COMMIT
             });
         });
     });
@@ -445,7 +442,7 @@ function createMemo(e, t) {
                 if (i === null) {
                     i = getOwner();
                     const e = new MicrotaskQueue;
-                    e.Le = i.C;
+                    e._parent = i.C;
                     i.C = e;
                 }
                 return read(t);
@@ -457,7 +454,7 @@ function createMemo(e, t) {
                 dispose(i);
             }, {
                 user: true,
-                At: CONFIG_DIRECT_COMMIT | CONFIG_AUTHORITATIVE_READ | CONFIG_FRESH_READ
+                kt: CONFIG_DIRECT_COMMIT | CONFIG_AUTHORITATIVE_READ | CONFIG_FRESH_READ
             });
             make();
         });
@@ -508,12 +505,20 @@ function createMemo(e, t) {
  *
  * Must be called *outside* a tracking scope.
  *
+ * Inside an action, call it from a step: after an `await`, put a bare `yield`
+ * before `yield until(...)`. The runtime cannot hook an async generator's
+ * `await` continuation, so the `until(...)` expression — which CREATES the
+ * predicate's reader — would otherwise run outside the transaction; created
+ * there it is born held (A29) and replays only at the commit its own promise
+ * holds open (#3482). See {@link action}.
+ *
  * @example
  * ```ts
  * const send = action(async function* (text: string) {
  *   const clientId = crypto.randomUUID();
  *   setMessages(m => { m.push({ clientId, text, pending: true }); }); // optimistic
  *   await socket.send({ clientId, text }); // fire-and-forget transport
+ *   yield; // re-enter the transaction after the await
  *   // Hold until the live source echoes the write (authoritative view —
  *   // the optimistic row above cannot satisfy this):
  *   yield until(() => messages.some(m => m.clientId === clientId), { timeout: 10_000 });
@@ -540,10 +545,10 @@ function createMemo(e, t) {
             // microtask so the promise can settle while the transaction the caller
             // yielded it into is still open — that transaction being open is the
             // entire point of the hold.
-            const s = getOwner();
-            const u = new MicrotaskQueue;
-            u.Le = s.C;
-            s.C = u;
+            const u = getOwner();
+            const s = new MicrotaskQueue;
+            s._parent = u.C;
+            u.C = s;
             let f;
             let a;
             const settle = e => {
@@ -572,7 +577,7 @@ function createMemo(e, t) {
             // the hold itself is keeping uncommitted.
             {
                 user: true,
-                At: CONFIG_AUTHORITATIVE_READ | CONFIG_DIRECT_COMMIT
+                kt: CONFIG_AUTHORITATIVE_READ | CONFIG_DIRECT_COMMIT
             });
             if (t?.timeout !== undefined) f = setTimeout(() => settle(() => i(new TimeoutError)), t.timeout);
             if (o !== undefined) {
@@ -694,12 +699,20 @@ function createOptimistic(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.T & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, () => {
+    t && !(t.T & 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
+        // read the optimistic source already reverted beside a sync memo of it
+        // 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.EE >= dirtyQueue.et) 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
         // dropped — never bound to an unrelated owner or run eagerly.
-        e();
+                e();
     });
 }
 

package/dist/prod/store/next/optimistic.js

@@ -1,6 +1,6 @@
 import { CONFIG_AUTO_DISPOSE, STATUS_PENDING, STATUS_UNINITIALIZED, NOT_PENDING, CONFIG_OPTIMISTIC, CONFIG_HELD_TRUTH, unwrapOverride } from "../../core/constants.js";
 
-import { computed, setSignal, isEqual } from "../../core/core.js";
+import { computed, hasActiveOverride, setSignal, isEqual, visibleOverride } from "../../core/core.js";
 
 import { getOwner } from "../../core/owner.js";
 
@@ -18,11 +18,11 @@ import { $TARGET, markRawIngest, setNextOptimisticViewResolver, isWrappable, raw
 
 import { runProjectionComputedNext } from "./projection.js";
 
-import { wrapNext, runAuthoritative, storeSetterNext, hasActiveOverride, unwrapValue, targetsEqual, getNode, getHasNode, getKeySetNode, bumpDeep, stagedTruthPB, authoritativeRead } from "./store.js";
+import { wrapNext, runAuthoritative, storeSetterNext, unwrapValue, targetsEqual, heldMaskView, getNode, getHasNode, getKeySetNode, bumpDeep, stagedTruthPB, authoritativeRead } from "./store.js";
 
 import { sameKey } from "./reconcile.js";
 
-import { setOptHooks } from "./target.js";
+import { setOptHooks, $OWNER, lookupTarget } from "./target.js";
 
 /**
  * Store rewrite — optimistic stores (§3/§7, RUL-3): no store-side layer, no
@@ -55,7 +55,7 @@ import { setOptHooks } from "./target.js";
  * staged values to converge (normal speculation). Resolves merges first:
  * merge unions optimistic nodes/stores into the target. */ function transitionHoldsOptimism(e) {
     const t = currentTransition(e);
-    return t.sn !== true && (t.Xe.length !== 0 || t.En.size !== 0);
+    return t.Tt !== true && (t.rt.length !== 0 || t.dn.size !== 0);
 }
 
 let blockedInstalled = false;
@@ -72,12 +72,15 @@ function installNextBlockedHalf() {
         applyTentative: applyTentative,
         retainsOptimism: transitionHoldsOptimism
     });
-    setNextOptimisticViewResolver((e, t) => optimisticView(e, t));
+    // The affects() declaration walk is a WRITER channel (A28 (5)): tagging a
+    // parent covers the record as the writer sees it, this tick's optimistic
+    // writes included — the draft view, not the reader view.
+        setNextOptimisticViewResolver((e, t) => optimisticView(e, t, true));
     // Scheduler flush tails call _clearOptimisticStores whenever tracked
     // stores exist; next has no layer to clear — reverts are engine-native —
     // so the hook only empties the batch set.
-        if (!GlobalQueue.Wt) {
-        GlobalQueue.Wt = e => {
+        if (!GlobalQueue.Cn) {
+        GlobalQueue.Cn = e => {
             for (const t of e) {
                 const e = t?.[$TARGET];
                 const n = e?.fam?.overlaid;
@@ -96,9 +99,9 @@ function installNextBlockedHalf() {
             e.clear();
         };
     }
-    const e = GlobalQueue.dn;
-    GlobalQueue.dn = t => {
-        for (const e of t.En) {
+    const e = GlobalQueue.Nn;
+    GlobalQueue.Nn = t => {
+        for (const e of t.dn) {
             const n = e?.[$TARGET];
             const i = n?.fam;
             const r = i?.node;
@@ -128,10 +131,10 @@ function familyHasLiveOverrides(e) {
             if (t === null) continue;
             for (const e of Reflect.ownKeys(t)) {
                 const n = t[e];
-                if (n.o?.Pe !== undefined && n.o?.Pe !== NOT_PENDING) return true;
+                if (n.o?.Ce !== undefined && n.o?.Ce !== NOT_PENDING) return true;
             }
         }
-        if (e.k !== null && e.k.o?.Pe !== undefined && e.k.o?.Pe !== NOT_PENDING) return true;
+        if (e.k !== null && e.k.o?.Ce !== undefined && e.k.o?.Ce !== NOT_PENDING) return true;
     }
     t.clear();
  // nothing live — drop the bookkeeping
@@ -178,7 +181,7 @@ function createOptimisticStoreNext(e, t, n) {
             if (e == null) return;
             let t = liveTransition(e);
             if (t === null) s.ft = t = createTransition();
-            s.node.Ae = t;
+            s.node.Ge = t;
             globalQueue.initTransition(t);
         };
         // Landing router (#3164 fold ruling): while a transaction retains
@@ -223,8 +226,8 @@ function createOptimisticStoreNext(e, t, n) {
         // (#2933: the loading rail is transaction-invisible); a sync run clears
         // the declaration.
                 const declareFlight = e => {
-            if (e.o?.Ie == null) {
-                if (!e.Ne) s.ft = null;
+            if (e.o?.Re == null) {
+                if (!e.ge) s.ft = null;
                 return;
             }
             // First flight (#3146 carve-out): nothing has ever committed, so there
@@ -236,13 +239,13 @@ function createOptimisticStoreNext(e, t, n) {
             // fallback never showed and the whole page stayed blank. The loading
             // window (#2933) already declares nothing for the same reason; once
             // the first truth lands, every refetch flight declares as before.
-                        if (e.Ne || e.S & STATUS_UNINITIALIZED) return;
+                        if (e.ge || e.S & STATUS_UNINITIALIZED) return;
             let t = activeTransition;
             if (t === null) globalQueue.initTransition(t = createTransition());
             s.ft = t;
-            e.Ae = t;
-            let n = t._e.get(e);
-            if (n === undefined) t._e.set(e, n = new Set);
+            e.Ge = t;
+            let n = t.oe.get(e);
+            if (n === undefined) t.oe.set(e, n = new Set);
             n.add(e);
         };
         let n;
@@ -274,8 +277,8 @@ function createOptimisticStoreNext(e, t, n) {
 
 /** Resolve a retained transition through its merge chain (`_done` holds the
  * merge target while merged, `true` once settled). Null = dead. */ function liveTransition(e) {
-    while (typeof e.sn === "object") e = e.sn;
-    return e.sn === true ? null : e;
+    while (typeof e.Tt === "object") e = e.Tt;
+    return e.Tt === true ? null : e;
 }
 
 /** The transaction truth landings fold into: the first live member of the
@@ -320,10 +323,10 @@ function createOptimisticStoreNext(e, t, n) {
  * stay unarmed — the override is their display and its revert their
  * notification, A17). */ function runFolded(e, t) {
     runAsTransitionBatch(e, t);
-    const n = e.Mt;
+    const n = e.Ot;
     for (let t = 0; t < n.length; t++) {
         const i = n[t];
-        i.Ae = e;
+        i.Ge = e;
         if (i.T & CONFIG_OPTIMISTIC && !hasActiveOverride(i)) i.T |= CONFIG_HELD_TRUTH;
     }
 }
@@ -363,7 +366,7 @@ function createOptimisticStoreNext(e, t, n) {
                 for (const e of Reflect.ownKeys(s)) {
                     const t = s[e];
                     if (!hasActiveOverride(t)) continue;
-                    const i = unwrapValue(unwrapOverride(t.o.Pe));
+                    const i = unwrapValue(unwrapOverride(t.o.Ce));
                     if (!isWrappable(i)) continue;
                     const o = n(i);
                     if (o === undefined) continue;
@@ -407,7 +410,7 @@ function createOptimisticStoreNext(e, t, n) {
     // Object merge; also the degenerate root-kind-change shape (arrays accept
     // keyed writes/deletes, so a wholesale restatement still lands staged).
         for (const r of Reflect.ownKeys(t)) {
-        if (i && r === "length") continue;
+        if (i && r === "length" || r === $OWNER) continue;
         const o = t[r];
         const s = unwrapValue(e[r]);
         if (s === o) continue;
@@ -428,7 +431,7 @@ function createOptimisticStoreNext(e, t, n) {
         }
     }
     for (const n of Reflect.ownKeys(e)) {
-        if (i && n === "length" || n in t) continue;
+        if (i && n === "length" || n === $OWNER || n in t) continue;
         delete e[n];
     }
 }
@@ -451,19 +454,33 @@ function createOptimisticStoreNext(e, t, n) {
         const e = liveTransition(n);
         if (e !== null) globalQueue.initTransition(e);
     }
-    const i = e.v;
-    const visible = (t, n) => {
+    // The write is judged against what ordinary readers SEE, not against the
+    // committed backing slot: under an adoption hold (#3074) `t.v` is already
+    // the truth a live transaction is holding, and an optimistic write equal
+    // to it compared as a no-op — no override, no lane, and the screen kept
+    // the pre-hold value until the transaction committed (#3330's store
+    // twin: `s.v = 1` after a `yield` while the derive had already staged
+    // `v: 1`). Signal parity: the override reveals on its lane now, with its
+    // derivations; the held truth reveals on the transaction's schedule.
+        const i = heldMaskView(e) ?? e.v;
+    // Compare RAWS on both sides (`nv` below is unwrapped already). A chained
+    // target's `old` is the inner store's proxy, whose reads hand back inner
+    // child PROXIES; the draft's clone holds the inner raws. Comparing the two
+    // as-is marked every untouched row changed, and the overlay then served
+    // each from an override as a fresh non-chained target — row identities
+    // churned for the life of the action and snapped back at settle (#3323).
+        const visible = (t, n) => {
         const i = e.n?.[t];
-        return i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.Pe) : n;
+        return unwrapValue(i !== undefined && hasActiveOverride(i) ? unwrapOverride(i.o?.Ce) : n);
     };
     const visiblePresent = t => {
         const n = e.h?.[t];
-        return n !== undefined && hasActiveOverride(n) ? !!unwrapOverride(n.o?.Pe) : t in i;
+        return n !== undefined && hasActiveOverride(n) ? !!unwrapOverride(n.o?.Ce) : t in i;
     };
     let r = false;
     const o = Array.isArray(t);
     for (const n of Reflect.ownKeys(t)) {
-        if (o && n === "length") continue;
+        if (o && n === "length" || n === $OWNER) continue;
         const s = unwrapValue(t[n]);
         if (!visiblePresent(n)) {
             // Optimistic add: value node + presence node + membership bump.
@@ -479,7 +496,7 @@ function createOptimisticStoreNext(e, t, n) {
         }
     }
     for (const n of Reflect.ownKeys(i)) {
-        if (o && n === "length") continue;
+        if (o && n === "length" || n === $OWNER) continue;
         if (n in t || !visiblePresent(n)) continue;
         // Optimistic delete: node reads undefined, presence flips, membership bumps.
                 setSignal(getNode(e, n, i[n]), () => undefined);
@@ -504,7 +521,7 @@ function createOptimisticStoreNext(e, t, n) {
         e.pb = stagedTruthPB.get(e) ?? null;
     if (e.pb !== null) stagedTruthPB.delete(e);
     (e.fam.overlaid ??= new Set).add(e);
-    GlobalQueue._n?.(e.fam.px ?? e.px);
+    GlobalQueue.Dn?.(e.fam.px ?? e.px);
 }
 
 /** Optimistic-view composition for snapshot/deep (O1: snapshot is the CURRENT
@@ -512,39 +529,43 @@ function createOptimisticStoreNext(e, t, n) {
  * RUL-12). Returns `src` untouched when no override is active on `t`.
  * Authoritative-view reads (until()'s predicate) skip composition entirely:
  * the predicate observes authoritative truth, never the caller's tentative
- * overlay. (Write-side emission callers never run under such a compute.) */ function optimisticView(e, t) {
+ * overlay. (Write-side emission callers never run under such a compute.) */ function optimisticView(e, t, n = false) {
     if (e.fam?.opt !== true || authoritativeRead()) return t;
-    let n = null;
-    const ensure = () => n ??= Array.isArray(t) ? [ ...t ] : {
+    let i = null;
+    const ensure = () => i ??= Array.isArray(t) ? [ ...t ] : {
         ...t
     };
-    const i = e.n;
-    if (i !== null) {
-        for (const e of Reflect.ownKeys(i)) {
-            const n = i[e];
-            if (!hasActiveOverride(n)) continue;
-            const r = unwrapOverride(n.o?.Pe);
-            if (e === "length" && Array.isArray(t)) {
-                if (t.length !== r) ensure().length = r;
-            } else if (!isEqual(t[e], r)) ensure()[e] = r;
-        }
-    }
-    const r = e.h;
+    const r = e.n;
     if (r !== null) {
         for (const e of Reflect.ownKeys(r)) {
             const i = r[e];
-            if (!hasActiveOverride(i)) continue;
-            const o = !!unwrapOverride(i.o?.Pe);
-            if (!o && e in (n ?? t)) delete ensure()[e];
+            // A28 (5): readers see an optimistic write once a flush carried it;
+            // the draft (writer channel) composes on it now.
+                        if (!(n ? hasActiveOverride(i) : visibleOverride(i))) continue;
+            const o = unwrapOverride(i.o?.Ce);
+            if (e === "length" && Array.isArray(t)) {
+                if (t.length !== o) ensure().length = o;
+            } else if (!isEqual(t[e], o)) ensure()[e] = o;
+        }
+    }
+    const o = e.h;
+    if (o !== null) {
+        for (const e of Reflect.ownKeys(o)) {
+            const r = o[e];
+            // A28 (5): readers see an optimistic write once a flush carried it;
+            // the draft (writer channel) composes on it now.
+                        if (!(n ? hasActiveOverride(r) : visibleOverride(r))) continue;
+            const s = !!unwrapOverride(r.o?.Ce);
+            if (!s && e in (i ?? t)) delete ensure()[e];
         }
     }
-    return n ?? t;
+    return i ?? t;
 }
 
 function applyTentative(e, t, n) {
     const i = e.pb ?? e.v;
     const r = optimisticView(e, i);
-    const o = e.fam.map;
+    const o = e.fam;
     const s = Array.isArray(t);
     if (Array.isArray(r) !== s) return;
  // kind change at root: flat overrides below
@@ -552,7 +573,7 @@ function applyTentative(e, t, n) {
     let u;
     if (s) u = [ ...t ]; else {
         u = {};
-        for (const e of Reflect.ownKeys(t)) u[e] = t[e];
+        for (const e of Reflect.ownKeys(t)) if (e !== $OWNER) u[e] = t[e];
     }
     const match = (e, t) => {
         if (!isWrappable(e) || !isWrappable(t)) return null;
@@ -565,7 +586,7 @@ function applyTentative(e, t, n) {
             // channel — NaN keys are self-equal.
                         if (i !== undefined && r !== undefined && !sameKey(i, r)) return null;
         }
-        return o.get(unwrapValue(e)) ?? null;
+        return lookupTarget(unwrapValue(e), o) ?? null;
     };
     if (s) {
         const e = r;
@@ -611,6 +632,7 @@ function applyTentative(e, t, n) {
         }
     } else {
         for (const e of Reflect.ownKeys(t)) {
+            if (e === $OWNER) continue;
             const n = unwrapValue(r[e]);
             const i = t[e];
             const o = match(n, i);

package/dist/prod/store/next/projection.js

@@ -55,22 +55,23 @@ import { storeSetterNext, wrapNext } from "./store.js";
  * Save/restore projectionWriteActive, never hard-reset: the draft can be
  * driven from inside an enclosing authoritative-write scope (next-store
  * optimistic derives), and a hard `false` would clobber it mid-derive.
- */ function wrapDraft(e, t, r) {
+ */ function wrapDraft(e, t, r, i) {
     const write = e => r ? r(e) : e();
-    const i = {
-        get(i, o) {
-            let n;
-            const c = projectionWriteActive;
+    const o = {
+        get(o, n) {
+            let c;
+            const s = projectionWriteActive;
             setWriteOverride(true);
             setProjectionWriteActive(true);
             try {
-                n = e[o];
+                c = e[n];
             } finally {
                 setWriteOverride(false);
-                setProjectionWriteActive(c);
+                setProjectionWriteActive(s);
             }
-            if (o === $TARGET) return n;
-            return typeof n === "object" && n !== null ? wrapDraft(n, t, r) : n;
+            // A shallow store's leaves are raw by contract (#3498): no draft proxy
+            // over them, so identity holds and a frozen leaf is never trapped.
+                        return !i && typeof c === "object" && c !== null && n !== $TARGET ? wrapDraft(c, t, r) : c;
         },
         has(t, r) {
             let i;
@@ -160,7 +161,7 @@ import { storeSetterNext, wrapNext } from "./store.js";
         }
     };
     // Matching-kind dummy so Array.isArray(draft) answers like the store.
-        return new Proxy(Array.isArray(e) ? [] : {}, i);
+        return new Proxy(Array.isArray(e) ? [] : {}, o);
 }
 
 function createProjectionNextInternal(e, t, r) {
@@ -207,30 +208,40 @@ function createProjectionNext(e, t, r) {
     } ];
 }
 
+// A detached copy of projection state: the root container alone for a shallow
+// store — its leaves are raw references by contract and stay so (#3498) — the
+// whole tree otherwise.
+function cloneState(e, t) {
+    return t ? Array.isArray(e) ? e.slice() : {
+        ...e
+    } : JSON.parse(JSON.stringify(e));
+}
+
 function runProjectionComputedNext(e, t, r, i, o) {
     const n = getOwner();
-    let c = false;
-    let s;
+    const c = e[$TARGET];
+    let s = false;
+    let u;
     // Open loading window (seedLoadingValue): the observable store IS commit #0
     // for the whole first flight — the derive works a detached shadow of the
     // seed so draft writes cannot tear through to readers (#2988). Every commit
     // point reconciles the shadow through the normal commit path.
-        const u = n.Ne ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
-    const l = wrapDraft(e, () => !c || n.o?.Ie === s, o);
-    storeSetterNext(l, o => {
-        s = t(u ?? o);
-        c = true;
+        const l = n.ge ? cloneState(c[STORE_VALUE], c.s) : null;
+    const a = wrapDraft(e, () => !s || n.o?.Re === u, o, c.s);
+    storeSetterNext(a, o => {
+        u = t(l ?? o);
+        s = true;
         const commit = t => {
             // Shadow run: commit a detached snapshot, never the shadow itself
             // (adoption takes the value by identity — handing it the live shadow
             // would fuse the draft to the observable store).
-            if (u && (t === undefined || t === u)) t = JSON.parse(JSON.stringify(u));
+            if (l && (t === undefined || t === l)) t = cloneState(l, c.s);
             if (t === o || t === undefined) return;
             const write = () => storeSetterNext(e, e => reconcileNextState(t, e, r, true), false);
             i ? i(write, t) : write();
         };
-        const l = handleAsync(n, s, commit);
-        if (!n.Ne) commit(l);
+        const a = handleAsync(n, u, commit);
+        if (!n.ge) commit(a);
     }, false);
     return n;
 }