@solidjs/signals 2.0.0-rc.7 → 2.0.0-rc.8

package/dist/types-cjs/core/dev.d.cts

@@ -1,136 +0,0 @@
-import { type Attribution } from "./attribution.cjs";
-import type { Computed, Link, Owner, Signal } from "./types.cjs";
-export interface DevHooks {
-    onOwner?: (owner: Owner) => void;
-    onGraph?: (value: any, owner: Owner | null) => void;
-    onUpdate?: () => void;
-    onStoreNodeUpdate?: (state: any, property: PropertyKey, value: any, prev: any) => void;
-}
-/**
- * `info` is the advisory tier: a structural fact worth surfacing that is not
- * presumptively a bug (e.g. a 2-deep sequential fetch chain, which may be an
- * intrinsic data dependency). Budget/assertion consumers should treat only
- * `warn`/`error` as failures unless they opt in to `info`.
- */
-export type DiagnosticSeverity = "info" | "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "REACTIVE_WRITE_IN_OWNED_SCOPE" | "ACTION_CALLED_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "SETTLED_CLEANUP_UNOWNED" | "SETTLE_WALK_UNINITIALIZED_SOURCE" | "FLUSH_IN_EFFECT_CALLBACK" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "INVALID_AFFECTS_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC" | "REACTIVITY_HALTED" | "INVARIANT_VIOLATION" | "HUGE_FAN_OUT" | "HUGE_FAN_IN" | "HOT_SCOPE_RERUNS" | "HOT_SCOPE_TIME" | "WIDE_SCOPE_DEPS" | "UNSTABLE_MEMO_OUTPUT" | "WIDE_WRITE" | "ASYNC_WATERFALL" | "HOT_SCOPE_FANOUT" | "SILENT_HOLD" | "LONG_HOLD" | "EFFECT_WRITES_OWN_SOURCE" | "EFFECT_RELAY_TEAR" | "IMMUTABLE_UPDATE_IN_STORE" | "UNSTABLE_LIST_IDENTITY";
-export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner" | "error" | "perf" | "graph"
-/** Perceived responsiveness: the runtime behaved correctly but the user saw no feedback. */
- | "responsiveness";
-/** First warning when a node's live edge count reaches this size. */
-export declare const GRAPH_SIZE_WARN_AT = 2000;
-/** Repeat the warning at this interval after the first. */
-export declare const GRAPH_SIZE_WARN_EVERY = 500;
-export interface DiagnosticEvent {
-    sequence: number;
-    code: DiagnosticCode;
-    kind: DiagnosticKind;
-    severity: DiagnosticSeverity;
-    message: string;
-    ownerId?: string;
-    ownerName?: string;
-    nodeName?: string;
-    /**
-     * Root-first chain of named owners enclosing the subject of the event —
-     * component roots as `<Name>`, computations by their `name` option (or
-     * the `effect`/`computed` default) — e.g. `["<App>", "<TodoRow>", "effect"]`.
-     * Unnamed owners (plain roots) are skipped. Absent when the subject has no
-     * named owner at all (a top-level scope, or an unowned primitive — which
-     * is usually the finding itself).
-     */
-    ownerPath?: string[];
-    data?: Record<string, unknown>;
-}
-export type DiagnosticListener = (event: DiagnosticEvent) => void;
-export interface DiagnosticCapture {
-    readonly events: readonly DiagnosticEvent[];
-    clear(): void;
-    stop(): DiagnosticEvent[];
-}
-export interface Diagnostics {
-    subscribe(listener: DiagnosticListener): () => void;
-    capture(): DiagnosticCapture;
-    /**
-     * Registers a console footer appended to the first console report of
-     * each diagnostic code — a discovery pointer to deeper guidance (e.g.
-     * solid-js registers its shipped repair skill). Reported events carry
-     * it as trailing lines of the same console entry; events that surface as
-     * a thrown error instead get it as a follow-up line. Returning undefined
-     * for an event suppresses the footer. Passing undefined unregisters and
-     * resets the once-per-code memory.
-     */
-    setConsoleFooter(footer: ((event: DiagnosticEvent) => string | undefined) | undefined): void;
-}
-export interface Dev {
-    hooks: DevHooks;
-    diagnostics: Diagnostics;
-    /** "Why did this run" re-run attribution — see attribution.ts. */
-    attribution: Attribution;
-    getChildren: typeof getChildren;
-    getSignals: typeof getSignals;
-    getParent: typeof getParent;
-    getSources: typeof getSources;
-    getObservers: typeof getObservers;
-}
-export declare const DEV: Dev;
-/**
- * Dev-mode internal consistency check. A failure means the reactive system
- * contradicted itself (not that user code misbehaved) — see
- * INTERNALS-ASYNC-STATE.md for the invariant catalog. Throws under __TEST__
- * so the suite (and fuzzing) treats any violation as a hard failure; logs in
- * dev builds so user apps degrade instead of crashing.
- */
-export declare function assertInvariant(condition: boolean, name: string, message: string): void;
-/** Anything a diagnostic can be about: an owner (root, computed, effect) or a signal. */
-export type DiagnosticSubject = Owner | Signal<any> | Computed<any>;
-/**
- * Root-first names of the owners enclosing `subject` (inclusive when the
- * subject is itself a named owner). Signals hop to their registering owner
- * (`_owner`, set by registerGraph). Unnamed owners are skipped so the path
- * reads as the component tree plus the scope: `<App> › <TodoRow> › effect`.
- */
-export declare function ownerPath(subject: DiagnosticSubject | null | undefined): string[] | undefined;
-/**
- * Records a diagnostic on the structured channel (listeners, captures) and
- * returns the entry. `subject` locates it: the current reactive `context` by
- * default (right for the synchronous rule checks — they fire inside the
- * scope that misbehaved); pass the node for scheduler-time findings whose
- * ambient context is the flush, or `null` for events that have no location
- * by nature. Console output is a separate step — see `reportDiagnostic`.
- */
-export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence" | "ownerPath">, subject?: DiagnosticSubject | null | undefined): DiagnosticEvent;
-/**
- * The console face of a diagnostic — ONE entry per finding: the message, the
- * owner path (`in <App> › <TodoRow> › effect`) so a human can locate it, the
- * once-per-code footer as trailing lines, and — when the subject is a
- * binding effect the rendering runtime tagged — the element it writes, as a
- * second console argument (hover highlights it, click jumps to Elements).
- * Severity picks the console method. Call sites report the entry
- * `emitDiagnostic` returned so the structured and console channels never
- * disagree.
- */
-export declare function reportDiagnostic(entry: DiagnosticEvent): void;
-/**
- * Shared strict-read diagnostics for core read() and the store proxy traps.
- * Single source for the message text — the #2897 safeguard parity between
- * memos and stores is exactly these firing identically from both paths.
- */
-export declare function throwPendingUntrackedRead(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence" | "data" | "ownerPath">>): never;
-export declare function warnStrictReadUntracked(strictReadLabel: string, fields?: Partial<Omit<DiagnosticEvent, "sequence" | "ownerPath">>): void;
-export declare function registerGraph(value: any, owner: Owner | null): void;
-export declare function clearSignals(node: Owner): void;
-export declare function getChildren(owner: Owner): Owner[];
-export declare function getSignals(owner: Owner): any[];
-export declare function getParent(owner: Owner): Owner | null;
-export declare function getSources(computation: Computed<any>): (Signal<any> | Computed<any>)[];
-export declare function getObservers(node: Signal<any> | Computed<any>): Computed<any>[];
-/**
- * DEV-only: bump live edge counts after a new graph link and warn when a
- * node grows an unusually large fan-out (many subscribers on one source) or
- * fan-in (many sources on one computation). Repeat-reads that `link()`
- * dedupes never reach here. Always-on in dev — unlike the opt-in attribution
- * engine, a graph-size pathology should surface without asking.
- */
-export declare function noteGraphLink(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;
-/** DEV-only: drop live edge counts when a link is removed. */
-export declare function unnoteGraphLink(link: Link): void;

package/dist/types-cjs/core/effect.d.cts

@@ -1,30 +0,0 @@
-import type { Computed, NodeOptions, Owner } from "./types.cjs";
-export interface Effect<T> extends Computed<T>, Owner {
-    _effectFn: (val: T, prev: T | undefined) => void | (() => void);
-    _errorFn?: (err: unknown, cleanup: () => void) => void;
-    _modified: boolean;
-    _prevValue: T | undefined;
-    _type: number;
-    _boundRunEffect?: () => void;
-}
-/**
- * Effects are the leaf nodes of our reactive graph. When their sources change, they are
- * automatically added to the queue of effects to re-execute, which will cause them to fetch their
- * sources and recompute
- */
-export declare function effect<T>(compute: (prev: T | undefined) => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown, cleanup: () => void) => void | (() => void), options?: NodeOptions<any> & {
-    user?: boolean;
-    defer?: boolean;
-    schedule?: boolean;
-}): void;
-export interface TrackedEffect extends Computed<void> {
-    _modified: boolean;
-    _type: number;
-    _run: () => void;
-}
-/**
- * Internal tracked effect - bypasses heap, goes directly to effect queue.
- * Runs as a leaf owner: child primitives and onCleanup are forbidden (__DEV__ throws).
- * Uses stale reads.
- */
-export declare function trackedEffect(fn: () => void | (() => void), options?: NodeOptions<any>): void;

package/dist/types-cjs/core/error.d.cts

@@ -1,56 +0,0 @@
-/**
- * Thrown by a tracked read whose value is currently pending (an async memo /
- * `createSignal(asyncFn)` / projection / store derivation that hasn't settled
- * yet). Surfacing through the reactive graph is what suspends the consumer
- * scope — the nearest enclosing `<Loading>` boundary catches the throw and
- * renders its fallback until the source resolves.
- *
- * App code rarely catches this directly; `<Loading>` is the canonical
- * handler. The error type is exposed for advanced cases — e.g. interop layers
- * that bridge Solid's pending-throw protocol to a different async strategy,
- * or tests that want to assert on the suspension shape.
- *
- * @example
- * ```ts
- * // Advanced: distinguish "not ready yet" from a real error in custom
- * // boundary plumbing. App code should rely on `<Loading>` / `<Errored>`.
- * try {
- *   const value = readReactiveSource();
- * } catch (err) {
- *   if (err instanceof NotReadyError) throw err; // re-throw to suspend
- *   reportError(err);
- * }
- * ```
- */
-export declare class NotReadyError extends Error {
-    /**
-     * Tags a visibility-only notification on the affects() boundary channel:
-     * boundaries update display state from it, but the root queue never
-     * registers a reporter — marks are invisible to completion accounting by
-     * construction.
-     */
-    _markVisual?: boolean;
-    source: any;
-    constructor(source: any);
-}
-export declare class StatusError extends Error {
-    source: any;
-    constructor(source: any, original: any);
-}
-/** 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();
-}

package/dist/types-cjs/core/external.d.cts

@@ -1,15 +0,0 @@
-export type ExternalSourceFactory = (fn: (prev: any) => any, trigger: () => void) => ExternalSource;
-export interface ExternalSource {
-    track: (prev: any) => any;
-    dispose: () => void;
-}
-export interface ExternalSourceConfig {
-    factory: ExternalSourceFactory;
-    untrack?: <T>(fn: () => T) => T;
-}
-export declare let externalSourceConfig: {
-    factory: ExternalSourceFactory;
-    untrack: <T>(fn: () => T) => T;
-} | null;
-export declare function enableExternalSource(config: ExternalSourceConfig): void;
-export declare function _resetExternalSourceConfig(): void;

package/dist/types-cjs/core/graph.d.cts

@@ -1,28 +0,0 @@
-import type { Computed, Link, Signal } from "./types.cjs";
-export declare function unlinkSubs(link: Link): Link | null;
-export declare function trimStaleDeps(el: Computed<any>): void;
-export declare function clearDeps(el: Computed<unknown>): void;
-export declare function unobserved(el: Computed<unknown>): 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>, pendingObserver?: boolean): void;

package/dist/types-cjs/core/heap.d.cts

@@ -1,24 +0,0 @@
-import type { Computed } from "./types.cjs";
-/** 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: inserted into its own
- * (zombie-flag-routed) 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 {
-    _heap: (Computed<unknown> | undefined)[];
-    _marked: boolean;
-    _min: number;
-    _max: number;
-}
-export declare function increaseHeapSize(n: number, heap: Heap): void;
-export declare function insertIntoHeap(n: Computed<any>, heap: Heap): void;
-export declare function insertIntoHeapHeight(n: Computed<unknown>, heap: Heap): void;
-export declare function deleteFromHeap(n: Computed<unknown>, heap: Heap): void;
-export declare function markHeap(heap: Heap): void;
-export declare function markNode(el: Computed<unknown>, newState?: number): void;
-export declare function runHeap(heap: Heap, recompute: (el: Computed<unknown>) => void): void;

package/dist/types-cjs/core/index.d.cts

@@ -1,13 +0,0 @@
-export { ContextNotFoundError, NoOwnerError, NotReadyError, TimeoutError } from "./error.cjs";
-export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, installAuthoritativeRead, markRefresh, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.cjs";
-export { enableExternalSource, _resetExternalSourceConfig, type ExternalSourceFactory, type ExternalSource, type ExternalSourceConfig } from "./external.cjs";
-export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, isDisposed, cleanup, peekNextChildId } from "./owner.cjs";
-export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.cjs";
-export { handleAsync } from "./async.cjs";
-export { isPending, latest } from "./verdict.cjs";
-export type { Computed, Disposable, FirewallSignal, Link, Owner, Root, Signal, NodeOptions } from "./types.cjs";
-export { effect, trackedEffect, type Effect, type TrackedEffect } from "./effect.cjs";
-export { action } from "./action.cjs";
-export { flush, Queue, GlobalQueue, enforceLoadingBoundary, resetErrorHalt, type IQueue, type QueueCallback } from "./scheduler.cjs";
-export { DEV, type Dev, type DevHooks, type DiagnosticCapture, type DiagnosticCode, type DiagnosticEvent, type DiagnosticKind, type Diagnostics, type DiagnosticSeverity } from "./dev.cjs";
-export * from "./constants.cjs";

package/dist/types-cjs/core/invariants.d.cts

@@ -1,59 +0,0 @@
-import type { OptimisticLane } from "./lanes.cjs";
-import type { Computed, Signal } from "./types.cjs";
-/**
- * Test-mode invariant checks for the async/transition/lane machinery.
- * 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.
- *
- * They are gated on `__TEST__` (not just `__DEV__`): the per-write Set
- * tracking and per-flush quiescence sweep are too expensive for shipped dev
- * builds and for benchmarks (they showed up as a 5-21% hit across the
- * CodSpeed suite when they ran under `__DEV__`). Call sites stay `__DEV__`
- * guarded so production tree-shakes the calls; each entry point here
- * early-returns unless `__TEST__` is set, so dev builds pay only a no-op
- * call. The test suite (vitest run) defines `__TEST__: true`; benchmark mode
- * 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.
- */
-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
- * transition-scoped state may survive, and the lazily-created companions must
- * agree with a fresh computation of their owner's state.
- */
-export declare function devCheckQuiescent(isQueuedForCommit: (node: AnyNode) => boolean): void;
-export {};

package/dist/types-cjs/core/lanes.d.cts

@@ -1,54 +0,0 @@
-import { type QueueCallback, type Transition } from "./scheduler.cjs";
-import type { Computed, Signal } from "./types.cjs";
-/**
- * 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;
-/**
- * Is the lane held? `_pendingAsync` records the async the lane OWNS (derived
- * under it); the transaction's reporter map records the async a render effect
- * OBSERVED pending with no boundary taking it (INV-3, the one registration
- * site). A hold needs both — the same rule the transaction itself uses, so a
- * memo nobody renders, or one a fallback-showing boundary caught, cannot tear
- * a frame and holds nothing (#3289). An orphan lane has no observation record
- * and never holds.
- */
-export declare function laneHeld(lane: OptimisticLane): boolean;
-/**
- * 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;

package/dist/types-cjs/core/optimistic.d.cts

@@ -1,6 +0,0 @@
-/**
- * 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.
- */
-export declare function installOptimisticEngine(): void;

package/dist/types-cjs/core/owner.d.cts

@@ -1,124 +0,0 @@
-import type { Computed, Disposable, Owner, Root } from "./types.cjs";
-export declare function markDisposal(el: Owner): void;
-export declare function dispose(node: Computed<unknown>): void;
-export declare function disposeChildren(node: Owner, self?: boolean, zombie?: boolean): void;
-/**
- * Allocates and returns the next stable child id for `owner`. Used by
- * hydration plumbing and `createUniqueId`. Not part of the user-facing API.
- *
- * @internal
- */
-export declare function getNextChildId(owner: Owner): string;
-/**
- * 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).
- */
-export declare function inheritId(options: {
-    id?: string;
-} | undefined, transparent: boolean, parent: Owner | null | undefined): string | 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
- */
-export declare function peekNextChildId(owner: Owner): string;
-/**
- * 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();
- * }
- * ```
- */
-export declare function getObserver(): Owner | 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));
- * }
- * ```
- */
-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.
- */
-export declare function cleanup(fn: Disposable): 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.
- *
- * @example
- * ```ts
- * function onSettleSafe(fn: () => void) {
- *   const owner = getOwner();
- *   queueMicrotask(() => {
- *     if (owner && isDisposed(owner)) return; // component unmounted; skip
- *     runWithOwner(owner, fn);
- *   });
- * }
- * ```
- */
-export declare function isDisposed(node: Owner): boolean;
-/**
- * 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
- */
-export declare function createOwner(options?: {
-    id?: string;
-    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.
- *
- * 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
- */
-export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
-    id?: string;
-    transparent?: boolean;
-}): T;