@zeix/cause-effect 0.17.3 → 0.18.1

package/types/index.d.ts

@@ -1,19 +1,17 @@
 /**
  * @name Cause & Effect
- * @version 0.17.3
+ * @version 0.18.1
  * @author Esther Brunner
  */
-export { type Collection, type CollectionCallback, type CollectionSource, DerivedCollection, isCollection, TYPE_COLLECTION, } from './src/classes/collection';
-export { type Computed, createComputed, isComputed, isMemoCallback, isTaskCallback, Memo, type MemoCallback, Task, type TaskCallback, TYPE_COMPUTED, } from './src/classes/computed';
-export { type ArrayToRecord, isList, type KeyConfig, List, TYPE_LIST, } from './src/classes/list';
-export { isRef, Ref, TYPE_REF } from './src/classes/ref';
-export { isState, State, TYPE_STATE } from './src/classes/state';
-export { BaseStore, createStore, isStore, type Store, TYPE_STORE, } from './src/classes/store';
-export { type DiffResult, diff, isEqual, type UnknownArray, type UnknownRecord, } from './src/diff';
-export { createEffect, type EffectCallback, type MaybeCleanup, } from './src/effect';
-export { CircularDependencyError, createError, DuplicateKeyError, type Guard, guardMutableSignal, InvalidCallbackError, InvalidCollectionSourceError, InvalidSignalValueError, NullishSignalValueError, ReadonlySignalError, validateCallback, validateSignalValue, } from './src/errors';
-export { type MatchHandlers, match } from './src/match';
-export { type ResolveResult, resolve } from './src/resolve';
-export { createSignal, isMutableSignal, isSignal, type Signal, type SignalValues, type UnknownSignalRecord, } from './src/signal';
-export { batch, type Cleanup, createWatcher, flush, notifyOf, type SignalOptions, subscribeTo, track, UNSET, untrack, type Watcher, } from './src/system';
-export { isAbortError, isAsyncFunction, isFunction, isNumber, isObjectOfType, isRecord, isRecordOrArray, isString, isSymbol, valueString, } from './src/util';
+export { CircularDependencyError, type Guard, InvalidCallbackError, InvalidSignalValueError, NullishSignalValueError, RequiredOwnerError, UnsetSignalValueError, } from './src/errors';
+export { batch, type Cleanup, type ComputedOptions, createScope, type EffectCallback, type MaybeCleanup, type MemoCallback, type Signal, type SignalOptions, SKIP_EQUALITY, type TaskCallback, untrack, } from './src/graph';
+export { type Collection, type CollectionCallback, type CollectionChanges, type CollectionOptions, createCollection, type DeriveCollectionCallback, isCollection, } from './src/nodes/collection';
+export { createEffect, type MatchHandlers, type MaybePromise, match, } from './src/nodes/effect';
+export { createList, isEqual, isList, type KeyConfig, type List, type ListOptions, } from './src/nodes/list';
+export { createMemo, isMemo, type Memo } from './src/nodes/memo';
+export { createSensor, isSensor, type Sensor, type SensorCallback, type SensorOptions, } from './src/nodes/sensor';
+export { createState, isState, type State, type UpdateCallback, } from './src/nodes/state';
+export { createStore, isStore, type Store, type StoreOptions, } from './src/nodes/store';
+export { createTask, isTask, type Task } from './src/nodes/task';
+export { createComputed, createMutableSignal, createSignal, isComputed, isMutableSignal, isSignal, type MutableSignal, } from './src/signal';
+export { isAsyncFunction, isFunction, isObjectOfType, isRecord, valueString, } from './src/util';

package/types/src/errors.d.ts

@@ -1,29 +1,85 @@
-import { type MutableSignal } from './signal';
-type Guard<T> = (value: unknown) => value is T;
+/**
+ * A type guard function that validates whether an unknown value is of type T.
+ * Used to ensure type safety when updating signals.
+ *
+ * @template T - The type to guard against
+ * @param value - The value to check
+ * @returns True if the value is of type T
+ */
+type Guard<T extends {}> = (value: unknown) => value is T;
+/**
+ * Error thrown on re-entrance on an already running function.
+ */
 declare class CircularDependencyError extends Error {
+    /**
+     * Constructs a new CircularDependencyError.
+     *
+     * @param where - The location where the error occurred.
+     */
     constructor(where: string);
 }
