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

package/dist/observe/core/owner.js

@@ -1,34 +1,28 @@
-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 { defaultContext, CONFIG_TRANSPARENT, REACTIVE_DISPOSED, STATUS_PENDING, REACTIVE_FRAME_READ, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE } from "./constants.js";
 
-import { context, runWithOwner, pendingCheckActive, latestReadActive, tracking } from "./core.js";
+import { context, runWithOwner, tracking } from "./core.js";
 
-import { unregisterRoot, registerRoot } from "./dev.js";
+import { registerRoot, unregisterRoot } from "./dev.js";
 
 import { clearDeps, unobserved } from "./graph.js";
 
-import { deleteFromHeap, queueFor, insertIntoHeap, insertIntoHeapHeight } from "./heap.js";
+import { deleteFromHeap } from "./heap.js";
 
-import { GlobalQueue, wokenTransitions, schedule, zombieQueue, dirtyQueue, globalQueue } from "./scheduler.js";
+import { 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 n = e._n;
+    let n = e.sn;
     while (n) {
-        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
-        // 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(n, e & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-            if (e & REACTIVE_IN_HEAP) insertIntoHeap(n, zombieQueue); else insertIntoHeapHeight(n, zombieQueue);
-        }
+        n.R |= REACTIVE_ZOMBIE;
         markDisposal(n);
-        n = n.Fn;
+        n = n.rn;
     }
 }
 
@@ -39,47 +33,35 @@ 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.C &= ~CONFIG_AUTO_DISPOSE;
+    e.u &= ~CONFIG_AUTO_DISPOSE;
     unobserved(e);
 }
 
 function disposeChildren(e, n = false, t) {
-    const i = e.oe;
+    const i = e.R;
     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.dt !== null || e.o.Et !== null)) disposeChildren(e, false, true);
+    // 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 && !t && e.m !== null && (e.m.St !== null || e.m.ct !== null)) disposeChildren(e, false, true);
     if (n) {
-        e.oe = i | REACTIVE_DISPOSED;
-        if (e._parent === null && e.Zt) unregisterRoot(e);
-        // 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.o?.xe || n.o?.Me) GlobalQueue.Qn(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.xt.forEach(GlobalQueue.Qn);
-        // 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.me;
-        if (t && n.S & STATUS_PENDING && !wokenTransitions.includes(t)) wokenTransitions.push(t), 
-        schedule();
+        e.R = i | REACTIVE_DISPOSED;
+        if (e._parent === null && e.Ht) unregisterRoot(e);
+    }
+    if (n && e.re) {
+        if (e.m !== null) e.m.De = 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).
+        // Nothing else re-examines a dead node, so make sure a seam comes.
+                if (e.G & STATUS_PENDING && e.m?._t != null || i & REACTIVE_FRAME_READ) schedule();
     }
