@solidjs/signals 2.0.0-rc.2 → 2.0.0-rc.20

package/dist/types/core/error-hooks.d.ts

@@ -0,0 +1,71 @@
+import type { Owner } from "./types.js";
+/**
+ * The client error hook — the prod-tier seam through which an app or an
+ * error monitor hears the one failure nothing else can see: an error
+ * boundary (`createErrorBoundary`, `<Errored>`) collected it and is rendering
+ * its fallback. The browser's global handlers hear what reaches
+ * `window.onerror`; a rendered fallback never does. An UNCAUGHT error is not
+ * this hook's: the halt (`REACTIVITY_HALTED`) hands its cause to the
+ * platform's `reportError`, the channel every monitor already listens on —
+ * one event, not two.
+ *
+ * Called once per error object: a boundary's `reset()` recomputing the same
+ * failing node re-collects the same error and does not report it again.
+ * Two tiers: ambient (`configureClientErrors`) and per root
+ * (`render`/`hydrate`'s `onError` in `@solidjs/web`), the nearest root's
+ * winning. Fires in every tier; no return — the client has no wire to map
+ * for. `ownerPath` carries the component labels where the runtime keeps
+ * owner names (the observe and dev artifacts).
+ *
+ * Pay-for-use: this module is retained by `createErrorBoundary` (which
+ * reports here) or the app's own `configureClientErrors` import. A root's
+ * hook is parked ON the root owner under a registered symbol
+ * (`ROOT_ERROR_HOOK`, defined in the scheduler), so `render` writes it
+ * without importing anything: an app that configures no hook and renders no
+ * boundary carries none of this.
+ */
+export interface ClientErrorContext {
+    /**
+     * Where the error was THROWN: labels root-first up the owner chain of the
+     * computation that threw — component labels and named primitives — when
+     * the runtime keeps owner names (the observe and dev artifacts). The
+     * boundary's own chain when the thrower is unknown (a value thrown
+     * outside any computation).
+     */
+    ownerPath?: string[];
+    /**
+     * Where the error was MET: the same labels up the chain of the `<Errored>`
+     * that rendered its fallback for it — what the user saw, as against
+     * `ownerPath`, which is what broke.
+     */
+    boundaryPath?: string[];
+}
+export type ClientErrorHook = (error: unknown, context: ClientErrorContext) => void;
+export interface ClientErrorsConfig {
+    /** The hook, or `undefined` to clear it. */
+    onError?: ClientErrorHook;
+}
+/**
+ * Registers the ambient client error hook — the one call a browser `init()`
+ * makes to see every failure a boundary renders a fallback for, in
+ * production. (Uncaught errors reach `reportError` / `window.onerror`.)
+ *
+ * ```ts
+ * configureClientErrors({
+ *   onError: (error, { ownerPath }) =>
+ *     Sentry.captureException(error, {
+ *       mechanism: { type: "solid.error_boundary", handled: true }
+ *     })
+ * });
+ * ```
+ */
+export declare function configureClientErrors(config: ClientErrorsConfig): void;
+/**
+ * Tells the client error hook about `error`, caught by the boundary whose
+ * owner is `owner`, thrown by `thrower` (the computation the engine's status
+ * wrapper named; unknown for a value that never crossed one) — once per
+ * error object. A throwing hook is reported on the console and otherwise
+ * ignored — a monitor must never take the app down.
+ * @internal
+ */
+export declare function reportClientError(error: unknown, owner: Owner | null | undefined, thrower?: Owner | null): void;

package/dist/types/core/error.d.ts

@@ -39,9 +39,26 @@ export declare class StatusError extends Error {
 }
 /** Return the user's error from an internal status wrapper. */
 export declare function unwrapStatusError(error: unknown): unknown;
+/**
+ * Rejection value of `until(fn, { timeout })` when the predicate does not turn
+ * truthy within the window. Inside an `action()`, the rejection is thrown back
+ * in at the `yield` point — catchable there, or the action fails and its
+ * optimistic state reverts.
+ */
+export declare class TimeoutError extends Error {
+    constructor(message?: string);
+}
 export declare class NoOwnerError extends Error {
     constructor();
 }
 export declare class ContextNotFoundError extends Error {
-    constructor();
+    /**
+     * In dev, a read site passes the context (and whether a provider above set
+     * it to `undefined`) so the message can name it and say why it has no
+     * value (#4181). Read through `arguments` so production — where the message
+     * is empty — keeps the zero-parameter constructor byte for byte.
+     */
+    constructor(context?: {
+        id: symbol;
+    }, providedUndefined?: boolean);
 }

