@solidjs/signals 0.13.12 → 2.0.0-beta.7

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

@@ -1,3 +1,4 @@
 import type { Computed, Link, Signal } from "./types.js";
 export declare function unlinkSubs(link: Link): Link | null;
+export declare function unobserved(el: Computed<unknown>): void;
 export declare function link(dep: Signal<any> | Computed<any>, sub: Computed<any>): void;

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

@@ -16,7 +16,7 @@ export interface NodeOptions<T> {
     name?: string;
     transparent?: boolean;
     equals?: ((prev: T, next: T) => boolean) | false;
-    pureWrite?: boolean;
+    ownedWrite?: boolean;
     /** Exclude this signal from snapshot capture (internal — not part of public API) */
     _noSnapshot?: boolean;
     unobserved?: () => void;
@@ -29,7 +29,7 @@ export interface RawSignal<T> {
     _snapshotValue?: any;
     _name?: string;
     _equals: false | ((a: T, b: T) => boolean);
-    _pureWrite?: boolean;
+    _ownedWrite?: boolean;
     _noSnapshot?: boolean;
     _unobserved?: () => void;
     _time: number;

package/dist/types/signals.d.ts

@@ -29,7 +29,7 @@ export interface SignalOptions<T> {
     /** Custom equality function, or `false` to always notify subscribers */
     equals?: false | ((prev: T, next: T) => boolean);
     /** Suppress dev-mode warnings when writing inside an owned scope */
-    pureWrite?: boolean;
+    ownedWrite?: boolean;
     /** Callback invoked when the signal loses all subscribers */
     unobserved?: () => void;
 }
@@ -56,7 +56,7 @@ export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
 /**
  * Creates a simple reactive state with a getter and setter.
  *
- * When called with a plain value, creates a signal with `SignalOptions` (name, equals, pureWrite, unobserved).
+ * When called with a plain value, creates a signal with `SignalOptions` (name, equals, ownedWrite, unobserved).
  * When called with a function, creates a writable memo with `SignalOptions & MemoOptions` (adds id, lazy).
  *
  * ```typescript
@@ -74,52 +74,46 @@ export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
  */
 export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createSignal<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
+export declare function createSignal<T>(fn: ComputeFunction<T>, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
 /**
  * Creates a readonly derived reactive memoized signal.
  *
  * ```typescript
- * const value = createMemo<T>(compute, initialValue?, options?: MemoOptions<T>);
+ * const value = createMemo<T>(compute, options?: MemoOptions<T>);
  * ```
- * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
- * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
+ * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param options `MemoOptions` -- id, name, equals, unobserved, lazy
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
  */
-export declare function createMemo<Next extends Prev, Prev = Next>(compute: ComputeFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
-export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(compute: ComputeFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
+export declare function createMemo<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, options?: MemoOptions<T>): Accessor<T>;
 /**
  * Creates a reactive effect that runs after the render phase.
  *
  * ```typescript
- * createEffect<T>(compute, effectFn | { effect, error }, initialValue?, options?: EffectOptions);
+ * createEffect<T>(compute, effectFn | { effect, error }, options?: EffectOptions);
  * ```
- * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param effectFn a function that receives the new value and is used to perform side effects (return a cleanup function), or an `EffectBundle` with `effect` and `error` handlers
- * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
  * @param options `EffectOptions` -- name, defer
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
  */
-export declare function createEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next> | EffectBundle<NoInfer<Next>, Next>): void;
-export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next> | EffectBundle<Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T> | EffectBundle<NoInfer<T>, T>, options?: EffectOptions): void;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements
  * are created and updated but not necessarily connected.
  *
  * ```typescript
- * createRenderEffect<T>(compute, effectFn, initialValue?, options?: EffectOptions);
+ * createRenderEffect<T>(compute, effectFn, options?: EffectOptions);
  * ```
- * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
+ * @param compute a function that receives its previous value and returns a new value used to react on a computation
  * @param effectFn a function that receives the new value and is used to perform side effects
- * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
  * @param options `EffectOptions` -- name, defer
  *
  * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
  */
-export declare function createRenderEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effectFn: EffectFunction<NoInfer<Next>, Next>): void;
-export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effectFn: EffectFunction<Next, Next>, value: Init, options?: EffectOptions): void;
+export declare function createRenderEffect<T>(compute: ComputeFunction<undefined | NoInfer<T>, T>, effectFn: EffectFunction<NoInfer<T>, T>, options?: EffectOptions): void;
 /**
  * Creates a tracked reactive effect where dependency tracking and side effects happen
  * in the same scope.
@@ -159,14 +153,14 @@ export declare function resolve<T>(fn: () => T): Promise<T>;
  * Creates an optimistic signal that can be used to optimistically update a value
  * and then revert it back to the previous value at end of transition.
  *
- * When called with a plain value, creates an optimistic signal with `SignalOptions` (name, equals, pureWrite, unobserved).
+ * When called with a plain value, creates an optimistic signal with `SignalOptions` (name, equals, ownedWrite, unobserved).
  * When called with a function, creates a writable optimistic memo with `SignalOptions & MemoOptions` (adds id, lazy).
  *
  * ```typescript
  * // Plain optimistic signal
  * const [state, setState] = createOptimistic<T>(value, options?: SignalOptions<T>);
  * // Writable optimistic memo (function overload)
- * const [state, setState] = createOptimistic<T>(fn, initialValue?, options?: SignalOptions<T> & MemoOptions<T>);
+ * const [state, setState] = createOptimistic<T>(fn, options?: SignalOptions<T> & MemoOptions<T>);
  * ```
  * @param value initial value of the signal; if empty, the signal's type will automatically extended with undefined
  * @param options optional object with a name for debugging purposes and equals, a comparator function for the previous and next value to allow fine-grained control over the reactivity
@@ -177,7 +171,7 @@ export declare function resolve<T>(fn: () => T): Promise<T>;
  */
 export declare function createOptimistic<T>(): Signal<T | undefined>;
 export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createOptimistic<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
