@solidjs/signals 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/prod/map.js

@@ -21,24 +21,24 @@ function mapArray(t, s, i) {
     const r = s.length > 1;
     const n = s;
     const h = {
-        jt: createOwner(),
-        Wt: 0,
-        Kt: t,
+        wt: createOwner(),
+        jt: 0,
+        Wt: t,
+        Mt: [],
+        Kt: n,
         xt: [],
-        $t: n,
-        qt: [],
-        zt: [],
-        Ht: e,
-        Jt: e || i?.keyed === false ? [] : undefined,
-        Xt: r && i?.keyed !== false ? [] : undefined,
-        Yt: i?.keyed === false,
-        Zt: i?.fallback
+        Ft: [],
+        Gt: e,
+        Ut: e || i?.keyed === false ? [] : undefined,
+        $t: r && i?.keyed !== false ? [] : undefined,
+        qt: i?.keyed === false,
+        zt: i?.fallback
     };
     const o = computed(updateKeyedMap.bind(h));
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
     // them through node lets store-proxy lookups see pending writes (not stale _value).
-        h.jt.Ct = o;
-    o.U &= ~CONFIG_AUTO_DISPOSE;
+        h.wt.Nt = o;
+    o.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(o);
 }
 
@@ -56,52 +56,52 @@ const pureOptions = {
 // strong-abort ordering: removed rows now dispose AFTER the pass's new rows
 // are created (you cannot destroy state before knowing the pass will land).
 function updateKeyedMap() {
-    const t = this.Kt() || [], s = t.length;
+    const t = this.Wt() || [], s = t.length;
     t[$TRACK];
  // top level tracking
-        runWithOwner(this.jt, () => {
+        runWithOwner(this.wt, () => {
         let i, e, r, n, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        h = this.Jt ? this.Yt ? () => {
+        h = this.Ut ? this.qt ? () => {
             r[e] = signal(t[e], pureOptions);
-            return this.$t(accessor(r[e]), e);
+            return this.Kt(accessor(r[e]), e);
         } : () => {
             r[e] = signal(t[e], pureOptions);
             n && (n[e] = signal(e, pureOptions));
-            return this.$t(accessor(r[e]), n ? accessor(n[e]) : undefined);
-        } : this.Xt ? () => {
+            return this.Kt(accessor(r[e]), n ? accessor(n[e]) : undefined);
+        } : this.$t ? () => {
             const s = t[e];
             n[e] = signal(e, pureOptions);
-            return this.$t(s, accessor(n[e]));
+            return this.Kt(s, accessor(n[e]));
         } : () => {
             const s = t[e];
-            return this.$t(s);
+            return this.Kt(s);
         };
         // fast path for empty arrays
                 if (s === 0) {
-            if (this.Wt !== 0) {
-                this.jt.dispose(false);
-                this.zt = [];
+            if (this.jt !== 0) {
+                this.wt.dispose(false);
+                this.Ft = [];
+                this.Mt = [];
                 this.xt = [];
-                this.qt = [];
-                this.Wt = 0;
-                this.Jt && (this.Jt = []);
-                this.Xt && (this.Xt = []);
+                this.jt = 0;
+                this.Ut && (this.Ut = []);
+                this.$t && (this.$t = []);
             }
-            if (this.Zt && !this.qt[0]) {
+            if (this.zt && !this.xt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.zt[0]?.dispose();
-                this.qt[0] = runWithOwner(this.zt[0] = createOwner(), this.Zt);
+                this.Ft[0]?.dispose();
+                this.xt[0] = runWithOwner(this.Ft[0] = createOwner(), this.zt);
             }
         }
         // fast path for new create
-         else if (this.Wt === 0) {
+         else if (this.jt === 0) {
             const o = new Array(s);
             const c = new Array(s);
-            r = this.Jt && new Array(s);
-            n = this.Xt && new Array(s);
+            r = this.Ut && new Array(s);
+            n = this.$t && new Array(s);
             try {
                 for (e = 0; e < s; e++) o[e] = runWithOwner(c[e] = createOwner(), h);
             } catch (t) {
@@ -109,53 +109,53 @@ function updateKeyedMap() {
                 throw t;
             }
             // commit
-                        if (this.zt[0]) this.zt[0].dispose();
+                        if (this.Ft[0]) this.Ft[0].dispose();
  // previous fallback
-                        this.qt = o;
-            this.zt = c;
-            r && (this.Jt = r);
-            n && (this.Xt = n);
-            this.xt = t.slice(0);
-            this.Wt = s;
+                        this.xt = o;
+            this.Ft = c;
+            r && (this.Ut = r);
+            n && (this.$t = n);
+            this.Mt = t.slice(0);
+            this.jt = s;
         } else {
             let o, c, a, f, u, p, w, l, d, O = new Array(s), m = new Array(s);
-            r = this.Jt ? new Array(s) : undefined;
-            n = this.Xt ? new Array(s) : undefined;
+            r = this.Ut ? new Array(s) : undefined;
+            n = this.$t ? new Array(s) : undefined;
             // skip common prefix
-                        for (o = 0, c = Math.min(this.Wt, s); o < c && (this.xt[o] === t[o] || this.Jt && compare(this.Ht, this.xt[o], t[o])); o++) {
-                if (this.Jt) setSignal(this.Jt[o], t[o]);
+                        for (o = 0, c = Math.min(this.jt, s); o < c && (this.Mt[o] === t[o] || this.Ut && compare(this.Gt, this.Mt[o], t[o])); o++) {
+                if (this.Ut) setSignal(this.Ut[o], t[o]);
             }
             // common suffix
-                        for (c = this.Wt - 1, a = s - 1; c >= o && a >= o && (this.xt[c] === t[a] || this.Jt && compare(this.Ht, this.xt[c], t[a])); c--, 
+                        for (c = this.jt - 1, a = s - 1; c >= o && a >= o && (this.Mt[c] === t[a] || this.Ut && compare(this.Gt, this.Mt[c], t[a])); c--, 
             a--) {
-                O[a] = this.qt[c];
-                m[a] = this.zt[c];
-                r && (r[a] = this.Jt[c]);
-                n && (n[a] = this.Xt[c]);
+                O[a] = this.xt[c];
+                m[a] = this.Ft[c];
+                r && (r[a] = this.Ut[c]);
+                n && (n[a] = this.$t[c]);
             }
             // 0) prepare a map of all indices in newItems, scanning backwards so we encounter them in natural order
                         p = new Map;
             w = new Array(a + 1);
             for (e = a; e >= o; e--) {
                 f = t[e];
-                u = this.Ht ? this.Ht(f) : f;
+                u = this.Gt ? this.Gt(f) : f;
                 i = p.get(u);
                 w[e] = i === undefined ? -1 : i;
                 p.set(u, e);
             }
             // 1) step through all old items and see if they can be found in the new set; if so, save them in a temp array and mark them moved; if not, queue them for disposal at commit
                         for (i = o; i <= c; i++) {
-                f = this.xt[i];
-                u = this.Ht ? this.Ht(f) : f;
+                f = this.Mt[i];
+                u = this.Gt ? this.Gt(f) : f;
                 e = p.get(u);
                 if (e !== undefined && e !== -1) {
-                    O[e] = this.qt[i];
-                    m[e] = this.zt[i];
-                    r && (r[e] = this.Jt[i]);
-                    n && (n[e] = this.Xt[i]);
+                    O[e] = this.xt[i];
+                    m[e] = this.Ft[i];
+                    r && (r[e] = this.Ut[i]);
+                    n && (n[e] = this.$t[i]);
                     e = w[e];
                     p.set(u, e);
-                } else (l ??= []).push(this.zt[i]);
+                } else (l ??= []).push(this.Ft[i]);
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
@@ -170,25 +170,25 @@ function updateKeyedMap() {
             }
             // 3) commit: land positions, then dispose exited rows
                         for (e = o; e < s; e++) {
-                this.qt[e] = O[e];
-                this.zt[e] = m[e];
+                this.xt[e] = O[e];
+                this.Ft[e] = m[e];
                 if (r) {
-                    this.Jt[e] = r[e];
-                    setSignal(this.Jt[e], t[e]);
+                    this.Ut[e] = r[e];
+                    setSignal(this.Ut[e], t[e]);
                 }
                 if (n) {
-                    this.Xt[e] = n[e];
-                    setSignal(this.Xt[e], e);
+                    this.$t[e] = n[e];
+                    setSignal(this.$t[e], e);
                 }
             }
             if (l) for (i = 0; i < l.length; i++) l[i].dispose();
             // 4) in case the new set is shorter than the old, set the length of the mapped array
-                        this.qt = this.qt.slice(0, this.Wt = s);
+                        this.xt = this.xt.slice(0, this.jt = s);
             // 5) save a copy of the mapped items for the next update
-                        this.xt = t.slice(0);
+                        this.Mt = t.slice(0);
         }
     });
-    return this.qt;
+    return this.xt;
 }
 
 /**
@@ -208,22 +208,22 @@ function updateKeyedMap() {
  */ function repeat(t, s, i) {
     const e = s;
     const r = {
-        jt: createOwner(),
-        Wt: 0,
-        ts: 0,
-        ss: t,
-        $t: e,
-        zt: [],
-        qt: [],
-        es: i?.from,
-        Zt: i?.fallback
+        wt: createOwner(),
+        jt: 0,
+        Bt: 0,
+        Ht: t,
+        Kt: e,
+        Ft: [],
+        xt: [],
+        Jt: i?.from,
+        zt: i?.fallback
     };
     const n = computed(updateRepeat.bind(r));
     // Same as mapArray: untracked reads inside the internal owner resolve via
     // _parentComputed, so async reads in row callbacks register with the node
     // (pending tracking + post-settle retry) instead of vanishing.
-        r.jt.Ct = n;
-    n.U &= ~CONFIG_AUTO_DISPOSE;
+        r.wt.Nt = n;
+    n.T &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
 
@@ -235,55 +235,55 @@ function updateKeyedMap() {
 // for the post-settle retry. The overlap math also subsumes the previous
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
-    const t = this.ss();
-    const s = this.es?.() || 0;
-    runWithOwner(this.jt, () => {
+    const t = this.Ht();
+    const s = this.Jt?.() || 0;
+    runWithOwner(this.wt, () => {
         if (t === 0) {
-            if (this.Wt !== 0) {
-                this.jt.dispose(false);
-                this.zt = [];
-                this.qt = [];
-                this.Wt = 0;
+            if (this.jt !== 0) {
+                this.wt.dispose(false);
+                this.Ft = [];
+                this.xt = [];
+                this.jt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.ts = 0;
+                                this.Bt = 0;
             }
-            if (this.Zt && !this.qt[0]) {
+            if (this.zt && !this.xt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.zt[0]?.dispose();
-                this.qt[0] = runWithOwner(this.zt[0] = createOwner(), this.Zt);
+                this.Ft[0]?.dispose();
+                this.xt[0] = runWithOwner(this.Ft[0] = createOwner(), this.zt);
             }
             return;
         }
         const i = s + t;
-        const e = this.ts + this.Wt;
+        const e = this.Bt + this.jt;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
-                const r = Math.max(s, this.ts);
+                const r = Math.max(s, this.Bt);
         const n = Math.min(i, e);
         const h = new Array(t);
         const o = new Array(t);
         for (let t = r; t < n; t++) {
-            o[t - s] = this.zt[t - this.ts];
-            h[t - s] = this.qt[t - this.ts];
+            o[t - s] = this.Ft[t - this.Bt];
+            h[t - s] = this.xt[t - this.Bt];
         }
         try {
             for (let t = s; t < i; t++) {
                 if (t >= r && t < n) continue;
-                h[t - s] = runWithOwner(o[t - s] = createOwner(), () => this.$t(t));
+                h[t - s] = runWithOwner(o[t - s] = createOwner(), () => this.Kt(t));
             }
         } catch (t) {
             for (let t = s; t < i; t++) if ((t < r || t >= n) && o[t - s]) o[t - s].dispose();
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.Wt === 0) this.zt[0]?.dispose(); else for (let t = this.ts; t < e; t++) if (t < s || t >= i) this.zt[t - this.ts].dispose();
-        this.qt = h;
-        this.zt = o;
-        this.ts = s;
-        this.Wt = t;
+                if (this.jt === 0) this.Ft[0]?.dispose(); else for (let t = this.Bt; t < e; t++) if (t < s || t >= i) this.Ft[t - this.Bt].dispose();
+        this.xt = h;
+        this.Ft = o;
+        this.Bt = s;
+        this.jt = t;
     });
-    return this.qt;
+    return this.xt;
 }
 
 function compare(t, s, i) {

package/dist/prod/signals.js

@@ -2,7 +2,7 @@ import { computed, optimisticComputed, setSignal, optimisticSignal, runWithOwner
 
 import { cleanup, createRoot, getOwner, dispose } from "./core/owner.js";
 
-import { globalQueue } from "./core/scheduler.js";
+import { globalQueue, Queue } from "./core/scheduler.js";
 
 import { CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH } from "./core/constants.js";
 
@@ -65,7 +65,7 @@ function accessor(e) {
 function createSignal(e, t) {
     if (typeof e === "function") {
         const n = computed(e, t);
-        n.U &= ~CONFIG_AUTO_DISPOSE;
+        n.T &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(n), setMemo.bind(null, n) ];
     }
     const n = signal(e, t);
@@ -239,6 +239,12 @@ function createEffect(e, t, n) {
     };
 }
 
+/** Delivers effect applies on a microtask instead of queueing them (#2930). */ class MicrotaskQueue extends Queue {
+    enqueue(e, t) {
+        queueMicrotask(() => t(e));
+    }
+}
+
 /**
  * Awaits a reactive expression and returns its first fully-settled value as a
  * `Promise`. Pending async reads (`createMemo` returning a promise, etc.) are
@@ -262,11 +268,23 @@ function createEffect(e, t, n) {
  */ function resolve(e) {
     return new Promise((t, n) => {
         createRoot(c => {
+            // Deliver effect applies on a microtask instead of the owner queue: an
+            // incomplete transition stashes its effect queues until it settles, but
+            // an action yielding this promise is itself what keeps the transition
+            // open — the stashed res() deadlocked the action (#2930). The compute
+            // still runs in place (under the transaction's view when created inside
+            // an action step), and status/boundary notifications keep their normal
+            // route through the inherited queue.
+            const r = getOwner();
+            const o = new MicrotaskQueue;
+            o.Ge = r.C;
+ // notify() forwards up the normal chain
+                        r.C = o;
             // A user effect rather than a bare computed: computeds are pull-based and
             // are only re-enqueued when a pending source *resolves* — a rejection just
             // marks them errored, so nothing would re-run and the promise would never
             // settle (#2842). The effect's error channel is notified on rejection.
-            effect(e, e => {
+                        effect(e, e => {
                 t(e);
                 c();
             }, e => {
@@ -288,7 +306,7 @@ function createOptimistic(e, t) {
     installOptimisticEngine();
     if (typeof e === "function") {
         const n = optimisticComputed(e, t);
-        n.U &= ~CONFIG_AUTO_DISPOSE;
+        n.T &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(n), setSignal.bind(null, n) ];
     }
     const n = optimisticSignal(e, t);
@@ -377,7 +395,7 @@ function createOptimistic(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.U & CONFIG_CHILDREN_FORBIDDEN) ? createTrackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, () => {
+    t && !(t.T & CONFIG_CHILDREN_FORBIDDEN) ? createTrackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, () => {
         // 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/optimistic.js

@@ -21,7 +21,7 @@ function createOptimisticStore(e, t, r) {
     // STORE_OPTIMISTIC take the engine's write path, so install it before any
     // node can be created.
     installOptimisticEngine();
-    GlobalQueue.Vt ||= clearOptimisticStores;
+    GlobalQueue.Dt ||= clearOptimisticStores;
     const i = typeof e === "function";
     const o = i ? t : e;
     const n = i ? e : undefined;
@@ -76,8 +76,8 @@ function clearOptimisticStores(e, t) {
                 // (initTransition mid-batch) or to the plain flush, so it clears on
                 // whichever clear call reaches this store first.
                                 if (e) {
-                    if (typeof e.cn === "object") e = o[O] = currentTransition(e);
-                    if (e !== t && e.cn !== true) {
+                    if (typeof e.fn === "object") e = o[O] = currentTransition(e);
+                    if (e !== t && e.fn !== true) {
                         s = true;
                         continue;
                     }
@@ -89,7 +89,7 @@ function clearOptimisticStores(e, t) {
             const T = i?.[O];
             if (T) {
                 // Clear lane association so effects go to regular queue
-                T.Je = undefined;
+                T.je = undefined;
                 // Re-read from base — this key left the optimistic layer above, so the
                 // overlay resolves to STORE_OVERRIDE or STORE_VALUE.
                                 const t = getOverlayLayer(e, O);
@@ -97,11 +97,11 @@ function clearOptimisticStores(e, t) {
                 const i = r === $DELETED ? undefined : r;
                 const o = isWrappable(i) ? wrap(i, e) : i;
                 const n = visibleNodeValue(T);
-                T.be = NOT_PENDING;
-                T.fn = null;
-                T.ge = NOT_PENDING;
-                T.Ue = o;
-                if (!T.Ge || !T.Ge(n, o)) {
+                T.Ee = NOT_PENDING;
+                T.sn = null;
+                T.Ne = NOT_PENDING;
+                T.Pe = o;
+                if (!T.Re || !T.Re(n, o)) {
                     insertSubs(T, true);
                     schedule();
                 }
@@ -113,7 +113,7 @@ function clearOptimisticStores(e, t) {
         }
         // Notify $TRACK
                 if (c && i?.[$TRACK]) {
-            i[$TRACK].Je = undefined;
+            i[$TRACK].je = undefined;
             notifySelf(e);
         }
     } finally {
@@ -173,7 +173,7 @@ function createOptimisticProjectionInternal(e, t, r) {
                 setProjectionWriteActive(false);
             }
         }, undefined);
-        i.U &= ~CONFIG_AUTO_DISPOSE;
+        i.T &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
         store: n,

package/dist/prod/store/projection.js

@@ -41,7 +41,7 @@ function createProjectionInternal(e, r, t) {
         if (!o) o = getOwner();
         runProjectionComputed(n, e, t?.key || "id");
     }, undefined);
-    o.U &= ~CONFIG_AUTO_DISPOSE;
+    o.T &= ~CONFIG_AUTO_DISPOSE;
     return {
         store: n,
         node: o
@@ -110,7 +110,7 @@ function createProjectionInternal(e, r, t) {
     const n = getOwner();
     let c = false;
     let s;
-    const u = new Proxy(e, createWriteTraps(() => !c || n.Ae === s, i));
+    const u = new Proxy(e, createWriteTraps(() => !c || n.Te === s, i));
     storeSetter(u, i => {
         s = r(i);
         c = true;

package/dist/prod/store/store.js

@@ -154,7 +154,7 @@ function ownEnumerableKeysPlain(e) {
  * The value a store leaf's backing signal currently shows to readers: active
  * override, else held pending value, else committed value.
  */ function visibleNodeValue(e) {
-    return e.be !== undefined && e.be !== NOT_PENDING ? unwrapOverride(e.be) : e.ge !== NOT_PENDING ? e.ge : e.Ue;
+    return e.Ee !== undefined && e.Ee !== NOT_PENDING ? unwrapOverride(e.Ee) : e.Ne !== NOT_PENDING ? e.Ne : e.Pe;
 }
 
 function hasOwnStoreProperty(e, t) {
@@ -205,11 +205,11 @@ function getNode(e, t, r, n, o = isEqual, i) {
         }
     }, e[STORE_FIREWALL]);
     if (e[STORE_OPTIMISTIC]) {
-        s.be = NOT_PENDING;
+        s.Ee = NOT_PENDING;
     }
     if (i && r in i) {
         const e = i[r];
-        s.Ye = e === undefined ? NO_SNAPSHOT : e;
+        s.Ve = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources?.add(s);
     }
     if (typeof r === "symbol" && r !== $TRACK && r !== $AFFECTS) symbolKeyedRecords.add(t);
@@ -238,8 +238,8 @@ function getNode(e, t, r, n, o = isEqual, i) {
  */ function inheritAffectsMarks(e, t, r) {
     // A live scope exists, so affects.ts already installed the mark engine.
     for (const [n, o] of affectsScopes) {
-        if (n.M && o.scope.has(t) && (o.key === undefined || o.key === r)) {
-            GlobalQueue.D(e);
+        if (n.t && o.scope.has(t) && (o.key === undefined || o.key === r)) {
+            GlobalQueue.M(e);
             o.inherited.push(e);
         }
     }
@@ -327,11 +327,11 @@ o) {
     // Callers guard on `pendingCheckActive`, which only flips inside
     // isPending() — the verdict layer is loaded and its hook installed.
     const r = e[STORE_NODE]?.[$AFFECTS];
-    if (r?.M) GlobalQueue.wt(r);
+    if (r?.t) GlobalQueue.Lt(r);
     if (affectsScopes.size) {
         const n = e[STORE_VALUE];
         for (const [e, o] of affectsScopes) {
-            if (e !== r && e.M && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.wt(e);
+            if (e !== r && e.t && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.Lt(e);
         }
     }
 }
@@ -348,11 +348,11 @@ o) {
  * @internal
  */ function getStoreAffectsNodes(e, t) {
     const r = getNodes(e, STORE_NODE);
-    GlobalQueue.T ||= e => {
+    GlobalQueue.p ||= e => {
         const t = affectsScopes.get(e);
         if (!t) return;
         affectsScopes.delete(e);
-        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.F(t.inherited[e]);
+        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.h(t.inherited[e]);
     };
     if (t === undefined) {
         const t = getNode(e, r, $AFFECTS, undefined, false);
@@ -473,13 +473,13 @@ function getPropertyDescriptor(e, t, r) {
 function prepareStoreWrite(e, t, r) {
     if (e[STORE_OPTIMISTIC]) {
         const t = e[STORE_FIREWALL];
-        if (t?.ve) {
-            globalQueue.initTransition(t.ve);
+        if (t?.Ue) {
+            globalQueue.initTransition(t.Ue);
         }
     }
     const n = e[STORE_VALUE];
     const o = n[r];
-    if (snapshotCaptureActive && typeof r !== "symbol" && !((e[STORE_FIREWALL]?.i ?? 0) & STATUS_PENDING)) {
+    if (snapshotCaptureActive && typeof r !== "symbol" && !((e[STORE_FIREWALL]?.S ?? 0) & STATUS_PENDING)) {
         if (!e[STORE_SNAPSHOT_PROPS]) {
             e[STORE_SNAPSHOT_PROPS] = Object.create(null);
             snapshotSources?.add(e);
@@ -507,7 +507,7 @@ function prepareStoreWrite(e, t, r) {
     // STORE_OPTIMISTIC is only set by createOptimisticStore, which installs the
     // optimistic engine before wrapping.
     if (e[STORE_OPTIMISTIC] && !projectionWriteActive) {
-        GlobalQueue.mn(t);
+        GlobalQueue.Nn(t);
     }
 }
 
@@ -580,7 +580,7 @@ let Writing = null;
  * itself (the derive function works its own draft while uninitialized).
  */ function throwIfUninitialized(e) {
     const t = e[STORE_FIREWALL];
-    if (t && t.i & STATUS_UNINITIALIZED) throw t.k ?? new NotReadyError(t);
+    if (t && t.S & STATUS_UNINITIALIZED) throw t._ ?? new NotReadyError(t);
 }
 
 const storeTraps = {

package/dist/types/affects.d.ts

@@ -4,15 +4,15 @@ import { type Store } from "./store/store.js";
  * Declares that in-flight work will change the targeted data: the named
  * slot(s) — and everything DERIVED from them — read as pending
  * (`isPending` → `true`) from the declaration until the surrounding
- * transaction settles or reverts. Marks ride the same status rails as real
- * in-flight async, so pendingness flows through memos and effects like any
- * other pending source, while the marked values themselves stay readable
- * (a mark is a promise of change, not an absence of value). This is the
- * declaration verb of the pending model — additive only. A mark can turn
- * pending ON for data the graph can't see changing yet; nothing can turn
- * pending OFF while a real change is in flight — a quiet `refresh()`
- * re-ask under a mark still reads pending (declaring the reload is what
- * makes it a real question).
+ * transaction settles or reverts. A mark lives on its own channel — a
+ * refcount on the marked node plus dep-graph reachability in the verdict
+ * layer — so the marked values themselves stay readable (a mark is a promise
+ * of change, not an absence of value), no reader ever suspends on one, and
+ * completion/settlement accounting never sees one. This is the declaration
+ * verb of the pending model — additive only. A mark can turn pending ON for
+ * data the graph can't see changing yet; nothing can turn pending OFF while
+ * a real change is in flight — a quiet `refresh()` re-ask under a mark still
+ * reads pending (declaring the reload is what makes it a real question).
  *
  * Targets:
  * - `affects(store)` — a store proxy (any record, root or nested): every

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

@@ -3,7 +3,7 @@ import type { Computed, Link } from "./types.js";
 export declare function addPendingSource(el: Computed<any>, source: Computed<any>): boolean;
 export declare function setPendingError(el: Computed<any>, source?: Computed<any>, error?: any): void;
 export declare function forEachDependent(el: Computed<any>, fn: (node: Computed<any>, link: Link) => void): void;
-export declare function settlePendingSource(el: Computed<any>, source?: Computed<any>, snap?: boolean): void;
+export declare function settlePendingSource(el: Computed<any>): void;
 export declare function isThenable<T>(value: T | PromiseLike<T>): value is PromiseLike<T>;
 export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
 export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;

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

@@ -24,6 +24,13 @@
  */
 export declare class NotReadyError extends Error {
     source: any;
+    /**
+     * Tags a visibility-only notification on the affects() boundary channel:
+     * boundaries update display state from it, but the root queue never
+     * registers a reporter — marks are invisible to completion accounting by
+     * construction.
+     */
+    _markVisual?: boolean;
     constructor(source: any);
 }
 export declare class StatusError extends Error {