package/dist/types/core/graph.d.ts

@@ -1,6 +1,45 @@
 import type { Computed, Link, Signal } from "./types.js";
+/** The store's shared slot-node release handler (store/store.ts installs it
+ * once) — a live binding read directly by the sweep site: no wrapper frame,
+ * no null check (a CONFIG_SLOT_NODE node existing implies the store module
+ * loaded and registered it). */
+export declare let slotUnobservedHook: (node: Signal<any>) => void;
+export declare function setSlotUnobserved(fn: (node: Signal<any>) => void): void;
 export declare function unlinkSubs(link: Link): Link | null;
 export declare function trimStaleDeps(el: Computed<any>): void;
 export declare function clearDeps(el: Computed<unknown>): void;
+/**
+ * Last-one-out releases held back while a pass tears down the frame of an
+ * earlier pass that never committed (#4142). The pass is about to rebuild
+ * the same children, which read the same lazy nodes again. Released on the
+ * spot, a lazy async memo whose only reader was the old frame's child memo
+ * was torn down, re-ran on the new child's read, went pending, and the cycle
+ * repeated forever. `recompute` collects them around that teardown and
+ * releases what is still unobserved when the pass ends.
+ */
+export declare let deferredReleases: Computed<any>[] | null;
+export declare const deferReleases: (list: Computed<any>[] | null) => Computed<any>[] | null;
 export declare function unobserved(el: Computed<unknown>): void;
-export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>, pendingObserver?: boolean): void;
+/**
+ * Deferred dormancy for never-observed auto-dispose computeds (#3078).
+ *
+ * An untracked top-level read of a subscriber-less observation-lifecycle memo
+ * used to call unobserved() inline at the end of read(). That kept the leak
+ * closed (the compute links the memo into its deps' sub lists — without a
+ * teardown point a never-observed memo is retained by its sources forever;
+ * upstream alien-signals has exactly this retention), but it made reads
+ * destructive: each read disposed the node, the next read revived it with a
+ * full recompute in whatever ambient transition/lane context happened to be
+ * current, so consecutive reads could return different answers with no write
+ * in between.
+ *
+ * Instead, reads queue the node here and the scheduler sweeps at the top of
+ * the next flush (before runHeap, so a same-tick dirtying is reclaimed
+ * instead of recomputed). Reads become idempotent within a tick (the node
+ * stays alive and serves its cache, uniform with observed memos) while
+ * reclamation still happens within one microtask — the enqueue site arms
+ * schedule(), so a flush is guaranteed even when no other work is queued.
+ */
+export declare const dormantNodes: Set<Computed<unknown>>;
+export declare function sweepDormant(): void;
+export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;

package/dist/types/core/heap.d.ts

@@ -1,10 +1,10 @@
 import type { Computed } from "./types.js";
-/** The queue a node belongs to, picked from its own zombie flag. */
-export declare function queueFor(n: Computed<any>): Heap;
 /**
- * Schedule one subscriber to re-run on the next flush: tracked effects bypass
- * the heap and go directly to their effect queue; everything else is inserted
- * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
+ * Schedule one subscriber to re-run on the next flush: inserted into the
+ * dirty heap with the `_min` cursor pulled down. Tracked effects ride the
+ * heap too — the heap visit is their (empty) compute phase, which hands the
+ * callback to the user queue once the pass has committed (see
+ * GlobalQueue._update, #3291).
  */
 export declare function enqueueSub(node: Computed<any>): void;
 export interface Heap {

package/dist/types/core/identities.d.ts

@@ -0,0 +1,17 @@
+/** @internal The identity of a plain signal named while identities were on. */
+export declare function signalName(node: object | undefined): string | undefined;
+/** @internal Name plain signals from now on (`on`), or stop. */
+export declare function setSignalIdentities(on: boolean): void;
+/**
+ * @internal Called with every plain signal `createSignal` makes, and every
+ * plain store root `createStore` makes, while set (the namer above). Never
+ * set unless `setSignalIdentities` is imported, so a bundle without it keeps
+ * only a null check.
+ */
+export declare let signalHook: ((node: object) => void) | null;
+/**
+ * @internal Dev only: `watch` is called with every node read while set (the
+ * dev hook `onRead`) — the frames client's identity-drift check watches the
+ * named signals a deferred occurrence reads as it mounts. A no-op in prod.
+ */
+export declare function setReadWatch(watch: ((node: object) => void) | null): void;

package/dist/types/core/index.d.ts

@@ -1,13 +1,17 @@
-export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
-export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, refresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
+export { ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError } from "./error.js";
+export { isPending, latest } from "./verdict.js";
+export { action } from "./action.js";
+export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setWriteHook, setMemo, markRefresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
 export { enableExternalSource, _resetExternalSourceConfig, type ExternalSourceFactory, type ExternalSource, type ExternalSourceConfig } from "./external.js";
 export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, isDisposed, cleanup, peekNextChildId } from "./owner.js";
