@solidjs/signals 2.0.0-rc.5 → 2.0.0-rc.6

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

@@ -1,4 +1,4 @@
-import { unwrapOverride, $REFRESH, CONFIG_OWNED_WRITE, NOT_PENDING, CONFIG_OPTIMISTIC, CONFIG_HELD_TRUTH, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN, CONFIG_AUTHORITATIVE_READ } from "../../core/constants.js";
+import { unwrapOverride, $REFRESH, NOT_PENDING, CONFIG_OWNED_WRITE, CONFIG_OPTIMISTIC, CONFIG_HELD_TRUTH, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN, CONFIG_AUTHORITATIVE_READ } from "../../core/constants.js";
 
 import { setSignal, isEqual, read, pendingCheckActive, latestReadActive, readNodeFast, READ_SLOW, signal, ext, setLatestReadActive, prepareComputed, context } from "../../core/core.js";
 
@@ -193,7 +193,7 @@ function getNode(e, t, n) {
         // Optimistic families: arm the override slot — setSignal routes armed
         // nodes through the core engine (lanes, ownership, reverts all native).
                 if (e.fam?.opt) {
-            ext(o).Oe = NOT_PENDING;
+            ext(o).Pe = NOT_PENDING;
             o.T |= CONFIG_OPTIMISTIC;
         }
         // A node born inside a live mark's identity scope inherits the mark
@@ -226,7 +226,7 @@ function getHasNode(e, t, n) {
         }, e.fam?.node ?? undefined);
         o.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(o).Oe = NOT_PENDING;
+            ext(o).Pe = NOT_PENDING;
             o.T |= CONFIG_OPTIMISTIC;
         }
         if (affectsScopesLive()) inheritAffectsMarks(o, e.v, t);
@@ -247,7 +247,7 @@ function getKeySetNode(e) {
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(n).Oe = NOT_PENDING;
+            ext(n).Pe = NOT_PENDING;
             n.T |= CONFIG_OPTIMISTIC;
         }
         e.k = t;
@@ -267,7 +267,7 @@ function getDeepNode(e) {
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(n).Oe = NOT_PENDING;
+            ext(n).Pe = NOT_PENDING;
             n.T |= CONFIG_OPTIMISTIC;
         }
         if (affectsScopesLive()) inheritAffectsMarks(n, e.v, $TRACK);
@@ -388,14 +388,14 @@ function ensurePB(e) {
             if (n !== null) {
                 for (const e of Reflect.ownKeys(n)) {
                     const r = n[e];
-                    if (hasActiveOverride(r)) t[e] = unwrapOverride(r.o?.Oe);
+                    if (hasActiveOverride(r)) t[e] = unwrapOverride(r.o?.Pe);
                 }
             }
             const r = e.h;
             if (r !== null) {
                 for (const e of Reflect.ownKeys(r)) {
                     const n = r[e];
-                    if (hasActiveOverride(n) && !unwrapOverride(n.o?.Oe)) delete t[e];
+                    if (hasActiveOverride(n) && !unwrapOverride(n.o?.Pe)) delete t[e];
                 }
             }
         }