-declare class DuplicateKeyError extends Error {
-    constructor(where: string, key: string, value?: unknown);
+/**
+ * Error thrown when a signal value is null or undefined.
+ */
+declare class NullishSignalValueError extends TypeError {
+    /**
+     * Constructs a new NullishSignalValueError.
+     *
+     * @param where - The location where the error occurred.
+     */
+    constructor(where: string);
 }
-declare class InvalidCallbackError extends TypeError {
-    constructor(where: string, value: unknown);
+/**
+ * Error thrown when a signal is read before it has a value.
+ */
+declare class UnsetSignalValueError extends Error {
+    /**
+     * Constructs a new UnsetSignalValueError.
+     *
+     * @param where - The location where the error occurred.
+     */
+    constructor(where: string);
 }
-declare class InvalidCollectionSourceError extends TypeError {
+/**
+ * Error thrown when a signal value is invalid.
+ */
+declare class InvalidSignalValueError extends TypeError {
+    /**
+     * Constructs a new InvalidSignalValueError.
+     *
+     * @param where - The location where the error occurred.
+     * @param value - The invalid value.
+     */
     constructor(where: string, value: unknown);
 }
-declare class InvalidSignalValueError extends TypeError {
+/**
+ * Error thrown when a callback is invalid.
+ */
+declare class InvalidCallbackError extends TypeError {
+    /**
+     * Constructs a new InvalidCallbackError.
+     *
+     * @param where - The location where the error occurred.
+     * @param value - The invalid value.
+     */
     constructor(where: string, value: unknown);
 }
-declare class NullishSignalValueError extends TypeError {
+/**
+ * Error thrown when an API requiring an owner is called without one.
+ */
+declare class RequiredOwnerError extends Error {
+    /**
+     * Constructs a new RequiredOwnerError.
+     *
+     * @param where - The location where the error occurred.
+     */
     constructor(where: string);
 }
-declare class ReadonlySignalError extends Error {
-    constructor(what: string, value: unknown);
+declare class DuplicateKeyError extends Error {
+    constructor(where: string, key: string, value?: unknown);
 }
-declare function assert(condition: unknown, msg?: string): asserts condition;
-declare const createError: (reason: unknown) => Error;
-declare const validateCallback: (where: string, value: unknown, guard?: (value: unknown) => boolean) => void;
-declare const validateSignalValue: (where: string, value: unknown, guard?: (value: unknown) => boolean) => void;
-declare const guardMutableSignal: <T extends {}>(what: string, value: unknown, signal: unknown) => signal is MutableSignal<T>;
-export { type Guard, CircularDependencyError, DuplicateKeyError, InvalidCallbackError, InvalidCollectionSourceError, InvalidSignalValueError, NullishSignalValueError, ReadonlySignalError, assert, createError, validateCallback, validateSignalValue, guardMutableSignal, };
+declare function validateSignalValue<T extends {}>(where: string, value: unknown, guard?: Guard<T>): asserts value is T;
+declare function validateReadValue<T extends {}>(where: string, value: T | null | undefined): asserts value is T;
+declare function validateCallback(where: string, value: unknown): asserts value is (...args: unknown[]) => unknown;
+declare function validateCallback<T>(where: string, value: unknown, guard: (value: unknown) => value is T): asserts value is T;
+export { type Guard, CircularDependencyError, NullishSignalValueError, InvalidSignalValueError, UnsetSignalValueError, InvalidCallbackError, RequiredOwnerError, DuplicateKeyError, validateSignalValue, validateReadValue, validateCallback, };

package/types/src/graph.d.ts

@@ -0,0 +1,218 @@
+import { type Guard } from './errors';
+type SourceFields<T extends {}> = {
+    value: T;
+    sinks: Edge | null;
+    sinksTail: Edge | null;
+    stop?: Cleanup;
+};
+type OptionsFields<T extends {}> = {
+    equals: (a: T, b: T) => boolean;
+    guard?: Guard<T>;
+};
+type SinkFields = {
+    fn: unknown;
+    flags: number;
+    sources: Edge | null;
+    sourcesTail: Edge | null;
+};
+type OwnerFields = {
+    cleanup: Cleanup | Cleanup[] | null;
+};
+type AsyncFields = {
+    controller: AbortController | undefined;
+    error: Error | undefined;
+};
+type StateNode<T extends {}> = SourceFields<T> & OptionsFields<T>;
+type MemoNode<T extends {}> = SourceFields<T> & OptionsFields<T> & SinkFields & {
+    fn: MemoCallback<T>;
+    error: Error | undefined;
+};
+type TaskNode<T extends {}> = SourceFields<T> & OptionsFields<T> & SinkFields & AsyncFields & {
+    fn: (prev: T, abort: AbortSignal) => Promise<T>;
+};
+type EffectNode = SinkFields & OwnerFields & {
+    fn: EffectCallback;
+};
+type Scope = OwnerFields;
+type SourceNode = SourceFields<unknown & {}>;
+type SinkNode = MemoNode<unknown & {}> | TaskNode<unknown & {}> | EffectNode;
+type OwnerNode = EffectNode | Scope;
+type Edge = {
+    source: SourceNode;
+    sink: SinkNode;
+    nextSource: Edge | null;
+    prevSink: Edge | null;
+    nextSink: Edge | null;
+};
+type Signal<T extends {}> = {
+    get(): T;
+};
+/**
+ * A cleanup function that can be called to dispose of resources.
+ */
+type Cleanup = () => void;
+type MaybeCleanup = Cleanup | undefined | void;
+/**
+ * Options for configuring signal behavior.
+ *
+ * @template T - The type of value in the signal
+ */
+type SignalOptions<T extends {}> = {
+    /**
+     * Optional type guard to validate values.
+     * If provided, will throw an error if an invalid value is set.
+     */
+    guard?: Guard<T>;
+    /**
+     * Optional custom equality function.
+     * Used to determine if a new value is different from the old value.
+     * Defaults to reference equality (===).
+     */
+    equals?: (a: T, b: T) => boolean;
+};
+type ComputedOptions<T extends {}> = SignalOptions<T> & {
+    /**
+     * Optional initial value.
+     * Useful for reducer patterns so that calculations start with a value of correct type.
+     */
+    value?: T;
+    /**
+     * Optional callback invoked when the signal is first watched by an effect.
+     * Receives an `invalidate` function that marks the signal dirty and triggers re-evaluation.
+     * Must return a cleanup function that is called when the signal is no longer watched.
+     *
+     * This enables lazy resource activation for computed signals that need to
+     * react to external events (e.g. DOM mutations, timers) in addition to
+     * tracked signal dependencies.
+     */
+    watched?: (invalidate: () => void) => Cleanup;
+};
+/**
+ * A callback function for memos that computes a value based on the previous value.
+ *
+ * @template T - The type of value computed
+ * @param prev - The previous computed value
+ * @returns The new computed value
+ */
+type MemoCallback<T extends {}> = (prev: T | undefined) => T;
+/**
+ * A callback function for tasks that asynchronously computes a value.
+ *
+ * @template T - The type of value computed
+ * @param prev - The previous computed value
+ * @param signal - An AbortSignal that will be triggered if the task is aborted
+ * @returns A promise that resolves to the new computed value
+ */
+type TaskCallback<T extends {}> = (prev: T | undefined, signal: AbortSignal) => Promise<T>;
+/**
+ * A callback function for effects that can perform side effects.
+ *
+ * @returns An optional cleanup function that will be called before the effect re-runs or is disposed
+ */
+type EffectCallback = () => MaybeCleanup;
+declare const TYPE_STATE = "State";
+declare const TYPE_MEMO = "Memo";
+declare const TYPE_TASK = "Task";
+declare const TYPE_SENSOR = "Sensor";
+declare const TYPE_LIST = "List";
+declare const TYPE_COLLECTION = "Collection";
+declare const TYPE_STORE = "Store";
+declare const FLAG_CLEAN = 0;
+declare const FLAG_DIRTY: number;
+declare let activeSink: SinkNode | null;
+declare let activeOwner: OwnerNode | null;
+declare let batchDepth: number;
+declare const DEFAULT_EQUALITY: <T extends {}>(a: T, b: T) => boolean;
+/**
+ * Equality function that always returns false, causing propagation on every update.
+ * Use with `createSensor` for observing mutable objects where the reference stays the same
+ * but internal state changes (e.g., DOM elements observed via MutationObserver).
+ *
+ * @example
+ * ```ts
+ * const el = createSensor<HTMLElement>((set) => {
+ *   const node = document.getElementById('box')!;
+ *   set(node);
+ *   const obs = new MutationObserver(() => set(node));
+ *   obs.observe(node, { attributes: true });
+ *   return () => obs.disconnect();
+ * }, { value: node, equals: SKIP_EQUALITY });
+ * ```
+ */
+declare const SKIP_EQUALITY: (_a?: unknown, _b?: unknown) => boolean;
+declare function link(source: SourceNode, sink: SinkNode): void;
+declare function unlink(edge: Edge): Edge | null;
+declare function trimSources(node: SinkNode): void;
+declare function propagate(node: SinkNode, newFlag?: number): void;
+declare function setState<T extends {}>(node: StateNode<T>, next: T): void;
+declare function registerCleanup(owner: OwnerNode, fn: Cleanup): void;
+declare function runCleanup(owner: OwnerNode): void;
+declare function runEffect(node: EffectNode): void;
+declare function refresh(node: SinkNode): void;
+declare function flush(): void;
+/**
+ * Batches multiple signal updates together.
+ * Effects will not run until the batch completes.
+ * Batches can be nested; effects run when the outermost batch completes.
+ *
+ * @param fn - The function to execute within the batch
+ *
+ * @example
+ * ```ts
+ * const count = createState(0);
+ * const double = createMemo(() => count.get() * 2);
+ *
+ * batch(() => {
+ *   count.set(1);
+ *   count.set(2);
+ *   count.set(3);
+ *   // Effects run only once at the end with count = 3
+ * });
+ * ```
+ */
+declare function batch(fn: () => void): void;
+/**
+ * Runs a callback without tracking dependencies.
+ * Any signal reads inside the callback will not create edges to the current active sink.
+ *
+ * @param fn - The function to execute without tracking
+ * @returns The return value of the function
+ *
+ * @example
+ * ```ts
+ * const count = createState(0);
+ * const label = createState('Count');
+ *
+ * createEffect(() => {
+ *   // Only re-runs when count changes, not when label changes
+ *   const name = untrack(() => label.get());
+ *   console.log(`${name}: ${count.get()}`);
+ * });
+ * ```
+ */
+declare function untrack<T>(fn: () => T): T;
+/**
+ * Creates a new ownership scope for managing cleanup of nested effects and resources.
+ * All effects created within the scope will be automatically disposed when the scope is disposed.
+ * Scopes can be nested - disposing a parent scope disposes all child scopes.
+ *
+ * @param fn - The function to execute within the scope, may return a cleanup function
+ * @returns A dispose function that cleans up the scope
+ *
+ * @example
+ * ```ts
+ * const dispose = createScope(() => {
+ *   const count = createState(0);
+ *
+ *   createEffect(() => {
+ *     console.log(count.get());
+ *   });
+ *
+ *   return () => console.log('Scope disposed');
+ * });
+ *
+ * dispose(); // Cleans up the effect and runs cleanup callbacks
+ * ```
+ */
+declare function createScope(fn: () => MaybeCleanup): Cleanup;
+export { type Cleanup, type ComputedOptions, type EffectCallback, type EffectNode, type MaybeCleanup, type MemoCallback, type MemoNode, type Scope, type Signal, type SignalOptions, type SinkNode, type StateNode, type TaskCallback, type TaskNode, activeOwner, activeSink, batch, batchDepth, createScope, DEFAULT_EQUALITY, SKIP_EQUALITY, FLAG_CLEAN, FLAG_DIRTY, flush, link, propagate, refresh, registerCleanup, runCleanup, runEffect, setState, trimSources, TYPE_COLLECTION, TYPE_LIST, TYPE_MEMO, TYPE_SENSOR, TYPE_STATE, TYPE_STORE, TYPE_TASK, unlink, untrack, };

package/types/src/nodes/collection.d.ts

@@ -0,0 +1,69 @@
+import { type Cleanup, type Signal } from '../graph';
+import { type KeyConfig, type List } from './list';
+type CollectionSource<T extends {}> = List<T> | Collection<T>;
+type DeriveCollectionCallback<T extends {}, U extends {}> = ((sourceValue: U) => T) | ((sourceValue: U, abort: AbortSignal) => Promise<T>);
+type Collection<T extends {}> = {
+    readonly [Symbol.toStringTag]: 'Collection';
+    readonly [Symbol.isConcatSpreadable]: true;
+    [Symbol.iterator](): IterableIterator<Signal<T>>;
+    keys(): IterableIterator<string>;
+    get(): T[];
+    at(index: number): Signal<T> | undefined;
+    byKey(key: string): Signal<T> | undefined;
+    keyAt(index: number): string | undefined;
+    indexOfKey(key: string): number;
+    deriveCollection<R extends {}>(callback: (sourceValue: T) => R): Collection<R>;
+    deriveCollection<R extends {}>(callback: (sourceValue: T, abort: AbortSignal) => Promise<R>): Collection<R>;
+    readonly length: number;
+};
+type CollectionChanges<T> = {
+    add?: T[];
+    change?: T[];
+    remove?: T[];
+};
+type CollectionOptions<T extends {}> = {
+    value?: T[];
+    keyConfig?: KeyConfig<T>;
+    createItem?: (value: T) => Signal<T>;
+};
+type CollectionCallback<T extends {}> = (apply: (changes: CollectionChanges<T>) => void) => Cleanup;
+/**
+ * Creates a derived Collection from a List or another Collection with item-level memoization.
+ * Sync callbacks use createMemo, async callbacks use createTask.
+ * Structural changes are tracked reactively via the source's keys.
+ *
+ * @since 0.18.0
+ * @param source - The source List or Collection to derive from
+ * @param callback - Transformation function applied to each item
+ * @returns A Collection signal
+ */
+declare function deriveCollection<T extends {}, U extends {}>(source: CollectionSource<U>, callback: (sourceValue: U) => T): Collection<T>;
+declare function deriveCollection<T extends {}, U extends {}>(source: CollectionSource<U>, callback: (sourceValue: U, abort: AbortSignal) => Promise<T>): Collection<T>;
+/**
+ * Creates an externally-driven Collection with a watched lifecycle.
+ * Items are managed via the `applyChanges(changes)` helper passed to the watched callback.
+ * The collection activates when first accessed by an effect and deactivates when no longer watched.
+ *
+ * @since 0.18.0
+ * @param watched - Callback invoked when the collection starts being watched, receives applyChanges helper
+ * @param options - Optional configuration including initial value, key generation, and item signal creation
+ * @returns A read-only Collection signal
+ */
+declare function createCollection<T extends {}>(watched: CollectionCallback<T>, options?: CollectionOptions<T>): Collection<T>;
+/**
+ * Checks if a value is a Collection signal.
+ *
+ * @since 0.17.2
+ * @param value - The value to check
+ * @returns True if the value is a Collection
+ */
+declare function isCollection<T extends {}>(value: unknown): value is Collection<T>;
+/**
+ * Checks if a value is a valid Collection source (List or Collection).
+ *
+ * @since 0.17.2
+ * @param value - The value to check
+ * @returns True if the value is a List or Collection
+ */
+declare function isCollectionSource<T extends {}>(value: unknown): value is CollectionSource<T>;
+export { createCollection, deriveCollection, isCollection, isCollectionSource, type Collection, type CollectionCallback, type CollectionChanges, type CollectionOptions, type CollectionSource, type DeriveCollectionCallback, };

package/types/src/nodes/effect.d.ts

@@ -0,0 +1,48 @@
+import { type Cleanup, type EffectCallback, type MaybeCleanup, type Signal } from '../graph';
+type MaybePromise<T> = T | Promise<T>;
+type MatchHandlers<T extends Signal<unknown & {}>[]> = {
+    ok: (values: {
+        [K in keyof T]: T[K] extends Signal<infer V> ? V : never;
+    }) => MaybePromise<MaybeCleanup>;
+    err?: (errors: readonly Error[]) => MaybePromise<MaybeCleanup>;
+    nil?: () => MaybePromise<MaybeCleanup>;
+};
+/**
+ * Creates a reactive effect that automatically runs when its dependencies change.
+ * Effects run immediately upon creation and re-run when any tracked signal changes.
+ * Effects are executed during the flush phase, after all updates have been batched.
+ *
+ * @since 0.1.0
+ * @param fn - The effect function that can track dependencies and register cleanup callbacks
+ * @returns A cleanup function that can be called to dispose of the effect
+ *
+ * @example
+ * ```ts
+ * const count = createState(0);
+ * const dispose = createEffect(() => {
+ *   console.log('Count is:', count.get());
+ * });
+ *
+ * count.set(1); // Logs: "Count is: 1"
+ * dispose(); // Stop the effect
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With cleanup
+ * createEffect(() => {
+ *   const timer = setInterval(() => console.log(count.get()), 1000);
+ *   return () => clearInterval(timer);
+ * });
+ * ```
+ */
+declare function createEffect(fn: EffectCallback): Cleanup;
+/**
+ * Runs handlers based on the current values of signals.
+ * Must be called within an active owner (effect or scope) so async cleanup can be registered.
+ *
+ * @since 0.15.0
+ * @throws RequiredOwnerError If called without an active owner.
+ */
+declare function match<T extends Signal<unknown & {}>[]>(signals: T, handlers: MatchHandlers<T>): MaybeCleanup;
+export { type MaybePromise, type MatchHandlers, createEffect, match };

package/types/src/nodes/list.d.ts

@@ -0,0 +1,66 @@
+import { type Cleanup, TYPE_LIST } from '../graph';
+import { type Collection } from './collection';
+import { type State } from './state';
+type UnknownRecord = Record<string, unknown>;
+type DiffResult = {
+    changed: boolean;
+    add: UnknownRecord;
+    change: UnknownRecord;
+    remove: UnknownRecord;
+};
+type KeyConfig<T> = string | ((item: T) => string | undefined);
+type ListOptions<T extends {}> = {
+    keyConfig?: KeyConfig<T>;
+    watched?: () => Cleanup;
+};
+type List<T extends {}> = {
+    readonly [Symbol.toStringTag]: 'List';
+    readonly [Symbol.isConcatSpreadable]: true;
+    [Symbol.iterator](): IterableIterator<State<T>>;
+    readonly length: number;
+    get(): T[];
+    set(next: T[]): void;
+    update(fn: (prev: T[]) => T[]): void;
+    at(index: number): State<T> | undefined;
+    keys(): IterableIterator<string>;
+    byKey(key: string): State<T> | undefined;
+    keyAt(index: number): string | undefined;
+    indexOfKey(key: string): number;
+    add(value: T): string;
+    remove(keyOrIndex: string | number): void;
+    sort(compareFn?: (a: T, b: T) => number): void;
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    deriveCollection<R extends {}>(callback: (sourceValue: T) => R): Collection<R>;
+    deriveCollection<R extends {}>(callback: (sourceValue: T, abort: AbortSignal) => Promise<R>): Collection<R>;
+};
+/**
+ * Checks if two values are equal with cycle detection
+ *
+ * @since 0.15.0
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @param visited - Set to track visited objects for cycle detection
+ * @returns Whether the two values are equal
+ */
+declare function isEqual<T>(a: T, b: T, visited?: WeakSet<object>): boolean;
+/** Shallow equality check for string arrays */
+declare function keysEqual(a: string[], b: string[]): boolean;
+declare function getKeyGenerator<T extends {}>(keyConfig?: KeyConfig<T>): [(item: T) => string, boolean];
+/**
+ * Creates a reactive list with stable keys and per-item reactivity.
+ *
+ * @since 0.18.0
+ * @param value - Initial array of items
+ * @param options - Optional configuration for key generation and watch lifecycle
+ * @returns A List signal
+ */
+declare function createList<T extends {}>(value: T[], options?: ListOptions<T>): List<T>;
+/**
+ * Checks if a value is a List signal.
+ *
+ * @since 0.15.0
+ * @param value - The value to check
+ * @returns True if the value is a List
+ */
+declare function isList<T extends {}>(value: unknown): value is List<T>;
+export { type DiffResult, type KeyConfig, type List, type ListOptions, type UnknownRecord, createList, isEqual, isList, getKeyGenerator, keysEqual, TYPE_LIST, };

package/types/src/nodes/memo.d.ts

@@ -0,0 +1,63 @@
+import { type ComputedOptions, type MemoCallback } from '../graph';
+/**
+ * A derived reactive computation that caches its result.
+ * Automatically tracks dependencies and recomputes when they change.
+ *
+ * @template T - The type of value computed by the memo
+ */
+type Memo<T extends {}> = {
+    readonly [Symbol.toStringTag]: 'Memo';
+    /**
+     * Gets the current value of the memo.
+     * Recomputes if dependencies have changed since last access.
+     * When called inside another reactive context, creates a dependency.
+     * @returns The computed value
+     * @throws UnsetSignalValueError If the memo value is still unset when read.
+     */
+    get(): T;
+};
+/**
+ * Creates a derived reactive computation that caches its result.
+ * The computation automatically tracks dependencies and recomputes when they change.
+ * Uses lazy evaluation - only computes when the value is accessed.
+ *
+ * @since 0.18.0
+ * @template T - The type of value computed by the memo
+ * @param fn - The computation function that receives the previous value
+ * @param options - Optional configuration for the memo
+ * @param options.value - Optional initial value for reducer patterns
+ * @param options.equals - Optional equality function. Defaults to strict equality (`===`)
+ * @param options.guard - Optional type guard to validate values
+ * @param options.watched - Optional callback invoked when the memo is first watched by an effect.
+ *   Receives an `invalidate` function to mark the memo dirty and trigger recomputation.
+ *   Must return a cleanup function called when no effects are watching.
+ * @returns A Memo object with a get() method
+ *
+ * @example
+ * ```ts
+ * const count = createState(0);
+ * const doubled = createMemo(() => count.get() * 2);
+ * console.log(doubled.get()); // 0
+ * count.set(5);
+ * console.log(doubled.get()); // 10
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Using previous value
+ * const sum = createMemo((prev) => prev + count.get(), { value: 0, equals: Object.is });
+ * ```
+ */
+declare function createMemo<T extends {}>(fn: (prev: T) => T, options: ComputedOptions<T> & {
+    value: T;
+}): Memo<T>;
+declare function createMemo<T extends {}>(fn: MemoCallback<T>, options?: ComputedOptions<T>): Memo<T>;
+/**
+ * Checks if a value is a Memo signal.
+ *
+ * @since 0.18.0
+ * @param value - The value to check
+ * @returns True if the value is a Memo
+ */
+declare function isMemo<T extends {} = unknown & {}>(value: unknown): value is Memo<T>;
+export { createMemo, isMemo, type Memo };