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

package/dist/prod/affects-marks.js

@@ -0,0 +1,86 @@
+import { CONFIG_VERDICT, CONFIG_AUTHORITATIVE, STATUS_ERROR, CONFIG_SLOT_NODE, REACTIVE_RECOMPUTING_DEPS } from "./core/constants.js";
+
+import { ext } from "./core/core.js";
+
+import { enqueueSub } from "./core/heap.js";
+
+import { GlobalQueue } from "./core/scheduler.js";
+
+// The mark core: a declared not-final state on a node that reads pending
+// (`isPending` → true) on the node and everything derived from it, without
+// holding anything or entangling a reader. Two declarers share it:
+// `affects()` (affects.ts — a mark scoped to a transaction, with a store
+// half) and `createDeferred` (deferred.ts — a mark whose lifetime is the
+// node's own flight). Split out so the second does not ship the first.
+// Representation: a count on the marked node (`_x._marks`). 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 when a node's marks
+// start and end (`repoll`): the only notification a mark makes.
+/** Live marks, every declarer — the gate on the probe's walk. */
+let active = 0;
+
+/** 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). Truth readers (`until`, the
+ * `refresh` waiter) too, which a lagging flight parked (deferred.ts) — but
+ * not through a derived store, whose leaves change only once its derive
+ * re-runs: they re-derive at that write. */ function repoll(e, r = new Set, o = CONFIG_VERDICT | CONFIG_AUTHORITATIVE) {
+    for (let t = e.o; t !== null; t = t.t) {
+        const e = t.u;
+        if (r.has(e)) continue;
+        r.add(e);
+        if (e.l & o) enqueueSub(e);
+        if (!e.i) repoll(e, r, o);
+        // A derived store's derive: its leaves' readers derive from it too
+        // (store/projection.ts; a live target's property, has and keys nodes).
+                const n = e.fam;
+        if (n) for (const e of n.live) for (const o of [ e.n, e.h, {
+            k: e.k,
+            d: e.dk
+        } ]) if (o) for (const e of Reflect.ownKeys(o)) o[e] && repoll(o[e], r, CONFIG_VERDICT);
+    }
+}
+
+/** A node is covered by a live mark iff it carries one, or derives — through
+ * its current dependencies — from one that does. A store slot derives from
+ * its family's derive (a derived store's leaves are not the derive's
+ * dependents, store/projection.ts), so coverage hops there. 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, r) {
+    if (e.T !== null && e.T.I !== 0) return true;
+    const o = e;
+    if (o.m & STATUS_ERROR || r.has(e)) return false;
+    r.add(e);
+    if (o.l & CONFIG_SLOT_NODE) {
+        const e = o.O?.fam?.node;
+        return e != null && marked(e, r);
+    }
+    const t = o.R & REACTIVE_RECOMPUTING_DEPS ? o._ : undefined;
+    if (t !== null) for (let e = o.C ?? null; e !== null; e = e.G) {
+        if (marked(e.S, r)) return true;
+        if (e === t) break;
+    }
+    return false;
+}
+
+/** One mark on `node`. The declarer repolls once its bookkeeping is done. */ function mark(e) {
+    ext(e).I++;
+    active++;
+}
+
+/** Drops one mark from `node`: true when it was the last — the node's
+ * verdict readers have re-derived. */ function unmark(e) {
+    active--;
+    if (--e.T.I !== 0) return false;
+    repoll(e);
+    return true;
+}
+
+GlobalQueue.p = e => active !== 0 && marked(e, new Set);
+
+GlobalQueue.N = mark;
+
+export { mark, repoll, unmark };

package/dist/prod/affects.js