@@ -575,7 +575,7 @@ function drainFolds() {
                 !plainProto(t.ovl ? t.v : i) ? Reflect.ownKeys(o) : e;
                 for (const e of n) {
                     const t = o[e];
-                    if (t !== undefined && t.Pe !== NOT_PENDING) {
+                    if (t !== undefined && t.Re !== NOT_PENDING) {
                         r = true;
                         break;
                     }
@@ -749,15 +749,15 @@ function drainFolds() {
             // projection recompute can run before the prior fold commits) — the
             // node's OWN current value is the true old side, and setSignal's
             // internal equality already checks exactly that.
-                        const f = e.del !== null && e.del.has(o) ? undefined : t[o];
-            setSignal(i, () => f);
+                        const l = e.del !== null && e.del.has(o) ? undefined : t[o];
+            setSignal(i, () => l);
         }
     }
-    const f = e.h;
-    if (f !== null) {
-        const n = o ?? Reflect.ownKeys(f);
+    const l = e.h;
+    if (l !== null) {
+        const n = o ?? Reflect.ownKeys(l);
         for (const r of n) {
-            const n = f[r];
+            const n = l[r];
             if (n !== undefined) setSignal(n, r in t && !(e.del !== null && e.del.has(r)));
         }
     }
@@ -881,9 +881,9 @@ i = true) {
             if (i?.get !== o?.get || i?.set !== o?.set || i?.value !== o?.value) setSignal(e, () => FORCE);
             return;
         }
-        const f = i?.value;
-        const l = o?.value;
-        if (!isEqual(f, l) && !targetsEqual(f, l)) setSignal(e, typeof l === "function" ? () => l : l);
+        const l = i?.value;
+        const f = o?.value;
+        if (!isEqual(l, f) && !targetsEqual(l, f)) setSignal(e, typeof f === "function" ? () => f : f);
     } else {
         const i = n[t];
         const o = r[t];
@@ -1030,7 +1030,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
     if (t === null) return false;
     for (const e of Reflect.ownKeys(t)) {
         const n = t[e];
-        if (n.Pe !== NOT_PENDING && n.Ae != null && n.Ae.sn !== true) return true;
+        if (n.Re !== NOT_PENDING && n.Ae != null && n.Ae.sn !== true) return true;
     }
     return false;
 }
@@ -1044,28 +1044,39 @@ function readSource(e) {
         const t = heldMaskView(e);
         if (t !== null) return t;
     }
-    // Signal-parity visibility (core read(): owner-context reads serve
-    // _pendingValue, context-free reads serve committed — effects recompute
-    // BEFORE commitPendingNodes in the flush, so the pending view must be
-    // servable). Drafts (setter window OR projection write-override) and
-    // owner-context reads see the pending backing; context-free reads see
-    // committed. Node reads apply the same rule, so both homes agree.
-        if (e.pb !== null && (inDraft(e) || getWriteOverride() || 
-    // Owner-context readers see the pending backing — EXCEPT held truth
-    // on an optimistic family (#3164 fold): a live pb on an opt family
-    // outside the draft/write-override windows is a staged landing
-    // (tentative drafts never outlive their setter), and only the
-    // authoritative postures and latest() see it (the backing-level twin
-    // of core read()'s A17-for-held-truth arm; ordinary readers keep
-    // committed until the transaction's reveal).
-    inOwnerContext() && !heldTruthMasked(e) || 
+    return pendingBackingVisible(e, false) ? e.pb : e.v;
+}
+
+/** The single pb-vs-committed visibility decision (#3147), shared by per-key
+ * backing reads (readSource) and deep()/snapshot composition (snapshotWalk)
+ * so the two reader families can never disagree about a HELD landing.
+ *
+ * Signal-parity visibility (core read(): owner-context reads serve
+ * _pendingValue, context-free reads serve committed — effects recompute
+ * BEFORE commitPendingNodes in the flush, so the pending view must be
+ * servable). Drafts (setter window OR projection write-override) and
+ * owner-context reads see the pending backing; context-free reads see
+ * committed. Node reads apply the same rule, so all homes agree.
+ *
+ * `speculative` is deep()/snapshot's posture: an untrack/deep PEEK that sees
+ * ordinary pending staging regardless of owner context (the documented
+ * divergence from context-free per-key reads) — but never through a hold:
+ * held truth stays masked exactly as it is for per-key readers. */ function pendingBackingVisible(e, t) {
+    return e.pb !== null && (inDraft(e) || getWriteOverride() || 
+    // Owner-context (and speculative-peek) readers see the pending
+    // backing — EXCEPT held truth on an optimistic family (#3164 fold):
+    // a live pb on an opt family outside the draft/write-override windows
+    // is a staged landing (tentative drafts never outlive their setter),
+    // and only the authoritative postures and latest() see it (the
+    // backing-level twin of core read()'s A17-for-held-truth arm;
+    // ordinary readers keep committed until the transaction's reveal).
+    (t || inOwnerContext()) && !heldTruthMasked(e) || 
     // A projection's pending backing is authoritative-elect: serve it to
     // context-free readers too UNLESS a transition is holding the node
     // commits (downstream async hold — stale committed is the contract)
     // or the reader is a CHILDREN_FORBIDDEN scope, which never observes
     // its own unsettled write (#3082, signal parity per #3006).
-    e.fam !== null && !heldTruthMasked(e) && !foldHeld(e) && !inForbiddenScope())) return e.pb;
-    return e.v;
+    e.fam !== null && !heldTruthMasked(e) && !foldHeld(e) && !inForbiddenScope());
 }
 
 /** #3164 fold: HELD truth on an optimistic family — a pending backing
@@ -1110,7 +1121,7 @@ function isOwnAccessor(e, t) {
 
 /** Active optimistic override on an armed node (armed slot idles at
  * NOT_PENDING; undefined = unarmed plain node). */ function hasActiveOverride(e) {
-    return e.o?.Oe !== undefined && e.o?.Oe !== NOT_PENDING;
+    return e.o?.Pe !== undefined && e.o?.Pe !== NOT_PENDING;
 }
 
 /** The reading computation is until()'s authoritative-view predicate — same
@@ -1145,14 +1156,14 @@ function isOwnAccessor(e, t) {
     // Authoritative-view reads (until()'s predicate) skip the override arm
     // only: staged pending values are authoritative, overrides are the
     // caller's optimism.
-    const n = !authoritativeServe() && hasActiveOverride(e) ? unwrapOverride(e.o?.Oe) : e.Pe !== NOT_PENDING && (latestReadActive || 
+    const n = !authoritativeServe() && hasActiveOverride(e) ? unwrapOverride(e.o?.Pe) : e.Re !== NOT_PENDING && (latestReadActive || 
     // Owner-context pending visibility — except HELD truth (#3164,
     // see CONFIG_HELD_TRUTH: fold-staged or entangle-stolen
     // confirming truth), which only authoritative/latest readers
     // see (core read()'s A17-for-held-truth twin; ordinary readers
     // keep committed until the transaction's reveal — latest() is
     // exempted by the leading arm above).
-    (inOwnerContext() || authoritativeServe()) && !(e.T & CONFIG_HELD_TRUTH && !authoritativeServe())) ? e.Pe : t;
+    (inOwnerContext() || authoritativeServe()) && !(e.T & CONFIG_HELD_TRUTH && !authoritativeServe())) ? e.Re : t;
     return n === FORCE ? t : n;
 }
 
@@ -1162,7 +1173,7 @@ function isOwnAccessor(e, t) {
  * node is linked only for adoption-swap notification, its value never
  * shadows the live chain. */ function serveDataKey(e, t, n, r, i) {
     const o = e.ch && r === e.v;
-    let f = n;
+    let l = n;
     // §6: on optimistic arrays LENGTH IS A VIEW, not a node value — one home
     // (backing ± presence overrides) for both length and indices makes torn
     // iteration impossible (a length node's value rides different visibility
@@ -1190,7 +1201,7 @@ function isOwnAccessor(e, t) {
         // seeding rule, applied to the read side (#3108).
         if (e.fam?.opt && e.pb === null && !authoritativeServe()) {
             const n = e.n?.[t];
-            if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.Oe);
+            if (n !== undefined && hasActiveOverride(n)) l = unwrapOverride(n.o?.Pe);
         }
     } else {
         if (i !== undefined) {
@@ -1202,28 +1213,28 @@ function isOwnAccessor(e, t) {
                 // parity): READ_SLOW = a global read window or non-plain node.
                 let e = readNodeFast(i);
                 if (e === READ_SLOW) e = read(i);
-                if (!o || hasActiveOverride(i)) f = e === FORCE ? n : e;
+                if (!o || hasActiveOverride(i)) l = e === FORCE ? n : e;
             } else if (!o || hasActiveOverride(i)) {
-                f = nodeValue(i, n);
+                l = nodeValue(i, n);
             }
         } else if (getObserver() !== null) {
             read(getNode(e, t, n));
         }
     }
     // Shallow stores serve data raw; store-proxy slots get boundary wrappers.
