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

package/dist/observe/reveal.js

@@ -32,124 +32,124 @@ const SEQUENTIAL_ACCESSOR = () => "sequential";
 
 const isController = t => t instanceof RevealController;
 
-const slotReady = t => isController(t) ? t.rs() : ready(t);
+const slotReady = t => isController(t) ? t.Lt() : ready(t);
 
-const slotMinReady = t => isController(t) ? t.ns() : ready(t);
+const slotMinReady = t => isController(t) ? t.Qt() : ready(t);
 
 /** Force a slot's state. A boundary re-derives its output when it changes;
  * a nested controller passes the state on to its own slots. Released
  * (`!gated`), a nested controller leaves its parent's ownership and runs its
  * own order; a boundary leaves when it has shown content (boundaries.ts). */ function setSlotState(t, e, s, r) {
     if (isController(t)) {
-        t.te = s;
-        t.oe = r;
-        t.ls();
+        t.$ = s;
+        t.ee = r;
+        t.Bt();
         // Released and ready — every slot of its own has shown — it graduates,
         // as a boundary does when it shows content. Released at the frontier
         // but not ready, it stays the parent's frontier.
-                if (!s && t.us && t._parent === e) t._parent = null;
+                if (!s && t.Jt && t._parent === e) t._parent = null;
         return;
     }
-    if (t.te !== s || t.oe !== r) {
-        t.te = s;
-        t.oe = r;
+    if (t.$ !== s || t.ee !== r) {
+        t.$ = s;
+        t.ee = r;
         redraw(t);
     }
 }
 
 class RevealController {
-    hs;
-    cs;
-    fs=[];
+    Xt;
+    Yt;
+    Zt=[];
     /** The controller gating this one, until it releases this one. */
     _parent=null;
     /** The state a parent forces on this whole group. */
-    te=false;
-    oe=false;
-    us=true;
-    ds=true;
-    Ss=false;
+    $=false;
+    ee=false;
+    Jt=true;
+    ts=true;
+    es=false;
     constructor(t, e) {
-        this.hs = t;
-        this.cs = e;
+        this.Xt = t;
+        this.Yt = 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). */    Rs(t) {
-        return (isController(t) ? t._parent : t.B) !== this;
+     * as ready whatever happens to it later (a re-arm gates nobody else). */    ss(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. */    _s(t) {
-        for (let e = 0; e < this.fs.length; e++) {
-            const s = this.fs[e];
-            if (!this.Rs(s) && t(s) === false) return false;
+     * ones the order's state is forced on. */    rs(t) {
+        for (let e = 0; e < this.Zt.length; e++) {
+            const s = this.Zt[e];
+            if (!this.ss(s) && t(s) === false) return false;
         }
         return true;
     }
-    /** Readiness is judged over every slot, done ones as ready. */    rs() {
-        for (let t = 0; t < this.fs.length; t++) {
-            const e = this.fs[t];
-            if (!this.Rs(e) && !slotReady(e)) return false;
+    /** Readiness is judged over every slot, done ones as ready. */    Lt() {
+        for (let t = 0; t < this.Zt.length; t++) {
+            const e = this.Zt[t];
+            if (!this.ss(e) && !slotReady(e)) return false;
         }
         return true;
     }
     /** Something visible to show under its own order — what an enclosing
      * `together` waits for: `together` — every slot minimally ready;
-     * `sequential` — the first slot; `natural` — any. */    ns() {
-        const t = untrack(this.hs);
-        const e = this.fs;
+     * `sequential` — the first slot; `natural` — any. */    Qt() {
+        const t = untrack(this.Xt);
+        const e = this.Zt;
         if (e.length === 0) return true;
-        if (t === "sequential") return this.Rs(e[0]) || slotMinReady(e[0]);
+        if (t === "sequential") return this.ss(e[0]) || slotMinReady(e[0]);
         for (let s = 0; s < e.length; s++) {
-            const r = this.Rs(e[s]) || slotMinReady(e[s]);
+            const r = this.ss(e[s]) || slotMinReady(e[s]);
             if (t === "natural" ? r : !r) return t === "natural";
         }
         return t !== "natural";
     }
-    ae(t) {
-        if (this.fs.includes(t)) return;
-        this.fs.push(t);
+    oe(t) {
+        if (this.Zt.includes(t)) return;
+        this.Zt.push(t);
         // Gated from the start (collapsed in a collapsed sequential tail); the
         // evaluation releases what the order allows.
-                const e = untrack(this.hs) === "sequential" && !!untrack(this.cs);
+                const e = untrack(this.Xt) === "sequential" && !!untrack(this.Yt);
         if (isController(t)) {
             t._parent = this;
-            t.te = true;
-            t.oe = e;
-            t.ls();
+            t.$ = true;
+            t.ee = e;
+            t.Bt();
         } else {
-            t.B = this;
-            t.te = true;
-            t.oe = e;
+            t.v = this;
+            t.$ = true;
+            t.ee = e;
         }
-        untrack(() => this.ls());
+        untrack(() => this.Bt());
     }
-    ue(t) {
-        const e = this.fs.indexOf(t);
-        if (e >= 0) this.fs.splice(e, 1);
-        untrack(() => this.ls());
+    te(t) {
+        const e = this.Zt.indexOf(t);
+        if (e >= 0) this.Zt.splice(e, 1);
+        untrack(() => this.Bt());
     }
     /** Apply the order to the owned slots — or, gated by a parent, its state
-     * to all of them. */    ls() {
-        if (this.Ss) return;
-        this.Ss = true;
-        const t = this.us;
-        const e = this.ds;
+     * to all of them. */    Bt() {
+        if (this.es) return;
+        this.es = true;
+        const t = this.Jt;
+        const e = this.ts;
         try {
-            const t = untrack(this.hs);
-            const e = t === "sequential" && !!untrack(this.cs);
-            if (this.te) {
-                this._s(t => setSlotState(t, this, true, this.oe));
+            const t = untrack(this.Xt);
+            const e = t === "sequential" && !!untrack(this.Yt);
+            if (this.$) {
+                this.rs(t => setSlotState(t, this, true, this.ee));
             } else if (t === "natural") {
-                this._s(t => {
+                this.rs(t => {
                     if (isController(t)) setSlotState(t, this, false, false); else setSlotState(t, this, !ready(t), false);
                 });
             } else if (t === "together") {
-                const t = this._s(slotMinReady);
-                this._s(e => setSlotState(e, this, !t, false));
+                const t = this.rs(slotMinReady);
+                this.rs(e => setSlotState(e, this, !t, false));
             } else {
                 let t = false;
-                this._s(s => {
+                this.rs(s => {
                     if (t) return setSlotState(s, this, true, e);
                     if (slotReady(s)) return setSlotState(s, this, false, false);
                     t = true;
@@ -159,11 +159,11 @@ class RevealController {
                 });
             }
         } finally {
-            this.us = this.rs();
-            this.ds = this.ns();
-            this.Ss = false;
+            this.Jt = this.Lt();
+            this.ts = this.Qt();
+            this.es = false;
         }
-        if (this._parent !== null && (t !== this.us || e !== this.ds)) this._parent.ls();
+        if (this._parent !== null && (t !== this.Jt || e !== this.ts)) this._parent.Bt();
     }
 }
 
@@ -179,23 +179,23 @@ class RevealController {
  *   slots behind the frontier render nothing instead of their fallbacks
  */ function createRevealOrder(t, e) {
     const s = createOwner();
-    const r = s.U[REVEAL];
+    const r = s.A[REVEAL];
     const i = new RevealController(e?.order || SEQUENTIAL_ACCESSOR, e?.collapsed || FALSE_ACCESSOR);
-    s.U = {
-        ...s.U,
+    s.A = {
+        ...s.A,
         [REVEAL]: i
     };
     return runWithOwner(s, () => {
         const e = t();
         const s = computed(() => {
-            i.hs();
-            i.cs();
-            i.ls();
+            i.Xt();
+            i.Yt();
+            i.Bt();
         });
         if (true) s._name = "reveal order";
         if (r) {
-            r.ae(i);
-            cleanup(() => r.ue(i));
+            r.oe(i);
+            cleanup(() => r.te(i));
         }
         return e;
     });
@@ -204,9 +204,9 @@ class RevealController {
 // Installed at module evaluation — present exactly when something imports
 // `createRevealOrder`; a Loading boundary without one pays a null check.
 setRevealHooks({
-    ae: (t, e) => t.ae(e),
-    ue: (t, e) => t.ue(e),
-    j: t => t.ls()
+    oe: (t, e) => t.oe(e),
+    te: (t, e) => t.te(e),
+    P: t => t.Bt()
 });
 
 export { createRevealOrder };

package/dist/observe/signals.js

@@ -1,21 +1,25 @@
-import { NotReadyError, unwrapStatusError, TimeoutError } from "./core/error.js";
+import { TimeoutError, NotReadyError, unwrapStatusError } from "./core/error.js";
 
 import "./core/verdict.js";
 
-import { CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH, CONFIG_REDERIVE, REACTIVE_JOINED, CONFIG_AUTO_DISPOSE, CONFIG_FRESH_READ, CONFIG_AUTHORITATIVE } from "./core/constants.js";
+import { CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH, CONFIG_AUTO_DISPOSE, CONFIG_AUTHORITATIVE, CONFIG_REDERIVE, REACTIVE_JOINED, CONFIG_FRESH_READ, CONFIG_GUESS, STATUS_PENDING, STATUS_ERROR } from "./core/constants.js";
 
 import { computed, signal, runWithOwner, setMemo, setSignal, markRefresh, read, untrack } from "./core/core.js";
 
 import { registerGraph } from "./core/dev.js";
 
-import { globalQueue, flushTransaction, resolveTx, passTx, staleReader, dirtyQueue, joinFuture } from "./core/scheduler.js";
+import { globalQueue, flushTransaction, dirtyQueue, GlobalQueue, resolveTx, passTx, staleReader, joinFuture } from "./core/scheduler.js";
 
 import { cleanup, createRoot, getOwner, dispose } from "./core/owner.js";
 
+import { signalHook } from "./core/identities.js";
+
 import { effect, trackedEffect } from "./core/effect.js";
 
 import { optimisticWrite } from "./core/lanes.js";
 
+import { truthRead, truthConfirmed } from "./core/truth.js";
+
 /**
  * Low-level reactive-cleanup primitive. Registers a callback that runs when
  * the surrounding owner is disposed.
@@ -73,18 +77,19 @@ function accessor(e) {
 function createSignal(e, t) {
     if (typeof e === "function") {
         const r = computed(e, t);
-        r.u &= ~CONFIG_AUTO_DISPOSE;
+        r.l &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(r), setMemo.bind(null, r) ];
     }
     const r = signal(e, t);
     registerGraph(r, getOwner());
+    if (signalHook !== null) signalHook(r);
     return [ accessor(r), setSignal.bind(null, r) ];
 }
 
 function createOptimistic(e, t) {
     if (typeof e === "function") {
         const r = computed(e, t);
-        r.u &= ~CONFIG_AUTO_DISPOSE;
+        r.l &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(r), optimisticWrite.bind(null, r) ];
     }
     const r = signal(e, t);
@@ -162,7 +167,7 @@ function createMemo(e, t) {
  * );
  * ```
  *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ * @description https://v2.solidjs.com/reference/solid-js/reactivity/create-effect
  */ function createEffect(e, t, r) {
     effect(e, t.effect || t, t.error, {
         user: true,
@@ -197,7 +202,7 @@ function createMemo(e, t) {
  * }
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-render-effect
  */ function createRenderEffect(e, t, r) {
     effect(e, t, undefined, r);
 }
@@ -245,7 +250,7 @@ function createMemo(e, t) {
  * });
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-tracked-effect
  */ function createTrackedEffect(e, t) {
     trackedEffect(e, t);
 }
@@ -274,7 +279,7 @@ function createMemo(e, t) {
  * setCount(1); // logs once, reaction re-armed for next change
  * ```
  *
- * @description https://docs.solidjs.com/reference/secondary-primitives/create-reaction
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/specialized-reactivity/create-reaction
  */ function createReaction(e, t) {
     let r = undefined;
     cleanup(() => r?.());
@@ -324,31 +329,41 @@ function createMemo(e, t) {
  * - a mainline reader whose pass read a frame another transaction holds
  *   joined it (L2, born held — A29) and delivers at that commit: the
  *   committed view, never a foreign hold's unrevealed frame. */ function watch(e, t, r, n = 0, o, c = flushTransaction) {
+    if (n & CONFIG_AUTHORITATIVE) {
+        GlobalQueue.rn = truthRead;
+        GlobalQueue.tn = truthConfirmed;
+    }
     // `config` is on the node for its first pass too (the pass runs inside
     // `computed()`): `until`'s predicate is authoritative from its first read,
     // or an already-displayed guess would satisfy it in a later slice. (REDERIVE
     // after: the first pass's own error is the promise's rejection.)
-    computed(() => {
-        let n;
+        computed(() => {
+        let i, u = false;
         try {
-            n = e();
+            i = e();
         } catch (e) {
             if (e instanceof NotReadyError) throw e;
-            queueMicrotask(() => r(unwrapStatusError(e)));
-            return;
+            // An error is an answer (D-41): delivered by the same frame rule.
+                        i = unwrapStatusError(e);
+            u = true;
         }
-        const i = getOwner();
+        const s = getOwner();
+        // A truth reader waits out a `createDeferred` flight its value derives
+        // from, which serves everyone else the stale answer (D-40).
+                const f = n & CONFIG_AUTHORITATIVE && GlobalQueue.er?.(s);
+        if (f) throw new NotReadyError(f);
         // (Outside a flush a mainline pass joins through `passTx`.)
-                const u = flushTransaction ?? passTx;
-        if (i.R & REACTIVE_JOINED && u !== null && (c === null || resolveTx(c) !== resolveTx(u))) {
-            staleReader(i, resolveTx(u));
+                const a = flushTransaction ?? passTx;
+        if (s.R & REACTIVE_JOINED && a !== null && (c === null || resolveTx(c) !== resolveTx(a))) {
+            staleReader(s, resolveTx(a));
             return;
         }
-        o?.(n);
-        queueMicrotask(() => t(n));
+        if (u) return void queueMicrotask(() => r(i));
+        o?.(i);
+        queueMicrotask(() => t(i));
     }, {
-        dt: n
-    }).u |= CONFIG_REDERIVE;
+        St: n
+    }).l |= CONFIG_REDERIVE;
 }
 
 /**
@@ -434,23 +449,29 @@ function createMemo(e, t) {
         const r = flushTransaction;
     const n = new Promise((n, o) => {
         queueMicrotask(() => {
-            // No createRoot: the microtask has no ambient owner, so the watcher is
-            // naturally detached, and settle disposes the node directly (dev keeps
-            // a root husk purely to stay quiet about the missing owner). The
-            // capture runs inside the watcher's own pass, where the ambient owner
-            // IS the watcher — exactly what dispose() takes.
+            // The root is load-bearing: an ownerless computed is auto-disposing,
+            // and the settle walk releases an unobserved one instead of re-running
+            // it, so the waiter would never see the refetch land (#3888). Settle
+            // disposes the waiter directly; the capture runs inside the watcher's
+            // own pass, where the ambient owner IS the watcher — exactly what
+            // dispose() takes.
             let c = null;
             const make = () => watch(() => {
                 if (c === null) c = getOwner();
-                return read(t);
+                // Authoritative: the truth beneath a guess (`until`'s view). A
+                // guessed node's own re-ask is not answered by it (#3895): park
+                // on that flight, or reject with its error.
+                                const e = read(t);
+                if (t.l & CONFIG_GUESS && t.m & (STATUS_PENDING | STATUS_ERROR)) throw t.T?.F;
+                return e;
             }, t => {
                 n(typeof e === "function" ? t : e);
                 dispose(c);
             }, e => {
                 o(e);
                 dispose(c);
-            }, CONFIG_FRESH_READ, undefined, r);
-            make();
+            }, CONFIG_FRESH_READ | CONFIG_AUTHORITATIVE, undefined, r);
+            createRoot(make);
         });
     });
     // Fire-and-forget refresh must not turn a failed refetch into an unhandled
@@ -519,7 +540,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.ee && resolveTx(c).tt !== 0) joinFuture(c);
+                if (e && c !== null && globalQueue.q && resolveTx(c).tt !== 0) joinFuture(c);
             });
             if (t?.timeout !== undefined) u = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
             if (o !== undefined) {
@@ -627,7 +648,7 @@ function createMemo(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.u & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), {
+    t && !(t.l & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), {
         name: "onSettled"
     }) : globalQueue.enqueue(EFFECT_USER, function fire() {
         // Settled means derived. A settle that reverts optimism (or replays
@@ -637,7 +658,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.Kt >= dirtyQueue.ut) return globalQueue.enqueue(EFFECT_USER, fire);
+        if (dirtyQueue.jt >= dirtyQueue.st) 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/observe/store/affects.js

@@ -1,10 +1,10 @@
-import { GlobalQueue } from "../core/scheduler.js";
+import { GlobalQueue, releaseMarksHook } from "../core/scheduler.js";
 
-import { installAffectsHooks, getNode, optHooks } from "./store.js";
+import { optHooks, installAffectsHooks } from "./hooks.js";
 
 import { lookupTarget, $OWNER } from "./target.js";
 
-import { isWrappable, $TARGET } from "./types.js";
+import { $TARGET } from "./types.js";
 
 /**
  * Store — the store half of `affects()` (plan sec. 29, plan sec. 37; A24 (4), #2882,
@@ -23,113 +23,120 @@ import { isWrappable, $TARGET } from "./types.js";
  * the verdict. A mark declared on a draft (inside a setter) or over an
  * optimistic family walks the view the writer sees.
  *
- * Installed by `store/index.ts`: a program with stores carries it; one
- * without pays nothing (affects.ts asks `GlobalQueue._storeMarks`).
+ * Imported by `affects()`, which installs it on its first store target
+ * (#3891, after #3912): a program with stores that never declares a mark
+ * carries none of it. It never imports store.ts — the engine's top level —
+ * so a program declaring marks without stores carries this module alone:
+ * the store's nodes and its wrappability test come through `GlobalQueue`
+ * (`_storeNode`, `_storeWrappable`), and node birth and the untracked traps
+ * reach back through `affectsHooks` (hooks.ts).
  */
 /** The keyless mark's carrier key: a leaf of the record no read serves. */ const $AFFECTS = Symbol(0);
 
 const scopes = new Map;
 
+function scopeOf(e, o) {
+    let n = scopes.get(e);
+    if (n === undefined) scopes.set(e, n = {
+        eo: new Set,
+        oo: [],
+        Vt: o
+    });
+    return n;
+}
+
 /** The nodes an `affects(store[, key])` declaration marks (affects.ts
- * registers each). */ function storeMarks(e, n) {
-    if (n === undefined) {
-        const n = getNode(e, $AFFECTS);
-        let o = scopes.get(n);
-        if (o === undefined) scopes.set(n, o = {
-            scope: new Set,
-            inherited: []
-        });
-        const t = [ n ];
-        walk(e.px, o, t, e.fam, new Set);
-        return t;
+ * registers each). */ function storeMarks(e, o) {
+    const n = GlobalQueue.no(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;
     }
-    const o = e.n?.[n] ?? getNode(e, n);
-    let t = scopes.get(o);
-    if (t === undefined) scopes.set(o, t = {
-        scope: new Set,
-        inherited: [],
-        key: n
-    });
-    t.scope.add(e.v);
-    if (e.pb !== null) t.scope.add(e.pb);
-    return [ o ];
+    t.eo.add(e.v);
+    if (e.pb !== null) t.eo.add(e.pb);
+    return [ n ];
 }
 
 /** The identities reachable from `value` into the scope (the draft's and
  * 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, n, o, t, s) {
-    if (!isWrappable(e)) return;
+ * construction: raws, never traps. */ function walk(e, o, n, t, s) {
+    if (!GlobalQueue.so(e)) return;
     const f = e[$TARGET] ?? lookupTarget(e, t);
-    let i = f !== undefined ? f.pb ?? f.v : e;
-    if (s.has(i)) return;
-    s.add(i);
-    n.scope.add(i);
+    let r = f !== undefined ? f.pb ?? f.v : e;
+    if (s.has(r)) return;
+    s.add(r);
+    o.eo.add(r);
     if (f !== undefined) {
-        if (f.pb !== null) n.scope.add(f.v);
+        if (f.pb !== null) o.eo.add(f.v);
         // The writer's view: the tick's own unflushed guesses are in motion too.
-                if (f.fam?.opt === true) i = optHooks.view(f, i, true);
+                if (f.fam?.opt === true) r = optHooks.view(f, r, true);
         const e = f.n;
-        if (e !== null) for (const n of Reflect.ownKeys(e)) 
+        if (e !== null) for (const o of Reflect.ownKeys(e)) 
         // Another mark's carrier is its own channel: counting it here would
         // extend that scope's lifetime to this declaration's.
-        if (n !== $AFFECTS) o.push(e[n]);
+        if (o !== $AFFECTS) n.push(e[o]);
         const s = f.h;
-        if (s !== null) for (const e of Reflect.ownKeys(s)) o.push(s[e]);
-        if (f.k !== null) o.push(f.k);
-        if (f.dk !== null) o.push(f.dk);
+        if (s !== null) for (const e of Reflect.ownKeys(s)) n.push(s[e]);
+        if (f.k !== null) n.push(f.k);
+        if (f.dk !== null) n.push(f.dk);
         t = f.fam ?? t;
     }
-    for (const e of Reflect.ownKeys(i)) {
-        if (e === $OWNER) continue;
-        const f = Object.getOwnPropertyDescriptor(i, e);
-        if (f === undefined || f.get !== undefined) continue;
-        walk(f.value, n, o, t, s);
+    for (const e of Reflect.ownKeys(r)) if (e !== $OWNER) {
+        const f = Object.getOwnPropertyDescriptor(r, e);
+        if (f.get === undefined) walk(f.value, o, n, t, s);
     }
 }
 
 /** A live scope covering `t`'s identity (keyed: for `key`). Chained
  * 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, n, o) {
+ * the BASE raw, so every identity along the chain is checked. */ function covering(e, o, n) {
     for (const [t, s] of scopes) {
-        if (t === o || s.key !== undefined && s.key !== n) continue;
-        for (let n = e.v; ;) {
-            if (s.scope.has(n)) return t;
-            const e = n?.[$TARGET];
+        if (t === n || s.Vt !== undefined && s.Vt !== o) continue;
+        for (let o = e.v; ;) {
+            if (s.eo.has(o)) return t;
+            const e = o?.[$TARGET];
             if (e === undefined) break;
-            const o = e.pb ?? e.v;
-            if (o === n) break;
-            n = o;
+            const n = e.pb ?? e.v;
+            if (n === o) break;
+            o = n;
         }
     }
     return null;
 }
 
-installAffectsHooks({
+/** The store's side: node birth and the untracked traps call it (store.ts,
+ * through `affectsHooks`) — with no live mark too: an empty scope map is
+ * no work. */ const hooks = {
     // A node born on a record a live mark covers inherits it (released with
     // the carrier's last registration).
-    born(e, n, o) {
-        if (o === $AFFECTS) return;
-        const t = covering(e, o, n);
-        if (t === null) return;
-        GlobalQueue.h(n);
-        scopes.get(t).inherited.push(n);
+    fo(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);
     },
     // 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.
-    witness(e, n) {
-        const o = e.n?.[$AFFECTS];
-        if (o !== undefined && o.m !== null && o.m.T !== 0 || covering(e, n) !== null) GlobalQueue.Bt();
+    ro(e, o) {
+        if (e.n?.[$AFFECTS]?.T?.I || covering(e, o)) GlobalQueue.bt();
     }
-});
+};
 
-GlobalQueue.O = storeMarks;
+/** `affects()` calls it before a store-targeted declaration (idempotent). */ function installStoreAffects() {
+    installAffectsHooks(hooks);
+}
 
 /** The carrier's last mark released (affects.ts): its scope dies, and the
- * nodes that inherited the mark release theirs. */ GlobalQueue.N = e => {
-    const n = scopes.get(e);
-    if (n === undefined) return;
+ * nodes that inherited the mark release theirs. */ function releaseMarkScope(e) {
+    const o = scopes.get(e);
+    if (o === undefined) return;
     scopes.delete(e);
-    GlobalQueue.A(n.inherited);
-};
+    releaseMarksHook(o.oo);
+}
+
+export { installStoreAffects, releaseMarkScope, storeMarks };