@solidjs/signals 2.0.0-beta.18 → 2.0.0-beta.20

package/dist/prod/core/lanes.js

@@ -0,0 +1,140 @@
+import { NOT_PENDING } from "./constants.js";
+
+import { currentTransition, activeTransition } from "./scheduler.js";
+
+// Map from optimistic signal to its lane (reused for multiple writes to same signal)
+const signalLanes = new WeakMap;
+
+// All active lanes (for cleanup on transition completion)
+const activeLanes = new Set;
+
+/**
+ * Get an existing lane for a signal or create a new one.
+ * Reuses lane for multiple writes to the same signal.
+ */ function getOrCreateLane(n) {
+    let e = signalLanes.get(n);
+    if (e) {
+        return findLane(e);
+    }
+    // Detect parent lane: _parentSource chains from pendingSignal → pendingValueComputed → original.
+    // The child lane should not merge with the parent lane.
+        const i = n.en;
+    const r = i?.Je ? findLane(i.Je) : null;
+    e = {
+        rn: n,
+        Pe: new Set,
+        tn: [ [], [] ],
+        an: null,
+        ve: activeTransition,
+        sn: r
+    };
+    signalLanes.set(n, e);
+    activeLanes.add(e);
+    // A companion may have written before the owner's first optimistic write
+    // (affects() as an action's first statement pokes the verdict companion of a
+    // still lane-less node, #2887), leaving its lane parentless. Adopt it now:
+    // parent-child is a property of the nodes, not of write order — otherwise
+    // the owner's write merges the companion's subscribers into this lane and
+    // their effects wait on its async instead of flushing immediately.
+        adoptCompanionLane(n.ye, e);
+    adoptCompanionLane(n.pe, e);
+    return e;
+}
+
+function adoptCompanionLane(n, e) {
+    if (!n) return;
+    const i = signalLanes.get(n);
+    if (!i) return;
+    const r = findLane(i);
+    // Only the companion's own unmerged root is safely re-parentable: a root
+    // that absorbed other lanes carries work that is not a child of this owner.
+        if (r !== e && r.rn === n && !r.sn) r.sn = e;
+}
+
+/**
+ * Union-find: find the root lane.
+ */ function findLane(n) {
+    while (n.an) n = n.an;
+    return n;
+}
+
+/**
+ * Merge two lanes when their dependency graphs overlap.
+ */ function mergeLanes(n, e) {
+    n = findLane(n);
+    e = findLane(e);
+    if (n === e) return n;
+    e.an = n;
+    // Move (not copy) the merged lane's work: after the merge all routing goes
+    // through findLane() to the root, so anything left behind here is dead —
+    // and anything *added* here later is a routing bug (INV-5).
+        for (const i of e.Pe) n.Pe.add(i);
+    e.Pe.clear();
+    n.tn[0].push(...e.tn[0]);
+    n.tn[1].push(...e.tn[1]);
+    e.tn[0].length = 0;
+    e.tn[1].length = 0;
+    return n;
+}
+
+/**
+ * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
+ */ function resolveLane(n) {
+    const e = n.Je;
+    if (!e) return undefined;
+    const i = findLane(e);
+    if (activeLanes.has(i)) return i;
+    n.Je = undefined;
+    return undefined;
+}
+
+function resolveTransition(n) {
+    // An active override answers with its owner, not its lane: lanes are
+    // scheduling affinity and a shared subscriber merges them across
+    // transactions (#2912) — the merged root's _transition would hand this
+    // node's override to whichever action wrote last through the shared
+    // reader. Chase merge chains; a dead owner settled through another path.
+    if (hasActiveOverride(n) && n.fn) {
+        const e = n.fn = currentTransition(n.fn);
+        if (e.cn !== true) return e;
+        n.fn = null;
+    }
+    return resolveLane(n)?.ve ?? n.ve;
+}
+
+/**
+ * Check if a node has an active optimistic override.
+ */ function hasActiveOverride(n) {
+    return !!(n.be !== undefined && n.be !== NOT_PENDING);
+}
+
+/**
+ * Assign or merge a lane onto a node. At convergence points (node already has
+ * a different active lane), merge unless the node has an active override.
+ */ function assignOrMergeLane(n, e) {
+    const i = findLane(e);
+    const r = n.Je;
+    if (r) {
+        // If the subscriber's lane was merged into another lane, it's stale —
+        // replace it with the new source lane instead of following the merge chain
+        // (which would incorrectly merge the new lane into the old group)
+        if (r.an) {
+            n.Je = e;
+            return;
+        }
+        const t = findLane(r);
+        if (activeLanes.has(t)) {
+            if (t !== i && !hasActiveOverride(n)) {
+                // Parent-child lanes stay independent so isPending resolves without
+                // waiting for the parent's async. The child keeps ownership.
+                if (i.sn && findLane(i.sn) === t) {
+                    n.Je = e;
+                } else if (t.sn && findLane(t.sn) === i) ; else mergeLanes(i, t);
+            }
+            return;
+        }
+    }
+    n.Je = e;
+}
+
+export { activeLanes, assignOrMergeLane, findLane, getOrCreateLane, hasActiveOverride, mergeLanes, resolveLane, resolveTransition, signalLanes };

