mutts 1.0.2 → 1.0.4

package/dist/reactive.d.ts

@@ -1,12 +1,13 @@
-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 and computed values
+ * 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/computed/watch
+ * Dependency access passed to user callbacks within effects/watch
  * Provides functions to track dependencies and information about the effect execution
  */
 interface DependencyAccess {
@@ -42,13 +43,13 @@ interface DependencyAccess {
      */
     ascend: DependencyFunction;
     /**
-     * Indicates whether this is the initial execution of the effect
-     * - `true`: First execution when the effect is created
-     * - `false`: Subsequent executions triggered by dependency changes
+     * 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(({ init }) => {
-     *   if (init) {
+     * effect(({ reaction }) => {
+     *   if (!reaction) {
      *     console.log('Effect initialized')
      *     // Setup code that should only run once
      *   } else {
@@ -58,12 +59,35 @@ interface DependencyAccess {
      * })
      * ```
      */
-    init: boolean;
+    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
  */
@@ -84,14 +108,43 @@ type State = {
     next: State;
 } | {};
 /**
- * Object containing internal reactive system state for debugging and profiling
+ * Structured error codes for machine-readable diagnosis
  */
-declare const profileInfo: any;
+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);
 }
 /**
  * Global options for the reactive system
@@ -101,27 +154,28 @@ 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: (targets: 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;
+    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
@@ -129,7 +183,13 @@ declare const options: {
      * @param props - The properties that changed
      * @param deps - The dependencies that changed
      */
-    touched: (obj: any, evolution: Evolution, props?: any[], deps?: Set<ScopedCallback>) => void;
+    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
@@ -142,6 +202,15 @@ declare const options: {
      * @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
@@ -159,9 +228,184 @@ declare const options: {
      * @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;
+
 /**
  * Registers a debug callback that is called when the current effect is triggered by a dependency change
  *
@@ -200,103 +444,104 @@ type EffectTracking = (obj: any, evolution: Evolution, prop: any) => void;
  * ```
  */
 declare function trackEffect(onTouch: EffectTracking): void;
-/**
- * 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 let activeEffect: ScopedCallback | undefined;
 /**
  * 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;
 /**
- * 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);
-/**
- * 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);
-/**
- * Always-reactive mixin that makes classes inherently reactive
- * Can be used as both a base class and a mixin function
- */
-declare const Reactive: (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;
-/**
- * Gets the original, non-reactive object from a reactive proxy
- * @param proxy - The reactive proxy
- * @returns The original object
- */
-declare function unwrap<T>(proxy: T): T;
-/**
- * Checks if an object is a reactive proxy
- * @param obj - The object to check
- * @returns True if the object is reactive
+ * 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 function isReactive(obj: any): boolean;
+declare const defer: typeof addBatchCleanup;
+declare function batch(effect: ScopedCallback | ScopedCallback[], immediate?: 'immediate'): any;
 /**
- * Executes a function without tracking dependencies
- * @param fn - The function to execute
+ * Decorator that makes methods atomic - batches all effects triggered within the method
  */
-declare function untracked<T>(fn: () => T): T;
+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
- * @param args - Additional arguments that are forwarded to the effect function
+ * @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<Args extends any[]>(fn: (access: DependencyAccess, ...args: Args) => ScopedCallback | undefined | void, ...args: Args): ScopedCallback;
+declare function effect(fn: (access: DependencyAccess) => ScopedCallback | undefined | void | Promise<any>, effectOptions?: EffectOptions): ScopedCallback;
 /**
- * Set of functions that test if objects are immutable
- * Objects that pass these tests will not be made 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 const immutables: Set<(tested: any) => boolean>;
+declare function untracked<T>(fn: () => T): T;
 /**
- * Checks if an object is marked as non-reactive
- * @param obj - The object to check
- * @returns True if the object is non-reactive
+ * 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 isNonReactive(obj: any): boolean;
+declare function root<T>(fn: () => T): T;
 
 /**
- * Registers a callback to be called when a computed property is invalidated
- * @param cb - The callback to register
- * @param warn - Whether to warn if used outside of a computed property
+ * 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 invalidateComputed(cb: () => void, warn?: boolean): void;
-type ComputedFunction<T> = (dep: DependencyAccess) => T;
-declare function computedFunction<T>(getter: ComputedFunction<T>): T;
+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;
+
 /**
- * Decorator and function for creating computed properties that cache their values
- * Only recomputes when dependencies change
+ * Symbol for accessing the cleanup function on cleaned objects
  */
-declare const computed: LegacyPropertyDecorator<any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any> & typeof computedFunction & {
-    map: typeof computedMap;
-    memo: typeof computedMapMemo;
-    self: typeof selfReferencing;
-};
+declare const cleanup: unique symbol;
 /**
  * Options for the watch function
  */
@@ -307,7 +552,7 @@ interface WatchOptions {
     deep?: boolean;
 }
 /**
- * Watches a computed value and calls a callback when it changes
+ * 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
@@ -317,7 +562,7 @@ declare function watch<T>(value: (dep: DependencyAccess) => T, changed: (value:
     deep?: false;
 }): ScopedCallback;
 /**
- * Watches a computed value with deep watching enabled
+ * 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
@@ -341,12 +586,272 @@ declare function unreactiveApplication<T extends object>(obj: T): T;
  * 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, cleanup: ScopedCallback): T & {
-    cleanup: () => void;
+declare function cleanedBy<T extends object>(obj: T, cleanupFn: ScopedCallback): T & {
+    [cleanup]: ScopedCallback;
 };
-declare function computedMap<T, U>(inputs: T[], compute: (input: T, index: number, oldValue?: U) => U, resize?: (newLength: number, oldLength: number) => void): U[];
-declare function computedMapMemo<I, O>(inputs: I[] | (() => I[]), compute: (input: I) => O): O[];
-declare function selfReferencing<T extends object>(compute: (dep: DependencyAccess) => T): T;
+/**
+ * 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 { Reactive, ReactiveBase, ReactiveError, activeEffect, addBatchCleanup, atomic, cleanedBy, computed, effect, getState, immutables, invalidateComputed, isNonReactive, isReactive, profileInfo, reactive, options as reactiveOptions, trackEffect, unreactive, untracked, unwrap, watch };
-export type { Evolution, ScopedCallback };
+export { ReactiveBase, ReactiveError, ReadOnlyError, Register, addBatchCleanup, atomic, batch, 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 };