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

package/dist/observe/affects.js

@@ -1,129 +1,150 @@
-import { forEachDependent } from "./core/async.js";
+import { $REFRESH, CONFIG_VERDICT, STATUS_PENDING, CONFIG_SLOT_NODE, STATUS_ERROR, REACTIVE_RECOMPUTING_DEPS } from "./core/constants.js";
 
-import { ext, statusNotifierOf } from "./core/core.js";
-
-import { $REFRESH, STATUS_PENDING } from "./core/constants.js";
+import { ext } from "./core/core.js";
 
 import "./core/dev.js";
 
-import { NotReadyError } from "./core/error.js";
-
-import { GlobalQueue, globalQueue, schedule, shiftAffectsMarks } from "./core/scheduler.js";
-
-import "./core/verdict.js";
-
-import "./core/effect.js";
-
-import "./core/invariants.js";
-
-import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
+import { enqueueSub } from "./core/heap.js";
+
+import { GlobalQueue, schedule, resolveTx, flushTransaction } from "./core/scheduler.js";
+
+import { $TARGET } from "./store/types.js";
+
+// `affects()` — the declaration verb of the pending model (A24 (4), ruled
+// 2026-07-13; the #2893 audit corollaries; rebuilt on L2 2026-10-02 as ruled:
+// transaction-inert).
+// A mark is a declared in-flight change: the marked node — and everything
+// derived from it — reads pending (`isPending` → true) from the declaration
+// until the surrounding transaction lands (an ambient mark, declared outside
+// one, releases at the next seam). The marked values stay readable: no reader
+// suspends on a mark, a mark holds nothing and entangles nothing — it is not
+// a node of its transaction (`blocked` never sees it), and a reader of marked
+// data joins nothing through it. A mark is never a re-ask, so a declared
+// reload's own `refresh()` cannot silence it; a real error outranks it.
+// Representation: a count on the marked node (`_x._marks`), listed with its
+// scope (the transaction's `_marks`, or the ambient list). Coverage of the
+// derivations is pull-derived at probe time — `isPending`'s read walks the
+// probed node's dependencies for a marked one (verdict.ts → `_marked`) — so
+// nothing is stored downstream and a mid-window recompute strands nothing.
+// The push half is the verdict readers' re-derivation at registration and at
+// release (`repoll`): the only notification a mark makes.
+// Installed on `GlobalQueue` when imported: a program that never declares a
+// mark carries none of this.
+/** Live marks, every scope — the gate on the probe's walk. */
+let active = 0;
+
+/** Marks declared outside a transaction: released at the next seam. */ const ambient = [];
+
+/** The verdict readers downstream of `node` — through derivations, stopping
+ * at effects — re-derive: the mark's one notification (a probe's answer
+ * changed with no value notifying anyone). */ function repoll(e, t = new Set) {
+    for (let n = e.t; n !== null; n = n.l) {
+        const e = n.o;
+        if (t.has(e)) continue;
+        t.add(e);
+        if (e.u & CONFIG_VERDICT) enqueueSub(e);
+        if (!e.i) repoll(e, t);
+    }
+}
 