+export declare function createOptimistic<T>(fn: ComputeFunction<T>, options?: SignalOptions<T> & MemoOptions<T>): Signal<T>;
 /**
  * Runs a callback after the current flush cycle completes.
  *

package/dist/types/store/optimistic.d.ts

@@ -8,12 +8,12 @@ import { type NoFn, type ProjectionOptions, type Store, type StoreSetter } from
  * When called with a function, creates a derived optimistic store with `ProjectionOptions` (name, key, all).
  *
  * @param fn a function that receives the current store and can be used to mutate it directly inside a transition
- * @param initial The initial value of the store.
+ * @param store The plain store value, or the backing seed when using the derived-store form.
  * @param options Optional projection options for reconciliation.
  *
  * @returns A tuple containing a store accessor and a setter function to apply changes.
  */
 export declare function createOptimisticStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
-export declare function createOptimisticStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
+export declare function createOptimisticStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
     [$REFRESH]: any;
 }, set: StoreSetter<T>];

package/dist/types/store/projection.d.ts

@@ -1,6 +1,6 @@
 import { $REFRESH, type Computed } from "../core/index.js";
 import { type ProjectionOptions, type Store } from "./store.js";
-export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: ProjectionOptions): {
+export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): {
     store: Store<T> & {
         [$REFRESH]: any;
     };
@@ -11,15 +11,15 @@ export declare function createProjectionInternal<T extends object = {}>(fn: (dra
  * draft and can mutate it directly or return a new value for reconciliation.
  *
  * ```typescript
- * const store = createProjection<T>(fn, initialValue?, options?: ProjectionOptions);
+ * const store = createProjection<T>(fn, seed, options?: ProjectionOptions);
  * ```
  * @param fn a function that receives the current draft and mutates it or returns new data
- * @param initialValue the initial store value (defaults to `{}`)
+ * @param seed the backing store host value to wrap and reconcile into
  * @param options `ProjectionOptions` -- name, key, all
  *
  * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
  */
-export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: ProjectionOptions): Store<T> & {
+export declare function createProjection<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, seed: Partial<T>, options?: ProjectionOptions): Store<T> & {
     [$REFRESH]: any;
 };
 export declare function createWriteTraps(isActive?: () => boolean): ProxyHandler<any>;

package/dist/types/store/store.d.ts

@@ -54,7 +54,7 @@ export declare function storeSetter<T extends object>(store: Store<T>, fn: (draf
  * // Plain store
  * const [store, setStore] = createStore<T>(initialValue);
  * // Derived store (projection)
- * const [store, setStore] = createStore<T>(fn, initialValue?, options?: ProjectionOptions);
+ * const [store, setStore] = createStore<T>(fn, seed, options?: ProjectionOptions);
  * ```
  * @param store initial value to wrap in a reactive proxy, or a derive function
  * @param options `ProjectionOptions` -- name, key, all (only for derived stores)
@@ -62,7 +62,7 @@ export declare function storeSetter<T extends object>(store: Store<T>, fn: (draf
  * @returns `[store: Store<T>, setStore: StoreSetter<T>]`
  */
 export declare function createStore<T extends object = {}>(store: NoFn<T> | Store<NoFn<T>>): [get: Store<T>, set: StoreSetter<T>];
-export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
+export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: Partial<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
     [$REFRESH]: any;
 }, set: StoreSetter<T>];
 export {};

package/dist/types-cjs/boundaries.d.cts

@@ -0,0 +1,52 @@
+import { Queue, type Computed, type Effect } from "./core/index.cjs";
+import type { Signal } from "./core/index.cjs";
+export interface BoundaryComputed<T> extends Computed<T> {
+    _propagationMask: number;
+}
+type RevealSlot = CollectionQueue | RevealController;
+type BoolAccessor = () => boolean;
+export declare class RevealController {
+    _togetherAccessor: BoolAccessor;
+    _collapsedAccessor: BoolAccessor;
+    _slots: RevealSlot[];
+    _parentController?: RevealController;
+    _disabled: Signal<boolean>;
+    _collapsed: Signal<boolean>;
+    _ready: boolean;
+    _evaluating: boolean;
+    constructor(together: BoolAccessor, collapsed: BoolAccessor);
+    _forEachOwnedSlot(fn: (slot: RevealSlot) => boolean | void): boolean;
+    isReady(): boolean;
+    register(slot: RevealSlot): void;
+    unregister(slot: RevealSlot): void;
+    evaluate(disabledOverride?: boolean, collapsedOverride?: boolean): void;
+}
+export declare class CollectionQueue extends Queue {
+    _collectionType: number;
+    _sources: Set<Computed<any>>;
+    _tree?: BoundaryComputed<any>;
+    _pending: boolean;
+    _disabled: Signal<boolean>;
+    _collapsed: Signal<boolean>;
+    _revealController?: RevealController;
+    _initialized: boolean;
+    _onFn: (() => any) | undefined;
+    _prevOn: any;
+    constructor(type: number);
+    run(type: number): void;
+    notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
+    checkSources(): void;
+}
+export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
+    on?: () => any;
+}): import("./signals.cjs").Accessor<unknown>;
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.cjs").Accessor<unknown>;
+export declare function createRevealOrder<T>(fn: () => T, options?: {
+    together?: BoolAccessor;
+    collapsed?: BoolAccessor;
+}): T;
+export declare function flatten(children: any, options?: {
+    skipNonRendered?: boolean;
+    doNotUnwrap?: boolean;
+}): any;
+export {};

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

@@ -0,0 +1 @@
+export declare function action<Args extends any[], Y, R>(genFn: (...args: Args) => Generator<Y, R, any> | AsyncGenerator<Y, R, any>): (...args: Args) => Promise<R>;

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

@@ -0,0 +1,6 @@
+import { type OptimisticLane } from "./lanes.cjs";
+import type { Computed } from "./types.cjs";
+export declare function settlePendingSource(el: Computed<any>): void;
+export declare function handleAsync<T>(el: Computed<T>, result: T | PromiseLike<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
+export declare function clearStatus(el: Computed<any>, clearUninitialized?: boolean): void;
+export declare function notifyStatus(el: Computed<any>, status: number, error: any, blockStatus?: boolean, lane?: OptimisticLane): void;

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

@@ -0,0 +1,25 @@
+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 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: {};
+export declare const $REFRESH: unique symbol;

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

@@ -0,0 +1,28 @@
+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>;
+/**
+ * Attempts to get a context value for the given key.
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ * @throws `ContextNotFoundError` if a context value has not been set yet.
+ */
+export declare function getContext<T>(context: Context<T>, owner?: Owner | null): T;
+/**
+ * Attempts to set a context value on the parent scope with the given key.
+ *
+ * @throws `NoOwnerError` if there's no owner at the time of call.
+ */
+export declare function setContext<T>(context: Context<T>, value?: T, owner?: Owner | null): void;

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

@@ -0,0 +1,54 @@
+import { $REFRESH } from "./constants.cjs";
+import { type OptimisticLane } from "./lanes.cjs";
+import type { Computed, FirewallSignal, NodeOptions, Owner, Signal } from "./types.cjs";
+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>, initialValue?: T, options?: NodeOptions<T>): Computed<T>;
+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>, initialValue?: 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;
+/**
+ * Executes `fn` without tracking reactive dependencies.
+ *
+ * Pass a `strictReadLabel` string to enable strict-read warnings: any reactive read inside `fn`
+ * that is not inside a nested tracking scope will log a warning in dev mode.
+ */
+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;
+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;
+export declare function latest<T>(fn: () => T): T;
+export declare function isPending(fn: () => any): boolean;
+export declare function refresh<T>(fn: (() => T) | (T & {
+    [$REFRESH]: any;
+})): T;
+export declare function isRefreshing(): boolean;

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

@@ -0,0 +1,49 @@
+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" | "NO_OWNER_EFFECT" | "NO_OWNER_BOUNDARY" | "ASYNC_OUTSIDE_LOADING_BOUNDARY";
+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/core/effect.d.cts

@@ -0,0 +1,30 @@
+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;
+    _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), initialValue?: T, options?: NodeOptions<any> & {
+    render?: boolean;
+    defer?: 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/core/error.d.cts

@@ -0,0 +1,14 @@
+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/core/external.d.cts

@@ -0,0 +1,26 @@
+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.
+ */
+export declare function enableExternalSource(config: ExternalSourceConfig): void;
+export declare function _resetExternalSourceConfig(): void;

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

@@ -0,0 +1,4 @@
+import type { Computed, Link, Signal } from "./types.cjs";
+export declare function unlinkSubs(link: Link): Link | null;
+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/core/heap.d.cts

@@ -0,0 +1,14 @@
+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/core/index.d.cts

@@ -0,0 +1,12 @@
+export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.cjs";
+export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, 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/core/lanes.d.cts

@@ -0,0 +1,54 @@
+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/core/owner.d.cts

@@ -0,0 +1,26 @@
+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;
+export declare function getNextChildId(owner: Owner): string;
+export declare function peekNextChildId(owner: Owner): string;
+export declare function getObserver(): Owner | null;
+export declare function getOwner(): Owner | null;
+export declare function cleanup(fn: Disposable): Disposable;
+export declare function isDisposed(node: Owner): boolean;
+export declare function createOwner(options?: {
+    id?: string;
+    transparent?: boolean;
+}): Root;
+/**
+ * Creates a new non-tracked reactive context with manual disposal
+ *
+ * @param fn a function in which the reactive state is scoped
+ * @returns the output of `fn`.
+ *
+ * @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;