@solidjs/signals 2.0.0-beta.14 → 2.0.0-beta.16

package/dist/types-cjs/src/core/constants.d.cts

@@ -1,51 +0,0 @@
-export declare const REACTIVE_NONE = 0;
-export declare const REACTIVE_CHECK: number;
-export declare const REACTIVE_DIRTY: number;
-export declare const REACTIVE_RECOMPUTING_DEPS: number;
-export declare const REACTIVE_IN_HEAP: number;
-export declare const REACTIVE_IN_HEAP_HEIGHT: number;
-export declare const REACTIVE_ZOMBIE: number;
-export declare const REACTIVE_DISPOSED: number;
-export declare const REACTIVE_OPTIMISTIC_DIRTY: number;
-export declare const REACTIVE_SNAPSHOT_STALE: number;
-export declare const REACTIVE_LAZY: number;
-export declare const REACTIVE_MANUAL_WRITE: number;
-export declare const CONFIG_OWNED_WRITE: number;
-export declare const CONFIG_NO_SNAPSHOT: number;
-export declare const CONFIG_TRANSPARENT: number;
-export declare const CONFIG_IN_SNAPSHOT_SCOPE: number;
-export declare const CONFIG_CHILDREN_FORBIDDEN: number;
-export declare const CONFIG_AUTO_DISPOSE: number;
-export declare const CONFIG_SYNC: number;
-export declare const STATUS_NONE = 0;
-export declare const STATUS_PENDING: number;
-export declare const STATUS_ERROR: number;
-export declare const STATUS_UNINITIALIZED: number;
-export declare const EFFECT_PURE = 0;
-export declare const EFFECT_RENDER = 1;
-export declare const EFFECT_USER = 2;
-export declare const EFFECT_TRACKED = 3;
-export declare const NOT_PENDING: {};
-export declare const NO_SNAPSHOT: {};
-export declare const STORE_SNAPSHOT_PROPS = "sp";
-export declare const SUPPORTS_PROXY: boolean;
-export declare const defaultContext: {};
-/**
- * Brand symbol used by `Refreshable<T>` values (projection stores, async
- * memos) to expose their underlying computation to `refresh()`. Not part of
- * the user-facing API.
- *
- * @internal
- */
-export declare const $REFRESH: unique symbol;
-/**
- * Brand applied to values that participate in the `refresh()` re-run protocol.
- * Accessors receive this handle internally; projected stores expose it through
- * their public return type so user-defined hooks that wrap `createOptimisticStore`
- * / `createProjection` / projection-form `createStore` can have their return
- * types inferred without leaking the internal `$REFRESH` symbol into public type
- * signatures (TS4058).
- */
-export type Refreshable<T> = T & {
-    readonly [$REFRESH]: any;
-};

package/dist/types-cjs/src/core/context.d.cts

@@ -1,36 +0,0 @@
-import type { Owner } from "./types.cjs";
-export interface Context<T> {
-    readonly id: symbol;
-    readonly defaultValue: T | undefined;
-}
-export type ContextRecord = Record<string | symbol, unknown>;
-/**
- * Context provides a form of dependency injection. It is used to save from needing to pass
- * data as props through intermediate components. This function creates a new context object
- * that can be used with `getContext` and `setContext`.
- *
- * A default value can be provided here which will be used when a specific value is not provided
- * via a `setContext` call.
- */
-export declare function createContext<T>(defaultValue?: T, description?: string): Context<T>;
-/**
- * Low-level owner-targeted context read. The user-facing read API is
- * `useContext` (in `solid-js`), which wraps this primitive. Exposed here for
- * cross-package wiring (e.g. hydration-aware context plumbing).
- *
- * @throws `NoOwnerError` if there's no owner at the time of call.
- * @throws `ContextNotFoundError` if a context value has not been set yet.
- *
- * @internal
- */
-export declare function getContext<T>(context: Context<T>, owner?: Owner | null): T;
-/**
- * Low-level owner-targeted context write. The user-facing API is
- * `createContext` (in `solid-js`); its provider component wraps this
- * primitive. Exposed here for cross-package wiring.
- *
- * @throws `NoOwnerError` if there's no owner at the time of call.
- *
- * @internal
- */
-export declare function setContext<T>(context: Context<T>, value?: T, owner?: Owner | null): void;

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