-/**
- * The counting half of a mark, shared by direct registration and store-scope
- * inheritance (a node created inside a live keyless mark's identity scope).
- * A mark is ONLY this count: coverage of everything derived from the node is
- * pull-derived by the verdict layer's `markWalk` (dep-graph reachability), so
- * nothing is stored downstream and nothing can be stranded or stripped by
- * mid-window recomputes.
- */ function markAffects(e) {
-    ext(e).t = (e.o?.t || 0) + 1;
-    shiftAffectsMarks(1);
+/** A node is covered by a live mark iff it carries one, or derives — through
+ * its current dependencies — from one that does. A real error outranks an
+ * inherited mark (A24 (c)): coverage does not flow through an errored node
+ * (a direct mark on one still reads pending). Mid-recompute, only the
+ * validated prefix of the dependency list is this pass's. */ function marked(e, t) {
+    if (e.m !== null && e.m.T !== 0) return true;
+    const n = e;
+    if (n.G & STATUS_ERROR || t.has(e)) return false;
+    t.add(e);
+    const r = n.R & REACTIVE_RECOMPUTING_DEPS ? n.S : undefined;
+    if (r !== null) for (let e = n._ ?? null; e !== null; e = e.p) {
+        if (marked(e.I, t)) return true;
+        if (e === r) break;
+    }
+    return false;
 }
 
-/**
- * Boundary visual channel: within a transaction, a live mark holds Loading
- * fallbacks / reveal ordering the way real in-flight async would — but the
- * notification is tagged visibility-only at the source (`_markVisual`), so
- * the root queue never registers reporters from it: marks are invisible to
- * ALL completion and settlement accounting by construction. Boundaries hold
- * the marked node in `_sources` while `_affectsCount` is live; the release
- * sweep (finalizePureQueue re-checks boundary children after mark release)
- * is the display-state update point. Ambient marks release inside the same
- * flush that would surface them, before effects run — verdict-only, netting
- * no visual change.
- */ function notifyMarkBoundaries(e) {
-    if (!e.u && !e.o?.i) return;
-    const r = new NotReadyError(e);
-    r.l = true;
-    const t = new Set;
-    const visit = e => {
-        if (t.has(e)) return;
-        t.add(e);
-        // Display consumers (render effects, boundary computeds) act on the
-        // notification; descent stops there, exactly like the status rails.
-                const o = statusNotifierOf(e);
-        if (o) {
-            o.call(e, STATUS_PENDING, r);
-            return;
+/** Releases one scope's marks (a landed transaction's, the ambient list at
+ * the seam): a node whose last mark drops re-derives its verdict readers. */ function release(e) {
+    for (let t = 0; t < e.length; t++) {
+        const n = e[t];
+        active--;
+        if (--n.m.T === 0) {
+            repoll(n);
+            // A store mark's carrier: its scope (and the marks the nodes born in
+            // its window inherited) goes with it.
+                        GlobalQueue.N?.(n);
         }
-        forEachDependent(e, visit);
-    };
-    forEachDependent(e, visit);
+    }
+    e.length = 0;
 }
 
-/**
- * Registers one `affects()` mark on a node: counts it, records the
- * registration with the current transaction (after initTransition the queue's
- * batch IS the active transition, mirroring `_optimisticNodes`), re-derives
- * every downstream verdict companion (the mark channel's only push — verdict
- * pokes, not state), and notifies boundary display state. Both walks run on
- * every registration (not just the first): subscribers gained since an
- * earlier overlapping registration get covered, and dedup stops re-descent.
- */ function registerAffectsMark(e) {
-    markAffects(e);
-    globalQueue.m.A.push(e);
-    // Companions only exist once the verdict layer (isPending/latest) loaded;
-    // without them there is no materialized verdict to poke.
-        GlobalQueue.k !== null && GlobalQueue.k(e);
-    notifyMarkBoundaries(e);
-    schedule();
+/** One registration: a count on the node, listed with the scope — the
+ * flush's transaction, or the ambient list (released at the seam). */ function register(e) {
+    mark(e);
+    const t = flushTransaction;
+    if (t === null) ambient.push(e); else {
+        const n = resolveTx(t);
+        (n.T ??= []).push(e);
+    }
+    repoll(e);
 }
 
-/**
- * Releases one registration. When the node's last mark drops, re-derives
- * every downstream verdict through the settlement snap (committed, not
- * transition-scoped — release runs inside queue finalization, where a
- * setSignal would open a fresh override window that nothing settles).
- */ function releaseAffectsMark(e) {
-    shiftAffectsMarks(-1);
-    e.o.t--;
-    if (!e.o.t) {
-        GlobalQueue.k !== null && GlobalQueue.k(e, true);
-        GlobalQueue.p?.(e);
-    }
+function mark(e) {
+    ext(e).T++;
+    active++;
 }
 
-/**
- * Releases one batch of affects marks (a settling transaction's, or the
- * ambient batch at a plain flush end).
- */ function releaseAffectsMarks(e) {
-    for (let r = 0; r < e.length; r++) releaseAffectsMark(e[r]);
-    e.length = 0;
+function affects(e, t) {
+    // A store (the store half, store/affects.ts): the slot's leaf, or the
+    // record's carrier and every live node under it.
+    const n = e?.[$TARGET];
+    if (n !== undefined) {
+        const e = GlobalQueue.O(n, t);
+        for (let t = 0; t < e.length; t++) register(e[t]);
+        schedule();
+        return;
+    }
+    const r = e?.[$REFRESH];
+    if (!r) {
+        return;
+    }
+    register(r);
+    schedule();
 }
 
-// Late installation (same pattern as `GlobalQueue._update`): the mark engine
-// lives with the feature so graphs that never declare a mark never ship it.
-// Each call site is gated by state only this module creates (a non-empty
-// `_affectsNodes` batch, a live scope in the store's `affectsScopes`), so the
-// hooks are installed before the first time any of them can fire.
-GlobalQueue.G = releaseAffectsMarks;
+GlobalQueue.C = e => active !== 0 && marked(e, new Set);
 
-GlobalQueue.M = markAffects;
+GlobalQueue.h = mark;
 
-GlobalQueue.j = releaseAffectsMark;
+GlobalQueue.A = release;
 
-function affects(e, r) {
-    const t = e?.[$TARGET];
-    if (t) {
-        const e = getStoreAffectsNodes(t, r);
-        for (let r = 0; r < e.length; r++) registerAffectsMark(e[r]);
+GlobalQueue.D = e => {
+    if (ambient.length === 0) return;
+    // The flush parked: the declaration's window is the frame's — the marks
+    // are its transaction's ("nothing async below ⇒ no window").
+        if (e !== null) {
+        const t = e.T ??= [];
+        for (let e = 0; e < ambient.length; e++) t.push(ambient[e]);
+        ambient.length = 0;
         return;
     }
-    const o = e?.[$REFRESH];
-    if (o) {
-        registerAffectsMark(o);
-        return;
+    // Nothing parked, but a marked node's own flight is up (a declared
+    // reload's quiet re-ask — the node's, or a store leaf's family derive):
+    // the window is the flight's; the mark stays to the seam after the
+    // landing. The rest release: verdict-only, nothing to show.
+        let t = 0;
+    const n = [];
+    for (let e = 0; e < ambient.length; e++) {
+        const r = ambient[e];
+        if (inFlight(r)) ambient[t++] = r; else n.push(r);
     }
+    ambient.length = t;
+    if (n.length !== 0) release(n);
+};
+
+function inFlight(e) {
+    return (e.G & STATUS_PENDING) !== 0 || (e.u & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.F?.(e) === true;
 }
 
 export { affects };