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

package/dist/observe/core/verdict.js

@@ -323,6 +323,9 @@ let probeFound = false;
         const u = (n.m & STATUS_PENDING) !== 0 && !quietPending(n);
         if (e.l & CONFIG_GUESS) {
             if (probing && (u || e.ue !== NOT_PENDING && (!e.Ye || !e.Ye(e.T.V, e.ue)))) probeFound = true;
+            // A lane a correction folded under (D-34): `latest()` shows the hold's
+            // world whole — the truth beneath each guess, else what it covered.
+                        if (latestActive && r.folded) return r.folded(null, e);
             return e.T.V;
         }
         if (probing && u) probeFound = true;

package/dist/observe/map.js

@@ -305,7 +305,7 @@ function updateKeyedMap() {
                 this.Kt && (this.Kt = []);
                 this.xt && (this.xt = []);
             }
-            if (this.L && !this.vt[0]) {
+            if (this.L && !this.vt.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.je[0]?.dispose();
@@ -543,7 +543,7 @@ function updateRepeat() {
                 // Reset offset to match the cleared data (#2767, repro 2).
                                 this.$t = 0;
             }
-            if (this.L && !this.vt[0]) {
+            if (this.L && !this.vt.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.je[0]?.dispose();

package/dist/observe/signals.js

@@ -296,7 +296,12 @@ function createMemo(e, t) {
             o = undefined;
         }
         runWithOwner(n, () => {
-            effect(() => (c(), o = getOwner()), t => {
+            effect(() => {
+                const e = getOwner();
+                o = e;
+                c();
+                return e;
+            }, t => {
                 o = undefined;
                 r?.();
                 const n = (e.effect || e)?.();

package/dist/observe/store/affects.js

@@ -38,8 +38,8 @@ const scopes = new Map;
 function scopeOf(e, o) {
     let n = scopes.get(e);
     if (n === undefined) scopes.set(e, n = {
-        eo: new Set,
-        oo: [],
+        oo: new Set,
+        no: [],
         Vt: o
     });
     return n;
@@ -47,15 +47,15 @@ function scopeOf(e, o) {
 
 /** The nodes an `affects(store[, key])` declaration marks (affects.ts
  * registers each). */ function storeMarks(e, o) {
-    const n = GlobalQueue.no(e, o === undefined ? $AFFECTS : o);
+    const n = GlobalQueue.so(e, o === undefined ? $AFFECTS : o);
     const t = scopeOf(n, o);
     if (o === undefined) {
         const o = [ n ];
         walk(e.px, t, o, e.fam, new Set);
         return o;
     }
-    t.eo.add(e.v);
-    if (e.pb !== null) t.eo.add(e.pb);
+    t.oo.add(e.v);
+    if (e.pb !== null) t.oo.add(e.pb);
     return [ n ];
 }
 
@@ -63,14 +63,14 @@ function scopeOf(e, o) {
  * the committed backing both, when a draft is open; an optimistic family's
  * view), every live node under each record into `found`. Untracked by
  * construction: raws, never traps. */ function walk(e, o, n, t, s) {
-    if (!GlobalQueue.so(e)) return;
+    if (!GlobalQueue.fo(e)) return;
     const f = e[$TARGET] ?? lookupTarget(e, t);
     let r = f !== undefined ? f.pb ?? f.v : e;
     if (s.has(r)) return;
     s.add(r);
-    o.eo.add(r);
+    o.oo.add(r);
     if (f !== undefined) {
-        if (f.pb !== null) o.eo.add(f.v);
+        if (f.pb !== null) o.oo.add(f.v);
         // The writer's view: the tick's own unflushed guesses are in motion too.
                 if (f.fam?.opt === true) r = optHooks.view(f, r, true);
         const e = f.n;
@@ -96,7 +96,7 @@ function scopeOf(e, o) {
     for (const [t, s] of scopes) {
         if (t === n || s.Vt !== undefined && s.Vt !== o) continue;
         for (let o = e.v; ;) {
-            if (s.eo.has(o)) return t;
+            if (s.oo.has(o)) return t;
             const e = o?.[$TARGET];
             if (e === undefined) break;
             const n = e.pb ?? e.v;
@@ -112,17 +112,17 @@ function scopeOf(e, o) {
  * no work. */ const hooks = {
     // A node born on a record a live mark covers inherits it (released with
     // the carrier's last registration).
-    fo(e, o, n) {
+    ro(e, o, n) {
         if (scopes.size === 0 || n === $AFFECTS) return;
         const t = covering(e, n, o);
         if (!t) return;
         GlobalQueue.N(o);
-        scopes.get(t).oo.push(o);
+        scopes.get(t).no.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) {
+    io(e, o) {
         if (e.n?.[$AFFECTS]?.T?.I || covering(e, o)) GlobalQueue.bt();
     }
 };
@@ -136,7 +136,7 @@ function scopeOf(e, o) {
     const o = scopes.get(e);
     if (o === undefined) return;
     scopes.delete(e);
-    releaseMarksHook(o.oo);
+    releaseMarksHook(o.no);
 }
 
 export { installStoreAffects, releaseMarkScope, storeMarks };

package/dist/observe/store/optimistic.js

@@ -1,12 +1,12 @@
-import { CONFIG_OVERRIDE, CONFIG_AUTO_DISPOSE, NOT_PENDING } from "../core/constants.js";
+import { CONFIG_OVERRIDE, CONFIG_GUESS, EFFECT_RENDER, CONFIG_CHILDREN_FORBIDDEN, NOT_PENDING, CONFIG_SLOT_NODE, CONFIG_AUTO_DISPOSE } from "../core/constants.js";
 
-import { computed, ext, untrack, read, isEqual } from "../core/core.js";
+import { computed, joinPassAt, ext, untrack, read, isEqual } from "../core/core.js";
 
 import { pendingGuessOf, optimisticWrite } from "../core/lanes.js";
 
 import { getOwner } from "../core/owner.js";
 
-import { GlobalQueue, txOf, list, insertSubs, laneDirty, notifyEpoch, schedule } from "../core/scheduler.js";
+import { GlobalQueue, txOf, insertSubs, joinFuture, resolveTx, passLane, list, laneDirty, notifyEpoch, schedule } from "../core/scheduler.js";
 
 import { runProjectionComputed } from "./projection.js";
 
@@ -93,16 +93,16 @@ function notifyOptimisticWrites(e, n) {
         // A chained draft holds the inner store's raws; a raw is the inner slot it
         // resolves to (as a read of it serves) — the row a held write staged is
         // the same row, not a guess over the slot (#3796).
-                const a = n[t];
-        const f = unwrapValue(o && a ? resolveChainedRaw(e, t, a) : a);
+                const u = n[t];
+        const f = unwrapValue(o && u ? resolveChainedRaw(e, t, u) : u);
         if (!(t in i)) {
             guess(getNode(e, t), t, false, f);
             guess(getHasNode(e, t), t, true, true);
             s = true;
         } else {
             const n = i[t];
-            const a = unwrapValue(o && n ? resolveChainedRaw(e, t, n) : n);
-            if (!isEqual(a, f) && !targetsEqual(a, f)) {
+            const u = unwrapValue(o && n ? resolveChainedRaw(e, t, n) : n);
+            if (!isEqual(u, f) && !targetsEqual(u, f)) {
                 guess(getNode(e, t), t, false, f);
                 if (r) s = true;
             }
@@ -122,29 +122,31 @@ function notifyOptimisticWrites(e, n) {
     if (s) {
         const o = r ? n.map(unwrapValue) : shallowKeys(n);
         // The rows the setter removed from the view it saw, by key: a later
-        // re-base over another action's truth must not bring them back.
+        // re-base over another action's truth must not bring them back. A set
+        // (empty or not) marks a keyed arrangement guess (`fold`).
                 let s = null;
-        const a = e.fam.key;
-        if (r && a !== null && a !== undefined) {
+        const u = e.fam.key;
+        if (r && u !== null && u !== undefined) {
+            s = new Set;
             const e = new Set;
             for (let n = 0; n < o.length; n++) {
-                const t = isWrappable(o[n]) ? a(o[n]) : undefined;
+                const t = isWrappable(o[n]) ? u(o[n]) : undefined;
                 if (t !== undefined) e.add(t);
             }
             for (let n = 0; n < i.length; n++) {
                 const t = unwrapValue(i[n]);
-                const r = isWrappable(t) ? a(t) : undefined;
-                if (r !== undefined && !e.has(r)) (s ??= new Set).add(r);
+                const r = isWrappable(t) ? u(t) : undefined;
+                if (r !== undefined && !e.has(r)) s.add(r);
             }
         }
         optimisticWrite(getContainerNode(e), new LaneView(o, t, s));
     }
     if (e.dk !== null) optimisticWrite(e.dk, {});
     markOverlaid(e);
-    const a = optStaged.get(e);
-    if (a === undefined) return null;
+    const u = optStaged.get(e);
+    if (u === undefined) return null;
     optStaged.delete(e);
-    return a;
+    return u;
 }
 
 /** The container comparator's lane arm (store.ts `containerEquals`): an
@@ -228,18 +230,18 @@ function arrangementEqual(e, n, t) {
             }
         }
         for (let s = 0; s < n.length; s++) {
-            const a = n[s];
+            const u = n[s];
             let f;
-            if (isWrappable(a)) {
+            if (isWrappable(u)) {
                 if (o !== null) {
-                    const e = t(a);
+                    const e = t(u);
                     if (e !== undefined) f = o.get(e);
                 } else if (s < i && isWrappable(unwrapValue(r[s]))) f = r[s];
             }
             if (f !== undefined) {
-                if (unwrapValue(f) !== a) reconcileDraft(f, a, t);
+                if (unwrapValue(f) !== u) reconcileDraft(f, u, t);
                 if (e[s] !== f) e[s] = f;
-            } else if (unwrapValue(e[s]) !== a) e[s] = a;
+            } else if (unwrapValue(e[s]) !== u) e[s] = u;
         }
         if (e.length !== n.length) e.length = n.length;
         return;
@@ -268,66 +270,105 @@ function arrangementEqual(e, n, t) {
  * node is born for it as the lane's derivation), on `length` only when the
  * committed length differs, and as the `LaneView`'s base for structural
  * reads. Unkeyed families compose
- * positionally — the guess stands as written (the documented residue). */ GlobalQueue.an = (e, n) => {
-    const t = e.O;
-    if (t === undefined || e.Vt !== $TRACK) return;
-    const i = e.T.V;
-    if (!(i instanceof LaneView)) return;
-    if (!Array.isArray(n) || !Array.isArray(i.rows)) {
-        i.base = n;
+ * positionally — the guess stands as written (the documented residue). */ GlobalQueue.an = (e, n, t) => {
+    if (!t) return fold(e, n);
+    const i = e.O;
+    if (i === undefined || e.Vt !== $TRACK) return;
+    const r = e.T.V;
+    if (!(r instanceof LaneView)) return;
+    if (!Array.isArray(n) || !Array.isArray(r.rows)) {
+        r.base = n;
         return;
     }
-    const r = t.fam?.key ?? null;
-    if (r === null) return;
-    const o = new Map;
+    const o = i.fam?.key ?? null;
+    if (o === null) return;
+    const s = new Map;
     for (let e = 0; e < n.length; e++) {
         const t = n[e];
-        const i = isWrappable(t) ? r(t) : undefined;
-        if (i !== undefined && !o.has(i)) o.set(i, t);
+        const i = isWrappable(t) ? o(t) : undefined;
+        if (i !== undefined && !s.has(i)) s.set(i, t);
     }
-    const s = new Set;
-    const a = [];
-    const f = i.rows;
-    for (let e = 0; e < f.length; e++) {
-        const n = f[e];
-        const t = isWrappable(n) ? r(n) : undefined;
-        const i = t !== undefined ? o.get(t) : undefined;
+    const u = new Set;
+    const f = [];
+    const a = r.rows;
+    for (let e = 0; e < a.length; e++) {
+        const n = a[e];
+        const t = isWrappable(n) ? o(n) : undefined;
+        const i = t !== undefined ? s.get(t) : undefined;
         if (i !== undefined) {
-            a.push(i);
-            s.add(t);
-        } else a.push(n);
+            f.push(i);
+            u.add(t);
+        } else f.push(n);
     }
-    const u = i.removed;
+    const l = r.removed;
     for (let e = 0; e < n.length; e++) {
         const t = n[e];
-        const i = isWrappable(t) ? r(t) : undefined;
-        if (i !== undefined && !s.has(i) && (u === null || !u.has(i))) a.push(t);
+        const i = isWrappable(t) ? o(t) : undefined;
+        if (i !== undefined && !u.has(i) && (l === null || !l.has(i))) f.push(t);
     }
-    i.rows = a;
-    i.base = a;
-    const l = txOf(e);
-    const c = committed(t);
-    const d = t.n;
-    for (let e = 0; e < a.length; e++) {
-        const n = d?.[e];
+    r.rows = f;
+    r.base = f;
+    const c = txOf(e);
+    const d = committed(i);
+    const p = i.n;
+    for (let e = 0; e < f.length; e++) {
+        const n = p?.[e];
         // A slot the lane does not own shows the committed row: it becomes the
         // lane's only where the composed row is another row (by key — the same
         // key's new object is the same row, its target adopted it).
                 if (n === undefined) {
-            if (!sameRow(c[e], a[e], r)) laneSet(getNode(t, e), a[e], l);
-        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.V : c[e], a[e], r)) laneSet(n, a[e], l);
+            if (!sameRow(d[e], f[e], o)) laneSet(getNode(i, e), f[e], c);
+        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.V : d[e], f[e], o)) laneSet(n, f[e], c);
     }
-    if (d !== null) {
-        for (let e = a.length; ;e++) {
-            const n = d[e];
+    if (p !== null) {
+        for (let e = f.length; ;e++) {
+            const n = p[e];
             if (n === undefined) break;
-            laneSet(n, undefined, l);
+            laneSet(n, undefined, c);
         }
-        const e = d.length;
-        if (e !== undefined && (e.l & CONFIG_OVERRIDE || c.length !== a.length)) laneSet(e, a.length, l);
+        const e = p.length;
+        if (e !== undefined && (e.l & CONFIG_OVERRIDE || d.length !== f.length)) laneSet(e, f.length, c);
     }
 };
 
+/** D-34 for a keyed arrangement guess: rows by key, not positions. A
+ * current truth that differs folds into the hold beneath it instead of
+ * voiding the lane: the guess stays the lane's value and the screen's until
+ * the hold commits, where rows match by key, and the graph outside the lane
+ * re-derives from the truth now (`foldedRead`). A confirmation is silent
+ * (A17): only truth readers are told. True: the lane stages the truth
+ * beneath (`laneWrite`). */ function fold(e, n) {
+    const t = e.O?.k;
+    const i = txOf(e);
+    // A guess the screen never showed is void at the correction (D-34); a
+    // keyed arrangement guess's view carries its removed-keys set.
+        if (!i.It || !(t?.l & CONFIG_OVERRIDE) || !t.T.V?.removed) return false;
+    const r = e.T.V;
+    if ((!e.Ye || !e.Ye(r, n)) && !GlobalQueue.sn(r, n)) {
+        i.folded = foldedRead;
+        insertSubs(e);
+    } else GlobalQueue.tn?.(i);
+    joinFuture(resolveTx(i._parent ?? i));
+    return true;
+}
+
+/** A folded lane's guess read by a deriving pass outside the lane, tracked
+ * or not (`untrack` is about dependencies, not about which world a pass
+ * derives from), or by `latest()` (`c` null): the hold's world — the truth
+ * staged beneath the guess, else the value it covered — and the pass joins
+ * the hold. Lane passes and the screen keep the guess: held truth is masked
+ * from lane passes only (#3164). The store's own derive reconciles its
+ * landings against the arrangement the guesses made: it is the author, not
+ * a reader. */ function foldedRead(e, n) {
+    if (e !== null) {
+        if (!(n.l & CONFIG_GUESS) || passLane !== null || e.i === EFFECT_RENDER || e.l & CONFIG_CHILDREN_FORBIDDEN || n.O?.fam?.node === e) return NOT_PENDING;
+        const t = txOf(n);
+        joinPassAt(e, resolveTx(t._parent ?? t));
+    }
+    if (n.ue !== NOT_PENDING) return n.ue;
+    return n.l & CONFIG_SLOT_NODE ? GlobalQueue.fn(n) : n.Ie;
+}
+
 function sameRow(e, n, t) {
     if (e === n) return true;
     if (!isWrappable(e) || !isWrappable(n)) return false;
@@ -521,11 +562,11 @@ i = false) {
     if (s !== null) {
         for (const e of Reflect.ownKeys(s)) {
             const o = s[e];
-            let a;
-            if (o.l & CONFIG_OVERRIDE) a = t(o); else if (!i || (a = pendingGuessOf(o)) === NOT_PENDING) continue;
-            const f = !!a;
-            const u = r ?? n;
-            if (!f && e in u) delete ensure()[e];
+            let u;
+            if (o.l & CONFIG_OVERRIDE) u = t(o); else if (!i || (u = pendingGuessOf(o)) === NOT_PENDING) continue;
+            const f = !!u;
+            const a = r ?? n;
+            if (!f && e in a) delete ensure()[e];
         }
     }
     return r ?? n;
@@ -538,7 +579,7 @@ function createOptimisticStore(e, n, t) {
     // createProjectionInternal).
         const o = i ? n || {} : e;
     const s = r?.key === undefined ? "id" : r.key;
-    const a = {
+    const u = {
         map: new WeakMap,
         node: null,
         live: new Set,
@@ -546,9 +587,9 @@ function createOptimisticStore(e, n, t) {
         opt: true,
         key: typeof s === "function" ? s : s === null ? null : e => isWrappable(e) ? e[s] : undefined
     };
-    const f = wrap(o, null, null, a);
+    const f = wrap(o, null, null, u);
     nameStore(f, r?.name, r?.loc);
-    if (a.shallow) {
+    if (u.shallow) {
         f[$TARGET].s = true;
         markRawIngest(o);
     }
@@ -564,11 +605,11 @@ function createOptimisticStore(e, n, t) {
             loc: r.loc
         };
         const i = computed(() => {
-            if (!a.node) a.node = getOwner();
+            if (!u.node) u.node = getOwner();
             runProjectionComputed(f, n, s);
         }, t);
         i.l &= ~CONFIG_AUTO_DISPOSE;
-        a.node = i;
+        u.node = i;
     }
     return [ f, e => storeSetter(f, e) ];
 }

package/dist/observe/store/store.js

@@ -14,7 +14,7 @@ import { getOwner, getObserver } from "../core/owner.js";
 
 import { insertIntoHeap } from "../core/heap.js";
 
-import { txOf, flushTransaction, holdNode, joinFuture, insertSubs, schedule, passLane, globalQueue, queuePendingNode, GlobalQueue, installStoreHooks, joinPassTx, dirtyQueue } from "../core/scheduler.js";
+import { txOf, flushTransaction, holdNode, joinFuture, insertSubs, schedule, passLane, globalQueue, queuePendingNode, resolveTx, GlobalQueue, installStoreHooks, joinPassTx, dirtyQueue } from "../core/scheduler.js";
 
 import { lookupTarget, storeOwners, setLookup, $OWNER, isOwned, markDescendants, devAssertNeverUserMutation } from "./target.js";
 
@@ -240,7 +240,7 @@ function releaseSlot(e) {
 /** A node was born on `target`: a family target enters the live index. */ function noteNode(e, n, t) {
     if (e.fam !== null) e.fam.live.add(e);
     markDescendants(e);
-    if (affectsHooks !== null) affectsHooks.fo(e, n, t);
+    if (affectsHooks !== null) affectsHooks.ro(e, n, t);
 }
 
 // Shared slot-node release handler: registered once; the core sweep
@@ -270,8 +270,13 @@ setSlotUnobserved(e => {
  // a node-less staging holds nothing (`stageOn`)
     // Held by the container's transaction only for a key the HELD staging
     // changed — a mainline layer's change above it stages mainline. (A
-    // container carrying a guess is a lane's: the flush's park decides.)
-        if ((o.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && heldKeyChanged(e, r)) holdNode(n, txOf(o));
+    // container carrying a guess is a lane's: the flush's park decides —
+    // unless a correction folded under the guess, D-34: the key is that
+    // correction's hold's.)
+        if (o.l & CONFIG_HELD && heldKeyChanged(e, r)) {
+        const e = txOf(o);
+        if (!(o.l & CONFIG_OVERRIDE) || e.folded) holdNode(n, resolveTx(e._parent ?? e));
+    }
     // A28 (4): a batch written inside a creation-time pass is promoted — its
     // late-materialized leaf with it.
         if (o.l & CONFIG_PROMOTED) notePromotedWrite(n);
@@ -787,9 +792,9 @@ installStoreHooks(storePark, () => {
 });
 
 /** The store half of `affects()` (store/affects.ts) makes its marks' nodes
- * and walks records through these: it never imports the engine. */ GlobalQueue.no = getNode;
+ * and walks records through these: it never imports the engine. */ GlobalQueue.so = getNode;
 
-GlobalQueue.so = isWrappable;
+GlobalQueue.fo = isWrappable;
 
 /** A projection's creation run commits directly (a memo's first value is
  * its `_value`, not a staging): the draft still writes a clone of the seed,
@@ -1578,7 +1583,7 @@ const traps = {
                 }
         // (The witness before the pull: a mark on an uninitialized derived
         // store is witnessed, then the pull throws — loading, declared pending.)
-                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.ro(e, n);
+                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(e, n);
         if (e.fam !== null) pullFamily(e);
         // Hot inline case: existing PLAIN node (non-accessor) read outside any
         // draft — the dbmon/uibench effect re-read shape. Core's `read()` serves
@@ -1675,7 +1680,7 @@ const traps = {
         if (n === $OWNER || n === $RECORD) return false;
         // (The witness before the pull: a mark on an uninitialized derived
         // store is witnessed, then the pull throws — loading, declared pending.)
-                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.ro(e, n);
+                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(e, n);
         if (e.fam !== null) pullFamily(e);
         const t = readSource(e, n);
         // A tracked reader's presence node answers (born from the two frames;
@@ -1700,14 +1705,14 @@ const traps = {
         return n in t && !(e.del !== null && t === e.pb && e.del.has(n));
     },
     ownKeys(e) {
-        if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.ro(e, undefined);
+        if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(e, undefined);
         if (e.fam !== null) pullFamily(e);
         return visibleKeys(e, enumerationSource(e));
     },
     getOwnPropertyDescriptor(e, n) {
         if (n === $OWNER || n === $RECORD) return undefined;
         const t = getObserver();
-        if (verdict !== null && affectsHooks !== null && t === null) affectsHooks.ro(e, n);
+        if (verdict !== null && affectsHooks !== null && t === null) affectsHooks.io(e, n);
         if (e.fam !== null) pullFamily(e);
         // An enumerator (spread, Object.entries) already holds the container
         // node and reads its frame; a descriptor read on its own tracks
@@ -1741,7 +1746,9 @@ const traps = {
     set(e, n, t) {
         const r = inDraft(e);
         const o = !r && writeOverride;
-        if (!r && !o) return true;
+        if (!r && !o) {
+            return true;
+        }
         if (n === "__proto__") return true;
  // pollution guard (core R30)
                 const i = e.s ? t : unwrapValue(t);
@@ -1790,7 +1797,9 @@ const traps = {
     defineProperty(e, n, t) {
         const r = inDraft(e);
         const o = !r && writeOverride;
-        if (!r && !o) return true;
+        if (!r && !o) {
+            return true;
+        }
         if (n === "__proto__") return true;
         if (t.get || t.set) e.a = true;
         if ("value" in t) t = {
@@ -1808,7 +1817,9 @@ const traps = {
     deleteProperty(e, n) {
         const t = inDraft(e);
         const r = !t && writeOverride;
-        if (!t && !r) return true;
+        if (!t && !r) {
+            return true;
+        }
         const o = ensurePB(e);
         touch(e, n);
         // The key count (`kc`, the overlay gate and the rebuild cap) follows a
@@ -1903,9 +1914,7 @@ function createStore(e, n) {
     }
     {
         const e = getOwner();
-        // Dev-tier graph registration (owner signal lists, onGraph); the
-        // `_owner` write itself never reaches the proxy, see storeOwners.
-                registerGraph(r, e);
+        registerGraph(r, e);
         // Only once the engine is installed, like the node stamping it feeds: a
         // WeakMap.set per fresh store is a growing ephemeron table and,
         // disabled, buys nothing.

package/dist/prod/boundaries.js

@@ -12,7 +12,7 @@ import { enqueueSub } from "./core/heap.js";
 
 import { createOwner, getOwner, cleanup, dispose } from "./core/owner.js";
 
-import { globalQueue, haltReactivity, passLane, joinFuture, GlobalQueue, flushTransaction, heldUnder, setPassLane, txOf, unhold, laneStageHook, schedule, installBoundaryHooks } from "./core/scheduler.js";
+import { globalQueue, haltReactivityAt, haltReactivity, passLane, joinFuture, GlobalQueue, flushTransaction, heldUnder, setPassLane, txOf, unhold, laneStageHook, schedule, installBoundaryHooks } from "./core/scheduler.js";
 
 import { flatten } from "./flatten.js";
 
@@ -349,7 +349,7 @@ function createBoundary(e, n, r, t) {
             } catch (e) {
                 if (!(e instanceof NotReadyError)) {
                     if (!globalQueue.notify(getOwner(), STATUS_ERROR, STATUS_ERROR, e)) {
-                        haltReactivity(e);
+                        if (false) ; else haltReactivity(e);
                         throw e;
                     }
                     return;

package/dist/prod/core/async.js

@@ -144,7 +144,9 @@ function releaseSettledDependents(e) {
     // Staged whether or not the flush has joined a hold yet: a pass that runs
     // before its async sibling joins is the seam's to decide, like a value
     // (#4109). A flush that parks nothing publishes it at its commit (S-38).
-    if (!(e.l & CONFIG_HELD || n && e.R & REACTIVE_STAGED_READ && globalQueue.q) || passLane) return false;
+    // Not a projection's derive: its readers learn its error through the
+    // family, which the commit's publish never reaches (#4189).
+    if (!(e.l & CONFIG_HELD || n && e.R & REACTIVE_STAGED_READ && globalQueue.q && !e.fam) || passLane) return false;
     // The node answered (an error ends the wait — no longer pending, nor
     // blocked); a shown error stays its display until the commit.
         clearPendingSources(e);

package/dist/prod/core/context.js

@@ -33,6 +33,8 @@ import { getOwner } from "./owner.js";
         let r = t.A[e.id];
     if (r === undefined) r = e.defaultValue;
     if (r === undefined) {
+        // Dev names the context and why it has no value: no provider, or a
+        // provider that passed `undefined` (the key is set, to `undefined`).
         throw new ContextNotFoundError;
     }
     return r;