-        if (e.s) return serveShallow(e, t, f);
+        if (e.s) return serveShallow(e, t, l);
     if (i !== undefined) {
         // Wrap cache (see getNode): only wrappables are ever cached, so a hit
         // skips isWrappable too — pointer-compare replaces both checks.
-        if (i.pxv === f && f !== undefined) return draftServe(e, i.px);
-        if (!isWrappable(f)) return f;
-        const n = wrapNext(f, e, t);
+        if (i.pxv === l && l !== undefined) return draftServe(e, i.px);
+        if (!isWrappable(l)) return l;
+        const n = wrapNext(l, e, t);
         i.px = n;
-        i.pxv = f;
+        i.pxv = l;
         return draftServe(e, n);
     }
-    if (!isWrappable(f)) return f;
-    return draftServe(e, wrapNext(f, e, t));
+    if (!isWrappable(l)) return l;
+    return draftServe(e, wrapNext(l, e, t));
 }
 
 /** §6c store-wide status gate for reads that DON'T flow through a node:
@@ -1357,15 +1368,15 @@ const traps = {
         // that is own on NEITHER.
                 const o = e.ovl && r === e.pb;
         if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return undefined;
-        let f = r[t];
-        if (f === undefined ? !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t)) : false) {
+        let l = r[t];
+        if (l === undefined ? !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t)) : false) {
             // Inherited: prototype getters/methods run with the proxy receiver.
-            f = Reflect.get(r, t, n);
-            if (typeof f === "function") return f;
+            l = Reflect.get(r, t, n);
+            if (typeof l === "function") return l;
  // proto methods untracked
             // Reading a currently-absent own key subscribes to it (R12) — for any
             // target OUTSIDE its own draft scope, even mid-setter (#3037, above).
-                        if (f === undefined && !inDraft(e)) {
+                        if (l === undefined && !inDraft(e)) {
                 if (getObserver() !== null) read(getNode(e, t, undefined));
                 const n = e.n?.[t];
                 if (n) {
@@ -1373,19 +1384,19 @@ const traps = {
                     if (e.s) return serveShallow(e, t, r);
                     return isWrappable(r) ? draftServe(e, wrapNext(r, e, t)) : r;
                 }
-            } else if (f === undefined && inDraft(e) && e.fam?.opt && e.pb === null && 
+            } else if (l === undefined && inDraft(e) && e.fam?.opt && e.pb === null && 
             // AUTHORITATIVE drafts (landing folds) never seed from overrides —
             // the caller's optimism is not truth (has-trap twin below).
             !authoritativeServe()) {
                 const n = e.n?.[t];
-                if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.Oe);
+                if (n !== undefined && hasActiveOverride(n)) l = unwrapOverride(n.o?.Pe);
             }
-            if (e.s) return serveShallow(e, t, f);
-            return isWrappable(f) ? draftServe(e, wrapNext(f, e, t)) : f;
+            if (e.s) return serveShallow(e, t, l);
+            return isWrappable(l) ? draftServe(e, wrapNext(l, e, t)) : l;
         }
-        if (typeof f === "function" && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return f;
+        if (typeof l === "function" && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return l;
  // proto method
-                return serveDataKey(e, t, f, r, i);
+                return serveDataKey(e, t, l, r, i);
     },
     has(e, t) {
         if (t === $TARGET || t === $PROXY || t === $TRACK) return true;
@@ -1404,11 +1415,11 @@ const traps = {
                 if (hasActiveOverride(n)) r = !!i;
             } else if (!authoritativeServe()) {
                 const n = e.h?.[t];
-                if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Oe);
+                if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Pe);
             }
         } else if (e.fam?.opt && e.pb === null && !authoritativeServe()) {
             const n = e.h?.[t];
-            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Oe);
+            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Pe);
         }
         return r;
     },
@@ -1439,7 +1450,7 @@ const traps = {
                 const i = e.h[r];
                 if (!hasActiveOverride(i)) continue;
                 t ??= new Set(n);
-                if (unwrapOverride(i.o?.Oe)) t.add(r); else t.delete(r);
+                if (unwrapOverride(i.o?.Pe)) t.add(r); else t.delete(r);
             }
             if (t !== null) return [ ...t ];
         }
@@ -1457,7 +1468,7 @@ const traps = {
         if (!authoritativeServe() && e.fam?.opt && !inDraft(e)) {
             const n = e.h?.[t];
             if (n !== undefined && hasActiveOverride(n)) {
-                if (!unwrapOverride(n.o?.Oe)) return undefined;
+                if (!unwrapOverride(n.o?.Pe)) return undefined;
  // opt delete
                                 if (r === undefined) {
                     const n = e.n?.[t];
@@ -1493,23 +1504,23 @@ const traps = {
         // passes through by reference (#2932; markRawOne skips proxies), while
         // deep stores unwrap to raw backings.
                 const o = e.s ? n : unwrapValue(n);
-        const f = ensurePB(e);
+        const l = ensurePB(e);
         pendingNotify.add(e);
         // Array length writes implicitly delete indices — the written-keys bound
         // can't see them, so poison to the full scan for this batch. Index
         // writes implicitly GROW length, so arrays always record it alongside.
-                const l = pcOf(e);
-        if (Array.isArray(f)) {
-            if (t === "length") l.wk = WK_ALL; else if (l.wk !== WK_ALL) {
-                const e = l.wk ??= new Set;
+                const f = pcOf(e);
+        if (Array.isArray(l)) {
+            if (t === "length") f.wk = WK_ALL; else if (f.wk !== WK_ALL) {
+                const e = f.wk ??= new Set;
                 e.add(t);
                 e.add("length");
             }
-        } else if (l.wk !== WK_ALL) (l.wk ??= new Set).add(t);
+        } else if (f.wk !== WK_ALL) (f.wk ??= new Set).add(t);
         // Own data keys literally named "prototype"/"constructor" land as data —
         // defineProperty sidesteps a proto-chain setter named the same.
                 if (UNSAFE_KEYS.has(t)) {
-            Object.defineProperty(f, t, {
+            Object.defineProperty(l, t, {
                 value: o,
                 writable: true,
                 enumerable: true,
@@ -1521,14 +1532,14 @@ const traps = {
         // Overlay first-write DEFINES the own key: assignment through the proto
         // chain would reject on a non-writable committed property (the clone
         // path normalized descriptors for exactly this — R51 parity).
-                if (e.ovl && !hasOwn.call(f, t)) {
-            Object.defineProperty(f, t, {
+                if (e.ovl && !hasOwn.call(l, t)) {
+            Object.defineProperty(l, t, {
                 value: o,
                 writable: true,
                 enumerable: true,
                 configurable: true
             });
-        } else f[t] = o;
+        } else l[t] = o;
         if (e.del !== null) e.del.delete(t);
         // Shallow ingest: written records are sticky raw-marked (one entity is
         // never both deep-wrapped and raw — R41/#2932, shared invariant).
@@ -1558,8 +1569,8 @@ const traps = {
         };
         const o = ensurePB(e);
         pendingNotify.add(e);
-        const f = pcOf(e);
-        if (f.wk !== WK_ALL) (f.wk ??= new Set).add(t);
+        const l = pcOf(e);
+        if (l.wk !== WK_ALL) (l.wk ??= new Set).add(t);
         Object.defineProperty(o, t, n);
         if (e.del !== null) e.del.delete(t);
         if (i) notifyWrites(e);
@@ -1697,15 +1708,15 @@ function createStoreNext(e, t = false) {
             if (o === null || typeof o !== "object") continue;
             // Stored proxies (chained slots) resolve through their own target;
             // raw children through the family map, created on first visit.
-                        let f = o[$TARGET] ?? r.get(o);
-            if (f === undefined) {
+                        let l = o[$TARGET] ?? r.get(o);
+            if (l === undefined) {
                 if (!isWrappable(o)) continue;
                 wrapNext(o, e, n);
-                f = r.get(o);
-                if (f === undefined) continue;
+                l = r.get(o);
+                if (l === undefined) continue;
  // raw-marked: leaf by contract
                         }
-            walkT(f);
+            walkT(l);
         }
     };
     walkT(t);
@@ -1742,12 +1753,17 @@ function snapshotWalk(e, t, n) {
         if (e === undefined) break;
         if (e.fam !== null) n = e.fam;
         if (e.fam?.opt === true) (i ??= []).push(e);
+        // The shared visibility decision (#3147): the speculative peek serves
+        // pending staging, but a HELD landing is masked to committed exactly as
+        // it is for per-key readers — the two families must answer alike while
+        // a transaction holds store landings.
+                const t = pendingBackingVisible(e, true);
         // Snapshot runs mid-flush (tracked memos execute before commit), so a
         // pending prototype overlay must present as a REAL merged container.
-                if (e.ovl) materializePB(e);
-        const t = e.pb ?? e.v;
-        if (t === r) break;
-        r = t;
+                if (t && e.ovl) materializePB(e);
+        const o = t ? e.pb : e.v;
+        if (o === r) break;
+        r = o;
     }
     if (!isWrappable(r)) return r;
     // Optimistic families: compose the visible view; a composed view is a fresh
@@ -1759,15 +1775,15 @@ function snapshotWalk(e, t, n) {
             const i = t.get(r);
             if (i !== undefined) return i;
             const o = Array.isArray(e);
-            const f = o ? [] : Object.create(Object.getPrototypeOf(e));
-            t.set(r, f);
+            const l = o ? [] : Object.create(Object.getPrototypeOf(e));
+            t.set(r, l);
             for (const r of Reflect.ownKeys(e)) {
                 if (o && r === "length") continue;
                 const i = e[r];
-                f[r] = i !== null && typeof i === "object" ? snapshotWalk(i, t, n) : i;
+                l[r] = i !== null && typeof i === "object" ? snapshotWalk(i, t, n) : i;
             }
-            if (o) f.length = e.length;
-            return f;
+            if (o) l.length = e.length;
+            return l;
         }
     }
     const o = t.get(r);
@@ -1782,16 +1798,16 @@ function snapshotWalk(e, t, n) {
         t.set(r, i);
         for (const o of Reflect.ownKeys(r)) {
             if (e && o === "length") continue;
-            const f = Object.getOwnPropertyDescriptor(r, o);
-            if (typeof o === "symbol" && !f.enumerable) continue;
-            if (f.get || f.set) {
-                Object.defineProperty(i, o, f);
+            const l = Object.getOwnPropertyDescriptor(r, o);
+            if (typeof o === "symbol" && !l.enumerable) continue;
+            if (l.get || l.set) {
+                Object.defineProperty(i, o, l);
                 continue;
             }
-            const l = f.value;
-            const u = l !== null && typeof l === "object" ? snapshotWalk(l, t, n) : l;
-            if (f.enumerable && f.writable && f.configurable) i[o] = u; else Object.defineProperty(i, o, {
-                ...f,
+            const f = l.value;
+            const u = f !== null && typeof f === "object" ? snapshotWalk(f, t, n) : f;
+            if (l.enumerable && l.writable && l.configurable) i[o] = u; else Object.defineProperty(i, o, {
+                ...l,
                 value: u
             });
         }
@@ -1801,22 +1817,22 @@ function snapshotWalk(e, t, n) {
     // UNOWNED (shared/user) subtrees keep identity unless a descendant
     // substituted; copy-on-substitution preserves the documented CoW contract.
         t.set(r, r);
-    let f = null;
+    let l = null;
     for (const e of Reflect.ownKeys(r)) {
         const i = Object.getOwnPropertyDescriptor(r, e);
         if (!i || i.get || i.set) continue;
         const o = i.value;
         if (o === null || typeof o !== "object") continue;
-        const l = snapshotWalk(o, t, n);
-        if (l !== o) {
-            if (f === null) {
-                f = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
-                t.set(r, f);
+        const f = snapshotWalk(o, t, n);
+        if (f !== o) {
+            if (l === null) {
+                l = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
+                t.set(r, l);
             }
-            f[e] = l;
+            l[e] = f;
         }
     }
-    return f ?? r;
+    return l ?? r;
 }
 
 export { adoptPB, arrayStructureChanged, authoritativeRead, authoritativeServe, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, materializePB, membershipChanged, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, pcOf, runAuthoritative, snapshotNext, stagedTruthPB, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetterNext, targetIsPlain, targetsEqual, unwrapValue, wrapNext };

package/dist/types/core/attribution-hooks.d.ts

@@ -36,6 +36,17 @@ export interface AttributionHooks {
     write(el: Signal<any> | Computed<any>, prev: unknown, value: unknown): void;
     /** refresh() invalidated this node (self-invalidation, no dep changed). */
     refreshed(el: Computed<any>): void;
