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

package/dist/observe/core/owner.js

@@ -1,10 +1,10 @@
-import { defaultContext, CONFIG_TRANSPARENT, REACTIVE_DISPOSED, STATUS_PENDING, REACTIVE_FRAME_READ, CONFIG_AUTO_DISPOSE, REACTIVE_ZOMBIE } 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, tracking } from "./core.js";
 
 import { registerRoot, unregisterRoot } from "./dev.js";
 
-import { clearDeps, unobserved } from "./graph.js";
+import { unobserved, clearDeps } from "./graph.js";
 
 import { deleteFromHeap } from "./heap.js";
 
@@ -18,11 +18,11 @@ import { schedule, dirtyQueue } from "./scheduler.js";
 // 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.nn;
+    let n = e.ze;
     while (n) {
         n.R |= REACTIVE_ZOMBIE;
         markDisposal(n);
-        n = n.tn;
+        n = n.Xe;
     }
 }
 
@@ -33,7 +33,7 @@ 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.i &= ~CONFIG_AUTO_DISPOSE;
+    e.l &= ~CONFIG_AUTO_DISPOSE;
     unobserved(e);
 }
 
@@ -45,21 +45,21 @@ function disposeChildren(e, n = false, t) {
     // 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 && !t && e.T !== null && (e.T.Nt !== null || e.T.ft !== null)) disposeChildren(e, false, true);
     if (n) {
         e.R = i | REACTIVE_DISPOSED;
-        if (e._parent === null && e.Ht) unregisterRoot(e);
+        if (e._parent === null && e.Pt) unregisterRoot(e);
     }
-    if (n && e.ee) {
-        if (e.m !== null) e.m.Te = null;
+    if (n && e.X) {
+        if (e.T !== null) e.T.Se = 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.S & STATUS_PENDING && e.m?._t != null || i & REACTIVE_FRAME_READ) schedule();
+                if (e.m & STATUS_PENDING && e.T?.Je != null || i & REACTIVE_FRAME_READ) schedule();
     }
-    let r = t ? e.m.St : e.nn;
-    if (t) e.m.St = null; else e.nn = null;
+    let r = t ? e.T.Nt : e.ze;
+    if (t) e.T.Nt = null; else e.ze = null;
     while (r) {
         const e = r;
         // Owner teardown is death regardless of the child's own lifecycle
@@ -69,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.i &= ~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 —
@@ -83,26 +83,26 @@ function disposeChildren(e, n = false, t) {
         // 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.
-                r.Gt = r;
+                r.Ct = 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.
-                r = r.tn;
+                r = r.Xe;
     }
-    if (!t) e.dt = 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 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.tn;
-        if (n !== null) n.tn = t; else e._parent.nn = t;
-        if (t !== null) t.Gt = n;
-        e.Gt = null;
+        const n = e.Ct;
+        const t = e.Xe;
+        if (n !== null) n.Xe = t; else e._parent.ze = t;
+        if (t !== null) t.Ct = n;
+        e.Ct = null;
     }
     runDisposal(e, t);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
@@ -115,11 +115,11 @@ function disposeChildren(e, n = false, t) {
 }
 
 function linkChild(e, n) {
-    const t = e.nn;
-    n.Gt = null;
-    n.tn = t;
-    if (t !== null) t.Gt = n;
-    e.nn = n;
+    const t = e.ze;
+    n.Ct = null;
+    n.Xe = t;
+    if (t !== null) t.Ct = n;
+    e.ze = n;
 }
 
 function runDisposal(e, n) {
@@ -129,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.m.ct : e.Re;
+    const t = n ? e.T.ft : e.rt;
     if (!t) return;
-    if (n) e.m.ct = null; else e.Re = null;
+    if (n) e.T.ft = null; else e.rt = 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,
@@ -148,8 +148,8 @@ function runDisposal(e, n) {
 
 function childId(e, n) {
     let t = e;
-    while (t.i & CONFIG_TRANSPARENT && t._parent) t = t._parent;
-    if (t.id != null) return formatId(t.id, n ? t.dt++ : t.dt);
+    while (t.l & CONFIG_TRANSPARENT && t._parent) t = t._parent;
+    if (t.id != null) return formatId(t.id, n ? t.ct++ : t.ct);
     throw new Error("");
 }
 
@@ -226,10 +226,12 @@ function formatId(e, n) {
 /**
  * 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.Re) context.Re = e; else if (Array.isArray(context.Re)) context.Re.push(e); else context.Re = [ context.Re, 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.rt) n.rt = e; else if (Array.isArray(n.rt)) n.rt.push(e); else n.rt = [ n.rt, e ];
     return e;
 }
 
@@ -267,24 +269,31 @@ function disposeRootSelf(e = true) {
     const n = context;
     const t = e?.transparent ?? false;
     // 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.
+    // 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 i = {
         id: inheritId(e, t, n),
-        i: t ? CONFIG_TRANSPARENT : 0,
-        Ht: true,
-        gt: n?.Ht ? n.gt : n,
-        nn: null,
-        tn: null,
-        Gt: null,
-        Re: null,
-        D: n?.D || defaultContext,
-        dt: 0,
-        m: null,
+        l: t ? 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,
+        Pt: true,
+        Ht: n?.Pt ? n.Ht : n,
+        ze: null,
+        Xe: null,
+        Ct: null,
+        rt: null,
+        A: n?.A || defaultContext,
+        ct: 0,
+        T: null,
         _parent: n,
         dispose: disposeRootSelf,
-        _name: undefined
+        _name: undefined,
+        _loc: undefined
     };
     if (n) linkChild(n, i); else registerRoot(i);
     return i;
@@ -323,10 +332,13 @@ function disposeRootSelf(e = true) {
  * const detached = runWithOwner(null, () => createRoot(d => d));
  * ```
  *
- * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/owner-introspection/create-root
  */ function createRoot(e, n) {
     const t = createOwner(n);
-    return runWithOwner(t, () => e(() => t.dispose()));
+    // 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(t, () => e(disposeRootSelf.bind(t, true)));
 }
 
 export { cleanup, createOwner, createRoot, dispose, disposeChildren, getNextChildId, getObserver, getOwner, inheritId, isDisposed, linkChild, markDisposal, peekNextChildId };