@solidjs/signals 2.0.0-rc.13 → 2.0.0-rc.15

package/dist/observe/signals.js

@@ -1,22 +1,20 @@
-import { TimeoutError } from "./core/error.js";
+import { TimeoutError, NotReadyError, unwrapStatusError } from "./core/error.js";
 
-import { computed, optimisticComputed, setSignal, optimisticSignal, runWithOwner, setMemo, signal, installAuthoritativeRead, markRefresh, read, untrack } from "./core/core.js";
-
-import { cleanup, createRoot, getOwner, dispose, getObserver } from "./core/owner.js";
-
-import { globalQueue, dirtyQueue, Queue, entangleConfirmingTransitions, activeTransition } from "./core/scheduler.js";
+import "./core/verdict.js";
 
-import { CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH, CONFIG_DIRECT_COMMIT, CONFIG_AUTHORITATIVE_READ, CONFIG_FRESH_READ } 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 "./core/invariants.js";
+import { computed, signal, runWithOwner, setMemo, setSignal, markRefresh, read, untrack } from "./core/core.js";
 
 import { registerGraph } from "./core/dev.js";
 
-import "./core/verdict.js";
+import { globalQueue, flushTransaction, dirtyQueue, GlobalQueue, resolveTx, passTx, staleReader, joinFuture } from "./core/scheduler.js";
+
+import { cleanup, createRoot, getOwner, dispose } from "./core/owner.js";
 
 import { effect, trackedEffect } from "./core/effect.js";
 