@@ -1,174 +0,0 @@
-import { type Refreshable } from "./constants.cjs";
-import { type OptimisticLane } from "./lanes.cjs";
-import type { Computed, FirewallSignal, NodeOptions, Owner, Signal } from "./types.cjs";
-export declare const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE = "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
-export declare let tracking: boolean;
-export declare let stale: boolean;
-export declare let refreshing: boolean;
-export declare let pendingCheckActive: boolean;
-export declare let foundPending: boolean;
-export declare let latestReadActive: boolean;
-export declare let context: Owner | null;
-export declare let currentOptimisticLane: OptimisticLane | null;
-export declare let snapshotCaptureActive: boolean;
-export declare let snapshotSources: Set<any> | null;
-export declare function setSnapshotCapture(active: boolean): void;
-export declare function markSnapshotScope(owner: Owner): void;
-export declare function releaseSnapshotScope(owner: Owner): void;
-export declare function clearSnapshots(): void;
-export declare function recompute(el: Computed<any>, create?: boolean): void;
-export declare function computed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>): Computed<T>;
-export declare function computed<T>(fn: (prev: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
-/**
- * Build an Effect node with all effect-specific fields baked into a single object literal,
- * so V8 sees the full hidden class shape at construction time. Effects always run in lazy
- * mode (recompute is called explicitly by `effect()`), so we hardcode the lazy bits and skip
- * the auto-dispose CONFIG bit (effect() previously cleared it post-construction).
- */
-export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val: T, prev: T | undefined) => void | (() => void), errorFn: ((err: unknown, cleanup: () => void) => void | (() => void)) | undefined, type: number, notifyStatus: ((status?: number, error?: any) => void) | undefined, options: NodeOptions<T> | undefined): any;
-export declare function signal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
-export declare function signal<T>(v: T, options?: NodeOptions<T>, firewall?: Computed<any>): FirewallSignal<T>;
-export declare function optimisticSignal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
-export declare function optimisticComputed<T>(fn: (prev?: T) => T | PromiseLike<T> | AsyncIterable<T>, options?: NodeOptions<T>): Computed<T>;
-export declare function isEqual<T>(a: T, b: T): boolean;
-/**
- * When set to a component name string, any reactive read that is not inside a nested tracking
- * scope will log a dev-mode warning. Managed automatically by `untrack(fn, strictReadLabel)`.
- */
-export declare let strictRead: string | false;
-export declare function setStrictRead(v: string | false): string | false;
-/**
- * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
- * subscribe the current scope. Returns whatever `fn` returns.
- *
- * Use `untrack` inside a memo or effect when you need to read a signal once
- * without making the surrounding computation depend on its future changes.
- *
- * Pass a `strictReadLabel` string to enable a dev-mode warning: any reactive
- * read inside `fn` that isn't inside a nested tracking scope will log a
- * warning naming the label.
- *
- * @example
- * ```ts
- * createEffect(
- *   () => trigger(),                 // tracks `trigger` only
- *   () => {
- *     const snapshot = untrack(() => state); // read once, untracked
- *     log(snapshot);
- *   }
- * );
- * ```
- */
-export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false): T;
-export declare function read<T>(el: Signal<T> | Computed<T>): T;
-export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
-/**
- * Suppresses automatic recomputation of `el` until the scheduler drains. Used
- * when a manual write should win over dependency changes queued in the same
- * tick. The MANUAL_WRITE flag is cleared by the pending-node drain; projection
- * computeds don't commit values, but they still need the same end-of-tick
- * cleanup point.
- */
-export declare function suppressComputedRecompute(el: Computed<unknown>): void;
-/**
- * User-facing setter for the memo form of `createSignal(fn)`. Behaves like
- * `setSignal`, but also cancels any pending recompute of the memo so the
- * manual value wins over a value that would otherwise be produced by an
- * upstream change in the same tick.
- */
-export declare function setMemo<T>(el: Computed<T>, v: T | ((prev: T) => T)): T;
-/**
- * Executes `fn` with the given `owner` set as the current owner. Any reactive
- * primitives (`createSignal`, `createMemo`, `createEffect`, `onCleanup`,
- * `cleanup`, etc.) created inside `fn` are attached to that owner, so they
- * are disposed when the owner is disposed.
- *
- * The classic pattern: capture the current owner with `getOwner()` inside a
- * component, then re-enter it from a callback (event handler, async resolve,
- * setTimeout) so disposables created in the callback get cleaned up with the
- * component.
- *
- * @example
- * ```ts
- * function delayed<T>(ms: number, fn: () => T) {
- *   const owner = getOwner();
- *   setTimeout(() => runWithOwner(owner, fn), ms);
- * }
- * ```
- */
-export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
-/**
- * Update _pendingSignal when pending state changes. When the override clears
- * (pending -> not pending), merge the sub-lane into the source's lane so
- * isPending effects are blocked until the full scope resolves.
- */
-export declare function updatePendingSignal(el: Signal<any> | Computed<any>): void;
-export declare function staleValues<T>(fn: () => T, set?: boolean): T;
-/**
- * Reads reactive expressions while bypassing any pending async overlay — i.e.
- * always returns the most-recently-committed value, even when newer reads
- * inside `fn` are still in flight.
- *
- * Useful inside a `<Loading>` boundary's children when you want to keep
- * showing the previous resolved data instead of the fallback while the next
- * value loads.
- *
- * @example
- * ```tsx
- * <Loading fallback={<Skeleton />}>
- *   {/* During a transition, render the previous user instead of skeleton: *\/}
- *   <UserCard user={latest(() => user())} />
- * </Loading>
- * ```
- */
-export declare function latest<T>(fn: () => T): T;
-/**
- * Returns `true` if any reactive read inside `fn` is currently in a pending
- * (async, not-yet-settled) state. Does not subscribe — pair with a tracked
- * memo if you want to react to pending status changes.
- *
- * Useful for showing inline transition indicators alongside the previous
- * value (rather than swapping to a `<Loading>` fallback).
- *
- * @example
- * ```tsx
- * const pending = createMemo(() => isPending(() => user()));
- *
- * <button disabled={pending()}>{pending() ? "Saving…" : "Save"}</button>
- * ```
- */
-export declare function isPending(fn: () => any): boolean;
-/**
- * Invalidates one reactive source, forcing it to re-execute even if its inputs
- * haven't changed.
- *
- * Pass either a Solid-created accessor or a projected store created from
- * `createStore(fn, ...)` / `createProjection(...)`. `refresh()` is a
- * write-like invalidation operation: it does not read the target's value, and
- * refreshing a plain signal accessor is a no-op.
- *
- * Use it to invalidate cached async values (e.g. force a re-fetch) without
- * tearing the consumer down.
- *
- * @example
- * ```ts
- * const user = createMemo(async () => fetch(`/users/${id()}`).then(r => r.json()));
- *
- * // Re-fetch on demand
- * <button onClick={() => refresh(user)}>Reload</button>
- * ```
- */
-export declare function refresh<T>(target: Refreshable<T>): void;
-/**
- * Returns `true` while a `refresh()` call is in progress. Useful for showing
- * a "refreshing" indicator distinct from the initial-load `<Loading>`
- * fallback.
- *
- * @example
- * ```tsx
- * <Show when={isRefreshing()}>
- *   <span class="badge">refreshing…</span>
- * </Show>
- * ```
- */
-export declare function isRefreshing(): boolean;

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