@@ -1,126 +1,112 @@
-import { forEachDependent } from "./core/async.js";
-
-import { ext } from "./core/core.js";
-
-import { $REFRESH, STATUS_PENDING } from "./core/constants.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";
-
-/**
- * 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);
-}
-
-/**
- * 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?.l) return;
-    const r = new NotReadyError(e);
-    r.i = 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.
-                if (e.o?.A) {
-            e.o.A.call(e, STATUS_PENDING, r);
-            return;
-        }
-        forEachDependent(e, visit);
-    };
-    forEachDependent(e, visit);
+import { $REFRESH, STATUS_PENDING, CONFIG_SLOT_NODE } from "./core/constants.js";
+
+import "./core/core.js";
+
+import { schedule, resolveTx, flushTransaction, installMarkHooks, GlobalQueue } from "./core/scheduler.js";
+
+import { mark, repoll, unmark } from "./affects-marks.js";
+
+import { storeMarks, installStoreAffects, releaseMarkScope } from "./store/affects.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; either, on a node whose own flight is
+// still up then, at the seam after that flight lands). 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: the mark core (affects-marks.ts) — a count on the marked
+// node, coverage pull-derived at probe time, readers repolled at registration
+// and release. Here: each mark's scope (the transaction's `_marks`, or the
+// ambient list) and the store half.
+// Installed on `GlobalQueue` when imported: a program that never declares a
+// mark carries none of this.
+/** Marks declared outside a transaction: released at the next seam. */
+const ambient = [];
+
+/** 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 r = e[t];
+        // A store mark's carrier: its scope (and the marks the nodes born in
+        // its window inherited) goes with the last mark.
+                if (unmark(r)) releaseMarkScope(r);
+    }
+    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.k.m.push(e);
-    // Companions only exist once the verdict layer (isPending/latest) loaded;
-    // without them there is no materialized verdict to poke.
-        GlobalQueue.p !== null && GlobalQueue.p(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 r = resolveTx(t);
+        (r.I ??= []).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.p !== null && GlobalQueue.p(e, true);
-        GlobalQueue.G?.(e);
+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 r = e?.[$TARGET];
+    if (r !== undefined) {
+        installStoreAffects();
+        const e = storeMarks(r, t);
+        for (let t = 0; t < e.length; t++) register(e[t]);
+        schedule();
+        return;
     }
+    const s = e?.[$REFRESH];
+    if (!s) {
+        return;
+    }
+    register(s);
+    schedule();
 }
 
-/**
- * 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]);
+installMarkHooks(e => {
+    // A landing's mark on a node whose own flight is up (a declared reload's
+    // quiet re-ask the action did not wait for) stays to the seam after
+    // that flight lands, as an ambient one does: the reload's window is the
+    // flight's (#4349). The rest release with the transaction.
+    const t = [];
+    for (let r = 0; r < e.length; r++) (inFlight(e[r]) ? ambient : t).push(e[r]);
     e.length = 0;
-}
-
-// 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.M = releaseAffectsMarks;
-
-GlobalQueue.h = markAffects;
-
-GlobalQueue.j = releaseAffectsMark;
-
-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]);
+    release(t);
+}, 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.I ??= [];
+        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 r = [];
+    for (let e = 0; e < ambient.length; e++) {
+        const s = ambient[e];
+        if (inFlight(s)) ambient[t++] = s; else r.push(s);
     }
+    ambient.length = t;
+    if (r.length !== 0) release(r);
+});
+
+function inFlight(e) {
+    return (e.m & STATUS_PENDING) !== 0 || (e.l & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.k?.(e) === true;
 }
 
 export { affects };

package/dist/prod/attribution.js

@@ -0,0 +1,45 @@
+const EMPTY = Object.freeze([]);
+
+const noop = () => {};
+
+const attribution = {
+    enable: () => noop,
+    disable: noop,
+    history: () => EMPTY,
+    markFlight: noop
+};
+
+// The named surface, inert: every fold empty, every query empty, every
+// formatter blank. Typed against the real entry's exports so the two cannot
+// drift.
+const costs = () => ({
+    scopes: [],
+    writes: []
+});
+
+const feedback = () => ({
+    sources: [],
+    interactions: [],
+    navigations: [],
+    flights: [],
+    fallbacks: []
+});
+
+const why = () => [];
+
+const subscriptions = () => [];
+
+const formatRerun = () => "";
+
+const formatOrigin = () => "";
+
+// Prod registers no roots: the graph has no observable size.
+const graphSize = () => ({
+    roots: 0,
+    owners: 0,
+    computations: 0,
+    signals: 0,
+    edges: 0
+});
+
+export { attribution, costs, feedback, formatOrigin, formatRerun, graphSize, subscriptions, why };