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

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,10 +1,10 @@
-import { $REFRESH, CONFIG_VERDICT, STATUS_PENDING, CONFIG_SLOT_NODE, STATUS_ERROR, REACTIVE_RECOMPUTING_DEPS } from "./core/constants.js";
+import { $REFRESH, STATUS_PENDING, CONFIG_SLOT_NODE } from "./core/constants.js";
 
-import { ext } from "./core/core.js";
+import "./core/core.js";
 
-import { enqueueSub } from "./core/heap.js";
+import { schedule, resolveTx, flushTransaction, installMarkHooks, GlobalQueue } from "./core/scheduler.js";
 
-import { schedule, resolveTx, flushTransaction, GlobalQueue } from "./core/scheduler.js";
+import { mark, repoll, unmark } from "./affects-marks.js";
 
 import { storeMarks, installStoreAffects, releaseMarkScope } from "./store/affects.js";
 
@@ -21,60 +21,22 @@ import { $TARGET } from "./store/types.js";
 // 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.
+// 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.
-/** 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 r = e.t; r !== null; r = r.o) {
-        const e = r.l;
-        if (t.has(e)) continue;
-        t.add(e);
-        if (e.i & CONFIG_VERDICT) enqueueSub(e);
-        if (!e.u) repoll(e, t);
-    }
-}
-
-/** 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 r = e;
-    if (r.S & STATUS_ERROR || t.has(e)) return false;
-    t.add(e);
-    const n = r.R & REACTIVE_RECOMPUTING_DEPS ? r.G : undefined;
-    if (n !== null) for (let e = r.p ?? null; e !== null; e = e._) {
-        if (marked(e.I, t)) return true;
-        if (e === n) break;
-    }
-    return false;
-}
+/** 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];
-        active--;
-        if (--r.m.T === 0) {
-            repoll(r);
-            // A store mark's carrier: its scope (and the marks the nodes born in
-            // its window inherited) goes with it.
-                        releaseMarkScope(r);
-        }
+        // 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;
 }
@@ -85,16 +47,11 @@ let active = 0;
     const t = flushTransaction;
     if (t === null) ambient.push(e); else {
         const r = resolveTx(t);
-        (r.T ??= []).push(e);
+        (r.I ??= []).push(e);
     }
     repoll(e);
 }
 
-function mark(e) {
-    ext(e).T++;
-    active++;
-}
-
 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.
@@ -106,26 +63,20 @@ function affects(e, t) {
         schedule();
         return;
     }
-    const n = e?.[$REFRESH];
-    if (!n) {
+    const s = e?.[$REFRESH];
+    if (!s) {
         return;
     }
-    register(n);
+    register(s);
     schedule();
 }
 
-GlobalQueue.N = e => active !== 0 && marked(e, new Set);
-
-GlobalQueue.O = mark;
-
-GlobalQueue.k = release;
-
-GlobalQueue.A = e => {
+installMarkHooks(release, 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 ??= [];
+        const t = e.I ??= [];
         for (let e = 0; e < ambient.length; e++) t.push(ambient[e]);
         ambient.length = 0;
         return;
@@ -137,15 +88,15 @@ GlobalQueue.A = e => {
         let t = 0;
     const r = [];
     for (let e = 0; e < ambient.length; e++) {
-        const n = ambient[e];
-        if (inFlight(n)) ambient[t++] = n; else r.push(n);
+        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.S & STATUS_PENDING) !== 0 || (e.i & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.C?.(e) === true;
+    return (e.m & STATUS_PENDING) !== 0 || (e.l & CONFIG_SLOT_NODE) !== 0 && GlobalQueue.k?.(e) === true;
 }
 
 export { affects };