+    /**
+     * A new async flight entered the system (`_inFlight` was just assigned
+     * during a recompute of `el`). Always fired inside the owning recompute —
+     * both call paths (core's recompute and the projection self-registration)
+     * run within one — so the engine can read the current frame stack to link
+     * the flight to the change that caused it (waterfall chaining). `flight`
+     * is the registered thenable/iterable itself: the engine keys a first-seen
+     * origin registry on its identity, so shared and preloader-marked promises
+     * carry their true start time instead of the moment the graph saw them.
+     */
+    flightStart(el: Computed<any>, flight: object): void;
     /** An async landing is about to apply its value (before any branch). */
     asyncStart(el: Computed<any>): void;
     /**

package/dist/types/core/attribution.d.ts

@@ -143,6 +143,24 @@ export interface AttributionOptions {
      * disables.
      */
     wideWrites?: number | false;
+    /**
+     * Async-waterfall warning: emit a diagnostic when an async flight that
+     * could only start after an upstream flight resolved (its recompute's
+     * cause chain reaches the upstream's async landing, and its origin
+     * post-dates that landing) forms a sequential chain of 2+ flights, each
+     * of which took at least `minFlightMs` (default 50ms). The duration gate
+     * is one safety valve for what the graph cannot see: a settled
+     * preload/cache hit resolves fast and never warns. In-flight preloads are
+     * absolved by origin: `markFlight()` stamps (and first-seen identity)
+     * prove work predated the upstream landing — parallel, not sequential.
+     * Chains of 2 emit at `info` severity, structured channel only (a
+     * dependent fetch is sometimes intrinsic, and unmarked external preloads
+     * are invisible); 3+ escalate to `warn` with console output. `false`
+     * disables.
+     */
+    waterfalls?: {
+        minFlightMs: number;
+    } | false;
 }
 export interface ScopeCost {
     name: string;
@@ -186,6 +204,36 @@ export interface Attribution {
         scopes: ScopeCost[];
         writes: WriteCost[];
     };
+    /**
+     * Every graph-provable sequential flight chain observed since enable()
+     * (ring-buffered like history()). Facts, not verdicts: chains are recorded
+     * regardless of the duration gate — the ASYNC_WATERFALL diagnostic is the
+     * thresholded view of the same data.
+     */
+    waterfalls(): readonly WaterfallRecord[];
+    /**
+     * Cooperative preload declaration: stamp a flight object (promise or async
+     * iterable) with its true kickoff time BEFORE the reactive graph sees it.
+     * A route preloader or query cache calls this on the promise it hands out
+     * (on the WRAPPER it mints, with the original kickoff time — wrapping
+     * defeats identity tracking otherwise); any dependent that later awaits it
+     * is then judged against the real start — work already in the air when its
+     * upstream landed is parallel, never a waterfall link. Callable while
+     * attribution is disabled (marks made at navigation time must survive a
+     * later enable()). Dev-only, like the whole DEV surface.
+     */
+    markFlight(flight: object, startedAt?: number): void;
     format: typeof formatRerun;
 }