+export { setSignalIdentities, signalName, signalHook, setReadWatch } from "./identities.js";
 export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.js";
 export { handleAsync } from "./async.js";
-export { isPending, latest } from "./verdict.js";
-export type { Computed, Disposable, FirewallSignal, Link, Owner, Root, Signal, NodeOptions } from "./types.js";
+export type { Computed, Disposable, Link, Owner, Root, Signal, NodeOptions } from "./types.js";
 export { effect, trackedEffect, type Effect, type TrackedEffect } from "./effect.js";
-export { action } from "./action.js";
-export { flush, Queue, GlobalQueue, enforceLoadingBoundary, resetErrorHalt, type IQueue, type QueueCallback } from "./scheduler.js";
-export { DEV, type Dev, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type Diagnostics, type DiagnosticSeverity } from "./dev.js";
+export { flush, GlobalQueue, enforceLoadingBoundary, resetErrorHalt, type IQueue, type QueueCallback } from "./scheduler.js";
+export type { InteractionRef, NavigationRef } from "./attribution-hooks.js";
+export { ROOT_ERROR_HOOK, clock } from "./scheduler.js";
+export { configureClientErrors, type ClientErrorContext, type ClientErrorHook, type ClientErrorsConfig } from "./error-hooks.js";
+export { DEV, OBSERVE, setConsoleFooter, type AttributionSlot, type Dev, type Observe, type ServerObserve, type Records, type RecordTypes, type HostRecordTypes, type RecordType, type RecordEvent, type RecordLive, type RecordListener, type RecordSubscribeOptions, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type DiagnosticListener, type Diagnostics, type DiagnosticSeverity, type DiagnosticSubject } from "./dev.js";
 export * from "./constants.js";

package/dist/types/core/invariants.d.ts

@@ -1,8 +1,7 @@
-import type { OptimisticLane } from "./lanes.js";
 import type { Computed, Signal } from "./types.js";
 /**
  * Test-mode invariant checks for the async/transition/lane machinery.
- * Catalog and rationale: packages/solid-signals/INTERNALS-ASYNC-STATE.md.
+ * Catalog and rationale: packages/signals/docs/INTERNALS-ASYNC-STATE.md.
  *
  * These are implementation self-consistency checks, not semantic rules: a
  * violation means the reactive system contradicted itself.
@@ -17,16 +16,7 @@ import type { Computed, Signal } from "./types.js";
  * defines `__TEST__: false`.
  */
 type AnyNode = Signal<any> | Computed<any>;
-/** Wired by core.ts at module init to avoid import cycles. */
-export declare const InvariantHooks: {
-    pendingProbeActive: (() => boolean) | null;
-    /** Fresh oracle for what an isPending companion SHOULD read right now. */
-    computePendingState: ((node: AnyNode) => boolean) | null;
-};
 export declare function devTrackHeldPending(node: AnyNode): void;
