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

package/dist/prod/core/heap.js

@@ -1,49 +1,44 @@
 import "./core.js";
 
-import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_ZOMBIE, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_CHECK, REACTIVE_DIRTY, CONFIG_FW_CHILDREN } from "./constants.js";
+import { REACTIVE_IN_HEAP, REACTIVE_RECOMPUTING_DEPS, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP_HEIGHT } from "./constants.js";
 
-import { zombieQueue, dirtyQueue } from "./scheduler.js";
-
-/** The queue a node belongs to, picked from its own zombie flag. */ function queueFor(e) {
-    return e.oe & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-}
+import { dirtyQueue } from "./scheduler.js";
 
 /**
- * Schedule one subscriber to re-run on the next flush: inserted into its own
- * (zombie-flag-routed) heap with the `_min` cursor pulled down. Tracked
- * effects ride the heap too — the heap visit is their (empty) compute phase,
- * which hands the callback to the user queue once the pass has committed
- * (see GlobalQueue._update, #3291).
+ * Schedule one subscriber to re-run on the next flush: inserted into the
+ * dirty heap with the `_min` cursor pulled down. Tracked effects ride the
+ * heap too — the heap visit is their (empty) compute phase, which hands the
+ * callback to the user queue once the pass has committed (see
+ * GlobalQueue._update, #3291).
  */ function enqueueSub(e) {
-    const E = queueFor(e);
-    if (E.ln > e.rn) E.ln = e.rn;
-    insertIntoHeap(e, E);
+    if (dirtyQueue.He > e.Le) dirtyQueue.He = e.Le;
+    insertIntoHeap(e, dirtyQueue);
 }
 