@@ -1,49 +0,0 @@
-import type { Computed, 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;
-}
-export type DiagnosticSeverity = "warn" | "error";
-export type DiagnosticCode = "STRICT_READ_UNTRACKED" | "PENDING_ASYNC_UNTRACKED_READ" | "PENDING_ASYNC_FORBIDDEN_SCOPE" | "SIGNAL_WRITE_IN_OWNED_SCOPE" | "RUN_WITH_DISPOSED_OWNER" | "NO_OWNER_CLEANUP" | "CLEANUP_IN_FORBIDDEN_SCOPE" | "PRIMITIVE_IN_FORBIDDEN_SCOPE" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY" | "INVALID_REFRESH_TARGET" | "MISSING_EFFECT_FN" | "SYNC_NODE_RECEIVED_ASYNC";
-export type DiagnosticKind = "strict-read" | "async" | "write" | "lifecycle" | "owner";
-export interface DiagnosticEvent {
-    sequence: number;
-    code: DiagnosticCode;
-    kind: DiagnosticKind;
-    severity: DiagnosticSeverity;
-    message: string;
-    ownerId?: string;
-    ownerName?: string;
-    nodeName?: 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;
-}
-export interface Dev {
-    hooks: DevHooks;
-    diagnostics: Diagnostics;
-    getChildren: typeof getChildren;
-    getSignals: typeof getSignals;
-    getParent: typeof getParent;
-    getSources: typeof getSources;
-    getObservers: typeof getObservers;
-}
-export declare const DEV: Dev;
-export declare function emitDiagnostic(event: Omit<DiagnosticEvent, "sequence">): DiagnosticEvent;
-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>[];

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

