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

package/dist/prod/core/owner.js

@@ -1,21 +1,21 @@
-import { REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_ZOMBIE, CONFIG_TRANSPARENT, defaultContext } from "./constants.js";
+import { REACTIVE_DISPOSED, CONFIG_CHILD_COMPANIONS, STATUS_PENDING, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, CONFIG_TRANSPARENT, defaultContext } from "./constants.js";
 
 import { context, runWithOwner, pendingCheckActive, latestReadActive, tracking } from "./core.js";
 
-import { unlinkSubs } from "./graph.js";
+import { clearDeps, unobserved } from "./graph.js";
 
 import { deleteFromHeap, queueFor, insertIntoHeap, insertIntoHeapHeight } from "./heap.js";
 
-import { GlobalQueue, zombieQueue, dirtyQueue, globalQueue } from "./scheduler.js";
+import { GlobalQueue, wokenTransitions, schedule, zombieQueue, dirtyQueue, globalQueue } from "./scheduler.js";
 
 const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let n = e.ke;
+    let n = e.tn;
     while (n) {
-        const e = n.se;
-        n.se = e | REACTIVE_ZOMBIE;
+        const e = n.oe;
+        n.oe = 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
@@ -26,104 +26,146 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(n, zombieQueue); else insertIntoHeapHeight(n, zombieQueue);
         }
         markDisposal(n);
-        n = n.He;
+        n = n.un;
     }
 }
 
 function dispose(e) {
-    // Leave every scheduler heap on disposal (mirrors `unobserved`): a node
-    // still queued here would be recomputed by the next flush, and recompute()
-    // rewriting `_flags` would clear REACTIVE_DISPOSED — resurrecting it (#2983).
-    deleteFromHeap(e, queueFor(e));
-    let n = e.tt;
-    while (n !== null) {
-        n = unlinkSubs(n);
-    }
-    e.tt = null;
-    e.Ye = null;
-    disposeChildren(e, true);
+    // Direct disposal is death, not dormancy: strip the observation lifecycle
+    // so a later read freezes at the last committed value instead of
+    // reawakening the node (#3024). The teardown itself (heap removal — a node
+    // 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.C &= ~CONFIG_AUTO_DISPOSE;
+    unobserved(e);
 }
 
 function disposeChildren(e, n = false, t) {
-    const i = e.se;
+    const i = e.oe;
     if (i & REACTIVE_DISPOSED) return;
+    // A previous frame parked as zombies (#3404) dies with its owner (#3024):
+    // the commit that would retire it returns on the DISPOSED flag set below,
+    // so it drains here or its cleanups never run and the zombies stay
+    // subscribed, to rerun in a torn-down tree (#3561). Death only (`self`):
+    // a rerun's `disposeChildren(el)` leaves the frame rendering until commit.
+        if (n && !t && e.o !== null && (e.o._n !== null || e.o.fn !== null)) disposeChildren(e, false, true);
     if (n) {
-        e.se = i | REACTIVE_DISPOSED;
+        e.oe = 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 n = e;
-        if (n.Oe || n.ge) GlobalQueue.un(n);
+        if (n.o?.Ze || n.o?.He) GlobalQueue.ri(n);
+        // A firewall's leaves have no lifecycle of their own, so a companion on
+        // one of them outlives its source the same way (INV-9's rationale). The
+        // firewall knows which leaves carry companions (CONFIG_CHILD_COMPANIONS,
+        // #3038): snap them with it — the snap retires a shadow whose firewall is
+        // disposed (spec O5).
+                if (n.C & CONFIG_CHILD_COMPANIONS) n.o.Un.forEach(GlobalQueue.ri);
+        // A pending reader parked in a transaction may be the only thing holding
+        // it (#3372): its death is a completion event the transaction must be
+        // re-judged for, and nothing else re-enters a parked transaction.
+                const t = n.we;
+        if (t && n.h & STATUS_PENDING && !wokenTransitions.includes(t)) wokenTransitions.push(t), 
+        schedule();
     }
-    if (n && e.ce) e.Te = null;
-    let l = t ? e.We : e.ke;
+    if (n && e.he && e.o !== null) e.o.Ce = null;
+    let l = t ? e.o?._n ?? null : e.tn;
+    if (!t) e.tn = null;
     while (l) {
-        const e = l.He;
-        const n = 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.
+        // Runs before the recursion so already-dormant children (whose
+        // 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.
+                e.C &= ~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 —
         // recompute() rewriting `_flags` clears REACTIVE_DISPOSED and the node
         // comes back to life (post-unmount runs, leaked cleanups, #2983).
-                if (n.se & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT)) deleteFromHeap(n, queueFor(n));
-        if (n.tt) {
-            let e = n.tt;
-            do {
-                e = unlinkSubs(e);
-            } while (e !== null);
-            n.tt = null;
-            n.Ye = null;
-        }
+        // deleteFromHeap self-guards on the in-heap flags (and tolerates plain
+        // Owners, whose _flags is undefined), so no gate here.
+                deleteFromHeap(e, queueFor(e));
+        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.gn = l;
         disposeChildren(l, true);
-        l = e;
+        // 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.un;
     }
     if (t) {
-        e.We = null;
-    } else {
-        e.ke = null;
-        e.qe = 0;
-    }
+        if (e.o !== null) e.o._n = null;
+    } else e.En = 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 (n && !t && !(i & REACTIVE_ZOMBIE) && e.Fe !== null && !(e.Fe.se & REACTIVE_DISPOSED)) {
-        const n = e.ct;
-        const t = e.He;
-        if (n !== null) n.He = t; else e.Fe.ke = t;
-        if (t !== null) t.ct = n;
-        e.ct = null;
+        if (n && !t && !(i & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.oe & REACTIVE_DISPOSED)) {
+        const n = e.gn;
+        const t = e.un;
+        if (n !== null) n.un = t; else e._parent.tn = t;
+        if (t !== null) t.gn = n;
+        e.gn = null;
     }
     runDisposal(e, t);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (n && e.Nt) {
-        const n = e.Nt;
-        e.Nt = undefined;
+        if (n && e.wn) {
+        const n = e.wn;
+        e.wn = undefined;
         n();
     }
 }
 
+function linkChild(e, n) {
+    const t = e.tn;
+    n.gn = null;
+    n.un = t;
+    if (t !== null) t.gn = n;
+    e.tn = n;
+}
+
 function runDisposal(e, n) {
-    let t = n ? e.Qe : e.he;
+    // 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 t = n ? e.o?.fn : e.qe;
     if (!t) return;
+    if (n) e.o.fn = null; else e.qe = null;
     if (Array.isArray(t)) {
-        for (let e = 0; e < t.length; e++) {
+        // 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 = t.length - 1; e >= 0; e--) {
             const n = t[e];
             n.call(n);
         }
     } else {
         t.call(t);
     }
-    n ? e.Qe = null : e.he = null;
 }
 
 function childId(e, n) {
     let t = e;
-    while (t.T & CONFIG_TRANSPARENT && t.Fe) t = t.Fe;
-    if (t.id != null) return formatId(t.id, n ? t.qe++ : t.qe);
+    while (t.C & CONFIG_TRANSPARENT && t._parent) t = t._parent;
+    if (t.id != null) return formatId(t.id, n ? t.En++ : t.En);
     throw new Error("");
 }
 
@@ -204,7 +246,7 @@ function formatId(e, n) {
  * 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 ];
+    if (!context.qe) context.qe = e; else if (Array.isArray(context.qe)) context.qe.push(e); else context.qe = [ context.qe, e ];
     return e;
 }
 
