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

package/dist/prod/core/graph.js

@@ -1,43 +1,58 @@
-import { CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, STATUS_PENDING, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
+import { NewSet, REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_SLOT_NODE } from "./constants.js";
 
-import { deleteFromHeap, queueFor } from "./heap.js";
+import { deleteFromHeap } from "./heap.js";
 
-import { disposeChildren } from "./owner.js";
+import { disposeChildren, runCleanup } from "./owner.js";
 
-import { bumpNotifyEpoch } from "./scheduler.js";
+import { bumpNotifyEpoch, dirtyQueue } from "./scheduler.js";
+
+/** The store's shared slot-node release handler (store/store.ts installs it
+ * once) — a live binding read directly by the sweep site: no wrapper frame,
+ * no null check (a CONFIG_SLOT_NODE node existing implies the store module
+ * loaded and registered it). */ let slotUnobservedHook;
+
+function setSlotUnobserved(e) {
+    slotUnobservedHook = e;
+}
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(e) {
-    const l = e.ut;
-    const n = e.it;
-    const u = e.fe;
-    const s = e.el;
-    if (u !== null) u.el = s; else l.rt = s;
-    if (s !== null) s.fe = u; else {
-        l.u = u;
-        if (u === null) {
-            l.o?.ft?.();
+    const n = e.S;
+    const l = e.G;
+    const o = e.t;
+    const s = e.$e;
+    if (o !== null) o.$e = s; else n.Ze = s;
+    if (s !== null) s.t = o; else {
+        n.o = o;
+        if (o === null) {
+            // Store slot nodes dispatch to the ONE shared hook — no per-node
+            // unobserved closure, no NodeExtension to hold it.
+            // A user hook that throws is collected like a cleanup (owner.ts): the
+            // unlink and the teardown around it carry on.
+            if (n.l & CONFIG_SLOT_NODE) slotUnobservedHook(n); else if (n.T?.Ye) runCleanup(n.T.Ye);
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
-            // A pending node is exempt: its in-flight async work (or the
-            // transition holding it) is an observer — tearing down would orphan
-            // the work and re-execute it on the next read. The settle path runs
-            // this same last-one-out check when that observer releases (the
-            // untracked-read dispose in core.ts guards on pending identically).
-                        const e = l;
-            e.Se && e.T & CONFIG_AUTO_DISPOSE && !(e.ie & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
+            // A pending node is exempt: its in-flight async work is an observer —
+            // tearing down would orphan the work and re-execute it on the next
+            // read. The settle path runs this same last-one-out check when that
+            // observer releases (the untracked-read dormancy sweep guards on
+            // pending identically).
+            // During a pass's teardown of its unfinished frame, the release waits
+            // for the pass to end (`deferredReleases`, #4142).
+                        const e = n;
+            e.X && e.l & CONFIG_AUTO_DISPOSE && !(e.R & REACTIVE_ZOMBIE) && !(e.m & STATUS_PENDING) && (deferredReleases ? deferredReleases.push(e) : unobserved(e));
         }
     }
-    return n;
+    return l;
 }
 
 function trimStaleDeps(e) {
-    const l = e.Ye;
-    let n = l !== null ? l.it : e.nt;
-    if (n !== null) {
+    const n = e._;
+    let l = n !== null ? n.G : e.C;
+    if (l !== null) {
         do {
-            n = unlinkSubs(n);
-        } while (n !== null);
-        if (l !== null) l.it = null; else e.nt = null;
+            l = unlinkSubs(l);
+        } while (l !== null);
+        if (n !== null) n.G = null; else e.C = null;
     }
 }
 
@@ -46,42 +61,80 @@ function trimStaleDeps(e) {
 // and skipping early also avoids adding one (hidden-class churn) via the
 // null-out below.
 function clearDeps(e) {
-    let l = e.nt;
-    if (!l) return;
+    let n = e.C;
+    if (!n) return;
     do {
-        l = unlinkSubs(l);
-    } while (l !== null);
-    e.nt = null;
-    e.Ye = null;
+        n = unlinkSubs(n);
+    } while (n !== null);
+    e.C = null;
+    e._ = null;
 }
 
+/**
+ * Last-one-out releases held back while a pass tears down the frame of an
+ * earlier pass that never committed (#4142). The pass is about to rebuild
+ * the same children, which read the same lazy nodes again. Released on the
+ * spot, a lazy async memo whose only reader was the old frame's child memo
+ * was torn down, re-ran on the new child's read, went pending, and the cycle
+ * repeated forever. `recompute` collects them around that teardown and
+ * releases what is still unobserved when the pass ends.
+ */ let deferredReleases = null;
+
+const deferReleases = e => deferredReleases = e;
+
 function unobserved(e) {
-    deleteFromHeap(e, queueFor(e));
+    deleteFromHeap(e, dirtyQueue);
     clearDeps(e);
     disposeChildren(e, true);
 }
 
-// https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
-function link(e, l, n = false) {
-    // Repeat touches within one pass AND-combine `_pendingObserver`: a probe
-    // read (`isPending(() => x())`) beside a value read of the same dep must
-    // not relabel the value dependency as probe-only — the value read is what
-    // real-error propagation and affects() coverage key off, regardless of
-    // read order within the computation.
-    const u = l.Ye;
-    if (u !== null && u.ut === e) {
-        u.me &&= n;
-        return;
+/**
+ * Deferred dormancy for never-observed auto-dispose computeds (#3078).
+ *
+ * An untracked top-level read of a subscriber-less observation-lifecycle memo
+ * used to call unobserved() inline at the end of read(). That kept the leak
+ * closed (the compute links the memo into its deps' sub lists — without a
+ * teardown point a never-observed memo is retained by its sources forever;
+ * upstream alien-signals has exactly this retention), but it made reads
+ * destructive: each read disposed the node, the next read revived it with a
+ * full recompute in whatever ambient transition/lane context happened to be
+ * current, so consecutive reads could return different answers with no write
+ * in between.
+ *
+ * Instead, reads queue the node here and the scheduler sweeps at the top of
+ * the next flush (before runHeap, so a same-tick dirtying is reclaimed
+ * instead of recomputed). Reads become idempotent within a tick (the node
+ * stays alive and serves its cache, uniform with observed memos) while
+ * reclamation still happens within one microtask — the enqueue site arms
+ * schedule(), so a flush is guaranteed even when no other work is queued.
+ */ const dormantNodes = new NewSet;
+
+function sweepDormant() {
+    if (dormantNodes.size === 0) return;
+    for (const e of dormantNodes) {
+        // Re-validate at sweep time: the node may have gained a subscriber (its
+        // lifecycle is the unlinkSubs cascade now), gone pending (in-flight async
+        // is an observer; the settle path re-runs last-one-out), lost its
+        // AUTO_DISPOSE bit (owner teardown strips it, #3024), or already been
+        // torn down.
+        if (!e.o && e.l & CONFIG_AUTO_DISPOSE && !(e.m & STATUS_PENDING) && !(e.R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+            unobserved(e);
+        }
     }
-    let s = null;
-    const o = l.ie & REACTIVE_RECOMPUTING_DEPS;
-    if (o) {
-        s = u !== null ? u.it : l.nt;
-        if (s !== null && s.ut === e) {
-            s.ll = l.Ze;
-            l.Ye = s;
-            // First touch of this pass: the previous pass's label is stale.
-                        s.me = n;
+    dormantNodes.clear();
+}
+
+// https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
+function link(e, n) {
+    const l = n._;
+    if (l !== null && l.S === e) return;
+    let o = null;
+    const s = n.R & REACTIVE_RECOMPUTING_DEPS;
+    if (s) {
+        o = l !== null ? l.G : n.C;
+        if (o !== null && o.S === e) {
+            o.Ne = n.de;
+            n._ = o;
             return;
         }
     }
@@ -90,26 +143,20 @@ function link(e, l, n = false) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
-        const t = e.rt;
-    if (t !== null && t.ae === l && (!o || t.ll === l.Ze)) {
-        // Gen-matched during a recompute = repeat touch this pass (AND); outside
-        // a recompute there is no pass boundary, so the latest read labels it.
-        if (o) t.me &&= n; else t.me = n;
-        return;
-    }
-    const i = l.Ye = e.rt = {
-        ut: e,
-        ae: l,
-        it: s,
-        el: t,
-        fe: null,
-        ll: l.Ze,
-        me: n
+        const r = e.Ze;
+    if (r !== null && r.u === n && (!s || r.Ne === n.de)) return;
+    const t = n._ = e.Ze = {
+        S: e,
+        u: n,
+        G: o,
+        $e: r,
+        t: null,
+        Ne: n.de
     };
-    if (u !== null) u.it = i; else l.nt = i;
-    if (t !== null) t.fe = i; else e.u = i;
+    if (l !== null) l.G = t; else n.C = t;
+    if (r !== null) r.t = t; else e.o = t;
     // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
         bumpNotifyEpoch();
 }
 
-export { clearDeps, link, trimStaleDeps, unlinkSubs, unobserved };
+export { clearDeps, deferReleases, deferredReleases, dormantNodes, link, setSlotUnobserved, slotUnobservedHook, sweepDormant, trimStaleDeps, unlinkSubs, unobserved };

package/dist/prod/core/heap.js

@@ -1,148 +1,124 @@
 import "./core.js";
 
-import { REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, EFFECT_TRACKED, EFFECT_USER, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MANUAL_WRITE, REACTIVE_ZOMBIE, 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.ie & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
-}
+import { dirtyQueue } from "./scheduler.js";
 
 /**
- * Schedule one subscriber to re-run on the next flush: tracked effects bypass
- * the heap and go directly to their effect queue; everything else is inserted
- * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
+ * 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) {
-    if (e.Re === EFFECT_TRACKED) {
-        const E = e;
-        if (!E.Xe) {
-            E.Xe = true;
-            E.C.enqueue(EFFECT_USER, E.Ut);
-        }
-        return;
-    }
-    const E = queueFor(e);
-    if (E.xe > e.Le) E.xe = e.Le;
-    insertIntoHeap(e, E);
+    if (dirtyQueue.Fe > e.he) dirtyQueue.Fe = e.he;
+    insertIntoHeap(e, dirtyQueue);
 }
 
-function actualInsertIntoHeap(e, E) {
-    const t = (e.ve?.Ct ? e.ve.Ot?.Le : e.ve?.Le) ?? -1;
-    if (t >= e.Le) e.Le = t + 1;
-    const n = e.Le;
-    const I = E.eE[n];
-    if (I === undefined) E.eE[n] = e; else {
-        const E = I.st;
-        E.ot = e;
-        e.st = E;
-        I.st = e;
+function actualInsertIntoHeap(e, t) {
+    const E = (e._parent?.Qe ? e._parent.Ke?.he : e._parent?.he) ?? -1;
+    if (E >= e.he) e.he = E + 1;
+    const n = e.he;
+    const I = t.et[n];
+    if (I === undefined) t.et[n] = e; else {
+        const t = I.We;
+        t.ve = e;
+        e.We = t;
+        I.We = e;
     }
-    if (n > E.EE) E.EE = n;
+    if (n > t.Et) t.Et = n;
 }
 
-function insertIntoHeap(e, E) {
-    let t = e.ie;
+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.ie = 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.ie = t | REACTIVE_IN_HEAP;
-        // An unmarked node entering a marked heap invalidates the markHeap memo:
-        // `_marked` is only reset by runHeap, so a write between two mid-tick
-        // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
-        // this node unmarked and every downstream pull stale until the next
-        // flush (#2922: the second `latest()` returned the first write's value).
-                if (E.tE && !(t & REACTIVE_DIRTY)) E.tE = false;
+        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 +
+        // updateIfNecessary) would otherwise leave this node unmarked and every
+        // downstream pull stale until the next flush (#2922: the second
+        // `latest()` returned the first write's value). Invalidating the memo
+        // instead re-walked the WHOLE heap on the next pull — with N effects
+        // 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 (t.p) 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.ie;
-    if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
-    e.ie = 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.ie;
-    if (!(t & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-    e.ie = t & -25;
-    const n = e.Le;
-    if (e.st === e) E.eE[n] = undefined; else {
-        const t = e.ot;
-        const I = E.eE[n];
-        const o = t ?? I;
-        if (e === I) E.eE[n] = t; else e.st.ot = t;
-        o.st = e.st;
+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.he;
+    if (e.We === e) t.et[n] = undefined; else {
+        const E = e.ve;
+        const I = t.et[n];
+        const i = E ?? I;
+        if (e === I) t.et[n] = E; else e.We.ve = E;
+        i.We = e.We;
     }
-    e.st = e;
-    e.ot = undefined;
+    e.We = e;
+    e.ve = 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.ot) {
-            if (t.ie & REACTIVE_IN_HEAP) markNode(t);
+    if (e.p) return;
+    e.p = true;
+    for (let t = 0; t <= e.Et; t++) {
+        for (let E = e.et[t]; E !== undefined; E = E.ve) {
+            if (E.R & REACTIVE_IN_HEAP) markNode(E);
         }
     }
 }
 
-function markNode(e, E = REACTIVE_DIRTY) {
-    const t = e.ie;
-    if ((t & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= E) return;
-    e.ie = t & -4 | E;
-    for (let E = e.u; E !== null; E = E.fe) {
-        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.T & CONFIG_FW_CHILDREN) {
-        for (let E = e.o.l; E !== null; E = E.ce) {
-            for (let e = E.u; e !== null; e = e.fe) {
-                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.o; t !== null; t = t.t) {
+        markNode(t.u, REACTIVE_CHECK);
     }
 }
 
-function runHeap(e, E) {
-    e.tE = false;
-    for (e.xe = 0; e.xe <= e.EE; e.xe++) {
-        let t = e.eE[e.xe];
-        while (t !== undefined) {
-            if (t.ie & REACTIVE_IN_HEAP) E(t); else adjustHeight(t, e);
-            t = e.eE[e.xe];
+function runHeap(e, t) {
+    e.p = false;
+    for (e.Fe = 0; e.Fe <= e.Et; e.Fe++) {
+        let E = e.et[e.Fe];
+        while (E !== undefined) {
+            if (E.R & REACTIVE_IN_HEAP) t(E); else adjustHeight(E, e);
+            E = e.et[e.Fe];
         }
     }
-    e.EE = 0;
+    e.Et = 0;
 }
 
-function adjustHeight(e, E) {
-    deleteFromHeap(e, E);
-    let t = e.Le;
-    for (let E = e.nt; E; E = E.it) {
-        const e = E.ut;
-        const n = e.lt || e;
-        if (n.Se && n.Le >= t) t = n.Le + 1;
+function adjustHeight(e, t) {
+    deleteFromHeap(e, t);
+    let E = e.he;
+    for (let t = e.C; t; t = t.G) {
+        const e = t.S;
+        if (e.X && e.he >= E) E = e.he + 1;
     }
-    if (e.Le !== t) {
-        e.Le = t;
-        for (let E = e.u; E !== null; E = E.fe) {
-            // 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.he !== E) {
+        e.he = E;
+        for (let E = e.o; E !== null; E = E.t) insertIntoHeapHeight(E.u, t);
     }
 }
 
-export { deleteFromHeap, enqueueSub, insertIntoHeap, insertIntoHeapHeight, markHeap, markNode, queueFor, runHeap };
+export { deleteFromHeap, enqueueSub, insertIntoHeap, insertIntoHeapHeight, markHeap, markNode, runHeap };

package/dist/prod/core/identities.js

@@ -0,0 +1,62 @@
+import { CONFIG_TRANSPARENT } from "./constants.js";
+
+import "./core.js";
+
+import { getOwner } from "./owner.js";
+
+// Deferred hydration, dependency edges: plain-signal identities.
+// While on (`setSignalIdentities`; the server-components client turns it on
+// before hydrating), a plain signal created under an id-bearing owner is
+// named `<owner id>~<n>`, n counting the plain signals (and plain store
+// roots: `createStore` over an object, store/edges.ts) created under that
+// owner in its current pass (transparent owners defer to the nearest
+// id-bearing one, as child ids do). The server names the same signal the
+// same way and restarts the count on every re-run, so an edge it shipped (a
+// slot fill read it) matches the client node; the write hook receives the
+// node and looks its name up (`signalName`). The count restarts when the owner's pass
+// generation (`_depGen`, bumped by every recompute) moves on. Only the
+// frames client imports this module, so nothing here ships without it.
+// Names live in a side table, not on the node: frames reads them across the
+// package boundary, where a mangled field would not survive.
+let counts = null;
+
+const names = new WeakMap;
+
+/** @internal The identity of a plain signal named while identities were on. */ function signalName(n) {
+    return n === undefined ? undefined : names.get(n);
+}
+
+function identify(n) {
+    let e = getOwner();
+    if (!e) return;
+    while (e.l & CONFIG_TRANSPARENT && e._parent) e = e._parent;
+    if (e.id == null) return;
+    const t = e.de;
+    let i = counts.get(e);
+    if (i === undefined || i[0] !== t) counts.set(e, i = [ t, 0 ]);
+    const s = e.id + "~" + i[1]++;
+    // A store root named twice (one object made into two stores, or a store
+    // handed to `createStore`) is one target under two server names: its
+    // writes cannot be attributed (an empty name).
+        names.set(n, names.has(n) ? "" : s);
+}
+
+/** @internal Name plain signals from now on (`on`), or stop. */ function setSignalIdentities(n) {
+    counts = n ? counts || new WeakMap : null;
+    signalHook = n ? identify : null;
+}
+
+/**
+ * @internal Called with every plain signal `createSignal` makes, and every
+ * plain store root `createStore` makes, while set (the namer above). Never
+ * set unless `setSignalIdentities` is imported, so a bundle without it keeps
+ * only a null check.
+ */ let signalHook = null;
+
+/**
+ * @internal Dev only: `watch` is called with every node read while set (the
+ * dev hook `onRead`) — the frames client's identity-drift check watches the
+ * named signals a deferred occurrence reads as it mounts. A no-op in prod.
+ */ function setReadWatch(n) {}
+
+export { setReadWatch, setSignalIdentities, signalHook, signalName };

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 };