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

package/dist/observe/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.st > e.ft) E.st = e.ft;
-    insertIntoHeap(e, E);
+    if (dirtyQueue.ut > e.it) dirtyQueue.ut = e.it;
+    insertIntoHeap(e, dirtyQueue);
 }
 
-function actualInsertIntoHeap(e, E) {
-    const t = (e._parent?.Zt ? e._parent.Yt?.ft : e._parent?.ft) ?? -1;
-    if (t >= e.ft) e.ft = t + 1;
-    const n = e.ft;
-    const I = E.eE[n];
-    if (I === undefined) E.eE[n] = e; else {
-        const E = I.vt;
-        E.gt = e;
-        e.vt = E;
-        I.vt = e;
+function actualInsertIntoHeap(e, t) {
+    const E = (e._parent?.Ht ? e._parent.gt?.it : e._parent?.it) ?? -1;
+    if (E >= e.it) e.it = E + 1;
+    const n = e.it;
+    const I = t.jt[n];
+    if (I === undefined) t.jt[n] = e; else {
+        const t = I.Rt;
+        t.Ot = e;
+        e.Rt = t;
+        I.Rt = e;
     }
-    if (n > E.EE) E.EE = n;
+    if (n > t.Kt) t.Kt = 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.N) 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.ft;
-    if (e.vt === e) E.eE[n] = undefined; else {
-        const t = e.gt;
-        const I = E.eE[n];
-        const o = t ?? I;
-        if (e === I) E.eE[n] = t; else e.vt.gt = t;
-        o.vt = e.vt;
+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.it;
+    if (e.Rt === e) t.jt[n] = undefined; else {
+        const E = e.Ot;
+        const I = t.jt[n];
+        const i = E ?? I;
+        if (e === I) t.jt[n] = E; else e.Rt.Ot = E;
+        i.Rt = e.Rt;
     }
-    e.vt = e;
-    e.gt = undefined;
+    e.Rt = e;
+    e.Ot = 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.gt) {
-            if (t.oe & REACTIVE_IN_HEAP) markNode(t);
+    if (e.N) return;
+    e.N = true;
+    for (let t = 0; t <= e.Kt; t++) {
+        for (let E = e.jt[t]; E !== undefined; E = E.Ot) {
+            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.Pe) {
-        markNode(E.Ae, 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.ge) {
-            for (let e = E.u; e !== null; e = e.Pe) {
-                markNode(e.Ae, 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.o) {
+        markNode(t.l, REACTIVE_CHECK);
     }
 }
 
-function runHeap(e, E) {
-    e.tE = false;
-    for (e.st = 0; e.st <= e.EE; e.st++) {
-        let t = e.eE[e.st];
-        while (t !== undefined) {
-            if (t.oe & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.st];
+function runHeap(e, t) {
+    e.N = false;
+    for (e.ut = 0; e.ut <= e.Kt; e.ut++) {
+        let E = e.jt[e.ut];
+        while (E !== undefined) {
+            if (E.R & REACTIVE_IN_HEAP) t(E); else adjustHeight(E, e);
+            E = e.jt[e.ut];
         }
     }
-    e.EE = 0;
+    e.Kt = 0;
 }
 
-function adjustHeight(e, E) {
-    deleteFromHeap(e, E);
-    let t = e.ft;
-    for (let E = e.Ee; E; E = E.Ie) {
-        const e = E.De;
-        const n = e.Ne || e;
-        if (n.Se && n.ft >= t) t = n.ft + 1;
+function adjustHeight(e, t) {
+    deleteFromHeap(e, t);
+    let E = e.it;
+    for (let t = e.G; t; t = t._) {
+        const e = t.I;
+        if (e.ee && e.it >= E) E = e.it + 1;
     }
-    if (e.ft !== t) {
-        e.ft = t;
-        for (let E = e.u; E !== null; E = E.Pe) {
-            // 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.Ae, queueFor(E.Ae));
-        }
+    if (e.it !== E) {
+        e.it = E;
+        for (let E = e.t; E !== null; E = E.o) insertIntoHeapHeight(E.l, t);
     }
 }
 
-export { deleteFromHeap, enqueueSub, insertIntoHeap, insertIntoHeapHeight, markHeap, markNode, queueFor, runHeap };
+export { deleteFromHeap, enqueueSub, insertIntoHeap, insertIntoHeapHeight, markHeap, markNode, runHeap };

package/dist/observe/core/invariants.js

@@ -1,38 +1,5 @@
-import "./core.js";
-
 import "./dev.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
@@ -42,4 +9,4 @@ function devCensusCompanions(e) {
     return;
 }
 
-export { devCensusCompanions, devCheckActiveOverrides, devCheckFlushStart, devCheckQuiescent };
+export { devCheckQuiescent };