mutts 1.0.6 → 1.0.8

package/dist/reactive.d.ts

@@ -1,910 +0,0 @@
-import { LegacyPropertyDecorator, ModernMethodDecorator, LegacyClassDecorator, ModernClassDecorator, GenericClassDecorator, ModernGetterDecorator, ModernAccessorDecorator } from './decorator.js';
-import { ArrayReadForward, forwardArray, getAt, setAt } from './indexable.js';
-
-/**
- * Function type for dependency tracking in effects
- * Restores the active effect context for dependency tracking
- */
-type DependencyFunction = <T>(cb: () => T) => T;
-/**
- * Dependency access passed to user callbacks within effects/watch
- * Provides functions to track dependencies and information about the effect execution
- */
-interface DependencyAccess {
-    /**
-     * Tracks dependencies in the current effect context
-     * Use this for normal dependency tracking within the effect
-     * @example
-     * ```typescript
-     * effect(({ tracked }) => {
-     *   // In async context, use tracked to restore dependency tracking
-     *   await someAsyncOperation()
-     *   const value = tracked(() => state.count) // Tracks state.count in this effect
-     * })
-     * ```
-     */
-    tracked: DependencyFunction;
-    /**
-     * Tracks dependencies in the parent effect context
-     * Use this when child effects should track dependencies in the parent,
-     * allowing parent cleanup to manage child effects while dependencies trigger the parent
-     * @example
-     * ```typescript
-     * effect(({ ascend }) => {
-     *   const length = inputs.length
-     *   if (length > 0) {
-     *     ascend(() => {
-     *       // Dependencies here are tracked in the parent effect
-     *       inputs.forEach(item => console.log(item))
-     *     })
-     *   }
-     * })
-     * ```
-     */
-    ascend: DependencyFunction;
-    /**
-     * Indicates whether the effect is running as a reaction (i.e. not the first call)
-     * - `false`: First execution when the effect is created
-     * - `true`: Subsequent executions triggered by dependency changes
-     * @example
-     * ```typescript
-     * effect(({ reaction }) => {
-     *   if (!reaction) {
-     *     console.log('Effect initialized')
-     *     // Setup code that should only run once
-     *   } else {
-     *     console.log('Effect re-ran due to dependency change')
-     *     // Code that runs on every update
-     *   }
-     * })
-     * ```
-     */
-    reaction: boolean;
-}
-/**
- * Type for effect cleanup functions
- */
-type ScopedCallback = () => void;
-/**
- * Async execution mode for effects
- * - `cancel`: Cancel previous async execution when dependencies change (default)
- * - `queue`: Queue next execution to run after current completes
- * - `ignore`: Ignore new executions while async work is running
- */
-type AsyncExecutionMode = 'cancel' | 'queue' | 'ignore';
-/**
- * Options for effect creation
- */
-interface EffectOptions {
-    /**
-     * How to handle async effect executions when dependencies change
-     * @default 'cancel'
-     */
-    asyncMode?: AsyncExecutionMode;
-    /**
-     * If true, this effect is "opaque" to deep optimizations: it sees the object reference itself
-     * and must be notified when it changes, regardless of deep content similarity.
-     * Use this for effects that depend on object identity (like memoize).
-     */
-    opaque?: boolean;
-}
-/**
- * Type for property evolution events
- */
-type PropEvolution = {
-    type: 'set' | 'del' | 'add' | 'invalidate';
-    prop: any;
-};
-/**
- * Type for collection operation evolution events
- */
-type BunchEvolution = {
-    type: 'bunch';
-    method: string;
-};
-type Evolution = PropEvolution | BunchEvolution;
-type State = {
-    evolution: Evolution;
-    next: State;
-} | {};
-/**
- * Context for a running projection item effect
- */
-interface ProjectionContext {
-    source: any;
-    key?: any;
-    target: any;
-    depth: number;
-    parent?: ProjectionContext;
-}
-/**
- * Structured error codes for machine-readable diagnosis
- */
-declare enum ReactiveErrorCode {
-    CycleDetected = "CYCLE_DETECTED",
-    MaxDepthExceeded = "MAX_DEPTH_EXCEEDED",
-    MaxReactionExceeded = "MAX_REACTION_EXCEEDED",
-    WriteInComputed = "WRITE_IN_COMPUTED",
-    TrackingError = "TRACKING_ERROR"
-}
-type CycleDebugInfo = {
-    code: ReactiveErrorCode.CycleDetected;
-    cycle: string[];
-    details?: string;
-};
-type MaxDepthDebugInfo = {
-    code: ReactiveErrorCode.MaxDepthExceeded;
-    depth: number;
-    chain: string[];
-};
-type MaxReactionDebugInfo = {
-    code: ReactiveErrorCode.MaxReactionExceeded;
-    count: number;
-    effect: string;
-};
-type GenericDebugInfo = {
-    code: ReactiveErrorCode;
-    causalChain?: string[];
-    creationStack?: string;
-    [key: string]: any;
-};
-type ReactiveDebugInfo = CycleDebugInfo | MaxDepthDebugInfo | MaxReactionDebugInfo | GenericDebugInfo;
-/**
- * Error class for reactive system errors
- */
-declare class ReactiveError extends Error {
-    debugInfo?: ReactiveDebugInfo;
-    constructor(message: string, debugInfo?: ReactiveDebugInfo);
-}
-/**
- * Global options for the reactive system
- */
-declare const options: {
-    /**
-     * Debug purpose: called when an effect is entered
-     * @param effect - The effect that is entered
-     */
-    enter: (_effect: Function) => void;
-    /**
-     * Debug purpose: called when an effect is left
-     * @param effect - The effect that is left
-     */
-    leave: (_effect: Function) => void;
-    /**
-     * Debug purpose: called when an effect is chained
-     * @param target - The effect that is being triggered
-     * @param caller - The effect that is calling the target
-     */
-    chain: (_targets: Function[], _caller?: Function) => void;
-    /**
-     * Debug purpose: called when an effect chain is started
-     * @param target - The effect that is being triggered
-     */
-    beginChain: (_targets: Function[]) => void;
-    /**
-     * Debug purpose: called when an effect chain is ended
-     */
-    endChain: () => void;
-    garbageCollected: (_fn: Function) => void;
-    /**
-     * Debug purpose: called when an object is touched
-     * @param obj - The object that is touched
-     * @param evolution - The type of change
-     * @param props - The properties that changed
-     * @param deps - The dependencies that changed
-     */
-    touched: (_obj: any, _evolution: Evolution, _props?: any[], _deps?: Set<ScopedCallback>) => void;
-    /**
-     * Debug purpose: called when an effect is skipped because it's already running
-     * @param effect - The effect that is already running
-     * @param runningChain - The array of effects from the detected one to the currently running one
-     */
-    skipRunningEffect: (_effect: ScopedCallback, _runningChain: ScopedCallback[]) => void;
-    /**
-     * Debug purpose: maximum effect chain (like call stack max depth)
-     * Used to prevent infinite loops
-     * @default 100
-     */
-    maxEffectChain: number;
-    /**
-     * Maximum number of times an effect can be triggered by the same cause in a single batch
-     * Used to detect aggressive re-computation or infinite loops
-     * @default 10
-     */
-    maxTriggerPerBatch: number;
-    /**
-     * Debug purpose: maximum effect reaction (like call stack max depth)
-     * Used to prevent infinite loops
-     * @default 'throw'
-     */
-    maxEffectReaction: "throw" | "debug" | "warn";
-    /**
-     * Callback called when a memoization discrepancy is detected (debug only)
-     * When defined, memoized functions will run a second time (untracked) to verify consistency.
-     * If the untracked run returns a different value than the cached one, this callback is triggered.
-     *
-     * This is the primary tool for detecting missing reactive dependencies in computed values.
-     *
-     * @param cached - The value currently in the memoization cache
-     * @param fresh - The value obtained by re-running the function untracked
-     * @param fn - The memoized function itself
-     * @param args - Arguments passed to the function
-     *
-     * @example
-     * ```typescript
-     * reactiveOptions.onMemoizationDiscrepancy = (cached, fresh, fn, args) => {
-     *   throw new Error(`Memoization discrepancy in ${fn.name}!`);
-     * };
-     * ```
-     */
-    onMemoizationDiscrepancy: ((cached: any, fresh: any, fn: Function, args: any[], cause: "calculation" | "comparison") => void) | undefined;
-    /**
-     * How to handle cycles detected in effect batches
-     * - 'throw': Throw an error with cycle information (default, recommended for development)
-     * - 'warn': Log a warning and break the cycle by executing one effect
-     * - 'break': Silently break the cycle by executing one effect (recommended for production)
-     * - 'strict': Prevent cycle creation by checking graph before execution (throws error)
-     * @default 'throw'
-     */
-    cycleHandling: "throw" | "warn" | "break" | "strict";
-    /**
-     * Internal flag used by memoization discrepancy detector to avoid counting calls in tests
-     * @warning Do not modify this flag manually, this flag is given by the engine
-     */
-    isVerificationRun: boolean;
-    /**
-     * Maximum depth for deep watching traversal
-     * Used to prevent infinite recursion in circular references
-     * @default 100
-     */
-    maxDeepWatchDepth: number;
-    /**
-     * Only react on instance members modification (not inherited properties)
-     * For instance, do not track class methods
-     * @default true
-     */
-    instanceMembers: boolean;
-    /**
-     * Ignore accessors (getters and setters) and only track direct properties
-     * @default true
-     */
-    ignoreAccessors: boolean;
-    /**
-     * Enable recursive touching when objects with the same prototype are replaced
-     * When enabled, replacing an object with another of the same prototype triggers
-     * recursive diffing instead of notifying parent effects
-     * @default true
-     */
-    recursiveTouching: boolean;
-    /**
-     * Default async execution mode for effects that return Promises
-     * - 'cancel': Cancel previous async execution when dependencies change (default, enables async zone)
-     * - 'queue': Queue next execution to run after current completes (enables async zone)
-     * - 'ignore': Ignore new executions while async work is running (enables async zone)
-     * - false: Disable async zone and async mode handling (effects run concurrently)
-     *
-     * **When truthy:** Enables async zone (Promise.prototype wrapping) for automatic context
-     * preservation in Promise callbacks. Warning: This modifies Promise.prototype globally.
-     * Only enable if no other library modifies Promise.prototype.
-     *
-     * **When false:** Async zone is disabled. Use `tracked()` manually in Promise callbacks.
-     *
-     * Can be overridden per-effect via EffectOptions
-     * @default 'cancel'
-     */
-    asyncMode: AsyncExecutionMode | false;
-    warn: (...args: any[]) => void;
-    /**
-     * Configuration for the introspection system
-     */
-    introspection: {
-        /**
-         * Whether to keep a history of mutations for debugging
-         * @default false
-         */
-        enableHistory: boolean;
-        /**
-         * Number of mutations to keep in history
-         * @default 50
-         */
-        historySize: number;
-    };
-    /**
-     * Configuration for zone hooks - control which async APIs are hooked
-     * Each option controls whether the corresponding async API is wrapped to preserve effect context
-     * Only applies when asyncMode is enabled (truthy)
-     */
-    zones: {
-        /**
-         * Hook setTimeout to preserve effect context
-         * @default true
-         */
-        setTimeout: boolean;
-        /**
-         * Hook setInterval to preserve effect context
-         * @default true
-         */
-        setInterval: boolean;
-        /**
-         * Hook requestAnimationFrame (runs in untracked context when hooked)
-         * @default true
-         */
-        requestAnimationFrame: boolean;
-        /**
-         * Hook queueMicrotask to preserve effect context
-         * @default true
-         */
-        queueMicrotask: boolean;
-    };
-};
-
-/**
- * Gets the current state of a reactive object for evolution tracking
- * @param obj - The reactive object
- * @returns The current state object
- */
-declare function getState(obj: any): State;
-/**
- * Triggers effects for a single property change
- * @param obj - The object that changed
- * @param evolution - The type of change
- * @param prop - The property that changed
- */
-declare function touched1(obj: any, evolution: Evolution, prop: any): void;
-/**
- * Triggers effects for property changes
- * @param obj - The object that changed
- * @param evolution - The type of change
- * @param props - The properties that changed
- */
-declare function touched(obj: any, evolution: Evolution, props?: Iterable<any>): void;
-
-/**
- * Debug utilities for the reactivity system
- * - Captures effect metadata (names, parent relationships)
- * - Records cause → consequence edges with object/prop labels
- * - Provides graph data for tooling (DevTools panel, etc.)
- */
-
-type NodeKind = 'effect' | 'external' | 'state';
-type EdgeKind = 'cause' | 'dependency' | 'trigger';
-interface EffectNode {
-    id: string;
-    label: string;
-    type: NodeKind;
-    depth: number;
-    parentId?: string;
-    debugName?: string;
-}
-interface ObjectNode {
-    id: string;
-    label: string;
-    type: NodeKind;
-    debugName?: string;
-}
-interface GraphEdge {
-    id: string;
-    source: string;
-    target: string;
-    type: EdgeKind;
-    label: string;
-    count?: number;
-}
-interface ReactivityGraph {
-    nodes: Array<EffectNode | ObjectNode>;
-    edges: GraphEdge[];
-    meta: {
-        generatedAt: number;
-        devtoolsEnabled: boolean;
-    };
-}
-/**
- * Assign a debug-friendly name to an effect (shown in DevTools)
- */
-declare function setEffectName(effect: ScopedCallback, name: string): void;
-/**
- * Assign a debug-friendly name to a reactive object
- */
-declare function setObjectName(obj: object, name: string): void;
-/**
- * Register an effect so it appears in the DevTools graph
- */
-declare function registerEffectForDebug(effect: ScopedCallback): void;
-/**
- * Register a reactive object so it appears in the DevTools graph
- */
-declare function registerObjectForDebug(obj: object): void;
-/**
- * Builds a graph representing current reactive state (effects, objects, and trigger edges)
- */
-declare function buildReactivityGraph(): ReactivityGraph;
-/**
- * Enables the DevTools bridge and exposes the debug API on window.
- * Call as early as possible in development builds.
- */
-declare function enableDevTools(): void;
-declare function isDevtoolsEnabled(): boolean;
-
-/**
- * Deep watch an object and all its nested properties
- * @param target - The object to watch deeply
- * @param callback - The callback to call when any nested property changes
- * @param options - Options for the deep watch
- * @returns A cleanup function to stop watching
- */
-/**
- * Sets up deep watching for an object, tracking all nested property changes
- * @param target - The object to watch
- * @param callback - The callback to call when changes occur
- * @param options - Options for deep watching
- * @returns A cleanup function to stop deep watching
- */
-declare function deepWatch<T extends object>(target: T, callback: (value: T) => void, { immediate }?: {
-    immediate?: boolean;
-}): (() => void) | undefined;
-
-declare function getActiveEffect(): ScopedCallback;
-
-type EffectTracking = (obj: any, evolution: Evolution, prop: any) => void;
-
-interface ActivationRecord {
-    effect: ScopedCallback;
-    obj: any;
-    evolution: Evolution;
-    prop: any;
-    batchId: number;
-}
-declare function getActivationLog(): Omit<ActivationRecord, "batchId">[];
-/**
- * Registers a debug callback that is called when the current effect is triggered by a dependency change
- *
- * This function is useful for debugging purposes as it pin-points exactly which reactive property
- * change triggered the effect. The callback receives information about:
- * - The object that changed
- * - The type of change (evolution)
- * - The specific property that changed
- *
- * **Note:** The tracker callback is automatically removed after being called once. If you need
- * to track multiple triggers, call `trackEffect` again within the effect.
- *
- * @param onTouch - Callback function that receives (obj, evolution, prop) when the effect is triggered
- * @throws {Error} If called outside of an effect context
- *
- * @example
- * ```typescript
- * const state = reactive({ count: 0, name: 'John' })
- *
- * effect(() => {
- *   // Register a tracker to see what triggers this effect
- *   trackEffect((obj, evolution, prop) => {
- *     console.log(`Effect triggered by:`, {
- *       object: obj,
- *       change: evolution.type,
- *       property: prop
- *     })
- *   })
- *
- *   // Access reactive properties
- *   console.log(state.count, state.name)
- * })
- *
- * state.count = 5
- * // Logs: Effect triggered by: { object: state, change: 'set', property: 'count' }
- * ```
- */
-declare function trackEffect(onTouch: EffectTracking): void;
-/**
- * Adds a cleanup function to be called when the current batch of effects completes
- * @param cleanup - The cleanup function to add
- */
-declare function addBatchCleanup(cleanup: ScopedCallback): void;
-/**
- * Semantic alias for `addBatchCleanup` - defers work to the end of the current reactive batch.
- *
- * Use this when an effect needs to perform an action that would modify state the effect depends on,
- * which would create a reactive cycle. The deferred callback runs after all effects complete.
- *
- * @param callback - The callback to defer until after the current batch completes
- *
- * @example
- * ```typescript
- * effect(() => {
- *   processData()
- *
- *   // Defer to avoid cycle (createMovement modifies state this effect reads)
- *   defer(() => {
- *     createMovement(data)
- *   })
- * })
- * ```
- */
-declare const defer: typeof addBatchCleanup;
-declare function batch(effect: ScopedCallback | ScopedCallback[], immediate?: 'immediate'): any;
-/**
- * Decorator that makes methods atomic - batches all effects triggered within the method
- */
-declare const atomic: LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & (<Args extends any[], Return>(original: (...args: Args) => Return) => (...args: Args) => Return);
-/**
- * @param fn - The effect function to run - provides the cleaner
- * @returns The cleanup function
- */
-/**
- * Creates a reactive effect that automatically re-runs when dependencies change
- * @param fn - The effect function that provides dependencies and may return a cleanup function or Promise
- * @param options - Options for effect execution
- * @returns A cleanup function to stop the effect
- */
-declare function effect(fn: (access: DependencyAccess) => ScopedCallback | undefined | void | Promise<any>, effectOptions?: EffectOptions): ScopedCallback;
-/**
- * Executes a function without tracking dependencies but maintains parent cleanup relationship
- * Effects created inside will still be cleaned up when the parent effect is destroyed
- * @param fn - The function to execute
- */
-declare function untracked<T>(fn: () => T): T;
-/**
- * Executes a function from a virgin/root context - no parent effect, no tracking
- * Creates completely independent effects that won't be cleaned up by any parent
- * @param fn - The function to execute
- */
-declare function root<T>(fn: () => T): T;
-
-/**
- * Creates a bidirectional binding between a reactive value and a non-reactive external value
- * Prevents infinite loops by automatically suppressing circular notifications
- *
- * @param received - Function called when the reactive value changes (external setter)
- * @param get - Getter for the reactive value OR an object with `{ get, set }` properties
- * @param set - Setter for the reactive value (required if `get` is a function)
- * @returns A function to manually provide updates from the external side
- *
- * @example
- * ```typescript
- * const model = reactive({ value: '' })
- * const input = { value: '' }
- *
- * // Bidirectional binding
- * const provide = biDi(
- *   (v) => input.value = v,  // external setter
- *   () => model.value,        // reactive getter
- *   (v) => model.value = v    // reactive setter
- * )
- *
- * // External notification (e.g., from input event)
- * provide('new value')  // Updates model.value, doesn't trigger circular loop
- * ```
- *
- * @example Using object syntax
- * ```typescript
- * const provide = biDi(
- *   (v) => setHTMLValue(v),
- *   { get: () => reactiveObj.value, set: (v) => reactiveObj.value = v }
- * )
- * ```
- */
-declare function biDi<T>(received: (value: T) => void, value: {
-    get: () => T;
-    set: (value: T) => void;
-}): (value: T) => void;
-declare function biDi<T>(received: (value: T) => void, get: () => T, set: (value: T) => void): (value: T) => void;
-
-/**
- * Symbol for accessing the cleanup function on cleaned objects
- */
-declare const cleanup: unique symbol;
-/**
- * Options for the watch function
- */
-interface WatchOptions {
-    /** Whether to call the callback immediately */
-    immediate?: boolean;
-    /** Whether to watch nested properties */
-    deep?: boolean;
-}
-/**
- * Watches a reactive value and calls a callback when it changes
- * @param value - Function that returns the value to watch
- * @param changed - Callback to call when the value changes
- * @param options - Watch options
- * @returns Cleanup function to stop watching
- */
-declare function watch<T>(value: (dep: DependencyAccess) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
-    deep?: false;
-}): ScopedCallback;
-/**
- * Watches a reactive value with deep watching enabled
- * @param value - Function that returns the value to watch
- * @param changed - Callback to call when the value changes
- * @param options - Watch options with deep watching enabled
- * @returns Cleanup function to stop watching
- */
-declare function watch<T extends object | any[]>(value: (dep: DependencyAccess) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
-    deep: true;
-}): ScopedCallback;
-/**
- * Watches a reactive object directly
- * @param value - The reactive object to watch
- * @param changed - Callback to call when the object changes
- * @param options - Watch options
- * @returns Cleanup function to stop watching
- */
-declare function watch<T extends object | any[]>(value: T, changed: (value: T) => void, options?: WatchOptions): ScopedCallback;
-declare function unreactiveApplication<T extends object>(...args: (keyof T)[]): GenericClassDecorator<T>;
-declare function unreactiveApplication<T extends object>(obj: T): T;
-/**
- * Decorator that marks classes or properties as non-reactive
- * Prevents objects from being made reactive
- */
-declare const unreactive: LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & typeof unreactiveApplication;
-declare function cleanedBy<T extends object>(obj: T, cleanupFn: ScopedCallback): T & {
-    [cleanup]: ScopedCallback;
-};
-/**
- * Creates a derived value that automatically recomputes when dependencies change
- * @param compute - Function that computes the derived value
- * @returns Object with value and cleanup function
- */
-declare function derived<T>(compute: (dep: DependencyAccess) => T): {
-    value: T;
-    [cleanup]: ScopedCallback;
-};
-
-declare class ReadOnlyError extends Error {
-}
-declare function mapped<T, U>(inputs: readonly T[], compute: (input: T, index: number, output: U[]) => U, resize?: (newLength: number, oldLength: number) => void): readonly U[];
-declare function reduced<T, U, R extends object = any>(inputs: readonly T[], compute: (input: T, factor: R) => readonly U[]): readonly U[];
-
-type Memoizable = object | any[] | symbol | ((...args: any[]) => any);
-declare function memoizeFunction<Result, Args extends Memoizable[]>(fn: (...args: Args) => Result): (...args: Args) => Result;
-declare const memoize: LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any> & typeof memoizeFunction;
-
-declare const immutables: Set<(tested: any) => boolean>;
-declare function isNonReactive(obj: any): boolean;
-declare function registerNativeReactivity(originalClass: new (...args: any[]) => any, reactiveClass: new (...args: any[]) => any): void;
-
-type KeyFunction<T, K extends PropertyKey> = (item: T) => K;
-interface RegisterInstance<T> extends ArrayReadForward<T> {
-    [index: number]: T;
-}
-declare const RegisterClass_base: new () => ArrayReadForward<any> & {
-    [x: number]: any;
-    toArray(): any[];
-};
-declare class RegisterClass<T, K extends PropertyKey = PropertyKey> extends RegisterClass_base implements RegisterInstance<T> {
-    #private;
-    protected get [forwardArray](): readonly T[];
-    constructor(keyFn: KeyFunction<T, K>, initial?: Iterable<T>);
-    private ensureKey;
-    private assertValidKey;
-    private setKeyValue;
-    private cleanupValue;
-    private disposeKeyEffects;
-    private incrementUsage;
-    private decrementUsage;
-    private normalizeIndex;
-    private assignAt;
-    private insertKeyValue;
-    private rebuildFrom;
-    get length(): number;
-    [getAt](index: number): T | undefined;
-    [setAt](index: number, value: T): void;
-    push(...items: T[]): number;
-    pop(): T | undefined;
-    shift(): T | undefined;
-    unshift(...items: T[]): number;
-    splice(start: number, deleteCount?: number, ...items: T[]): T[];
-    clear(): void;
-    get(key: K): T | undefined;
-    set(key: K, value: T): void;
-    remove(key: K): void;
-    removeAt(index: number): T | undefined;
-    /**
-     * Keep only the items for which the predicate returns true.
-     * Items for which the predicate returns false are removed.
-     *
-     * The predicate is evaluated once per distinct key; duplicate keys
-     * will follow the same keep/remove decision.
-     */
-    keep(predicate: (value: T) => boolean): void;
-    hasKey(key: K): boolean;
-    indexOfKey(key: K): number;
-    mapKeys(): IterableIterator<K>;
-    update(...values: T[]): void;
-    upsert(insert: (value: T) => void, ...values: T[]): void;
-    entries(): IterableIterator<[number, T]>;
-    [Symbol.iterator](): IterableIterator<T>;
-    toString(): string;
-    at(index: number): T | undefined;
-    reverse(): this;
-    sort(compareFn?: ((a: T, b: T) => number) | undefined): this;
-    fill(value: T, start?: number, end?: number): this;
-    copyWithin(target: number, start: number, end?: number): this;
-}
-type Register<T, K extends PropertyKey = PropertyKey> = RegisterClass<T, K> & T[];
-declare const Register: new <T, K extends PropertyKey = PropertyKey>(keyFn: KeyFunction<T, K>, initial?: Iterable<T>) => Register<T, K>;
-declare function register<T, K extends PropertyKey = PropertyKey>(keyFn: KeyFunction<T, K>, initial?: Iterable<T>): Register<T, K>;
-
-/**
- * Returns the projection context of the currently running effect, if any.
- */
-declare function getActiveProjection(): ProjectionContext | undefined;
-type ProjectOldValue<Target> = Target extends readonly (infer Item)[] ? Item : Target extends Map<any, infer Item> ? Item : Target extends Record<PropertyKey, infer Item> ? Item : unknown;
-type ProjectAccess<SourceValue, Key, SourceType, Target> = {
-    readonly key: Key;
-    get(): SourceValue;
-    set(value: SourceValue): boolean;
-    readonly source: SourceType;
-    readonly old?: ProjectOldValue<Target>;
-    value: SourceValue;
-};
-type BivariantProjectCallback<Args extends any[], Return> = {
-    bivarianceHack(...args: Args): Return;
-}['bivarianceHack'];
-type ProjectCallback<SourceValue, Key, Target extends object, SourceType, Result> = BivariantProjectCallback<[ProjectAccess<SourceValue, Key, SourceType, Target>, Target], Result>;
-type ProjectResult<Target extends object> = Target & {
-    [cleanup]: ScopedCallback;
-};
-declare function projectArray<SourceValue, ResultValue>(source: readonly SourceValue[], apply: ProjectCallback<SourceValue, number, ResultValue[], readonly SourceValue[], ResultValue>): ProjectResult<ResultValue[]>;
-declare function projectRegister<Key extends PropertyKey, SourceValue, ResultValue>(source: Register<SourceValue, Key>, apply: ProjectCallback<SourceValue, Key, Map<Key, ResultValue>, Register<SourceValue, Key>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
-declare function projectRecord<Source extends Record<PropertyKey, any>, ResultValue>(source: Source, apply: ProjectCallback<Source[keyof Source], keyof Source, Record<keyof Source, ResultValue>, Source, ResultValue>): ProjectResult<Record<keyof Source, ResultValue>>;
-declare function projectMap<Key, Value, ResultValue>(source: Map<Key, Value>, apply: ProjectCallback<Value, Key, Map<Key, ResultValue>, Map<Key, Value>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
-type ProjectOverload = {
-    <SourceValue, ResultValue>(source: readonly SourceValue[], apply: ProjectCallback<SourceValue, number, ResultValue[], readonly SourceValue[], ResultValue>): ProjectResult<ResultValue[]>;
-    <Key extends PropertyKey, SourceValue, ResultValue>(source: Register<SourceValue, Key>, apply: ProjectCallback<SourceValue, Key, Map<Key, ResultValue>, Register<SourceValue, Key>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
-    <Source extends Record<PropertyKey, any>, ResultValue>(source: Source, apply: ProjectCallback<Source[keyof Source], keyof Source, Record<keyof Source, ResultValue>, Source, ResultValue>): ProjectResult<Record<keyof Source, ResultValue>>;
-    <Key, Value, ResultValue>(source: Map<Key, Value>, apply: ProjectCallback<Value, Key, Map<Key, ResultValue>, Map<Key, Value>, ResultValue>): ProjectResult<Map<Key, ResultValue>>;
-    array: typeof projectArray;
-    register: typeof projectRegister;
-    record: typeof projectRecord;
-    map: typeof projectMap;
-};
-declare const project: ProjectOverload;
-
-declare function unwrap<T>(obj: T): T;
-declare function isReactive(obj: any): boolean;
-
-/**
- * Base mixin for reactive classes that provides proper constructor reactivity
- * Solves constructor reactivity issues in complex inheritance trees
- */
-declare const ReactiveBase: (new (...args: any[]) => {
-    [x: string]: any;
-}) & (<Base>(base: abstract new (...args: any[]) => Base) => new (...args: any[]) => {
-    [x: string]: any;
-} & Base);
-declare function reactiveObject<T>(anyTarget: T): T;
-/**
- * Main decorator for making classes reactive
- * Automatically makes class instances reactive when created
- */
-declare const reactive: LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & typeof reactiveObject;
-
-/**
- * Provides type-safe access to a source object's property within the organized callback.
- * @template Source - The type of the source object
- * @template Key - The type of the property key in the source object
- */
-type OrganizedAccess<Source extends Record<PropertyKey, any>, Key extends keyof Source> = {
-    /** The property key being accessed */
-    readonly key: Key;
-    /**
-     * Gets the current value of the property from the source object
-     * @returns The current value of the property
-     */
-    get(): Source[Key];
-    /**
-     * Updates the property value in the source object
-     * @param value - The new value to set
-     * @returns {boolean} True if the update was successful
-     */
-    set(value: Source[Key]): boolean;
-    /**
-     * The current value of the property (equivalent to using get()/set() directly)
-     */
-    value: Source[Key];
-};
-/**
- * Callback function type for the organized function that processes each source property.
- * @template Source - The type of the source object
- * @template Target - The type of the target object
- */
-type OrganizedCallback<Source extends Record<PropertyKey, any>, Target extends object> = <Key extends keyof Source>(
-/**
- * Accessor object for the current source property
- */
-access: OrganizedAccess<Source, Key>, 
-/**
- * The target object where organized data will be stored
- */
-target: Target) => ScopedCallback | undefined;
-/**
- * The result type of the organized function, combining the target object with cleanup capability.
- * @template Target - The type of the target object
- */
-type OrganizedResult<Target extends object> = Target & {
-    /**
-     * Cleanup function to dispose of all reactive bindings created by organized().
-     * This is automatically called when the effect that created the organized binding is disposed.
-     */
-    [cleanup]: ScopedCallback;
-};
-/**
- * Organizes a source object's properties into a target object using a callback function.
- * This creates a reactive mapping between source properties and a target object,
- * automatically handling property additions, updates, and removals.
- *
- * @template Source - The type of the source object
- * @template Target - The type of the target object (defaults to Record<PropertyKey, any>)
- *
- * @param {Source} source - The source object to organize
- * @param {OrganizedCallback<Source, Target>} apply - Callback function that defines how each source property is mapped to the target
- * @param {Target} [baseTarget={}] - Optional base target object to use (will be made reactive if not already)
- *
- * @returns {OrganizedResult<Target>} The target object with cleanup capability
- *
- * @example
- * // Organize user permissions into role-based access
- * const user = reactive({ isAdmin: true, canEdit: false });
- * const permissions = organized(
- *   user,
- *   (access, target) => {
- *     if (access.key === 'isAdmin') {
- *       target.hasFullAccess = access.value;
- *     }
- *     target[`can${access.key.charAt(0).toUpperCase() + access.key.slice(1)}`] = access.value;
- *   }
- * );
- *
- * @example
- * // Transform object structure with cleanup
- * const source = reactive({ firstName: 'John', lastName: 'Doe' });
- * const formatted = organized(
- *   source,
- *   (access, target) => {
- *     if (access.key === 'firstName' || access.key === 'lastName') {
- *       target.fullName = `${source.firstName} ${source.lastName}`.trim();
- *     }
- *   }
- * );
- *
- * @example
- * // Using with cleanup in a component
- * effect(() => {
- *   const data = fetchData();
- *   const organizedData = organized(data, (access, target) => {
- *     // Transform data
- *   });
- *
- *   // The cleanup will be called automatically when the effect is disposed
- *   return () => organizedData[cleanup]();
- * });
- */
-declare function organized<Source extends Record<PropertyKey, any>, Target extends object = Record<PropertyKey, any>>(source: Source, apply: OrganizedCallback<Source, Target>, baseTarget?: Target): OrganizedResult<Target>;
-/**
- * Organizes a property on a target object
- * Shortcut for defineProperty/delete with touched signal
- * @param target - The target object
- * @param property - The property to organize
- * @param access - The access object
- * @returns The property descriptor
- */
-declare function organize<T>(target: object, property: PropertyKey, access: {
-    get?(): T;
-    set?(value: T): boolean;
-}): () => boolean;
-
-/**
- * Manually enable/disable the zone (for testing)
- */
-declare function setZoneEnabled(enabled: boolean): void;
-/**
- * Check if zone is currently hooked
- */
-declare function isZoneEnabled(): boolean;
-
-/**
- * Object containing internal reactive system state for debugging and profiling
- */
-declare const profileInfo: any;
-
-export { ReactiveBase, ReactiveError, ReadOnlyError, Register, addBatchCleanup, atomic, batch, biDi, buildReactivityGraph, cleanedBy, cleanup, deepWatch, defer, derived, effect, enableDevTools, getActivationLog, getActiveEffect, getActiveProjection, getState, immutables, isDevtoolsEnabled, isNonReactive, isReactive, isZoneEnabled, mapped, memoize, organize, organized, profileInfo, project, reactive, options as reactiveOptions, reduced, register, registerEffectForDebug, registerNativeReactivity, registerObjectForDebug, root, setEffectName, setObjectName, setZoneEnabled, touched, touched1, trackEffect, unreactive, untracked, unwrap, watch };
-export type { DependencyAccess, DependencyFunction, Evolution, Memoizable, ReactivityGraph, ScopedCallback };