-import { installOptimisticEngine } from "./core/optimistic.js";
+import { optimisticWrite, truthRead, truthConfirmed } from "./core/lanes.js";
 
 /**
  * Low-level reactive-cleanup primitive. Registers a callback that runs when
@@ -75,7 +73,7 @@ function accessor(e) {
 function createSignal(e, t) {
     if (typeof e === "function") {
         const r = computed(e, t);
-        r.C &= ~CONFIG_AUTO_DISPOSE;
+        r.i &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(r), setMemo.bind(null, r) ];
     }
     const r = signal(e, t);
@@ -83,6 +81,17 @@ function createSignal(e, t) {
     return [ accessor(r), setSignal.bind(null, r) ];
 }
 
+function createOptimistic(e, t) {
+    if (typeof e === "function") {
+        const r = computed(e, t);
+        r.i &= ~CONFIG_AUTO_DISPOSE;
+        return [ accessor(r), optimisticWrite.bind(null, r) ];
+    }
+    const r = signal(e, t);
+    registerGraph(r, getOwner());
+    return [ accessor(r), optimisticWrite.bind(null, r) ];
+}
+
 function createMemo(e, t) {
     return accessor(computed(e, t));
 }
@@ -275,15 +284,15 @@ function createMemo(e, t) {
     // sources stayed live (firing the callback for replaced dependencies), each
     // accumulated arm delivered its own fire, and un-fired arms leaked as live
     // effect nodes until the owner disposed (#2861).
-        let i;
-    return o => {
-        if (i) {
-            dispose(i);
-            i = undefined;
+        let o;
+    return c => {
+        if (o) {
+            dispose(o);
+            o = undefined;
         }
         runWithOwner(n, () => {
-            effect(() => (o(), i = getOwner()), t => {
-                i = undefined;
+            effect(() => (c(), o = getOwner()), t => {
+                o = undefined;
                 r?.();
                 const n = (e.effect || e)?.();
                 if (false && n !== undefined && typeof n !== "function") ;
@@ -298,10 +307,52 @@ function createMemo(e, t) {
     };
 }
 
-/** Delivers effect applies on a microtask instead of queueing them (#2930). */ class MicrotaskQueue extends Queue {
-    enqueue(e, t) {
-        queueMicrotask(() => t(e));
+/** A promise over a reactive expression (`resolve`, `until`): a pass that
+ * runs the expression and settles on a microtask. Not an effect — an
+ * effect's run is the flush's effect phase, and a flush parked by the
+ * action that is `yield`ing on this promise stashes its runs with the
+ * transaction (#2930); the heap runs a pass parked or not. A pending read
+ * re-runs it when the source lands (the pass is pending itself); the
+ * expression throwing settles the rejection. */
+/** The promise-delivery readers' pass (`resolve`, `until`, `refresh`'s
+ * waiter): delivers what it read on a microtask. By posture (#3482, #3490):
+ * - the reader of the transaction it was created in (`own`: an action's
+ *   body, a `refresh()` called there — the waiter reads its slice's frame on
+ *   a later microtask) delivers that frame — the staged landing an action
+ *   holds (the action awaits the promise that would otherwise wait on its
+ *   own settle);
+ * - 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.Nn = truthRead;
+        GlobalQueue.rn = 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;
+        try {
+            n = e();
+        } catch (e) {
+            if (e instanceof NotReadyError) throw e;
+            queueMicrotask(() => r(unwrapStatusError(e)));
+            return;
+        }
+        const u = getOwner();
+        // (Outside a flush a mainline pass joins through `passTx`.)
+                const i = flushTransaction ?? passTx;
+        if (u.R & REACTIVE_JOINED && i !== null && (c === null || resolveTx(c) !== resolveTx(i))) {
+            staleReader(u, resolveTx(i));
+            return;
+        }
+        o?.(n);
+        queueMicrotask(() => t(n));
+    }, {
+        Ct: n
+    }).i |= CONFIG_REDERIVE;
 }
 
 /**
@@ -326,41 +377,7 @@ function createMemo(e, t) {
  * @param fn a reactive expression to resolve
  */ function resolve(e) {
     return new Promise((t, r) => {
-        createRoot(n => {
-            // 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 i = getOwner();
-            const o = new MicrotaskQueue;
-            o._parent = i.T;
- // notify() forwards up the normal chain
-                        i.T = 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 => {
-                t(e);
-                n();
-            }, e => {
-                // The error arm already unwraps StatusError (#2840) — `err` is the
-                // user's original error, matching what error boundaries expose.
-                r(e);
-                n();
-            }, 
-            // DIRECT_COMMIT: a source settling INTO the held transaction (e.g. a
-            // refresh this action issued) stages its landing; the effect's own
-            // recompute must not stage too, or the microtask apply reads the
-            // stale mainline value and resolves with old data.
-            {
-                user: true,
-                Qt: CONFIG_DIRECT_COMMIT
-            });
-        });
+        createRoot(n => watch(e, e => (t(e), n()), e => (r(e), n())));
     });
 }
 
@@ -380,19 +397,10 @@ function createMemo(e, t) {
  * read:
  * - Accessor targets resolve with the settled value; store targets resolve
  *   with the store node passed (reads through it are fresh after the await).
- * - A failed re-ask rejects with the error (inside an action's generator,
- *   `yield refresh(x)` throws back at the yield point and the action reverts
- *   like any other failure).
+ * - A failed re-ask rejects with the error.
  * - Semantics are quiescence, not flight identity: if another refresh (or
  *   any invalidation) supersedes this one mid-flight, the promise waits for
  *   — and delivers — whatever finally lands.
- * - Inside an action, truth landing into the held transaction is STAGED;
- *   the promise still settles then (matching `resolve()`/`until()`, #2930)
- *   and delivers the staged value — the caller's own optimistic override is
- *   never the delivered value.
- * - The re-ask itself stays verdict-quiet exactly as before: `isPending`
- *   does not flip for a bare refresh (pair with `affects()` for a visible
- *   pending window).
  *
  * @example
  * ```ts
@@ -419,59 +427,46 @@ function createMemo(e, t) {
     // no-ops, so N waiters cost one pull; this also closes the race where a
     // waiter reads the PRE-re-ask value as settled and delivers stale), after
     // which the read either parks on the re-ask's pending window (async — the
-    // settle walk re-runs it on every landing, equal-value and
-    // staged-under-hold included, and a rejection arrives through the effect's
-    // error channel) or serves the sync answer. AUTHORITATIVE_READ keeps an
-    // action's own optimistic override out of the delivered value. resolve()'s
-    // own eager compute is untouched: created after a refresh it still settles
-    // stale-while-revalidate (#2930) — its contract is "first settled value",
-    // not "next quiescent state".
-    
-    // An authoritative reader is woken through a late-bound hook when the truth
-    // lands EQUAL to a standing override (the A17-silent path). Every setter of
-    // that reader bit must install it — until() does, and this waiter is the
-    // other one (#3303: refresh of an optimistic in an app that never called
-    // until() dereferenced the null hook).
-        installAuthoritativeRead();
-    markRefresh(t);
-    const r = new Promise((r, n) => {
+    // settle walk re-runs it on every landing, equal-value included, and a
+    // rejection arrives through the effect's error channel) or serves the sync
+    // answer. resolve()'s own eager compute is untouched: created after a
+    // refresh it still settles stale-while-revalidate (#2930) — its contract is
+    // "first settled value", not "next quiescent state".
+        markRefresh(t);
+    // The transaction `refresh()` is called in (an action's slice): the
+    // waiter, created on the microtask below, is its reader (`watch`).
+        const r = flushTransaction;
+    const n = new Promise((n, o) => {
         queueMicrotask(() => {
-            // No createRoot: the microtask has no ambient owner, so the effect is
-            // naturally detached, and settle disposes the node directly — the root
-            // added ~560B of otherwise-shakeable machinery for nothing but the
-            // dev-mode NO_OWNER_EFFECT warning, so dev keeps a root husk purely to
-            // stay quiet. The waiter swaps in its microtask queue during its own
-            // first compute (before the initial apply enqueue), replacing the
-            // root-owner plumbing.
-            // Typed as the effect node, not Owner: the capture runs inside the
-            // effect's own compute, where the ambient owner IS the effect —
-            // exactly what dispose() takes.
-            let i = null;
-            const make = () => effect(() => {
-                if (i === null) {
-                    i = getOwner();
-                    const e = new MicrotaskQueue;
-                    e._parent = i.T;
-                    i.T = e;
-                }
-                return read(t);
+            // 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();
+                // 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.i & CONFIG_GUESS && t.S & (STATUS_PENDING | STATUS_ERROR)) throw t.m?.F;
+                return e;
             }, t => {
-                r(typeof e === "function" ? t : e);
-                dispose(i);
+                n(typeof e === "function" ? t : e);
+                dispose(c);
             }, e => {
-                n(e);
-                dispose(i);
-            }, {
-                user: true,
-                Qt: CONFIG_DIRECT_COMMIT | CONFIG_AUTHORITATIVE_READ | CONFIG_FRESH_READ
-            });
-            make();
+                o(e);
+                dispose(c);
+            }, CONFIG_FRESH_READ | CONFIG_AUTHORITATIVE, undefined, r);
+            createRoot(make);
         });
     });
     // Fire-and-forget refresh must not turn a failed refetch into an unhandled
     // rejection; awaiting callers attach their own handlers to `promise`.
-        r.catch(() => {});
-    return r;
+        n.catch(() => {});
+    return n;
 }
 
 /**
@@ -483,115 +478,63 @@ function createMemo(e, t) {
  *
  * Where {@link resolve} answers "what is this value" (first settled value,
  * whatever it is), `until` answers "when does the world confirm this
- * condition". The difference matters inside an `action()`: `yield until(...)`
- * holds the action's transaction — and any optimistic state riding it — open
- * until the condition is independently true.
- *
- * To make that sound, `until`'s predicate reads the AUTHORITATIVE view — and
- * this is the one read-semantics difference from `resolve`, which reads the
- * normal (transaction's own) view where overrides are visible:
- *
- * - **Optimistic overrides are invisible** to the predicate. Your own
- *   tentative write can never satisfy your own ack, even on the
- *   single-primitive shape where the optimistic store IS the live-fed store.
- *   (Derived computeds serve their normal cached values — express the
- *   condition over sources of truth, not derived views of the overlay.)
- * - **Everything else reads normally, including uncommitted transition-staged
- *   data.** Real data is real wherever it currently lives. This is
- *   load-bearing, not a loophole: truth that arrives *into* the open
- *   transaction (a `refresh()` this action issued, an entangled landing)
- *   stages and cannot commit until the hold releases — a predicate that
- *   refused staged reads would deadlock on the very data it is waiting for.
+ * condition".
  *
  * This is the acknowledgment mechanism for mutations confirmed on a live data
  * channel (sockets, subscriptions, live queries) rather than by the mutation's
  * own response: correlate by a client-generated id or version in the predicate,
  * and let truth arrive however it arrives — push, refetch, or another tab.
  *
- * Failure composes with action semantics: a rejection is thrown back into the
- * generator at the `yield` point — catchable there, or the action fails and
- * its optimistic state reverts.
- *
  * Must be called *outside* a tracking scope.
  *
- * Inside an action, call it from a step: after an `await`, put a bare `yield`
- * before `yield until(...)`. The runtime cannot hook an async generator's
- * `await` continuation, so the `until(...)` expression — which CREATES the
- * predicate's reader — would otherwise run outside the transaction; created
- * there it is born held (A29) and replays only at the commit its own promise
- * holds open (#3482). See {@link action}.
- *
  * @example
  * ```ts
- * const send = action(async function* (text: string) {
- *   const clientId = crypto.randomUUID();
- *   setMessages(m => { m.push({ clientId, text, pending: true }); }); // optimistic
- *   await socket.send({ clientId, text }); // fire-and-forget transport
- *   yield; // re-enter the transaction after the await
- *   // Hold until the live source echoes the write (authoritative view —
- *   // the optimistic row above cannot satisfy this):
- *   yield until(() => messages.some(m => m.clientId === clientId), { timeout: 10_000 });
- * });
+ * const clientId = crypto.randomUUID();
+ * await socket.send({ clientId, text }); // fire-and-forget transport
+ * // Wait until the live source echoes the write:
+ * await until(() => messages.some(m => m.clientId === clientId), { timeout: 10_000 });
  * ```
  *
- * @param fn a reactive predicate over authoritative state
+ * @param fn a reactive predicate
  * @param options optional `timeout` (ms) and abort `signal`
  */ function until(e, t) {
-    // Late-bind the wakeup hook for the A17-silent ack paths (pay-for-use:
-    // apps that never call until() never retain it).
-    installAuthoritativeRead();
-    // Flip-entanglement (#3164 follow-up): the transaction this until() holds
-    // open (the action's, when yielded from one). The predicate is the user's
-    // declaration of what confirms it — when a foreign transition's staged
-    // write flips it truthy, that transition merges here and reveals at the
-    // joint settle instead of painting the confirmation under live optimism.
-        const r = activeTransition;
-    return new Promise((n, i) => {
+    return new Promise((r, n) => {
         const o = t?.signal;
-        if (o?.aborted) return i(o.reason);
-        createRoot(c => {
-            // Same delivery contract as resolve() (#2930): effect applies ride a
-            // microtask so the promise can settle while the transaction the caller
-            // yielded it into is still open — that transaction being open is the
-            // entire point of the hold.
-            const u = getOwner();
-            const s = new MicrotaskQueue;
-            s._parent = u.T;
-            u.T = s;
-            let f;
-            let a;
+        if (o?.aborted) return n(o.reason);
+        // The awaiting action's transaction, if any (its body runs joined to
+        // it). `until()` is a declaration of relatedness (#3164 follow-up): the
+        // predicate names the condition that confirms the action, so the frame
+        // whose landing flips it truthy is the confirming event by the user's
+        // own definition — it reveals WITH the action's settle, not before
+        // (`saving=true` beside the confirmed `version=1` is a tear no timeline
+        // contains). Updates that do not flip the predicate reveal freely.
+                const c = flushTransaction;
+        createRoot(u => {
+            let i;
+            let s;
             const settle = e => {
-                if (f !== undefined) clearTimeout(f);
-                if (a !== undefined) o.removeEventListener("abort", a);
+                if (i !== undefined) clearTimeout(i);
+                if (s !== undefined) o.removeEventListener("abort", s);
                 e();
-                c();
+                u();
             };
-            effect(r === null ? e : () => {
-                const t = e();
-                // Runs inside the compute (pure phase): the confirming
-                // transition's stamps are live and its commit hasn't run, so
-                // the merge lands before any reveal. Falsy evaluations skip —
-                // non-flipping updates were never named as the confirmation.
-                                if (t) entangleConfirmingTransitions(getObserver(), r);
-                return t;
-            }, e => {
+            // Authoritative: the predicate sees the truth, never the action's own
+            // optimistic guess — a guess cannot satisfy the wait for its own
+            // confirmation.
+                        watch(e, e => {
                 // Falsy is "not yet": keep the subscription live and wait for the
                 // next evaluation. Only a truthy settled value resolves.
-                if (e) settle(() => n(e));
-            }, e => settle(() => i(e)), 
-            // AUTHORITATIVE_READ: overrides invisible to the predicate.
-            // DIRECT_COMMIT: truth that stages into the held transaction (a
-            // refresh the action issued) must flow through to the microtask
-            // apply — a staged effect value would deadlock the hold on data
-            // the hold itself is keeping uncommitted.
-            {
-                user: true,
-                Qt: CONFIG_AUTHORITATIVE_READ | CONFIG_DIRECT_COMMIT
+                if (e) settle(() => r(e));
+            }, e => settle(() => n(e)), CONFIG_AUTHORITATIVE, e => {
+                // 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.X && resolveTx(c).tt !== 0) joinFuture(c);
             });
-            if (t?.timeout !== undefined) f = setTimeout(() => settle(() => i(new TimeoutError)), t.timeout);
+            if (t?.timeout !== undefined) i = setTimeout(() => settle(() => n(new TimeoutError)), t.timeout);
             if (o !== undefined) {
-                a = () => settle(() => i(o.reason));
-                o.addEventListener("abort", a, {
+                s = () => settle(() => n(o.reason));
+                o.addEventListener("abort", s, {
                     once: true
                 });
             }
@@ -599,21 +542,6 @@ function createMemo(e, t) {
     });
 }
 
-function createOptimistic(e, t) {
-    // Install before the node exists: only engine-installed programs can carry
-    // an _overrideValue slot (same runtime-install pattern as
-    // GlobalQueue._clearOptimisticStore in createOptimisticStore).
-    installOptimisticEngine();
-    if (typeof e === "function") {
-        const r = optimisticComputed(e, t);
-        r.C &= ~CONFIG_AUTO_DISPOSE;
-        return [ accessor(r), setSignal.bind(null, r) ];
-    }
-    const r = optimisticSignal(e, t);
-    registerGraph(r, getOwner());
-    return [ accessor(r), setSignal.bind(null, r) ];
-}
-
 /**
  * Schedules `callback` to run **once** after the reactive graph has fully
  * settled — i.e. once every pending async read inside the current owner has
@@ -709,7 +637,7 @@ function createOptimistic(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.C & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), {
+    t && !(t.i & CONFIG_CHILDREN_FORBIDDEN) ? trackedEffect(() => untrack(e), {
         name: "onSettled"
     }) : globalQueue.enqueue(EFFECT_USER, function fire() {
         // Settled means derived. A settle that reverts optimism (or replays
@@ -719,7 +647,7 @@ function createOptimistic(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.EE >= dirtyQueue.st) return globalQueue.enqueue(EFFECT_USER, fire);
+        if (dirtyQueue.Kt >= dirtyQueue.ut) 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

@@ -0,0 +1,142 @@
+import { GlobalQueue } from "../core/scheduler.js";
+
+import { optHooks, installAffectsHooks } from "./hooks.js";
+
+import { lookupTarget, $OWNER } from "./target.js";
+
+import { $TARGET } from "./types.js";
+
+/**
+ * Store — the store half of `affects()` (plan sec. 29, plan sec. 37; A24 (4), #2882,
+ * #2893, #2904).
+ *
+ * A mark on a store is a mark on nodes (affects.ts: a count on the node, a
+ * dependency walk at probe time): `affects(record, key)` marks the slot's
+ * leaf; `affects(record)` marks a carrier (the record's `$AFFECTS` leaf)
+ * and every live node in the record's subtree — the edges existing readers
+ * subscribed through. Coverage is by RAW IDENTITY, not read path (#2882: a
+ * captured row proxy, a derived store sharing the source's raw, never read
+ * through the declaration's proxy): the identities reachable at the
+ * declaration are the mark's `scope`, so a node born inside the window on
+ * a covered record inherits the mark (released with the carrier's last),
+ * and an untracked probe through a record with no nodes is witnessed into
+ * the verdict. A mark declared on a draft (inside a setter) or over an
+ * optimistic family walks the view the writer sees.
+ *
+ * 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: [],
+        bt: 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 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);
+    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, o, n, t, s) {
+    if (!GlobalQueue.so(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);
+    if (f !== undefined) {
+        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) r = optHooks.view(f, r, true);
+        const e = f.n;
+        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 (o !== $AFFECTS) n.push(e[o]);
+        const s = f.h;
+        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(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, o, n) {
+    for (const [t, s] of scopes) {
+        if (t === n || s.bt !== undefined && s.bt !== o) continue;
+        for (let o = e.v; ;) {
+            if (s.eo.has(o)) return t;
+            const e = o?.[$TARGET];
+            if (e === undefined) break;
+            const n = e.pb ?? e.v;
+            if (n === o) break;
+            o = n;
+        }
+    }
+    return null;
+}
+
+/** 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).
+    fo(e, o, n) {
+        if (scopes.size === 0 || n === $AFFECTS) return;
+        const t = covering(e, n, o);
+        if (!t) return;
+        GlobalQueue.O(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.
+    ro(e, o) {
+        if (e.n?.[$AFFECTS]?.m?.T || covering(e, o)) GlobalQueue.Bt();
+    }
+};
+
+/** `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. */ function releaseMarkScope(e) {
+    const o = scopes.get(e);
+    if (o === undefined) return;
+    scopes.delete(e);
+    GlobalQueue.k(o.oo);
+}
+
+export { installStoreAffects, releaseMarkScope, storeMarks };

package/dist/observe/store/hooks.js

@@ -0,0 +1,13 @@
+let optHooks = null;
+
+function installOptHooks(o) {
+    optHooks = o;
+}
+
+let affectsHooks = null;
+
+function installAffectsHooks(o) {
+    affectsHooks = o;
+}
+
+export { affectsHooks, installAffectsHooks, installOptHooks, optHooks };