@@ -1,32 +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;
-    _cleanup?: () => void;
-    _cleanupRegistered?: boolean;
-    _modified: boolean;
-    _prevValue: T | undefined;
-    _type: number;
-}
-/**
- * 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> {
-    _cleanup?: () => 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/src/core/error.d.cts

@@ -1,38 +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 {
-    source: any;
-    constructor(source: any);
-}
-export declare class StatusError extends Error {
-    source: any;
-    constructor(source: any, original: any);
-}
-export declare class NoOwnerError extends Error {
-    constructor();
-}
-export declare class ContextNotFoundError extends Error {
-    constructor();
-}

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

@@ -1,45 +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;
-/**
- * Registers a factory that bridges external reactive systems (e.g. MobX, Vue refs)
- * into Solid's tracking graph. Every computation will be wrapped so that the
- * external library can track its own dependencies alongside Solid's.
- *
- * Multiple calls pipe together: each new factory wraps the previous one.
- *
- * @param config.factory receives `(fn, trigger)` — wrap fn execution in external tracking,
- *   call trigger when external deps change. Return `{ track, dispose }`.
- * @param config.untrack optional wrapper for `untrack` — disables external tracking too.
- *
- * @example
- * ```ts
- * // Bridge an external "subscribe / notify" library into Solid's graph.
- * // `factory` wraps every Solid compute so the external library can attach
- * // its own dependency tracker; `trigger` re-runs the compute on external
- * // change. `untrack` mirrors Solid's `untrack()` into the external library
- * // so that reads inside `untrack(...)` don't get tracked twice.
- * enableExternalSource({
- *   factory: (compute, trigger) => {
- *     const sub = externalLib.subscribe(trigger);
- *     return {
- *       track: prev => externalLib.run(() => compute(prev)),
- *       dispose: () => sub.unsubscribe()
- *     };
- *   },
- *   untrack: fn => externalLib.untracked(fn)
- * });
- * ```
- */
-export declare function enableExternalSource(config: ExternalSourceConfig): void;
-export declare function _resetExternalSourceConfig(): void;

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

@@ -1,5 +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 unobserved(el: Computed<unknown>): void;
-export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;

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

@@ -1,14 +0,0 @@
-import type { Computed } from "./types.cjs";
-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/src/core/index.d.cts

@@ -1,12 +0,0 @@
-export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.cjs";
-export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, setMemo, suppressComputedRecompute, optimisticSignal, optimisticComputed, isPending, latest, refresh, isRefreshing, 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 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, trackOptimisticStore, enforceLoadingBoundary, 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/src/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;
-/**
- * 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: {
-    _optimisticLane?: OptimisticLane;
-}): OptimisticLane | undefined;
-export declare function resolveTransition(el: {
-    _optimisticLane?: OptimisticLane;
-    _transition?: Transition | null;
-}): Transition | null | undefined;
-/**
- * Check if a node has an active optimistic override.
- */
-export declare function hasActiveOverride(el: {
-    _overrideValue?: 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: {
-    _optimisticLane?: OptimisticLane;
-    _overrideValue?: any;
-}, sourceLane: OptimisticLane): void;

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

@@ -1,116 +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;
-/**
- * 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;