-    if (n && e.Se && e.o !== null) e.o.pe = null;
-    let o = t ? e.o?.dt ?? null : e._n;
-    if (!t) e._n = null;
-    while (o) {
-        const e = o;
+    let r = t ? e.m.St : e.sn;
+    if (t) e.m.St = null; else e.sn = null;
+    while (r) {
+        const e = r;
         // 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.
@@ -87,7 +69,7 @@ function disposeChildren(e, n = false, t) {
         // 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;
+                e.u &= ~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 —
@@ -95,50 +77,49 @@ function disposeChildren(e, n = false, t) {
         // 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(e, queueFor(e));
+                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.
-                o.kt = o;
-        disposeChildren(o, true);
+                r.Gt = r;
+        disposeChildren(r, 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.
-                o = o.Fn;
+                r = r.rn;
     }
-    if (t) {
-        if (e.o !== null) e.o.dt = null;
-    } else e.Nt = 0;
+    if (!t) e.Ct = 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._parent !== null && !(e._parent.oe & REACTIVE_DISPOSED)) {
-        const n = e.kt;
-        const t = e.Fn;
-        if (n !== null) n.Fn = t; else e._parent._n = t;
-        if (t !== null) t.kt = n;
-        e.kt = 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 && !t && !(i & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.R & REACTIVE_DISPOSED)) {
+        const n = e.Gt;
+        const t = e.rn;
+        if (n !== null) n.rn = t; else e._parent.sn = t;
+        if (t !== null) t.Gt = n;
+        e.Gt = 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.qt) {
-        const n = e.qt;
-        e.qt = undefined;
+        if (n && e.kt) {
+        const n = e.kt;
+        e.kt = undefined;
         n();
     }
 }
 
 function linkChild(e, n) {
-    const t = e._n;
-    n.kt = null;
-    n.Fn = t;
-    if (t !== null) t.kt = n;
-    e._n = n;
+    const t = e.sn;
+    n.Gt = null;
+    n.rn = t;
+    if (t !== null) t.Gt = n;
+    e.sn = n;
 }
 
 function runDisposal(e, n) {
@@ -148,9 +129,9 @@ function runDisposal(e, n) {
     // 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?.Et : e.Ve;
+    const t = n ? e.m.ct : e.Pe;
     if (!t) return;
-    if (n) e.o.Et = null; else e.Ve = null;
+    if (n) e.m.ct = null; else e.Pe = null;
     if (Array.isArray(t)) {
         // Unwind order (#3572, restores 1.x #1562): later registrations run
         // before earlier ones. Children have already been disposed by the caller,
@@ -167,8 +148,8 @@ function runDisposal(e, n) {
 
 function childId(e, n) {
     let t = e;
-    while (t.C & CONFIG_TRANSPARENT && t._parent) t = t._parent;
-    if (t.id != null) return formatId(t.id, n ? t.Nt++ : t.Nt);
+    while (t.u & CONFIG_TRANSPARENT && t._parent) t = t._parent;
+    if (t.id != null) return formatId(t.id, n ? t.Ct++ : t.Ct);
     throw new Error("");
 }
 
@@ -219,7 +200,6 @@ function formatId(e, n) {
  * }
  * ```
  */ function getObserver() {
-    if (pendingCheckActive || latestReadActive) return PENDING_OWNER;
     return tracking ? context : null;
 }
 
@@ -249,14 +229,14 @@ function formatId(e, n) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.Ve) context.Ve = e; else if (Array.isArray(context.Ve)) context.Ve.push(e); else context.Ve = [ context.Ve, e ];
+    if (!context.Pe) context.Pe = e; else if (Array.isArray(context.Pe)) context.Pe.push(e); else context.Pe = [ context.Pe, 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
@@ -269,7 +249,7 @@ function formatId(e, n) {
  * }
  * ```
  */ function isDisposed(e) {
-    return !!(e.oe & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+    return !!(e.R & REACTIVE_DISPOSED);
 }
 
 function disposeRootSelf(e = true) {
@@ -292,17 +272,16 @@ function disposeRootSelf(e = true) {
     // is a plain store rather than a shape fork between labelled and plain roots.
         const i = {
         id: inheritId(e, t, n),
-        C: t ? CONFIG_TRANSPARENT : 0,
-        Zt: true,
-        Yt: n?.Zt ? n.Yt : n,
-        _n: null,
-        Fn: null,
-        kt: null,
-        Ve: null,
-        T: n?.T ?? globalQueue,
-        rt: n?.rt || defaultContext,
-        Nt: 0,
-        o: null,
+        u: t ? CONFIG_TRANSPARENT : 0,
+        Ht: true,
+        gt: n?.Ht ? n.gt : n,
+        sn: null,
+        rn: null,
+        Gt: null,
+        Pe: null,
+        U: n?.U || defaultContext,
+        Ct: 0,
+        m: null,
         _parent: n,
         dispose: disposeRootSelf,
         _name: undefined