mutts 1.0.1 → 1.0.3

package/dist/reactive.d.ts

@@ -1,11 +1,103 @@
-import { LegacyPropertyDecorator, ModernMethodDecorator, LegacyClassDecorator, ModernClassDecorator, ModernGetterDecorator, ModernAccessorDecorator, GenericClassDecorator } from './decorator.js';
+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;
@@ -15,36 +107,110 @@ type State = {
     evolution: Evolution;
     next: State;
 } | {};
-declare const profileInfo: any;
+/**
+ * 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 {
-    constructor(message: string);
+    debugInfo?: ReactiveDebugInfo;
+    constructor(message: string, debugInfo?: ReactiveDebugInfo);
 }
 /**
- * Options for the reactive system, can be configured at runtime
+ * 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;
+    enter: (_effect: Function) => void;
     /**
      * Debug purpose: called when an effect is left
      * @param effect - The effect that is left
      */
-    leave: (effect: Function) => void;
+    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: (target: Function, caller?: Function) => void;
+    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;
+    /**
+     * Debug purpose: maximum effect reaction (like call stack max depth)
+     * Used to prevent infinite loops
+     * @default 'throw'
+     */
+    maxEffectReaction: "throw" | "debug" | "warn";
+    /**
+     * 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";
     /**
      * Maximum depth for deep watching traversal
      * Used to prevent infinite recursion in circular references
@@ -57,59 +223,634 @@ declare const options: {
      * @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;
-declare const atomic: LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & (<Args extends any[], Return>(original: (...args: Args) => Return) => (...args: Args) => Return);
-declare class ReactiveBase {
-    constructor();
+/**
+ * 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;
 }
-declare function reactiveObject<T>(anyTarget: T): T;
-declare const reactive: LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & typeof reactiveObject;
-declare function unwrap<T>(proxy: T): T;
-declare function isReactive(obj: any): boolean;
-declare function untracked(fn: () => ScopedCallback | undefined | void): void;
+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;
+
+/**
+ * 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;
+/**
+ * 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
  */
-declare function effect<Args extends any[]>(fn: (dep: DependencyFunction, ...args: Args) => ScopedCallback | undefined | void, ...args: Args): ScopedCallback;
 /**
- * Set of functions to test if an object is immutable
+ * 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 const immutables: Set<(tested: any) => boolean>;
+declare function effect(fn: (access: DependencyAccess) => ScopedCallback | undefined | void | Promise<any>, effectOptions?: EffectOptions): ScopedCallback;
 /**
- * Check if an object is marked as non-reactive (for testing purposes)
- * @param obj - The object to check
- * @returns true if the object is marked as non-reactive
+ * 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 isNonReactive(obj: any): boolean;
+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;
 
 /**
- * When used in a computed property computation, it will register the callback to be called when the computed property is invalidated
- * @param cb - The callback to register
- * @param warn - Whether to warn if used outside of a computed property
+ * Symbol for accessing the cleanup function on cleaned objects
  */
-declare function invalidateComputed(cb: () => void, warn?: boolean): void;
-type ComputedFunction<T> = (dep: DependencyFunction) => T;
+declare const cleanup: unique symbol;
 /**
- * Get the cached value of a computed function - cache is invalidated when the dependencies change
+ * Options for the watch function
  */
-declare const computed: LegacyPropertyDecorator<any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any> & (<T>(getter: ComputedFunction<T>) => T);
 interface WatchOptions {
+    /** Whether to call the callback immediately */
     immediate?: boolean;
+    /** Whether to watch nested properties */
     deep?: boolean;
 }
-declare function watch<T>(value: (dep: DependencyFunction) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
+/**
+ * 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;
-declare function watch<T extends object | any[]>(value: (dep: DependencyFunction) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
+/**
+ * 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>;
+
+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, atomic, computed, effect, getState, immutables, invalidateComputed, isNonReactive, isReactive, profileInfo, reactive, options as reactiveOptions, unreactive, untracked, unwrap, watch };
-export type { ScopedCallback };
+export { ReactiveBase, ReactiveError, ReadOnlyError, Register, addBatchCleanup, atomic, biDi, buildReactivityGraph, cleanedBy, cleanup, deepWatch, defer, derived, effect, enableDevTools, getActiveEffect, 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 };