@solidjs/signals 2.0.0-rc.19 → 2.0.0-rc.20

package/dist/prod/map.js

@@ -14,7 +14,7 @@ import "./core/effect.js";
 
 import { accessor } from "./signals.js";
 
-import { $TRACK } from "./store/types.js";
+import { $TRACK, shallowView, $TARGET } from "./store/types.js";
 
 function mapArray(t, e, i) {
     const s = typeof i?.keyed === "function" ? i.keyed : undefined;
@@ -28,7 +28,7 @@ function mapArray(t, e, i) {
         ft: r,
         ht: [],
         tn: [],
-        ze: s,
+        Xe: s,
         ct: s || i?.keyed === false ? [] : undefined,
         lt: n && i?.keyed !== false ? [] : undefined,
         ut: i?.keyed === false,
@@ -69,26 +69,26 @@ function trySmallMove(t, e, i, s) {
         }
         u = false;
         // Bounded realignment lookahead, shorter distance wins.
-                let d = -1;
-        let w = Math.min(32 - o.length, r - a, c);
-        for (let t = 1; t <= w; t++) {
+                let w = -1;
+        let d = Math.min(32 - o.length, r - a, c);
+        for (let t = 1; t <= d; t++) {
             if (n[a + t] === s) {
-                d = t;
+                w = t;
                 break;
             }
         }
-        c -= d === -1 ? w : d;
+        c -= w === -1 ? d : w;
         let p = -1;
-        w = Math.min(32 - f.length, i - 1 - l, c);
-        for (let i = 1; i <= w; i++) {
+        d = Math.min(32 - f.length, i - 1 - l, c);
+        for (let i = 1; i <= d; i++) {
             if (e[l + i] === t) {
                 p = i;
                 break;
             }
         }
-        c -= p === -1 ? w : p;
-        if (d !== -1 && (p === -1 || d <= p)) {
-            while (d-- > 0) o.push(a++);
+        c -= p === -1 ? d : p;
+        if (w !== -1 && (p === -1 || w <= p)) {
+            while (w-- > 0) o.push(a++);
             continue;
         }
         if (p !== -1) {
@@ -155,14 +155,14 @@ function trySmallMove(t, e, i, s) {
     const a = t.ht;
     const l = t.tn;
     const u = a.slice(0, i);
-    const d = l.slice(0, i);
+    const w = l.slice(0, i);
     for (let t = 0; t < r.length; t += 3) {
         const e = r[t];
         const i = r[t + 1];
         if (e !== i) {
             for (let s = 0; s < r[t + 2]; s++) {
                 u[i + s] = a[e + s];
-                d[i + s] = l[e + s];
+                w[i + s] = l[e + s];
             }
         }
     }
@@ -170,10 +170,10 @@ function trySmallMove(t, e, i, s) {
         const t = n[h] >> 6;
         const e = s[n[h] & 63];
         u[t] = a[e];
-        d[t] = l[e];
+        w[t] = l[e];
     }
     t.ht = u;
-    t.tn = d;
+    t.tn = w;
     t.it = i;
     t.ot = e.slice(0);
     // Dispose unmatched sources LAST (general-path ordering).
@@ -191,24 +191,24 @@ function trySmallMove(t, e, i, s) {
  * the map path below starts from scratch (it rewrites every window slot of
  * `temp` / `rows` / `indexes`, so only `tempNodes`' `!== undefined` probe
  * needs the reset). The stage arrays are scratch — nothing live is touched. */ function stageRemoval(t, e, i, s, n, r, o, f, h) {
-    const c = t.ze;
+    const c = t.Xe;
     const a = t.ot;
     const l = t.tn;
     const u = [];
-    let d = i;
-    for (let w = i; w <= n; d++, w++) {
-        const n = c ? c(e[w]) : e[w];
-        while (d <= s && (c ? c(a[d]) : a[d]) !== n) u.push(l[d++]);
-        if (d > s) {
+    let w = i;
+    for (let d = i; d <= n; w++, d++) {
+        const n = c ? c(e[d]) : e[d];
+        while (w <= s && (c ? c(a[w]) : a[w]) !== n) u.push(l[w++]);
+        if (w > s) {
             o.fill(undefined);
             return null;
         }
-        r[w] = t.ht[d];
-        o[w - i] = l[d];
-        if (f) f[w - i] = t.ct[d];
-        if (h) h[w - i] = t.lt[d];
+        r[d] = t.ht[w];
+        o[d - i] = l[w];
+        if (f) f[d - i] = t.ct[w];
+        if (h) h[d - i] = t.lt[w];
     }
-    for (;d <= s; d++) u.push(l[d]);
+    for (;w <= s; w++) u.push(l[w]);
     return u;
 }
 
@@ -222,24 +222,24 @@ function trySmallMove(t, e, i, s) {
     const a = t.ct;
     const l = t.lt;
     const u = t.it;
-    const d = i - u;
-    let w, p;
-    if (d > 0) {
+    const w = i - u;
+    let d, p;
+    if (w > 0) {
         // Grow first: a store past the end from the top is a third slower than
         // filling a pre-sized tail (measured on 1k refs, 2026-10-15).
         c.length = i;
         if (a) a.length = i;
         if (l) l.length = i;
-        for (w = u - 1, p = i - 1; w > n; w--, p--) {
-            c[p] = c[w];
-            if (a) a[p] = a[w];
-            if (l) l[p] = l[w];
+        for (d = u - 1, p = i - 1; d > n; d--, p--) {
+            c[p] = c[d];
+            if (a) a[p] = a[d];
+            if (l) l[p] = l[d];
         }
-    } else if (d < 0) {
-        for (w = n + 1, p = r + 1; w < u; w++, p++) {
-            c[p] = c[w];
-            if (a) a[p] = a[w];
-            if (l) l[p] = l[w];
+    } else if (w < 0) {
+        for (d = n + 1, p = r + 1; d < u; d++, p++) {
+            c[p] = c[d];
+            if (a) a[p] = a[d];
+            if (l) l[p] = l[d];
         }
         c.length = i;
         if (a) a.length = i;
@@ -252,7 +252,7 @@ function trySmallMove(t, e, i, s) {
     }
     for (p = r + 1; p < i; p++) {
         if (a) setSignal(a[p], e[p]);
-        if (l && d !== 0) setSignal(l[p], p);
+        if (l && w !== 0) setSignal(l[p], p);
     }
 }
 
@@ -263,11 +263,15 @@ function updateKeyedMap() {
     // the flight's reader (pending tracking + post-settle retry) instead of
     // vanishing. Set per pass: the first pass runs inside `computed()`, before
     // the node exists to the caller.
-    this.H.Ye = getOwner();
-    const t = this.st() || [], e = t.length;
+    this.H.Ke = getOwner();
+    let t = this.st() || [];
     t[$TRACK];
  // top level tracking (a store array's container node)
-        runWithOwner(this.H, () => {
+    // A shallow store array diffs its backing: its slots are raw records, and
+    // a trap per slot read was most of a one-row write on a 1k-row list.
+        t = shallowView?.(t[$TARGET]) ?? t;
+    const e = t.length;
+    runWithOwner(this.H, () => {
         let i, s, 
         // The stage slot a mapper writes its row/index signal into: `j` on the
         // create-all path, `j - start` on the general path, whose stage arrays
@@ -333,7 +337,7 @@ function updateKeyedMap() {
             this.ot = t.slice(0);
             this.it = e;
         } else {
-            let h, c, a, l, u, d, w, p, m, 
+            let h, c, a, l, u, w, d, p, m, 
             // Dev (attribution engine installed): the items behind the exited and
             // entered rows, for the list-identity census.
             O, _;
@@ -360,12 +364,12 @@ function updateKeyedMap() {
             // CARVE 2: the lane-slot arm (`_landOnOverride`, F1) went with the engine.
                         const y = setSignal;
             // skip common prefix
-                        for (h = 0, c = Math.min(this.it, e); h < c && (this.ot[h] === t[h] || this.ct && compare(this.ze, this.ot[h], t[h])); h++) {
+                        for (h = 0, c = Math.min(this.it, e); h < c && (this.ot[h] === t[h] || this.ct && compare(this.Xe, this.ot[h], t[h])); h++) {
                 if (this.ct) y(this.ct[h], t[h]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (c = this.it - 1, a = e - 1; c >= h && a >= h && (this.ot[c] === t[a] || this.ct && compare(this.ze, this.ot[c], t[a])); c--, 
+                        for (c = this.it - 1, a = e - 1; c >= h && a >= h && (this.ot[c] === t[a] || this.ct && compare(this.Xe, this.ot[c], t[a])); c--, 
             a--) ;
             // no structural change (every position matched in place at equal
             // length — the common post-reconcile shape): keep the same mapped
@@ -394,7 +398,7 @@ function updateKeyedMap() {
                 while (r <= n && this.ot[r] !== s) r++;
                 if (r <= n && trySmallMove(this, t, e, h)) return;
             }
-            const g = e - this.it;
+            const A = e - this.it;
             // WINDOW-SIZED STAGING, IN-PLACE COMMIT (2026-10-15). The strong-abort
             // contract (#2903) only needs the pass to touch nothing live before
             // every mapper has succeeded; it never needed four fresh newLen-sized
@@ -410,14 +414,14 @@ function updateKeyedMap() {
             // staging plus a position-sized chain array per commit (uibench's
             // one-item tree ops at 4–6× Octane, jfb-reorder `removefirst` at
             // 2.5×); now it stages one slot.
-                        const A = a - h + 1;
+                        const g = a - h + 1;
             const S = new Array(e);
-            const M = new Array(A);
-            r = this.ct ? new Array(A) : undefined;
-            o = this.lt ? new Array(A) : undefined;
+            const M = new Array(g);
+            r = this.ct ? new Array(g) : undefined;
+            o = this.lt ? new Array(g) : undefined;
             // A shrinking pass is tried as a pure removal first (stageRemoval: no
             // key map, one key call per item); anything else takes the map path.
-                        const k = g < 0 ? stageRemoval(this, t, h, c, a, S, M, r, o) : null;
+                        const k = A < 0 ? stageRemoval(this, t, h, c, a, S, M, r, o) : null;
             if (k !== null) {
                 // (The list-churn census below wants removals AND creations in one
                 // pass; a pure removal has none, so no item ledger is kept here.)
@@ -425,29 +429,29 @@ function updateKeyedMap() {
             } else {
                 // 0) prepare a map of all indices in the changed window of newItems,
                 // scanning backwards so we encounter them in natural order
-                d = new Map;
-                w = new Array(A);
+                w = new Map;
+                d = new Array(g);
                 for (s = a; s >= h; s--) {
                     l = t[s];
-                    u = this.ze ? this.ze(l) : l;
-                    i = d.get(u);
-                    w[s - h] = i === undefined ? -1 : i;
-                    d.set(u, s);
+                    u = this.Xe ? this.Xe(l) : l;
+                    i = w.get(u);
+                    d[s - h] = i === undefined ? -1 : i;
+                    w.set(u, s);
                 }
                 // 1) step through the old changed window and see if items can be found
                 // in the new set; if so, stage them at their new positions; if not,
                 // queue them for disposal at commit
                                 for (i = h; i <= c; i++) {
                     l = this.ot[i];
-                    u = this.ze ? this.ze(l) : l;
-                    s = d.get(u);
+                    u = this.Xe ? this.Xe(l) : l;
+                    s = w.get(u);
                     if (s !== undefined && s !== -1) {
                         S[s] = this.ht[i];
                         M[s - h] = this.tn[i];
                         r && (r[s - h] = this.ct[i]);
                         o && (o[s - h] = this.lt[i]);
-                        s = w[s - h];
-                        d.set(u, s);
+                        s = d[s - h];
+                        w.set(u, s);
                     } else {
                         (p ??= []).push(this.tn[i]);
                         if (false && attrHooks !== null) ;
@@ -472,7 +476,7 @@ function updateKeyedMap() {
             // function: kept out of this body on purpose, see commitWindow); then
             // the exited rows dispose
                         for (i = 0; i < h; i++) S[i] = this.ht[i];
-            for (s = a + 1; s < e; s++) S[s] = this.ht[s - g];
+            for (s = a + 1; s < e; s++) S[s] = this.ht[s - A];
             commitWindow(this, t, e, h, c, a, M, r, o);
             this.ht = S;
             this.it = e;
@@ -504,8 +508,8 @@ function updateKeyedMap() {
     const n = {
         H: createOwner(),
         it: 0,
-        dt: 0,
-        wt: t,
+        wt: 0,
+        dt: t,
         ft: s,
         tn: [],
         ht: [],
@@ -526,8 +530,8 @@ function updateKeyedMap() {
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
     // As in updateKeyedMap: the node is the row callbacks' reader, per pass.
-    this.H.Ye = getOwner();
-    const t = this.wt();
+    this.H.Ke = getOwner();
+    const t = this.dt();
     const e = this.Ot?.() || 0;
     runWithOwner(this.H, () => {
         if (t === 0) {
@@ -537,7 +541,7 @@ function updateRepeat() {
                 this.ht = [];
                 this.it = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.dt = 0;
+                                this.wt = 0;
             }
             if (this.L && !this.ht.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
@@ -548,16 +552,16 @@ function updateRepeat() {
             return;
         }
         const i = e + t;
-        const s = this.dt + this.it;
+        const s = this.wt + this.it;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
-                const n = Math.max(e, this.dt);
+                const n = Math.max(e, this.wt);
         const r = Math.min(i, s);
         const o = new Array(t);
         const f = new Array(t);
         for (let t = n; t < r; t++) {
-            f[t - e] = this.tn[t - this.dt];
-            o[t - e] = this.ht[t - this.dt];
+            f[t - e] = this.tn[t - this.wt];
+            o[t - e] = this.ht[t - this.wt];
         }
         try {
             for (let t = e; t < i; t++) {
@@ -569,10 +573,10 @@ function updateRepeat() {
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.it === 0) this.tn[0]?.dispose(); else for (let t = this.dt; t < s; t++) if (t < e || t >= i) this.tn[t - this.dt].dispose();
+                if (this.it === 0) this.tn[0]?.dispose(); else for (let t = this.wt; t < s; t++) if (t < e || t >= i) this.tn[t - this.wt].dispose();
         this.ht = o;
         this.tn = f;
-        this.dt = e;
+        this.wt = e;
         this.it = t;
     });
     return this.ht;

package/dist/prod/reveal.js

@@ -59,37 +59,37 @@ const slotMinReady = t => isController(t) ? t.Rt() : ready(t);
 
 class RevealController {
     yt;
-    Et;
-    At=[];
+    At;
+    kt=[];
     /** The controller gating this one, until it releases this one. */
     _parent=null;
     /** The state a parent forces on this whole group. */
     $=false;
     ee=false;
     Ct=true;
-    kt=true;
-    vt=false;
+    vt=true;
+    gt=false;
     constructor(t, e) {
         this.yt = t;
-        this.Et = e;
+        this.At = e;
     }
     /** A slot that has left this controller's ownership: a boundary that has
      * shown content, a nested group that is ready. Shown is shown — it counts
-     * as ready whatever happens to it later (a re-arm gates nobody else). */    gt(t) {
+     * as ready whatever happens to it later (a re-arm gates nobody else). */    Lt(t) {
         return (isController(t) ? t._parent : t.v) !== this;
     }
     /** The slots this controller still owns, in registration order — the
-     * ones the order's state is forced on. */    Lt(t) {
-        for (let e = 0; e < this.At.length; e++) {
-            const s = this.At[e];
-            if (!this.gt(s) && t(s) === false) return false;
+     * ones the order's state is forced on. */    Mt(t) {
+        for (let e = 0; e < this.kt.length; e++) {
+            const s = this.kt[e];
+            if (!this.Lt(s) && t(s) === false) return false;
         }
         return true;
     }
     /** Readiness is judged over every slot, done ones as ready. */    St() {
-        for (let t = 0; t < this.At.length; t++) {
-            const e = this.At[t];
-            if (!this.gt(e) && !slotReady(e)) return false;
+        for (let t = 0; t < this.kt.length; t++) {
+            const e = this.kt[t];
+            if (!this.Lt(e) && !slotReady(e)) return false;
         }
         return true;
     }
@@ -97,21 +97,21 @@ class RevealController {
      * `together` waits for: `together` — every slot minimally ready;
      * `sequential` — the first slot; `natural` — any. */    Rt() {
         const t = untrack(this.yt);
-        const e = this.At;
+        const e = this.kt;
         if (e.length === 0) return true;
-        if (t === "sequential") return this.gt(e[0]) || slotMinReady(e[0]);
+        if (t === "sequential") return this.Lt(e[0]) || slotMinReady(e[0]);
         for (let s = 0; s < e.length; s++) {
-            const r = this.gt(e[s]) || slotMinReady(e[s]);
+            const r = this.Lt(e[s]) || slotMinReady(e[s]);
             if (t === "natural" ? r : !r) return t === "natural";
         }
         return t !== "natural";
     }
     te(t) {
-        if (this.At.includes(t)) return;
-        this.At.push(t);
+        if (this.kt.includes(t)) return;
+        this.kt.push(t);
         // Gated from the start (collapsed in a collapsed sequential tail); the
         // evaluation releases what the order allows.
-                const e = untrack(this.yt) === "sequential" && !!untrack(this.Et);
+                const e = untrack(this.yt) === "sequential" && !!untrack(this.At);
         if (isController(t)) {
             t._parent = this;
             t.$ = true;
@@ -125,31 +125,31 @@ class RevealController {
         untrack(() => this._t());
     }
     oe(t) {
-        const e = this.At.indexOf(t);
-        if (e >= 0) this.At.splice(e, 1);
+        const e = this.kt.indexOf(t);
+        if (e >= 0) this.kt.splice(e, 1);
         untrack(() => this._t());
     }
     /** Apply the order to the owned slots — or, gated by a parent, its state
      * to all of them. */    _t() {
-        if (this.vt) return;
-        this.vt = true;
+        if (this.gt) return;
+        this.gt = true;
         const t = this.Ct;
-        const e = this.kt;
+        const e = this.vt;
         try {
             const t = untrack(this.yt);
-            const e = t === "sequential" && !!untrack(this.Et);
+            const e = t === "sequential" && !!untrack(this.At);
             if (this.$) {
-                this.Lt(t => setSlotState(t, this, true, this.ee));
+                this.Mt(t => setSlotState(t, this, true, this.ee));
             } else if (t === "natural") {
-                this.Lt(t => {
+                this.Mt(t => {
                     if (isController(t)) setSlotState(t, this, false, false); else setSlotState(t, this, !ready(t), false);
                 });
             } else if (t === "together") {
-                const t = this.Lt(slotMinReady);
-                this.Lt(e => setSlotState(e, this, !t, false));
+                const t = this.Mt(slotMinReady);
+                this.Mt(e => setSlotState(e, this, !t, false));
             } else {
                 let t = false;
-                this.Lt(s => {
+                this.Mt(s => {
                     if (t) return setSlotState(s, this, true, e);
                     if (slotReady(s)) return setSlotState(s, this, false, false);
                     t = true;
@@ -160,10 +160,10 @@ class RevealController {
             }
         } finally {
             this.Ct = this.St();
-            this.kt = this.Rt();
-            this.vt = false;
+            this.vt = this.Rt();
+            this.gt = false;
         }
-        if (this._parent !== null && (t !== this.Ct || e !== this.kt)) this._parent._t();
+        if (this._parent !== null && (t !== this.Ct || e !== this.vt)) this._parent._t();
     }
 }
 
@@ -189,7 +189,7 @@ class RevealController {
         const e = t();
         const s = computed(() => {
             i.yt();
-            i.Et();
+            i.At();
             i._t();
         });
         if (false) ;

package/dist/prod/signals.js

@@ -363,7 +363,7 @@ function createMemo(e, t) {
         o?.(u);
         queueMicrotask(() => t(u));
     }, {
-        Le: n
+        xe: n
     }).l |= CONFIG_REDERIVE;
 }
 
@@ -541,7 +541,7 @@ function createMemo(e, t) {
                 // The flip, inside the pass of the flush carrying it: the flush
                 // joins the action's transaction, and what it staged is held and
                 // revealed with the action.
-                if (e && c !== null && globalQueue.q && resolveTx(c).tt !== 0) joinFuture(c);
+                if (e && c !== null && globalQueue.Y && resolveTx(c).tt !== 0) joinFuture(c);
             });
             if (t?.timeout !== undefined) i = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
             if (o !== undefined) {
@@ -657,7 +657,7 @@ function createMemo(e, t) {
         // still holding the optimistic value — reads do not pull (#3411). Fall
         // to the next pass while the heap has work; `run` swapped the queue,
         // so this lands there, and `enqueue` keeps the drain alive.
-        if (dirtyQueue.et >= dirtyQueue.Fe) return globalQueue.enqueue(EFFECT_USER, fire);
+        if (dirtyQueue.Et >= dirtyQueue.Fe) return globalQueue.enqueue(EFFECT_USER, fire);
         // Unowned, out-of-band fire (no owner, or a children-forbidden one this
         // one-shot must not bind to): a returned cleanup has no lifecycle to
         // attach to. Reject it in dev; in production the return is simply

package/dist/prod/store/affects.js

@@ -38,24 +38,24 @@ const scopes = new Map;
 function scopeOf(e, o) {
     let n = scopes.get(e);
     if (n === undefined) scopes.set(e, n = {
-        eo: new Set,
-        oo: [],
-        ze: o
+        oo: new Set,
+        no: [],
+        Xe: o
     });
     return n;
 }
 
 /** 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 (optHooks && f.fam?.opt === true) r = optHooks.view(f, r, true);
         const e = f.n;
@@ -94,9 +94,9 @@ function scopeOf(e, o) {
  * backings (§7b): a view's backing is another store's proxy — marks cover
  * the BASE raw, so every identity along the chain is checked. */ function covering(e, o, n) {
     for (const [t, s] of scopes) {
-        if (t === n || s.ze !== undefined && s.ze !== o) continue;
+        if (t === n || s.Xe !== undefined && s.Xe !== 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.rt();
     }
 };
@@ -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 };