+/** One landed flight: its node name, wall duration, and upstream chain. */
+export interface FlightLink {
+    name: string;
+    ms: number;
+}
+export interface WaterfallRecord {
+    /** Sequential flights, oldest first, ending at the flight that landed. */
+    chain: FlightLink[];
+    /** Summed wall time of the chain — the serialized cost. */
+    sequentialMs: number;
+}
 export declare const attribution: Attribution;

package/dist/types/core/dev.d.ts

@@ -6,8 +6,14 @@ export interface DevHooks {
     onUpdate?: () => void;
     onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
 }
-export type DiagnosticSeverity = "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WIDE_WRITE";
+/**
+ * `info` is the advisory tier: a structural fact worth surfacing that is not
+ * presumptively a bug (e.g. a 2-deep sequential fetch chain, which may be an
+ * intrinsic data dependency). Budget/assertion consumers should treat only
+ * `warn`/`error` as failures unless they opt in to `info`.
+ */
+export type DiagnosticSeverity = "info" | "warn" | "error";
+export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "SETTLE_WALK_UNINITIALIZED_SOURCE" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WIDE_WRITE" | "ASYNC_WATERFALL" | "HOT_SCOPE_FANOUT";
 export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error" | "perf" | "graph";
 /** First warning when a node's live edge count reaches this size. */
 export declare const GRAPH_SIZE_WARN_AT = 2000;

