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

package/dist/observe/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/observe/affects.js

@@ -0,0 +1,112 @@
+import { $REFRESH, STATUS_PENDING, CONFIG_SLOT_NODE } from "./core/constants.js";
+
+import "./core/dev.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;
+}
+
+/** 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);
+}
+
+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();
+}
+
+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;
+    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;
+    }
+    // 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/observe/attribution.js

@@ -0,0 +1,7 @@
+export { attribution, formatOrigin, formatRerun, graphSize } from "./core/attribution.js";
+
+export { costs } from "./core/attribution-costs.js";
+
+export { feedback } from "./core/attribution-feedback.js";
+
+export { subscriptions, why } from "./core/attribution-queries.js";