package/dist/prod/core/optimistic.js

@@ -0,0 +1,273 @@
+import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, OVERRIDE_UNDEFINED, STATUS_PENDING, CONFIG_OWNED_WRITE, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, EFFECT_RENDER, EFFECT_USER } from "./constants.js";
+
+import { latestReadActive, currentOptimisticLane, stale } from "./core.js";
+
+import { NotReadyError } from "./error.js";
+
+import { enqueueSub } from "./heap.js";
+
+import "./invariants.js";
+
+import { resolveTransition, getOrCreateLane, hasActiveOverride, activeLanes, signalLanes, findLane, resolveLane, assignOrMergeLane } from "./lanes.js";
+
+import { GlobalQueue, activeTransition, globalQueue, clock, insertSubs, schedule, finalizePureQueue } from "./scheduler.js";
+
+/**
+ * The optimistic write engine, moved out of core.ts/scheduler.ts. Everything
+ * here serves only optimistic overrides — createOptimistic,
+ * createOptimisticStore (and its store-node writes), and the verdict layer's
+ * companions (which are optimistic nodes). Modules that can create optimistic
+ * state call `installOptimisticEngine()` before creating it; apps that never
+ * import one of those APIs never retain any of this.
+ *
+ * Core call sites fire the hooks behind guards on state only this module can
+ * create (`_overrideValue !== undefined`, `currentOptimisticLane !== null`,
+ * `_optimisticNodes.length`, `activeLanes.size`), so `!` invocations are safe
+ * once the gate holds — the same late-binding contract as verdict.ts.
+ */
+// When a background transition is stashed, plain optimistic signals need one
+// committed-view rerun. Keep that override local to the stash flush.
+let stashedOptimisticReads = null;
+
+/** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
+    const t = e.be !== NOT_PENDING;
+    const i = t ? unwrapOverride(e.be) : e.Ue;
+    if (typeof n === "function") n = n(i);
+    const u = !!(e.i & STATUS_UNINITIALIZED) || !e.Ge || !e.Ge(i, n);
+    if (!u) {
+        // Same-value write with an active override still entangles the current
+        // action's transition — the hold must outlast all overlapping actions.
+        if (t) {
+            const n = resolveTransition(e);
+            if (n && activeTransition !== n) globalQueue.initTransition(n);
+        }
+        return n;
+    }
+    if (t) globalQueue.initTransition(resolveTransition(e));
+    // No revert target is stashed: while the override is active every reader
+    // sees it (A17), so authoritative arrivals commit silently into _value and
+    // reverting is just dropping the override — _value is already correct.
+     else globalQueue.N.Be.push(e);
+    // Stamp ownership on the node (post-merge, so entangled writers share the
+    // joint root). resolveTransition prefers this over the lane's _transition,
+    // which a shared subscriber can merge across transactions (#2912).
+        e.fn = activeTransition;
+    const s = getOrCreateLane(e);
+    e.Je = s;
+    // Literal undefined must not land raw: the slot doubles as the optimistic
+    // brand, and erasing it makes the write invisible and routes follow-up
+    // writes off the optimistic path into permanent commits (#2898).
+        e.be = n === undefined ? OVERRIDE_UNDEFINED : n;
+    GlobalQueue._e !== null && GlobalQueue._e(e, n);
+    e.Ie = clock;
+    insertSubs(e, true);
+    schedule();
+    return n;
+}
+
+function readStashed(e) {
+    return !!stashedOptimisticReads?.has(e);
+}
+
+function queueStashedOptimisticEffects(e) {
+    for (let n = e.p; n !== null; n = n.de) {
+        const e = n.Ee;
+        if (!e.De) continue;
+        enqueueSub(e);
+    }
+}
+
+/**
+ * Incomplete-transition finalization when the stashed transition holds
+ * optimistic nodes: give plain optimistic signals one committed-view rerun.
+ */ function stashOptimistic(e) {
+    stashedOptimisticReads = new Set;
+    for (let n = 0; n < e.Be.length; n++) {
+        const t = e.Be[n];
+        if (t.xe || t.U & CONFIG_OWNED_WRITE) continue;
+        stashedOptimisticReads.add(t);
+        queueStashedOptimisticEffects(t);
+    }
+    try {
+        finalizePureQueue(null, true);
+    } finally {
+        stashedOptimisticReads = null;
+    }
+}
+
+/**
+ * transitionComplete's override blockage: a settling transition stays open
+ * while one of its optimistic nodes holds an active override that is still
+ * pending on real (non-affects-sentinel) async.
+ */ function transitionBlocked(e) {
+    for (let n = 0; n < e.Be.length; n++) {
+        const t = e.Be[n];
+        if (hasActiveOverride(t) && "i" in t && t.i & STATUS_PENDING && t.k instanceof NotReadyError && 
+        // Mark-sourced pending never blocks settlement: affects() releases AT
+        // settle, so counting its sentinel here would deadlock the window it
+        // is scoped to.
+        !t.k.source?.l) {
+            return true;
+        }
+    }
+    return false;
+}
+
+function resolveOptimisticNodes(e) {
+    // Settlement writes below (snapCompanionsToState → updatePendingSignal-style
+    // notifications) may push fresh optimistic nodes; only this batch settles
+    // now, so iterate a fixed window and splice it out at the end.
+    const n = e.length;
+    for (let t = 0; t < n; t++) {
+        const n = e[t];
+        n.Je = undefined;
+        // Revert is a pure drop: there is no revert target to commit —
+        // override-covered authoritative values hold in _pendingValue and
+        // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
+                if (!(n.i & STATUS_PENDING)) n.i &= ~STATUS_UNINITIALIZED;
+        const i = n.be;
+        n.be = NOT_PENDING;
+        if (i !== NOT_PENDING && n.Ue !== unwrapOverride(i)) insertSubs(n, true);
+        n.ve = null;
+        n.fn = null;
+    }
+    // Settlement checkpoint (#2838): companions caught in this batch (or owned
+    // by a node in it) re-derive from committed state, so verdicts survive the
+    // transition that produced them (A19 — pending is a property of the data).
+        for (let t = 0; t < n; t++) {
+        const n = e[t];
+        if (n.ye || n.pe) GlobalQueue.R(n);
+        const i = n.en;
+        if (i && (i.ye === n || i.pe === n)) GlobalQueue.R(i);
+    }
+    e.splice(0, n);
+}
+
+function runQueue(e, n) {
+    for (let t = 0; t < e.length; t++) e[t](n);
+}
+
+/**
+ * Run effects from all lanes that are ready (no pending async).
+ */ function runLaneEffects(e) {
+    for (const n of activeLanes) {
+        if (n.an || n.Pe.size > 0) continue;
+        const t = n.tn[e - 1];
+        if (t.length) {
+            n.tn[e - 1] = [];
+            runQueue(t, e);
+        }
+    }
+}
+
+function cleanupCompletedLanes(e) {
+    for (const n of activeLanes) {
+        const t = e ? n.ve === e : !n.ve;
+        if (!t) continue;
+        if (!n.an) {
+            if (n.tn[0].length) runQueue(n.tn[0], EFFECT_RENDER);
+            if (n.tn[1].length) runQueue(n.tn[1], EFFECT_USER);
+        }
+        if (n.rn.Je === n) n.rn.Je = undefined;
+        n.Pe.clear();
+        n.tn[0].length = 0;
+        n.tn[1].length = 0;
+        activeLanes.delete(n);
+        signalLanes.delete(n.rn);
+    }
+}
+
+/** read()'s per-lane suspension test (pending-throw path, lane context). */ function laneSuspends(e) {
+    // Per-lane suspension: only throw if in same lane as pending async
+    // AND the node doesn't have an active override (overrides are the visible value,
+    // downstream in the lane should read the override, not throw)
+    const n = e.Je;
+    if (!n) return false;
+    return findLane(n) === findLane(currentOptimisticLane) && !hasActiveOverride(e);
+}
+
+/**
+ * read()'s entanglement gate: a reader recomputing under an optimistic lane
+ * that reads a pending mid-transition write sees the committed value; the sub
+ * is recorded for replay at commit.
+ */ function gatedRead(e, n, t) {
+    if (latestReadActive || e.ge === NOT_PENDING || e.xe || n !== e && !(n.u & REACTIVE_MANUAL_WRITE)) {
+        return false;
+    }
+    activeTransition.un.add(t);
+    return true;
+}
+
+/**
+ * read()'s value selection under a lane: return the committed `_value` for
+ * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
+ */ function laneReadsCommitted(e, n, t) {
+    return e.be !== undefined || !!e.Je || n === e && stale && t.en !== e || !!(n.i & STATUS_PENDING);
+}
+
+/**
+ * recompute()'s lane posture: resolve the node's own lane (own=true), or adopt
+ * a dependency's optimistic lane (own=false — parent-deeper-than-owned-child
+ * can run before its OPT-dirty child propagates).
+ */ function recomputeLane(e, n) {
+    if (n) return resolveLane(e) ?? null;
+    for (let n = e.S; n; n = n.st) {
+        const t = n.ot;
+        if (t.u & REACTIVE_OPTIMISTIC_DIRTY) {
+            const n = resolveLane(t);
+            if (n) {
+                e.u |= REACTIVE_OPTIMISTIC_DIRTY;
+                assignOrMergeLane(e, n);
+                return n;
+            }
+        }
+    }
+    return null;
+}
+
+/** recompute()'s catch path: track pending async in the current lane. */ function laneAsyncPending(e) {
+    const n = findLane(currentOptimisticLane);
+    if (n.rn !== e) {
+        n.Pe.add(e);
+        e.Je = n;
+        GlobalQueue.P !== null && GlobalQueue.P(n.rn);
+    }
+}
+
+/** recompute()'s success path: the node's async settled, clear it from its lane. */ function laneAsyncSettled(e) {
+    const n = resolveLane(e);
+    if (n) {
+        n.Pe.delete(e);
+        GlobalQueue.P !== null && GlobalQueue.P(n.rn);
+    }
+}
+
+function trackOptimisticStore(e) {
+    // After initTransition, globalQueue._batch IS activeTransition (same reference)
+    globalQueue.N.dn.add(e);
+    schedule();
+}
+
+/**
+ * Installs the engine's hooks. Idempotent; called by every module that can
+ * create optimistic state (verdict.ts at module top level, createOptimistic
+ * and createOptimisticStore at first call) BEFORE any optimistic node exists.
+ */ function installOptimisticEngine() {
+    if (GlobalQueue.bt !== null) return;
+    GlobalQueue.bt = optimisticWrite;
+    GlobalQueue.En = resolveOptimisticNodes;
+    GlobalQueue.Tn = stashOptimistic;
+    GlobalQueue.In = transitionBlocked;
+    GlobalQueue.Nn = cleanupCompletedLanes;
+    GlobalQueue.On = runLaneEffects;
+    GlobalQueue.Dt = readStashed;
+    GlobalQueue.gt = gatedRead;
+    GlobalQueue.ht = laneSuspends;
+    GlobalQueue.vt = laneReadsCommitted;
+    GlobalQueue.$e = recomputeLane;
+    GlobalQueue.et = laneAsyncPending;
+    GlobalQueue.Xe = laneAsyncSettled;
+    GlobalQueue.mn = trackOptimisticStore;
+}
+
+export { installOptimisticEngine };

