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

package/dist/prod/core/owner.js

@@ -1,32 +1,26 @@
-import { REACTIVE_DISPOSED, REACTIVE_ZOMBIE, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, CONFIG_TRANSPARENT, defaultContext, CONFIG_AUTO_DISPOSE } from "./constants.js";
+import { defaultContext, CONFIG_TRANSPARENT, REACTIVE_NONE, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIVE_FRAME_READ, REACTIVE_ZOMBIE } from "./constants.js";
 
-import { context, runWithOwner, pendingCheckActive, latestReadActive, tracking } from "./core.js";
+import { context, runWithOwner, tracking } from "./core.js";
 
-import { clearDeps, unobserved } from "./graph.js";
+import { unobserved, clearDeps } from "./graph.js";
 
-import { deleteFromHeap, queueFor, insertIntoHeap, insertIntoHeapHeight } from "./heap.js";
+import { deleteFromHeap } from "./heap.js";
 
-import { GlobalQueue, zombieQueue, dirtyQueue, globalQueue } from "./scheduler.js";
+import { globalQueue, pendingNodes, schedule, dirtyQueue } from "./scheduler.js";
 
-const PENDING_OWNER = {};
-
- // Dummy owner to trigger store's read() path
+// L2 (step 2): the parked frame. A pass parks the previous frame's children
+// and `_disposal` list on `_x._pendingFirstChild` / `_x._pendingDisposal`
+// (`parkChildren`, core.ts); they keep reacting until the node's commit
+// disposes them (`zombie` walk below) or the owner dies. `markDisposal` flags
+// the parked subtree REACTIVE_ZOMBIE: the splice guard and the reawaken path
+// key off it, and the heap defers a zombie's recompute past the seam (no
+// second heap — the deferral list in scheduler.ts).
 function markDisposal(e) {
-    let t = e.ke;
-    while (t) {
-        const e = t.ie;
-        t.ie = e | REACTIVE_ZOMBIE;
-        // migrate height-adjust entries too, not just recompute entries: every
-        // `deleteFromHeap` call site picks the queue from the zombie flag, so a
-        // node left physically linked in `dirtyQueue` after being zombified gets
-        // unlinked from the wrong queue on dispose, corrupting the bucket and
-        // livelocking the next `runHeap` that reaches it (#2759)
-                if (e & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT)) {
-            deleteFromHeap(t, e & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-            if (e & REACTIVE_IN_HEAP) insertIntoHeap(t, zombieQueue); else insertIntoHeapHeight(t, zombieQueue);
-        }
-        markDisposal(t);
-        t = t.Ve;
+    let n = e.pe;
+    while (n) {
+        n.R |= REACTIVE_ZOMBIE;
+        markDisposal(n);
+        n = n.Ge;
     }
 }
 
@@ -37,28 +31,59 @@ function dispose(e) {
     // left queued would be recomputed and resurrected by the next flush (#2983)
     // — dep unlinking, child disposal) is exactly unobserved()'s body; only
     // this flag distinguishes death from dormancy.
-    e.T &= ~CONFIG_AUTO_DISPOSE;
+    e.l &= ~CONFIG_AUTO_DISPOSE;
     unobserved(e);
 }
 
-function disposeChildren(e, t = false, n) {
-    const i = e.ie;
-    if (i & REACTIVE_DISPOSED) return;
-    if (t) {
-        e.ie = i | REACTIVE_DISPOSED;
-        // Companions are created detached and outlive their owner, but a verdict
-        // must not: a disposed source can never settle, so an isPending companion
-        // latched `true` here would hold a spinner forever (INV-9, the PR #2845
-        // edge). Snap runs after the DISPOSED flag is set so the oracle reads
-        // false, and notifies subscribers still watching the companion.
-                const t = e;
-        if (t.o?.Ge || t.o?.ge) GlobalQueue.un(t);
+// The first error a cleanup threw, boxed so a thrown `undefined` still
+// counts. A throwing cleanup stops neither its siblings nor the rest of the
+// tree: every cleanup runs. The error is rethrown once the teardown is over:
+// by a root's dispose call outside a flush (`disposeRootSelf`), otherwise when
+// the flush ends (`flush`; `runCleanup` schedules one), so a flush is never
+// left half-applied. A halt drops it: the error that halted is the one
+// reported, and a stale one must not surface from a later, unrelated dispose.
+let cleanupError;
+
+/** Runs a cleanup or `unobserved` hook; a throw is collected, not raised. @internal */ function runCleanup(e) {
+    try {
+        e();
+    } catch (e) {
+        cleanupError ||= [ e ];
+        schedule();
+    }
+}
+
+/** Rethrows the error `runCleanup` collected, once; `drop` discards it. @internal */ function rethrowCleanupError(e) {
+    const n = cleanupError;
+    cleanupError = undefined;
+    if (n && !e) throw n[0];
+}
+
+function disposeChildren(e, n = false, r) {
+    const t = e.R;
+    if (t & REACTIVE_DISPOSED) return;
+    // A parked frame dies with its owner (#3024): the commit that would retire
+    // it never comes once the node is DISPOSED, so it drains here or its
+    // cleanups never run and it stays subscribed, rerunning in a torn-down
+    // tree (#3561). Death only (`self`): a re-pass leaves the frame reacting
+    // until the commit.
+        if (n && !r && e.T !== null && (e.T.me !== null || e.T.Le !== null)) disposeChildren(e, false, true);
+    if (n) {
+        e.R = t | REACTIVE_DISPOSED;
+    }
+    if (n && e.X) {
+        if (e.T !== null) e.T.Ee = null;
+        // A death that can unblock the future (L2, `futureBlocked`): a held
+        // flight's — a transaction's or a lane's (its `_x._transaction`) — or a
+        // stale reader's (REACTIVE_FRAME_READ — a frame that derived from one).
+        // An idle pending queue would also pin it until an unrelated flush.
+        // Nothing else re-examines a dead node, so make sure a seam comes.
+                if (e.m & STATUS_PENDING && e.T?.Re != null || t & REACTIVE_FRAME_READ || pendingNodes.length) schedule();
     }
-    if (t && e.Se && e.o !== null) e.o.Ee = null;
-    let o = n ? e.o?.qe ?? null : e.ke;
-    while (o) {
-        const e = o.Ve;
-        const t = o;
+    let l = r ? e.T.me : e.pe;
+    if (r) e.T.me = null; else e.pe = null;
+    while (l) {
+        const e = l;
         // Owner teardown is death regardless of the child's own lifecycle
         // (#3024): strip AUTO_DISPOSE so a post-disposal read freezes at the
         // last committed value instead of reawakening in a torn-down tree.
@@ -66,7 +91,7 @@ function disposeChildren(e, t = false, n) {
         // disposeChildren call early-returns on REACTIVE_DISPOSED) die too.
         // Only unobserved()'s own node keeps its dormancy — it is never in
         // this loop; its children are rebuilt fresh on reawaken.
-                t.T &= ~CONFIG_AUTO_DISPOSE;
+                e.l &= ~CONFIG_AUTO_DISPOSE;
         // Heap removal must not be gated on `_deps`: a dependency-free
         // computation queued by refresh() has a null dep list but still sits in
         // the dirty heap, and left there the post-disposal flush recomputes it —
@@ -74,58 +99,78 @@ function disposeChildren(e, t = false, n) {
         // comes back to life (post-unmount runs, leaked cleanups, #2983).
         // deleteFromHeap self-guards on the in-heap flags (and tolerates plain
         // Owners, whose _flags is undefined), so no gate here.
-                deleteFromHeap(t, queueFor(t));
-        clearDeps(t);
-        disposeChildren(o, true);
-        o = e;
-    }
-    if (n) {
-        if (e.o !== null) e.o.qe = null;
-    } else {
-        e.ke = null;
-        e.Me = 0;
+                deleteFromHeap(e, dirtyQueue);
+        clearDeps(e);
+        // The chain is detached above so a node a cleanup links mid-drain lands
+        // on the fresh head and survives. Pointing each drained child's prev at
+        // itself routes its later splice onto the detached chain, never the head,
+        // and keeps the dev owner-chain-head invariant honest for those children.
+                l.we = l;
+        disposeChildren(l, true);
+        // Read after, not before: a sibling this disposal made dormant spliced
+        // itself out of the detached chain, and a cleanup may then have linked
+        // it at the fresh head, which rewrote the `_nextSibling` a pre-read
+        // would still be holding.
+                l = l.Ge;
     }
+    if (!r) e.be = 0;
     // O(1) splice out of parent's chain on individual dispose. Skipped during
-    // batch dispose (parent already disposed) and zombie disposal (node sits on
-    // parent's _pendingFirstChild). We leave node._nextSibling intact so outer
-    // walks that already advanced past us still reach later siblings.
-        if (t && !n && !(i & REACTIVE_ZOMBIE) && e.ve !== null && !(e.ve.ie & REACTIVE_DISPOSED)) {
-        const t = e.ct;
-        const n = e.Ve;
-        if (t !== null) t.Ve = n; else e.ve.ke = n;
-        if (n !== null) n.ct = t;
-        e.ct = null;
+    // batch dispose (parent already disposed) and for a zombie (it sits on the
+    // parent's parked frame, drained whole by the commit). We leave
+    // node._nextSibling intact so outer walks that already advanced past us
+    // still reach later siblings.
+        if (n && !r && !(t & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.R & REACTIVE_DISPOSED)) {
+        const n = e.we;
+        const r = e.Ge;
+        if (n !== null) n.Ge = r; else e._parent.pe = r;
+        if (r !== null) r.we = n;
+        e.we = null;
     }
-    runDisposal(e, n);
+    runDisposal(e, r);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (t && e.At) {
-        const t = e.At;
-        e.At = undefined;
-        t();
+        if (n && e.ze) {
+        const n = e.ze;
+        e.ze = undefined;
+        runCleanup(n);
     }
 }
 
-function runDisposal(e, t) {
-    let n = t ? e.o?.We : e.he;
-    if (!n) return;
-    if (Array.isArray(n)) {
-        for (let e = 0; e < n.length; e++) {
-            const t = n[e];
-            t.call(t);
+function linkChild(e, n) {
+    const r = e.pe;
+    n.we = null;
+    n.Ge = r;
+    if (r !== null) r.we = n;
+    e.pe = n;
+}
+
+function runDisposal(e, n) {
+    // Detach the list BEFORE running it (#3601), as `_cleanup` is (#2813). A
+    // cleanup that disposes an ancestor re-enters this node through the death
+    // walk while the loop is still running; with the list still attached, that
+    // walk ran every entry a second time. Detached, the re-entrant drain finds
+    // nothing. The same shape latched a throwing cleanup: the list survived the
+    // throw and every later drain re-ran and re-threw it.
+    const r = n ? e.T.Le : e.ke;
+    if (!r) return;
+    if (n) e.T.Le = null; else e.ke = null;
+    if (Array.isArray(r)) {
+        // Unwind order (#3572, restores 1.x #1562): later registrations run
+        // before earlier ones. Children have already been disposed by the caller,
+        // so with LIFO a body that registers cleanup before creating its children
+        // tears down after them — the same order a per-component owner gives.
+        for (let e = r.length - 1; e >= 0; e--) {
+            runCleanup(r[e]);
         }
     } else {
-        n.call(n);
+        runCleanup(r);
     }
-    if (t) {
-        if (e.o !== null) e.o.We = null;
-    } else e.he = null;
 }
 
-function childId(e, t) {
-    let n = e;
-    while (n.T & CONFIG_TRANSPARENT && n.ve) n = n.ve;
-    if (n.id != null) return formatId(n.id, t ? n.Me++ : n.Me);
+function childId(e, n) {
+    let r = e;
+    while (r.l & CONFIG_TRANSPARENT && r._parent) r = r._parent;
+    if (r.id != null) return formatId(r.id, n ? r.be++ : r.be);
     throw new Error("");
 }
 
@@ -142,8 +187,8 @@ function childId(e, t) {
  * The id a freshly-created node inherits: an explicit `options.id` wins;
  * transparent nodes share their parent's id; otherwise the parent's next
  * child id is consumed (or `undefined` outside an id-carrying tree).
- */ function inheritId(e, t, n) {
-    return e?.id ?? (t ? n?.id : n?.id != null ? getNextChildId(n) : undefined);
+ */ function inheritId(e, n, r) {
+    return e?.id ?? (n ? r?.id : r?.id != null ? getNextChildId(r) : undefined);
 }
 
 /**
@@ -155,9 +200,9 @@ function childId(e, t) {
     return childId(e, false);
 }
 
-function formatId(e, t) {
-    const n = t.toString(36), i = n.length - 1;
-    return e + (i ? String.fromCharCode(64 + i) : "") + n;
+function formatId(e, n) {
+    const r = n.toString(36), t = r.length - 1;
+    return e + (t ? String.fromCharCode(64 + t) : "") + r;
 }
 
 /**
@@ -176,7 +221,6 @@ function formatId(e, t) {
  * }
  * ```
  */ function getObserver() {
-    if (pendingCheckActive || latestReadActive) return PENDING_OWNER;
     return tracking ? context : null;
 }
 
@@ -203,17 +247,19 @@ function formatId(e, t) {
 /**
  * Low-level: registers `fn` as a disposal callback on the current owner.
  * Most code should use `onCleanup()` from `solid-js`, which adds dev-mode
- * checks. `cleanup()` is the unchecked primitive used by internals.
- */ function cleanup(e) {
-    if (!context) return e;
-    if (!context.he) context.he = e; else if (Array.isArray(context.he)) context.he.push(e); else context.he = [ context.he, e ];
+ * checks. `cleanup()` is the unchecked primitive used by internals; `owner`
+ * (internal) targets a specific owner's disposal list instead of the ambient
+ * one.
+ */ function cleanup(e, n = context) {
+    if (!n) return e;
+    if (!n.ke) n.ke = e; else if (Array.isArray(n.ke)) n.ke.push(e); else n.ke = [ n.ke, e ];
     return e;
 }
 
 /**
- * Returns `true` if the owner has been disposed (or marked zombie pending
- * disposal). Pair with a captured owner to bail out of late callbacks whose
- * surrounding component already unmounted.
+ * Returns `true` if the owner has been disposed. Pair with a captured owner
+ * to bail out of late callbacks whose surrounding component already
+ * unmounted.
  *
  * @example
  * ```ts
@@ -226,11 +272,14 @@ function formatId(e, t) {
  * }
  * ```
  */ function isDisposed(e) {
-    return !!(e.ie & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+    return !!(e.R & REACTIVE_DISPOSED);
 }
 
 function disposeRootSelf(e = true) {
     disposeChildren(this, e);
+    // Outside a flush the dispose call rethrows; inside one, the flush does.
+    // Kept out of `disposeChildren`, whose hot path it slows.
+        if (cleanupError && !globalQueue.Y) rethrowCleanupError();
 }
 
 /**
@@ -241,41 +290,47 @@ function disposeRootSelf(e = true) {
  *
  * @internal
  */ function createOwner(e) {
-    const t = context;
-    const n = e?.transparent ?? false;
-    const i = {
-        id: inheritId(e, n, t),
-        T: n ? CONFIG_TRANSPARENT : 0,
-        Ct: true,
-        Ot: t?.Ct ? t.Ot : t,
+    const n = context;
+    const r = e?.transparent ?? false;
+    // Prod and observe boilerplates (see core.ts computed()). The observe
+    // literal carries the `_name` and `_loc` slots the rendering layer fills
+    // with the component label and JSX site (`owner._name = "<App>"`,
+    // `owner._loc = "src/App.tsx:3:5"`) — slots, so labelling a root is a
+    // plain store rather than a shape fork between labelled and plain roots.
+        const t = {
+        id: inheritId(e, r, n),
+        l: r ? CONFIG_TRANSPARENT : 0,
+        // Present from birth: disposeChildren marks death here on roots too, and
+        // a first store of a missing property is a shape transition plus a
+        // properties-store allocation per root — on a 100×4 table teardown that
+        // was 12 KB and most of disposal's time (2026-10-17).
+        R: REACTIVE_NONE,
+        Qe: true,
+        Ke: n?.Qe ? n.Ke : n,
+        pe: null,
+        Ge: null,
+        we: null,
         ke: null,
-        Ve: null,
-        ct: null,
-        he: null,
-        C: t?.C ?? globalQueue,
-        we: t?.we || defaultContext,
-        Me: 0,
-        o: null,
-        ve: t,
+        A: n?.A || defaultContext,
+        be: 0,
+        T: null,
+        _parent: n,
         dispose: disposeRootSelf
     };
-    if (t) {
-        const e = t.ke;
-        if (e === null) {
-            t.ke = i;
-        } else {
-            i.Ve = e;
-            e.ct = i;
-            t.ke = i;
-        }
-    }
-    return i;
+    if (n) linkChild(n, t);
+    return t;
 }
 
 /**
- * Creates a detached reactive root. The callback receives a `dispose()`
- * function which, when called, tears down every signal, memo, effect, and
- * `onCleanup` registered inside the root.
+ * Creates a reactive root — an owner scope with its own `dispose()`. A root
+ * created inside an existing owner is owned by it and is disposed when the
+ * parent is disposed; call `dispose()` to tear it down earlier. To create a
+ * root that outlives its creator, detach explicitly:
+ * `runWithOwner(null, () => createRoot(...))`. Pass `id` to seed hydration
+ * ids for the tree it owns.
+ *
+ * `dispose()` tears down every signal, memo, effect, and `onCleanup`
+ * registered inside the root.
  *
  * Use this to host long-lived reactive scopes outside of a component (custom
  * controllers, app bootstrapping, tests). Inside a component, prefer
@@ -283,6 +338,7 @@ function disposeRootSelf(e = true) {
  *
  * @example
  * ```ts
+ * // At module level there is no owner, so this root lives until disposed.
  * const dispose = createRoot(dispose => {
  *   const [n, setN] = createSignal(0);
  *   createEffect(() => n(), value => console.log(value));
@@ -292,12 +348,19 @@ function disposeRootSelf(e = true) {
  *
  * // Later, to tear everything down:
  * dispose();
+ *
+ * // Inside an owner (component, effect, another root), detach explicitly
+ * // if the root must outlive its creator:
+ * const detached = runWithOwner(null, () => createRoot(d => d));
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
- */ function createRoot(e, t) {
-    const n = createOwner(t);
-    return runWithOwner(n, () => e(() => n.dispose()));
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/owner-introspection/create-root
+ */ function createRoot(e, n) {
+    const r = createOwner(n);
+    // A bound function, not an arrow: an arrow would share this scope, which
+    // holds `init`, so keeping `dispose` would keep `init` and all it closes
+    // over alive (#4095).
+        return runWithOwner(r, () => e(disposeRootSelf.bind(r, true)));
 }
 
-export { cleanup, createOwner, createRoot, dispose, disposeChildren, getNextChildId, getObserver, getOwner, inheritId, isDisposed, markDisposal, peekNextChildId };
+export { cleanup, createOwner, createRoot, dispose, disposeChildren, getNextChildId, getObserver, getOwner, inheritId, isDisposed, linkChild, markDisposal, peekNextChildId, rethrowCleanupError, runCleanup };