@@ -224,7 +266,7 @@ function formatId(e, n) {
  * }
  * ```
  */ function isDisposed(e) {
-    return !!(e.se & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+    return !!(e.oe & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
 }
 
 function disposeRootSelf(e = true) {
@@ -241,40 +283,40 @@ function disposeRootSelf(e = true) {
  */ function createOwner(e) {
     const n = context;
     const t = e?.transparent ?? false;
-    const i = {
+    // Prod and observe boilerplates (see core.ts computed()). The observe
+    // literal carries the `_name` slot the rendering layer fills with the
+    // component label (`owner._name = "<App>"`) — a slot, so labelling a root
+    // is a plain store rather than a shape fork between labelled and plain roots.
+        const i = {
         id: inheritId(e, t, n),
-        T: t ? CONFIG_TRANSPARENT : 0,
-        Tt: true,
-        It: n?.Tt ? n.It : n,
-        ke: null,
-        He: null,
-        ct: null,
-        he: null,
-        C: n?.C ?? globalQueue,
-        we: n?.we || defaultContext,
-        qe: 0,
-        Qe: null,
-        We: null,
-        Fe: n,
+        C: t ? CONFIG_TRANSPARENT : 0,
+        Wn: true,
+        qn: n?.Wn ? n.qn : n,
+        tn: null,
+        un: null,
+        gn: null,
+        qe: null,
+        T: n?.T ?? globalQueue,
+        Je: n?.Je || defaultContext,
+        En: 0,
+        o: null,
+        _parent: n,
         dispose: disposeRootSelf
     };
-    if (n) {
-        const e = n.ke;
-        if (e === null) {
-            n.ke = i;
-        } else {
-            i.He = e;
-            e.ct = i;
-            n.ke = i;
-        }
-    }
+    if (n) linkChild(n, i);
     return i;
 }
 
 /**
- * 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
@@ -282,6 +324,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));
@@ -291,6 +334,10 @@ 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
@@ -299,4 +346,4 @@ function disposeRootSelf(e = true) {
     return runWithOwner(t, () => e(() => t.dispose()));
 }
 
-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 };