package/dist/prod/core/owner.js

@@ -0,0 +1,293 @@
+import { REACTIVE_DISPOSED, 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 { deleteFromHeap, queueFor, insertIntoHeap, insertIntoHeapHeight } from "./heap.js";
+
+import { GlobalQueue, zombieQueue, dirtyQueue, globalQueue } from "./scheduler.js";
+
+const PENDING_OWNER = {};
+
+ // Dummy owner to trigger store's read() path
+function markDisposal(e) {
+    let n = e.He;
+    while (n) {
+        const e = n.u;
+        n.u = 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);
+        }
+        markDisposal(n);
+        n = n.Ve;
+    }
+}
+
+function dispose(e) {
+    let n = e.S;
+    while (n !== null) {
+        n = unlinkSubs(n);
+    }
+    e.S = null;
+    e.Ke = null;
+    disposeChildren(e, true);
+}
+
+function disposeChildren(e, n = false, t) {
+    const i = e.u;
+    if (i & REACTIVE_DISPOSED) return;
+    if (n) {
+        e.u = 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.ye || n.pe) GlobalQueue.R(n);
+    }
+    if (n && e.xe) e.Ae = null;
+    let l = t ? e.Ze : e.He;
+    while (l) {
+        const e = l.Ve;
+        if (l.S) {
+            const e = l;
+            deleteFromHeap(e, queueFor(e));
+            let n = e.S;
+            do {
+                n = unlinkSubs(n);
+            } while (n !== null);
+            e.S = null;
+            e.Ke = null;
+        }
+        disposeChildren(l, true);
+        l = e;
+    }
+    if (t) {
+        e.Ze = null;
+    } else {
+        e.He = null;
+        e.je = 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.u & REACTIVE_DISPOSED)) {
+        const n = e.Nt;
+        const t = e.Ve;
+        if (n !== null) n.Ve = t; else e.Fe.He = t;
+        if (t !== null) t.Nt = n;
+        e.Nt = 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.dt) {
+        const n = e.dt;
+        e.dt = undefined;
+        n();
+    }
+}
+
+function runDisposal(e, n) {
+    let t = n ? e.We : e.Me;
+    if (!t) return;
+    if (Array.isArray(t)) {
+        for (let e = 0; e < t.length; e++) {
+            const n = t[e];
+            n.call(n);
+        }
+    } else {
+        t.call(t);
+    }
+    n ? e.We = null : e.Me = null;
+}
+
+function childId(e, n) {
+    let t = e;
+    while (t.U & CONFIG_TRANSPARENT && t.Fe) t = t.Fe;
+    if (t.id != null) return formatId(t.id, n ? t.je++ : t.je);
+    throw new Error("");
+}
+
+/**
+ * Allocates and returns the next stable child id for `owner`. Used by
+ * hydration plumbing and `createUniqueId`. Not part of the user-facing API.
+ *
+ * @internal
+ */ function getNextChildId(e) {
+    return childId(e, true);
+}
+
+/**
+ * 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);
+}
+
+/**
+ * Returns the *next* child id for `owner` without consuming it. Used by
+ * hydration plumbing to peek at the id a future child will receive.
+ *
+ * @internal
+ */ function peekNextChildId(e) {
+    return childId(e, false);
+}
+
+function formatId(e, n) {
+    const t = n.toString(36), i = t.length - 1;
+    return e + (i ? String.fromCharCode(64 + i) : "") + t;
+}
+
+/**
+ * Returns the currently-tracking observer (the computation that subscribes to
+ * reactive reads at this point), or `null` if reads here would be untracked.
+ * Used by reactive primitives that need to know whether they're inside a
+ * tracking scope. App code rarely needs this — see `getOwner()` for the
+ * lifecycle owner instead.
+ *
+ * @example
+ * ```ts
+ * // Library predicate: only register a hot-path subscription when the
+ * // caller is inside a tracking scope (memo / effect compute / JSX).
+ * function trackIfTracked(source: () => unknown) {
+ *   if (getObserver()) source();
+ * }
+ * ```
+ */ function getObserver() {
+    if (pendingCheckActive || latestReadActive) return PENDING_OWNER;
+    return tracking ? context : null;
+}
+
+/**
+ * Returns the current reactive **owner** — the lifecycle node that the next
+ * `cleanup()` / `onCleanup()` / `createSignal()` etc. will be attached to.
+ *
+ * Returns `null` if called outside any owner. Capture the owner with
+ * `getOwner()` and re-enter it later with `runWithOwner(owner, fn)` to attach
+ * disposables created from a callback (event handler, async resolution, etc.)
+ * back to a component's lifecycle.
+ *
+ * @example
+ * ```ts
+ * function defer<T>(fn: () => T) {
+ *   const owner = getOwner();
+ *   queueMicrotask(() => runWithOwner(owner, fn));
+ * }
+ * ```
+ */ function getOwner() {
+    return context;
+}
+
+/**
+ * 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.Me) context.Me = e; else if (Array.isArray(context.Me)) context.Me.push(e); else context.Me = [ context.Me, 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.
+ *
+ * @example
+ * ```ts
+ * function onSettleSafe(fn: () => void) {
+ *   const owner = getOwner();
+ *   queueMicrotask(() => {
+ *     if (owner && isDisposed(owner)) return; // component unmounted; skip
+ *     runWithOwner(owner, fn);
+ *   });
+ * }
+ * ```
+ */ function isDisposed(e) {
+    return !!(e.u & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+}
+
+function disposeRootSelf(e = true) {
+    disposeChildren(this, e);
+}
+
+/**
+ * Creates a fresh owner attached as a child of the current owner (or as a
+ * detached root if there is none). Used by framework internals to group
+ * cleanups; app code should use `createRoot()` (host a reactive scope outside
+ * a component) or `runWithOwner()` (re-enter a captured owner).
+ *
+ * @internal
+ */ function createOwner(e) {
+    const n = context;
+    const t = e?.transparent ?? false;
+    const i = {
+        id: inheritId(e, t, n),
+        U: t ? CONFIG_TRANSPARENT : 0,
+        At: true,
+        Ct: n?.At ? n.Ct : n,
+        He: null,
+        Ve: null,
+        Nt: null,
+        Me: null,
+        v: n?.v ?? globalQueue,
+        we: n?.we || defaultContext,
+        je: 0,
+        We: null,
+        Ze: null,
+        Fe: n,
+        dispose: disposeRootSelf
+    };
+    if (n) {
+        const e = n.He;
+        if (e === null) {
+            n.He = i;
+        } else {
+            i.Ve = e;
+            e.Nt = i;
+            n.He = 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.
+ *
+ * Use this to host long-lived reactive scopes outside of a component (custom
+ * controllers, app bootstrapping, tests). Inside a component, prefer
+ * letting Solid's component lifecycle own things.
+ *
+ * @example
+ * ```ts
+ * const dispose = createRoot(dispose => {
+ *   const [n, setN] = createSignal(0);
+ *   createEffect(() => n(), value => console.log(value));
+ *   setInterval(() => setN(x => x + 1), 1000);
+ *   return dispose;
+ * });
+ *
+ * // Later, to tear everything down:
+ * dispose();
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
+ */ function createRoot(e, n) {
+    const t = createOwner(n);
+    return runWithOwner(t, () => e(() => t.dispose()));
+}
+
+export { cleanup, createOwner, createRoot, dispose, disposeChildren, getNextChildId, getObserver, getOwner, inheritId, isDisposed, markDisposal, peekNextChildId };