package/dist/types/core/scheduler.d.ts

@@ -209,6 +209,11 @@ export declare const globalQueue: GlobalQueue;
  */
 export declare function flush(): void;
 export declare function flush<T>(fn: () => T): T;
+/** A fresh, unentered transaction (#3146): the optimistic store's truth
+ * flight DECLARES an owned transaction instead of relying on whatever the
+ * ambient adoption machinery stamped on its firewall. Activate it with
+ * initTransition; it is a plain batch until then. */
+export declare function createTransition(): Transition;
 export declare function currentTransition(transition: Transition): Transition;
 export declare function setActiveTransition(transition: Transition | null): void;
 export declare function runInTransition<T>(transition: Transition, fn: () => T): T;

package/dist/types/signals.d.ts

@@ -365,17 +365,6 @@ export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInf
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
  */
 export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
-/**
- * @deprecated `createEffect(compute)` (single argument) is no longer supported.
- * Pass a separate effect function as the second argument:
- * `createEffect(compute, effect)`. See [MISSING_EFFECT_FN].
- *
- * - For a side effect that reacts to changes, split the work:
- *   `createEffect(() => signal(), value => doWork(value))`.
- * - For a derived value, use `createMemo(() => signal())`.
- * - For a one-shot side effect at construction time, just call the function.
- */
-export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>): never;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements
  * are created and updated but not necessarily connected.