-export declare function devTrackCompanionOwner(node: AnyNode): void;
-export declare function devTrackOptimistic(node: AnyNode): void;
-export declare function devTrackAffects(node: AnyNode): void;
 /**
  * Open/close the sanctioned registration window. Call sites are `__DEV__`
  * guarded (no prod cost); the code inside the window must not throw.
@@ -34,21 +24,6 @@ export declare function devTrackAffects(node: AnyNode): void;
 export declare function beginAsyncReporterWrites(): void;
 export declare function endAsyncReporterWrites(): void;
 export declare function createAsyncReporters(): Map<Computed<any>, Set<Computed<any>>>;
-/**
- * INV-2: a node with an *active* override must be registered for reversion in
- * the queue's or a transition's `_optimisticNodes`. An unregistered active
- * override would survive transition completion forever. Runs at the end of
- * every flush (not just quiescence — the invariant holds mid-transition).
- * (There is no revert-target requirement: authoritative values commit
- * silently into `_value` under the override mask — A17 — so reverting is
- * just dropping the override.)
- */
-export declare function devCheckActiveOverrides(isRegisteredForRevert: (node: AnyNode) => boolean): void;
-/** INV-1: an isPending() probe must never leak past its own call. */
-export declare function devCheckFlushStart(): void;
-/** INV-5: a merged lane's work moved to its root on merge and must stay empty. */
-export declare function devCheckMergedLaneEmpty(lane: OptimisticLane): void;
-export declare function devCensusCompanions(isQueuedForCommit?: (node: AnyNode) => boolean): void;
 /**
  * Quiescence checks. Run only when the system is fully drained: nothing
  * scheduled, no active/stashed transitions, no live lanes. At that point no

package/dist/types/core/lanes.d.ts

@@ -1,44 +1,75 @@
-import { type QueueCallback, type Transition } from "./scheduler.js";
+import { laneValueOf } from "./truth.js";
+import { type Transaction } from "./scheduler.js";
 import type { Computed, Signal } from "./types.js";
-/**
- * OptimisticLane represents the context for a single optimistic write.
- * Each optimistic signal creates its own lane. Lanes merge when their
- * dependency graphs overlap.
- */
-export interface OptimisticLane {
-    _source: Signal<any>;
-    _pendingAsync: Set<Computed<any>>;
-    _effectQueues: [QueueCallback[], QueueCallback[]];
-    _mergedInto: OptimisticLane | null;
-    _transition: Transition | null;
-    _parentLane: OptimisticLane | null;
-}
-export declare const signalLanes: WeakMap<Signal<any>, OptimisticLane>;
-export declare const activeLanes: Set<OptimisticLane>;
-/**
- * Get an existing lane for a signal or create a new one.
- * Reuses lane for multiple writes to the same signal.
- */
-export declare function getOrCreateLane(signal: Signal<any>): OptimisticLane;
-/**
- * Union-find: find the root lane.
- */
-export declare function findLane(lane: OptimisticLane): OptimisticLane;
-/**
- * Merge two lanes when their dependency graphs overlap.
- */
-export declare function mergeLanes(lane1: OptimisticLane, lane2: OptimisticLane): OptimisticLane;
-/**
- * Resolve a node's lane: follow union-find chain, verify active, clear if stale.
- */
-export declare function resolveLane(el: Signal<any> | Computed<any>): OptimisticLane | undefined;
-export declare function resolveTransition(el: Signal<any> | Computed<any>): Transition | null | undefined;
-/**
- * Check if a node has an active optimistic override.
- */
-export declare function hasActiveOverride(el: Signal<any> | Computed<any>): boolean;
-/**
- * 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.
- */
-export declare function assignOrMergeLane(el: Signal<any> | Computed<any>, sourceLane: OptimisticLane): void;
+export { laneValueOf };
+/** What the screen shows for a lane's node: the lane's value once the lane
+ * has revealed, the committed truth before — NOT_PENDING when there is none
+ * (uninitialized, as `laneValueOf`): its read throws NotReady. */
+export declare function display(el: Signal<any> | Computed<any>): unknown;
+/** What the writer sees of a node: an unflushed guess to it, else the
+ * lane's value or the committed one — what an optimistic updater composes
+ * on (a store setter's draft too, store/optimistic.ts). */
+export declare function guessedValueOf<T>(n: Signal<T> | Computed<T>): T;
+/** The unflushed guess to `n`, else NOT_PENDING. */
+export declare function pendingGuessOf(n: Signal<any> | Computed<any>): unknown;
+/** Lane `l` takes `n`'s guess (another action's), kept to come back if `l`
+ * reverts. Its readers saw the guess: they re-derive at the lane's reveal
+ * (and, a flight's, hold the lane while they would show it). `d`: a guess
+ * `l` takes without writing it (a store target's other slots) — the node
+ * shows its truth in `l`'s world until the guess comes back. */
+export declare function take(n: Signal<any>, l: Transaction, d?: boolean): void;
+export declare function optimisticWrite<T>(n: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
+/** The running pass read lane `l`'s work as a derivation: it is `l`'s — or,
+ * already another lane's, the frame it computes derives from both guesses
+ * and cannot show one without the other (#3335, A15 for lanes): the two
+ * lanes are linked — one reveal unit, each blocked while any is — while
+ * their lifetimes stay their own (#2912: a guess reverts with its own
+ * action, not with the one it shares a reader with). A nested lane reading
+ * through an ancestor's guess stays its own (the screen plus its own
+ * guesses). */
+export declare function enterLane(l: Transaction, c: Computed<any>): void;
+/** Verdicts (maintainer, 2026-10-01): `isPending` and `latest` are
+ * optimistic state the system supplies — a verdict is a guess ("pending,
+ * until this lands"; "the proposal is the value") decided at the seam like
+ * a user's, and its readers break out of the hold the same way: work of a
+ * lane under the holder, shown now, re-derived at the landing, ending with
+ * it. Judged at the seam like any lane: blocked while a verdict reader's
+ * own derivation is in flight (lane rule 3), shown otherwise. */
+export declare function verdictLane(t: Transaction): Transaction;
+/** A lane pass's node (core.ts `recompute`, before its staging; a pending
+ * propagation under a lane pass, async.ts): listed, carrying the lane's
+ * value from now (a derivation of a guess — its readers become lane work).
+ * Entering the lane supersedes a frame staging the node carried: this
+ * pass's answer replaces it, and the frame's hold on it is over. An
+ * effect's value slot is private (no lane value). A pass in a lane's seat
+ * that read none of the lane's world has left it (false): its result is the
+ * frame's — a derivation whose branch no longer reaches the guess — and no
+ * hold the lane took over from a transaction stays on it (#3698: lane work
+ * never makes its node transaction work; a born-held effect's hold went to
+ * the lane). A pass interrupted before it got there (pending, errored) did
+ * not leave (A30: it never got there). A first pass under a lane is the
+ * lane's (ruling A); a guess is written, not derived — it never leaves this
+ * way. `errored`: the pass has no answer — or, a lane pass's pending
+ * propagation (async.ts `propagateStatus`), the node gone pending. */
+export declare function laneStage(el: Computed<any>, l: Transaction, create: boolean, errored: boolean | Computed<any>): boolean;
+export declare function supersede(n: Signal<any> | Computed<any>, value: unknown, changed: boolean): void;
+/** Lanes. A lane's node is read by its reader's kind: an authoritative
+ * reader (`until`) sees the truth — staged beneath a guess, else committed
+ * — and is no lane's; an untracked read sees the lane's latest value (A17:
+ * "direct read shows optimistic"; A28); a children-forbidden reader sees
+ * the frame (A32). A render effect in the frame's seat reading a lane the
+ * seam found blocked, or a member whose own flight is up (held or not — the
+ * lane-membership ruling, 2026-10-05), sees the screen, re-derived at the
+ * reveal (#3460's stale reader) — or, the node a
+ * flight that has never shown (nothing to show), waits on it: its own frame
+ * holds (A15, #3334), not the lane's parent. Any other tracked reader is
+ * the lane's work from this read — a derivation; a leaf reading a lane that
+ * has shown, or one the seam has not judged yet (its run waits on the
+ * verdict: released if the lane shows, held if it blocks) — and sees the
+ * lane's latest. NOT_PENDING falls through: lane work's read of a pending
+ * member throws like any. A verdict reader entering a lane the seam has
+ * not judged reads ahead of it like a staging read: if the seam holds the
+ * lane, the pass re-derives on the screen (`entered`, #4284) — `latest()`
+ * beside the lane's nodes tears ahead of the hold however the reads are
+ * grouped into effects. */
+export declare function laneRead(c: Computed<any> | null, el: Signal<any> | Computed<any>): unknown;

package/dist/types/core/owner.d.ts

@@ -1,7 +1,12 @@
 import type { Computed, Disposable, Owner, Root } from "./types.js";
 export declare function markDisposal(el: Owner): void;
 export declare function dispose(node: Computed<unknown>): void;
+/** Runs a cleanup or `unobserved` hook; a throw is collected, not raised. @internal */
+export declare function runCleanup(fn: () => void): void;
+/** Rethrows the error `runCleanup` collected, once; `drop` discards it. @internal */
+export declare function rethrowCleanupError(drop?: boolean): void;
 export declare function disposeChildren(node: Owner, self?: boolean, zombie?: boolean): void;
+export declare function linkChild(parent: Owner, node: Owner): void;
 /**
  * Allocates and returns the next stable child id for `owner`. Used by
  * hydration plumbing and `createUniqueId`. Not part of the user-facing API.
@@ -62,13 +67,15 @@ export declare function getOwner(): Owner | null;
 /**
  * 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.
+ * checks. `cleanup()` is the unchecked primitive used by internals; `owner`
+ * (internal) targets a specific owner's disposal list instead of the ambient
+ * one.
  */
-export declare function cleanup(fn: Disposable): Disposable;
+export declare function cleanup(fn: Disposable, owner?: Owner | null): Disposable;
 /**
- * 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
@@ -95,9 +102,15 @@ export declare function createOwner(options?: {
     transparent?: boolean;
 }): Root;
 /**
- * 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
@@ -105,6 +118,7 @@ export declare function createOwner(options?: {
  *
  * @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));
@@ -114,9 +128,13 @@ export declare function createOwner(options?: {
  *
  * // 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
+ * @description https://v2.solidjs.com/reference/solid-js/advanced/owner-introspection/create-root
  */
 export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
     id?: string;