-function actualInsertIntoHeap(e, E) {
-    const t = (e._parent?.Wn ? e._parent.qn?.rn : e._parent?.rn) ?? -1;
-    if (t >= e.rn) e.rn = t + 1;
-    const n = e.rn;
-    const I = E.eE[n];
-    if (I === undefined) E.eE[n] = e; else {
-        const E = I.Fn;
-        E.Pn = e;
-        e.Fn = E;
-        I.Fn = e;
+function actualInsertIntoHeap(e, t) {
+    const E = (e._parent?.Et ? e._parent.ut?.Le : e._parent?.Le) ?? -1;
+    if (E >= e.Le) e.Le = E + 1;
+    const n = e.Le;
+    const I = t.Ht[n];
+    if (I === undefined) t.Ht[n] = e; else {
+        const t = I.Ke;
+        t.je = e;
+        e.Ke = t;
+        I.Ke = e;
     }
-    if (n > E.EE) E.EE = n;
+    if (n > t.At) t.At = n;
 }
 
-function insertIntoHeap(e, E) {
-    let t = e.oe;
+function insertIntoHeap(e, t) {
+    let E = e.R;
     // RECOMPUTING refusals are not always losses: a genuinely missed wake (a
     // write to a link this pass already validated) is latched link-side in
     // insertSubs as REACTIVE_MISSED_WAKE for recompute's tail (#3037).
-        if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
-    if (t & REACTIVE_CHECK) {
-        e.oe = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+        if (E & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
+    if (E & REACTIVE_CHECK) {
+        e.R = E & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
     } else {
-        e.oe = t | REACTIVE_IN_HEAP;
+        e.R = E | REACTIVE_IN_HEAP;
         // An unmarked node entering an already-marked heap is marked on the
         // spot, keeping the markHeap memo valid. `_marked` is only reset by
         // runHeap, so a write between two mid-tick pulls (read-time markHeap +
@@ -54,94 +49,76 @@ function insertIntoHeap(e, E) {
         // parked in the heap for a synchronous mount (each row writing a ref
         // signal its effect subscribes to), mounting N rows was O(N²) (#3350).
         // markNode's own guard skips an already-DIRTY node.
-                if (E.tE) markNode(e);
+                if (t.C) markNode(e);
     }
-    if (!(t & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, E);
+    if (!(E & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
 }
 
-function insertIntoHeapHeight(e, E) {
-    let t = e.oe;
-    if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
-    e.oe = t | REACTIVE_IN_HEAP_HEIGHT;
-    actualInsertIntoHeap(e, E);
+function insertIntoHeapHeight(e, t) {
+    let E = e.R;
+    if (E & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
+    e.R = E | REACTIVE_IN_HEAP_HEIGHT;
+    actualInsertIntoHeap(e, t);
 }
 
-function deleteFromHeap(e, E) {
-    const t = e.oe;
-    if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-    e.oe = t & -25;
-    const n = e.rn;
-    if (e.Fn === e) E.eE[n] = undefined; else {
-        const t = e.Pn;
-        const I = E.eE[n];
-        const o = t ?? I;
-        if (e === I) E.eE[n] = t; else e.Fn.Pn = t;
-        o.Fn = e.Fn;
+function deleteFromHeap(e, t) {
+    const E = e.R;
+    if (!(E & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
+    e.R = E & -25;
+    const n = e.Le;
+    if (e.Ke === e) t.Ht[n] = undefined; else {
+        const E = e.je;
+        const I = t.Ht[n];
+        const i = E ?? I;
+        if (e === I) t.Ht[n] = E; else e.Ke.je = E;
+        i.Ke = e.Ke;
     }
-    e.Fn = e;
-    e.Pn = undefined;
+    e.Ke = e;
+    e.je = undefined;
 }
 
 function markHeap(e) {
-    if (e.tE) return;
-    e.tE = true;
-    for (let E = 0; E <= e.EE; E++) {
-        for (let t = e.eE[E]; t !== undefined; t = t.Pn) {
-            if (t.oe & REACTIVE_IN_HEAP) markNode(t);
+    if (e.C) return;
+    e.C = true;
+    for (let t = 0; t <= e.At; t++) {
+        for (let E = e.Ht[t]; E !== undefined; E = E.je) {
+            if (E.R & REACTIVE_IN_HEAP) markNode(E);
         }
     }
 }
 
-function markNode(e, E = REACTIVE_DIRTY) {
-    const t = e.oe;
-    if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
-    e.oe = t & -4 | E;
-    for (let E = e.u; E !== null; E = E.Ae) {
-        markNode(E.ge, REACTIVE_CHECK);
-    }
-    // Firewall children (projection machinery only): gate the cold-extension
-    // deref on the config bit — markNode runs per sub edge per write, and an
-    // unconditional _x chase here taxed every propagation (diamond -22%).
-        if (e.C & CONFIG_FW_CHILDREN) {
-        for (let E = e.o.i; E !== null; E = E.Ue) {
-            for (let e = E.u; e !== null; e = e.Ae) {
-                markNode(e.ge, REACTIVE_CHECK);
-            }
-        }
+function markNode(e, t = REACTIVE_DIRTY) {
+    const E = e.R;
+    if ((E & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
+    e.R = E & -4 | t;
+    for (let t = e.t; t !== null; t = t.l) {
+        markNode(t.o, REACTIVE_CHECK);
     }
 }
 
-function runHeap(e, E) {
-    e.tE = false;
-    for (e.ln = 0; e.ln <= e.EE; e.ln++) {
-        let t = e.eE[e.ln];
-        while (t !== undefined) {
-            if (t.oe & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.ln];
+function runHeap(e, t) {
+    e.C = false;
+    for (e.He = 0; e.He <= e.At; e.He++) {
+        let E = e.Ht[e.He];
+        while (E !== undefined) {
+            if (E.R & REACTIVE_IN_HEAP) t(E); else adjustHeight(E, e);
+            E = e.Ht[e.He];
         }
     }
-    e.EE = 0;
+    e.At = 0;
 }
 
-function adjustHeight(e, E) {
-    deleteFromHeap(e, E);
-    let t = e.rn;
-    for (let E = e.Ie; E; E = E.Ne) {
-        const e = E.Oe;
-        const n = e.De || e;
-        if (n.he && n.rn >= t) t = n.rn + 1;
+function adjustHeight(e, t) {
+    deleteFromHeap(e, t);
+    let E = e.Le;
+    for (let t = e._; t; t = t.p) {
+        const e = t.I;
+        if (e.re && e.Le >= E) E = e.Le + 1;
     }
-    if (e.rn !== t) {
-        e.rn = t;
-        for (let E = e.u; E !== null; E = E.Ae) {
-            // Route each subscriber by its own zombie flag, mirroring the
-            // post-recompute height-adjust path. Inserting into the running `heap`
-            // unconditionally can park a zombie in `dirtyQueue` (or a live node in
-            // `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap`
-            // relies on — the same corruption class as #2759.
-            insertIntoHeapHeight(E.ge, queueFor(E.ge));
-        }
+    if (e.Le !== E) {
+        e.Le = E;
+        for (let E = e.t; E !== null; E = E.l) insertIntoHeapHeight(E.o, t);
     }
 }
 
-export { deleteFromHeap, enqueueSub, insertIntoHeap, insertIntoHeapHeight, markHeap, markNode, queueFor, runHeap };
+export { deleteFromHeap, enqueueSub, insertIntoHeap, insertIntoHeapHeight, markHeap, markNode, runHeap };

package/dist/prod/core/invariants.js

@@ -1,36 +1,5 @@
 import "./core.js";
 
-/**
- * INV-2: a node with an *active* override must be registered for reversion in
- * the queue's or a transition's `_optimisticNodes`. An unregistered active
- * override would survive transition completion forever. Runs at the end of
- * every flush (not just quiescence — the invariant holds mid-transition).
- * (There is no revert-target requirement: authoritative values commit
- * silently into `_value` under the override mask — A17 — so reverting is
- * just dropping the override.)
- */ function devCheckActiveOverrides(e) {
-    return;
-}
-
-/** INV-1: an isPending() probe must never leak past its own call. */ function devCheckFlushStart() {
-    return;
-}
-
-/**
- * Companion-vs-oracle census (#2838 pre-work). A NON-ASSERTING diff logger:
- * at the end of every flush it compares each live companion's cached state
- * against a fresh oracle and logs every distinct divergence fingerprint once
- * (console, `[census]` prefix). Legit lane-scoped windows will show up too —
- * the census exists to enumerate the full taxonomy of mid-flight divergence
- * so the write-driven redesign knows every case it must produce, not to
- * judge them. Enabled only when the COMPANION_CENSUS env var is set (in
- * addition to `false`), so normal test runs pay one boolean check.
- */ typeof globalThis !== "undefined" && !!globalThis.process?.env?.COMPANION_CENSUS;
-
-function devCensusCompanions(e) {
-    return;
-}
-
 /**
  * Quiescence checks. Run only when the system is fully drained: nothing
  * scheduled, no active/stashed transitions, no live lanes. At that point no
@@ -40,4 +9,4 @@ function devCensusCompanions(e) {
     return;
 }
 
-export { devCensusCompanions, devCheckActiveOverrides, devCheckFlushStart, devCheckQuiescent };
+export { devCheckQuiescent };