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

package/dist/prod/core/core.js

@@ -10,7 +10,7 @@ import { insertIntoHeap, deleteFromHeap, insertIntoHeapHeight, enqueueSub, markN
 
 import { inheritId, linkChild, disposeChildren, markDisposal } from "./owner.js";
 
-import { schedule, externalUntrackHook, clock, txOf, flushTransaction, laneWriteHook, joinFuture, queuePendingNode, globalQueue, notifyEpoch, insertSubs, dirtyQueue, observeFlightHook, laneReadHook, laneStageHook, passLane, wireExternalSourceHook, bumpNotifyEpoch, setPassLane, joinPassTx, freshHook, GlobalQueue, laneOutcomeHook, passTx, holdNode, laneDirty, heldTrim, staleReader, laneSeamsHook, stagedReaders, deferZombie } from "./scheduler.js";
+import { schedule, externalUntrackHook, clock, txOf, flushTransaction, laneWriteHook, joinFuture, queuePendingNode, globalQueue, notifyEpoch, insertSubs, dirtyQueue, observeFlightHook, laneStageHook, passLane, laneReadHook, wireExternalSourceHook, bumpNotifyEpoch, setPassLane, joinPassTx, freshHook, GlobalQueue, laneOutcomeHook, passTx, holdNode, laneDirty, heldTrim, staleReader, laneSeamsHook, stagedReaders, deferZombie } from "./scheduler.js";
 
 // The heap's per-node step. A tracked effect's heap visit is its compute
 // phase — empty, like a user effect whose compute reads nothing — and hands
@@ -210,7 +210,9 @@ function recompute(e, t = false) {
         // and own nothing to park.
                 if (n === EFFECT_TRACKED || e.l & CONFIG_STAGED) {
             // A lazy node only those children read is released when this pass
-            // ends, if the pass doesn't read it again (#4142).
+            // ends, if the pass doesn't read it again (#4142). A cleanup or
+            // `unobserved` hook that throws here neither stops the pass nor skips
+            // that drain: its error is rethrown when the flush ends (owner.ts).
             const t = deferredReleases;
             deferReleases(o = []);
             disposeChildren(e);
@@ -331,7 +333,10 @@ function recompute(e, t = false) {
         // (markNode(c) in read()) marks the running node as part of ordinary
         // bookkeeping, and those marks are correctly discarded here.
                 c = (e.R & REACTIVE_MISSED_WAKE) !== 0;
-        A = !!(e.R & (i ? REACTIVE_JOINED | REACTIVE_STAGED_READ : REACTIVE_JOINED));
+        // A mount's staged read joins it — except a nested derivation left
+        // pending: no render effect reaches it yet, so it holds nothing and
+        // reaches no boundary (Reader, #4203). A reader that does is caught.
+                A = !!(e.R & (i && (E || n || !(e.m & STATUS_PENDING)) ? REACTIVE_JOINED | REACTIVE_STAGED_READ : REACTIVE_JOINED));
         // A verdict reader is one for as long as it probes, or reads a memo
         // that does (`read`): a pass that did neither (REACTIVE_PROBED, the same
         // bit) is an ordinary derivation again.
@@ -653,8 +658,8 @@ function computed(e, t) {
         me: null,
         Re: null,
         Ve: false,
-        Be: NOT_PENDING,
-        Qe: -1,
+        je: NOT_PENDING,
+        Be: -1,
         Ee: 0,
         v: NOT_PENDING,
         I: 0,
@@ -682,6 +687,12 @@ function computed(e, t) {
         if (t.m & STATUS_UNINITIALIZED || e.i !== EFFECT_RENDER) joinPassTx(txOf(t), !e.i && e.m & STATUS_UNINITIALIZED || freshHook?.(e));
 }
 
+/** `joinPass` into the hold `t` (a folded guess's: store/optimistic.ts
+ * `foldedRead`, D-34) — a reader is never a render effect there. */ function joinPassAt(e, t) {
+    e.R |= REACTIVE_JOINED;
+    joinPassTx(t, !e.i && e.m & STATUS_UNINITIALIZED || freshHook?.(e));
+}
+
 /** A15's stale reader (shared-hole and reveal corollaries): a render effect
  * reading a node held by a transaction that is not the flush's. It is served
  * the committed value — a pending one's too — publishes mainline, and is
@@ -739,7 +750,7 @@ function computed(e, t) {
 
 /** The computed whose pass a creation under `owner` belongs to (a root's is
  * its nearest computed ancestor's), or null outside every pass. */ function creatorPass(e) {
-    return e !== null && e.je ? e.Ye : e;
+    return e !== null && e.Qe ? e.Ye : e;
 }
 
 /** L2 — park the previous pass's frame for this node's commit: the children
@@ -837,7 +848,7 @@ const lazyOptions = {
 
 function setupComputedNode(e, t) {
     e.We = e;
-    const n = context?.je ? context.Ye : context;
+    const n = context?.Qe ? context.Ye : context;
     if (context) linkChild(context, e);
     if (n) e.Fe = n.Fe + 1;
     wireExternalSourceHook?.(e);
@@ -1058,7 +1069,7 @@ function markUnflushedStaged() {
     // A held node (L2) carries a staged value between flushes too, but it was
     // flushed — and parked. Not an unflushed write — unless rewritten since:
     // then the flushed staging is what the world sees until the next flush.
-        if (e.l & CONFIG_HELD) return e.T.Qe === clock ? e.T.Be : NOT_PENDING;
+        if (e.l & CONFIG_HELD) return e.T.Be === clock ? e.T.je : NOT_PENDING;
     return e.Ie;
 }
 
@@ -1066,9 +1077,9 @@ function markUnflushedStaged() {
  * flush left (`_flushed`) until the flush that carries the rewrite — the
  * stash is stamped with the clock, which that flush advances. */ function stashFlushed(e) {
     const t = e.T;
-    if (t.Qe !== clock) {
-        t.Be = e.se;
-        t.Qe = clock;
+    if (t.Be !== clock) {
+        t.je = e.se;
+        t.Be = clock;
         unflushedStaged = true;
     }
 }
@@ -1115,7 +1126,7 @@ function resyncUnflushedCompanions() {
 
 function read(e) {
     let t = context;
-    if (t?.je) t = t.Ye;
+    if (t?.Qe) t = t.Ye;
     const n = e;
     // CARVE 1: `owner` was `el._firewall || el` — a store leaf's status,
     // height and error were read off its projection computed. (Typed loosely
@@ -1149,7 +1160,9 @@ function read(e) {
         // Committed visibility for untracked and children-forbidden readers.
                 if (!t || e.se === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN) return e.Ie;
         // (A plain signal is never uninitialized — the carve-out is `serve`'s.)
-                if (observeFlightHook && t.l & CONFIG_VERDICT && stagedScreen(t)) return e.Ie;
+        // Lane work over a folded lane (D-34), once the frame has a
+        // transaction, reads the screen too.
+                if ((observeFlightHook && t.l & CONFIG_VERDICT || laneStageHook && passLane?.folded) && stagedScreen(t)) return e.Ie;
         stagedRead(t);
         return e.se;
     }
@@ -1290,7 +1303,10 @@ function read(e) {
 
 /** A pass read a staging of this flush: it derives from what the flush may
  * yet hold (REACTIVE_STAGED_READ — the seam decides). Lane work too (plan sec. 28, a
- * lane sees the screen plus its own guesses): the staging is the screen if
+ * lane sees the screen plus its own guesses) — a folded lane's only before
+ * the frame has a transaction (after, it reads the screen like a verdict
+ * reader, `stagedScreen` — a list pass never pairs a held length with the
+ * guess's rows, D-34): the staging is the screen if
  * the frame commits — one pass, the common case — and a held write if it
  * parks, which the seam repairs (`stagedReaders`): the pass re-derives on
  * the committed world and its lane's runs wait that round, so the held
@@ -1527,4 +1543,4 @@ function staleValues(e, t = true) {
     }
 }
 
-export { bornInto, captureWriteSnapshot, clearSnapshots, computed, context, createEffectNode, effectStatusNotify, ext, isEqual, isSame, joinPass, markLateLinker, markRefresh, markSnapshotScope, markUnflushedStaged, notePromotedWrite, prepareComputed, pullComputed, read, readerSeesCommitted, recompute, releaseSnapshotScope, resyncUnflushedCompanions, runWithOwner, serve, setEffectStatusNotify, setMemo, setSignal, setSnapshotCapture, setVerdict, setWriteHook, signal, slotSignal, snapshotCaptureActive, snapshotSources, spectating, stagedRead, stagedScreen, staleValues, stashFlushed, statusNotifierOf, tracking, unflushedStaged, unflushedValue, untrack, verdict, writeHook };
+export { bornInto, captureWriteSnapshot, clearSnapshots, computed, context, createEffectNode, effectStatusNotify, ext, isEqual, isSame, joinPass, joinPassAt, markLateLinker, markRefresh, markSnapshotScope, markUnflushedStaged, notePromotedWrite, prepareComputed, pullComputed, read, readerSeesCommitted, recompute, releaseSnapshotScope, resyncUnflushedCompanions, runWithOwner, serve, setEffectStatusNotify, setMemo, setSignal, setSnapshotCapture, setVerdict, setWriteHook, signal, slotSignal, snapshotCaptureActive, snapshotSources, spectating, stagedRead, stagedScreen, staleValues, stashFlushed, statusNotifierOf, tracking, unflushedStaged, unflushedValue, untrack, verdict, writeHook };

package/dist/prod/core/effect.js

@@ -46,6 +46,8 @@ function notifyEffectStatus(t, e) {
             return;
         }
         if (!globalQueue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+            // Dev locates the halt at the node that threw: the StatusError's
+            // source, upstream of this effect when a computed failed.
             haltReactivity(unwrapStatusError(u));
             throw u;
         }

package/dist/prod/core/graph.js

@@ -2,7 +2,7 @@ import { REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTO_DISPOSE, STATUS_PENDING, REACTIV
 
 import { deleteFromHeap } from "./heap.js";
 
-import { disposeChildren } from "./owner.js";
+import { disposeChildren, runCleanup } from "./owner.js";
 
 import { bumpNotifyEpoch, dirtyQueue } from "./scheduler.js";
 
@@ -27,7 +27,9 @@ function unlinkSubs(e) {
         if (o === null) {
             // Store slot nodes dispatch to the ONE shared hook — no per-node
             // unobserved closure, no NodeExtension to hold it.
-            if (n.l & CONFIG_SLOT_NODE) slotUnobservedHook(n); else n.T?.we?.();
+            // 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?.we) runCleanup(n.T.we);
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
             // 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
@@ -141,18 +143,18 @@ function link(e, n) {
     // [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.ve;
-    if (t !== null && t.u === n && (!s || t.Te === n.Ne)) return;
-    const r = n._ = e.ve = {
+        const r = e.ve;
+    if (r !== null && r.u === n && (!s || r.Te === n.Ne)) return;
+    const t = n._ = e.ve = {
         S: e,
         u: n,
         G: o,
-        Xe: t,
+        Xe: r,
         t: null,
         Te: n.Ne
     };
-    if (l !== null) l.G = r; else n.C = r;
-    if (t !== null) t.t = r; else e.o = r;
+    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();
 }

package/dist/prod/core/heap.js

@@ -16,7 +16,7 @@ import { dirtyQueue } from "./scheduler.js";
 }
 
 function actualInsertIntoHeap(e, t) {
-    const E = (e._parent?.je ? e._parent.Ye?.Fe : e._parent?.Fe) ?? -1;
+    const E = (e._parent?.Qe ? e._parent.Ye?.Fe : e._parent?.Fe) ?? -1;
     if (E >= e.Fe) e.Fe = E + 1;
     const n = e.Fe;
     const I = t.$e[n];

package/dist/prod/core/lanes.js

@@ -435,12 +435,21 @@ function supersede(e, n, s) {
  * lane's latest. NOT_PENDING falls through: lane work's read of a pending
  * member throws like any. */ function laneRead(e, n) {
     const s = n.l & CONFIG_GUESS;
+    const t = txOf(n);
+    // A lane a correction folded under (D-34): store/optimistic.ts reads it.
+    // Before the authoritative arm: an `until` outside the lane reads the
+    // same truth there, and joins the hold it folded into — its posture over
+    // a foreign hold (D-31), which the truth read alone would not take.
+        const l = e !== null && t.folded;
+    if (l) {
+        const s = l(e, n);
+        if (s !== NOT_PENDING) return s;
+    }
     if (e !== null && e.l & CONFIG_AUTHORITATIVE) return GlobalQueue.rn(n);
-    const t = n.m;
+    const u = n.m;
     // An errored member's lane value predates its error; the error is the answer (#4106).
-        if (!s && t & STATUS_ERROR) return NOT_PENDING;
+        if (!s && u & STATUS_ERROR) return NOT_PENDING;
     if (e === null) return laneValueOf(n);
-    const l = txOf(n);
     if (!tracking || e.l & CONFIG_CHILDREN_FORBIDDEN) {
         // An untracked read inside lane work derives from the lane like a
         // tracked one, minus the subscription — `untrack` is about
@@ -449,33 +458,33 @@ function supersede(e, n, s) {
         // lanes read by one pass link, as for tracked reads). Outside lane
         // work, the screen.
         if (passLane === null || e.l & CONFIG_CHILDREN_FORBIDDEN) return display(n);
-        enterLane(l, e);
-        if (!s && t & STATUS_PENDING) return NOT_PENDING;
+        enterLane(t, e);
+        if (!s && u & STATUS_PENDING) return NOT_PENDING;
         return laneValueOf(n);
     }
-    if (e.i === EFFECT_RENDER && (passLane === null || !sameLane(passLane, l))) {
+    if (e.i === EFFECT_RENDER && (passLane === null || !sameLane(passLane, t))) {
         if (!s) {
             // A flight whose value has never shown: nothing to show — the leaf
             // waits on it, and its own frame holds (A15, #3334), not the lane's
             // parent. The landing lands the frame: its own pass (the flush
             // joined its transaction) reads the answer it waited on — the lane's
             // staging, revealed at this seam.
-            if (t & STATUS_PENDING && n.T.v === NOT_PENDING) return NOT_PENDING;
+            if (u & STATUS_PENDING && n.T.v === NOT_PENDING) return NOT_PENDING;
             if (n.se !== NOT_PENDING && e.l & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.se;
         }
-        if (l.ln || !s && t & STATUS_PENDING) {
-            if (!s && !l.ke && t & STATUS_UNINITIALIZED) throw new NotReadyError(null);
+        if (t.ln || !s && u & STATUS_PENDING) {
+            if (!s && !t.ke && u & STATUS_UNINITIALIZED) throw new NotReadyError(null);
             // Re-derived at the reveal; once per pass (the pass may also be a stale
             // reader of a transaction, REACTIVE_FRAME_READ — both reruns apply).
                         if (!(e.R & REACTIVE_SCREEN_READ)) {
                 e.R |= REACTIVE_FRAME_READ | REACTIVE_SCREEN_READ;
-                l.En.push(e);
+                t.En.push(e);
             }
             return display(n);
         }
     }
-    enterLane(l, e);
-    if (!s && t & STATUS_PENDING) return NOT_PENDING;
+    enterLane(t, e);
+    if (!s && u & STATUS_PENDING) return NOT_PENDING;
     return laneValueOf(n);
 }
 
@@ -598,10 +607,12 @@ function laneSeam(e, n) {
         // question is the one being asked (`question`: a slice's, a derive's
         // continuation's — the flight's); unstamped writes and mainline are
         // current.
-        if (stale(e, question)) {
+        // A store re-bases a keyed arrangement guess over an older truth, and
+        // folds a current one beneath it (D-34): true.
+        const s = stale(e, question);
+        if (GlobalQueue.an?.(e, n, s) || s) {
             e.se = n;
             e.l |= CONFIG_HELD;
-            GlobalQueue.an?.(e, n);
             schedule();
             return n;
         }

package/dist/prod/core/owner.js

@@ -6,7 +6,7 @@ import { unobserved, clearDeps } from "./graph.js";
 
 import { deleteFromHeap } from "./heap.js";
 
-import { schedule, dirtyQueue } from "./scheduler.js";
+import { globalQueue, schedule, dirtyQueue } from "./scheduler.js";
 
 // L2 (step 2): the parked frame. A pass parks the previous frame's children
 // and `_disposal` list on `_x._pendingFirstChild` / `_x._pendingDisposal`
@@ -35,17 +35,41 @@ function dispose(e) {
     unobserved(e);
 }
 
-function disposeChildren(e, n = false, t) {
-    const i = e.R;
-    if (i & REACTIVE_DISPOSED) return;
+// 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 && !t && e.T !== null && (e.T.Ue !== null || e.T.me !== null)) disposeChildren(e, false, true);
+        if (n && !r && e.T !== null && (e.T.Ue !== null || e.T.me !== null)) disposeChildren(e, false, true);
     if (n) {
-        e.R = i | REACTIVE_DISPOSED;
+        e.R = t | REACTIVE_DISPOSED;
     }
     if (n && e.X) {
         if (e.T !== null) e.T.Se = null;
@@ -53,10 +77,10 @@ function disposeChildren(e, n = false, t) {
         // 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.m & STATUS_PENDING && e.T?.Re != null || i & REACTIVE_FRAME_READ) schedule();
+                if (e.m & STATUS_PENDING && e.T?.Re != null || t & REACTIVE_FRAME_READ) schedule();
     }
-    let l = t ? e.T.Ue : e.De;
-    if (t) e.T.Ue = null; else e.De = null;
+    let l = r ? e.T.Ue : e.De;
+    if (r) e.T.Ue = null; else e.De = null;
     while (l) {
         const e = l;
         // Owner teardown is death regardless of the child's own lifecycle
@@ -88,34 +112,34 @@ function disposeChildren(e, n = false, t) {
         // would still be holding.
                 l = l.pe;
     }
-    if (!t) e.ye = 0;
+    if (!r) e.ye = 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)) {
+        if (n && !r && !(t & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.R & REACTIVE_DISPOSED)) {
         const n = e.Ze;
-        const t = e.pe;
-        if (n !== null) n.pe = t; else e._parent.De = t;
-        if (t !== null) t.Ze = n;
+        const r = e.pe;
+        if (n !== null) n.pe = r; else e._parent.De = r;
+        if (r !== null) r.Ze = n;
         e.Ze = null;
     }
-    runDisposal(e, t);
+    runDisposal(e, r);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
         if (n && e.Je) {
         const n = e.Je;
         e.Je = undefined;
-        n();
+        runCleanup(n);
     }
 }
 
 function linkChild(e, n) {
-    const t = e.De;
+    const r = e.De;
     n.Ze = null;
-    n.pe = t;
-    if (t !== null) t.Ze = n;
+    n.pe = r;
+    if (r !== null) r.Ze = n;
     e.De = n;
 }
 
@@ -126,27 +150,26 @@ 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.T.me : e.He;
-    if (!t) return;
+    const r = n ? e.T.me : e.He;
+    if (!r) return;
     if (n) e.T.me = null; else e.He = null;
-    if (Array.isArray(t)) {
+    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 = t.length - 1; e >= 0; e--) {
-            const n = t[e];
-            n.call(n);
+        for (let e = r.length - 1; e >= 0; e--) {
+            runCleanup(r[e]);
         }
     } else {
-        t.call(t);
+        runCleanup(r);
     }
 }
 
 function childId(e, n) {
-    let t = e;
-    while (t.l & CONFIG_TRANSPARENT && t._parent) t = t._parent;
-    if (t.id != null) return formatId(t.id, n ? t.ye++ : t.ye);
+    let r = e;
+    while (r.l & CONFIG_TRANSPARENT && r._parent) r = r._parent;
+    if (r.id != null) return formatId(r.id, n ? r.ye++ : r.ye);
     throw new Error("");
 }
 
@@ -163,8 +186,8 @@ function childId(e, n) {
  * 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, n, t) {
-    return e?.id ?? (n ? t?.id : t?.id != null ? getNextChildId(t) : undefined);
+ */ function inheritId(e, n, r) {
+    return e?.id ?? (n ? r?.id : r?.id != null ? getNextChildId(r) : undefined);
 }
 
 /**
@@ -177,8 +200,8 @@ function childId(e, n) {
 }
 
 function formatId(e, n) {
-    const t = n.toString(36), i = t.length - 1;
-    return e + (i ? String.fromCharCode(64 + i) : "") + t;
+    const r = n.toString(36), t = r.length - 1;
+    return e + (t ? String.fromCharCode(64 + t) : "") + r;
 }
 
 /**
@@ -253,6 +276,9 @@ function formatId(e, n) {
 
 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.q) rethrowCleanupError();
 }
 
 /**
@@ -264,22 +290,22 @@ function disposeRootSelf(e = true) {
  * @internal
  */ function createOwner(e) {
     const n = context;
-    const t = e?.transparent ?? false;
+    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 i = {
-        id: inheritId(e, t, n),
-        l: t ? CONFIG_TRANSPARENT : 0,
+        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,
-        je: true,
-        Ye: n?.je ? n.Ye : n,
+        Qe: true,
+        Ye: n?.Qe ? n.Ye : n,
         De: null,
         pe: null,
         Ze: null,
@@ -290,8 +316,8 @@ function disposeRootSelf(e = true) {
         _parent: n,
         dispose: disposeRootSelf
     };
-    if (n) linkChild(n, i);
-    return i;
+    if (n) linkChild(n, t);
+    return t;
 }
 
 /**
@@ -329,11 +355,11 @@ function disposeRootSelf(e = true) {
  *
  * @description https://v2.solidjs.com/reference/solid-js/advanced/owner-introspection/create-root
  */ function createRoot(e, n) {
-    const t = createOwner(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(t, () => e(disposeRootSelf.bind(t, true)));
+        return runWithOwner(r, () => e(disposeRootSelf.bind(r, true)));
 }
 
-export { cleanup, createOwner, createRoot, dispose, disposeChildren, getNextChildId, getObserver, getOwner, inheritId, isDisposed, linkChild, markDisposal, peekNextChildId };
+export { cleanup, createOwner, createRoot, dispose, disposeChildren, getNextChildId, getObserver, getOwner, inheritId, isDisposed, linkChild, markDisposal, peekNextChildId, rethrowCleanupError, runCleanup };