mutts 1.0.8 → 1.0.9

package/dist/browser.d.ts

@@ -1,3 +1,6 @@
+import { c as cleanup, S as ScopedCallback, d as EffectCloser, e as EffectAccess, f as State, a as Evolution, b as EffectCleanup, Z as ZoneAggregator, g as EffectOptions, E as EffectTrigger, C as CatchFunction, P as ProjectionContext } from './types-DaHFfhlN.js';
+export { A as AZone, F as FunctionWrapper, R as ReactiveError, h as ReactiveErrorCode, i as Zone, j as ZoneHistory, k as asyncZone, o as reactiveOptions } from './types-DaHFfhlN.js';
+
 /**
  * Error thrown when decorator operations fail
  */
@@ -193,18 +196,19 @@ interface ContextManager<T = any> {
  * Base type for event maps - all event handlers must be functions
  */
 type EventsBase = Record<string, (...args: any[]) => void>;
+declare const events: unique symbol;
+declare const hooks$1: unique symbol;
 /**
  * A type-safe event system that provides a clean API for event handling
  * @template Events - The event map defining event names and their handler signatures
  */
 declare class Eventful<Events extends EventsBase> {
-    #private;
+    private readonly [events];
+    private readonly [hooks$1];
     hook(cb: <EventType extends keyof Events>(event: EventType, ...args: Parameters<Events[EventType]>) => void): () => void;
-    on(events: Partial<Events>): void;
-    on<EventType extends keyof Events>(event: EventType, cb: Events[EventType]): () => void;
-    off(events: Partial<Events>): void;
-    off<EventType extends keyof Events>(event: EventType, cb?: Events[EventType]): void;
-    emit<EventType extends keyof Events>(event: EventType, ...args: Parameters<Events[EventType]>): void;
+    on: ((events: Partial<Events>) => void) & (<EventType extends keyof Events>(event: EventType, cb: Events[EventType]) => () => void) & { [event in keyof Events]: (cb: Events[event]) => () => void; };
+    off: ((events: Partial<Events>) => void) & (<EventType extends keyof Events>(event: EventType, cb?: Events[EventType]) => void) & { [event in keyof Events]: (cb?: Events[event]) => void; };
+    emit: (<EventType extends keyof Events>(event: EventType, ...args: Parameters<Events[EventType]>) => void) & Events;
 }
 
 /**
@@ -546,399 +550,123 @@ type PromiseChain<T> = T extends (...args: infer Args) => infer R ? PromiseAnd<(
  */
 declare function chainPromise<T>(given: Promise<T> | T): PromiseChain<T>;
 
-declare abstract class AZone<T> {
-    abstract active?: T;
-    protected enter(value?: T): unknown;
-    protected leave(entered: unknown): void;
-    with<R>(value: T, fn: () => R): R;
-    root<R>(fn: () => R): R;
-    get zoned(): FunctionWrapper;
-}
-type FunctionWrapper = <R>(fn?: () => R) => R;
-declare class Zone<T> extends AZone<T> {
-    active: T | undefined;
-}
-type HistoryValue<T> = {
-    present: T | undefined;
-    history: Set<T>;
-};
-declare class ZoneHistory<T> extends AZone<HistoryValue<T>> {
-    private controlled;
-    private history;
-    readonly present: AZone<T>;
-    has(value: T): boolean;
-    some(predicate: (value: T) => boolean): boolean;
-    constructor(controlled?: AZone<T>);
-    get active(): HistoryValue<T> | undefined;
-    set active(value: HistoryValue<T> | undefined);
-}
-declare class ZoneAggregator extends AZone<Map<AZone<unknown>, unknown>> {
-    #private;
-    constructor(...zones: AZone<unknown>[]);
-    get active(): Map<AZone<unknown>, unknown> | undefined;
-    set active(value: Map<AZone<unknown>, unknown> | undefined);
-    enter(value?: Map<AZone<unknown>, unknown> | undefined): Map<AZone<unknown>, unknown>;
-    leave(entered: Map<AZone<unknown>, unknown>): void;
-    add(z: AZone<unknown>): void;
-    delete(z: AZone<unknown>): void;
-    clear(): void;
-}
-declare const asyncZone: ZoneAggregator;
-
-/**
- * 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: FunctionWrapper;
-    /**
-     * 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: FunctionWrapper;
-    /**
-     * 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
+ * Reactively attends to each entry of a collection or each key yielded by an
+ * enumeration callback. For each key, an inner effect runs the callback. When a
+ * key disappears, its inner effect is disposed. The callback may return a cleanup
+ * (like a regular effect closer).
+ *
+ * Accepts arrays, records, Maps, Sets, or a raw `() => Iterable<Key>` callback.
+ *
+ * @example
+ * ```typescript
+ * // Record shorthand
+ * attend(record, (key) => { console.log(key, record[key]) })
+ *
+ * // Array shorthand
+ * attend(array, (index) => { console.log(index, array[index]) })
+ *
+ * // Raw enumeration callback
+ * attend(() => Object.keys(record), (key) => { ... })
+ * ```
  */
-type PropEvolution = {
-    type: 'set' | 'del' | 'add' | 'invalidate';
-    prop: any;
-};
+declare function attend<T>(source: readonly T[], callback: (index: number) => EffectCloser | void): ScopedCallback;
+declare function attend<K, V>(source: Map<K, V>, callback: (key: K) => EffectCloser | void): ScopedCallback;
+declare function attend<T>(source: Set<T>, callback: (value: T) => EffectCloser | void): ScopedCallback;
+declare function attend<S extends Record<PropertyKey, any>>(source: S, callback: (key: keyof S & string) => EffectCloser | void): ScopedCallback;
+declare function attend<Key>(enumerate: () => Iterable<Key>, callback: (key: Key) => EffectCloser | void): ScopedCallback;
 /**
- * Type for collection operation evolution events
+ * Result of a reactive scan, which is a reactive array of accumulated values
+ * with an attached cleanup function.
  */
-type BunchEvolution = {
-    type: 'bunch';
-    method: string;
+type ScanResult<Output> = readonly Output[] & {
+    [cleanup]: ScopedCallback;
 };
-type Evolution = PropEvolution | BunchEvolution;
-type State = {
-    evolution: Evolution;
-    next: State;
-} | {};
 /**
- * Symbol to check if an effect is stopped
- */
-declare const stopped: unique symbol;
-/**
- * Symbol to access effect cleanup function
- */
-declare const cleanup$1: unique symbol;
-/**
- * Context for a running projection item effect
+ * Perform a reactive scan over an array of items.
+ *
+ * This implementation is highly optimized for performance and fine-grained reactivity:
+ * - **Incremental Updates**: Changes to an item only trigger re-computation from that
+ *   point onwards in the result chain.
+ * - **Move Optimization**: If items are moved within the array, their accumulated
+ *   values are reused as long as their predecessor remains the same.
+ * - **Duplicate Support**: Correctly handles multiple occurrences of the same object
+ *   instance using an internal occurrence tracking mechanism.
+ * - **Memory Efficient**: Uses `WeakMap` for caching intermediates, which are
+ *   automatically cleared when source items are garbage collected.
+ *
+ * @example
+ * ```typescript
+ * const source = reactive([{ val: 1 }, { val: 2 }, { val: 3 }])
+ * const sum = scan(source, (acc, item) => acc + item.val, 0)
+ *
+ * expect([...sum]).toEqual([1, 3, 6])
+ *
+ * // Modifying an item only re-computes subsequent sums
+ * source[1].val = 10
+ * expect([...sum]).toEqual([1, 11, 14])
+ * ```
+ *
+ * @param source The source array of objects (will be made reactive)
+ * @param callback The accumulator function called with (accumulator, currentItem)
+ * @param initialValue The starting value for the accumulation
+ * @returns A reactive array of accumulated values, with a [cleanup] property to stop the tracking
  */
-interface ProjectionContext {
-    source: any;
-    key?: any;
-    target: any;
-    depth: number;
-    parent?: ProjectionContext;
-}
+declare function scan<Input extends object, Output>(source: readonly Input[], callback: (acc: Output, val: Input) => Output, initialValue: Output): ScanResult<Output>;
 /**
- * Structured error codes for machine-readable diagnosis
+ * Lifts a callback that returns an array into a reactive array that automatically
+ * synchronizes with the source array returned by the callback.
+ *
+ * The returned reactive array will update whenever the callback's dependencies change,
+ * efficiently syncing only the elements that differ from the previous result.
+ *
+ * @example
+ * ```typescript
+ * const items = reactive([1, 2, 3])
+ * const doubled = lift(() => items.map(x => x * 2))
+ *
+ * console.log([...doubled]) // [2, 4, 6]
+ *
+ * items.push(4)
+ * console.log([...doubled]) // [2, 4, 6, 8]
+ * ```
+ *
+ * @param cb Callback function that returns an array
+ * @returns A reactive array synchronized with the callback's result, with a [cleanup] property to stop tracking
  */
-declare enum ReactiveErrorCode {
-    CycleDetected = "CYCLE_DETECTED",
-    MaxDepthExceeded = "MAX_DEPTH_EXCEEDED",
-    MaxReactionExceeded = "MAX_REACTION_EXCEEDED",
-    WriteInComputed = "WRITE_IN_COMPUTED",
-    TrackingError = "TRACKING_ERROR",
-    BrokenEffects = "BROKEN_EFFECTS"
-}
-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 BrokenEffectsDebugInfo = {
-    code: ReactiveErrorCode.BrokenEffects;
-    cause: any;
-};
-type GenericDebugInfo = {
-    code: ReactiveErrorCode;
-    causalChain?: string[];
-    creationStack?: string;
-    [key: string]: any;
+declare function lift<Output extends any[]>(cb: (access: EffectAccess) => Output): Output & {
+    [cleanup]: ScopedCallback;
 };
-type ReactiveDebugInfo = CycleDebugInfo | MaxDepthDebugInfo | MaxReactionDebugInfo | BrokenEffectsDebugInfo | GenericDebugInfo;
-/**
- * Error class for reactive system errors
- */
-declare class ReactiveError extends Error {
-    debugInfo?: ReactiveDebugInfo;
-    constructor(message: string, debugInfo?: ReactiveDebugInfo);
-    get code(): ReactiveErrorCode | undefined;
-    get cause(): any;
-}
 /**
- * Global options for the reactive system
+ * Lifts a callback that returns an object into a reactive object that automatically
+ * synchronizes with the source object returned by the callback.
+ *
+ * The returned reactive object will update whenever the callback's dependencies change,
+ * efficiently syncing only the properties that differ from the previous result using
+ * Object.assign(). Properties that no longer exist in the source are automatically removed.
+ *
+ * @example
+ * ```typescript
+ * const user = reactive({ name: 'John', age: 30 })
+ * const profile = lift(() => ({
+ *   displayName: user.name.toUpperCase(),
+ *   isAdult: user.age >= 18,
+ *   description: `${user.name} is ${user.age} years old`
+ * }))
+ *
+ * console.log(profile.displayName) // JOHN
+ * console.log(profile.isAdult) // true
+ *
+ * user.name = 'Jane'
+ * console.log(profile.displayName) // JANE
+ * console.log(profile.description) // Jane is 30 years old
+ * ```
+ *
+ * @param cb Callback function that returns an object
+ * @returns A reactive object synchronized with the callback's result, with a [cleanup] property to stop tracking
  */
-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) => 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.
-     *
-     * - `'none'` (Default): High-performance mode. Disables dependency graph maintenance and
-     *   Topological Sorting in favor of a simple FIFO queue. Use this for trustworthy, acyclic UI code.
-     *   Cycle detection is heuristic (uses execution counts).
-     *
-     * - `'throw'`: Traditional Topological Sorting. Guarantees dependency order and catches
-     *   circular dependencies mathematically before execution.
-     *
-     * - `'warn'`: Topological sorting, but logs a warning instead of throwing on cycles.
-     * - `'break'`: Topological sorting, but silently breaks cycles.
-     * - `'strict'`: Prevents cycle creation by checking the graph *during* dependency discovery.
-     *
-     * @default 'none'
-     */
-    cycleHandling: "none" | "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)
-     * @deprecated Should take all when we made sure PIXI.create, Game.create, ... are -> .root()
-     */
-    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;
-    };
+declare function lift<Output extends object>(cb: (access: EffectAccess) => Output): Output & {
+    [cleanup]: ScopedCallback;
 };
 
 /**
@@ -962,72 +690,6 @@ declare function touched1(obj: any, evolution: Evolution, prop: any): void;
  */
 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
@@ -1044,16 +706,52 @@ declare function isDevtoolsEnabled(): boolean;
  */
 declare function deepWatch<T extends object>(target: T, callback: (value: T) => void, { immediate }?: {
     immediate?: boolean;
-}): (() => void) | undefined;
+}): EffectCleanup | undefined;
+
+/**
+ * Aggregator for zones that need to be tracked along effects.
+ * ie. in each effect, the active zone of the given zoning will be the one active at effect's definition
+ */
+declare const effectAggregator: ZoneAggregator;
+declare function getActiveEffect(): ScopedCallback;
+/**
+ * ADD a cleanup function to an object using the cleanup symbol.
+ * The cleanup function will be called when the object needs to be disposed.
+ *
+ * Note: most of the time, you don't need to use this function directly.
+ * The main use if for the cleanup function to be stored with the object, as GC calls the cleanup function when the *function* is garbage collected.
+ *
+ * @param obj - The object to attach the cleanup function to
+ * @param cleanupFn - The cleanup function to attach
+ * @returns The object with the cleanup function attached
+ */
+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: EffectAccess) => T): {
+    value: T;
+    [cleanup]: ScopedCallback;
+};
 
-type EffectTracking = (obj: any, evolution: Evolution, prop: any) => void;
+type EffectTracking = (obj: any, evolution: Evolution, prop: any, effect: EffectTrigger) => void;
 interface ActivationRecord {
-    effect: ScopedCallback;
+    effect: EffectTrigger;
     obj: any;
     evolution: Evolution;
     prop: any;
     batchId: number;
 }
+/**
+ * Returns the activation log containing recent effect activations for debugging.
+ * The log is a circular buffer of the last 100 activations.
+ *
+ * @returns Array of activation records
+ */
 declare function getActivationLog(): Omit<ActivationRecord, "batchId">[];
 /**
  * Registers a debug callback that is called when the current effect is triggered by a dependency change
@@ -1065,7 +763,7 @@ declare function getActivationLog(): Omit<ActivationRecord, "batchId">[];
  * - 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.
+ * to track multiple triggers, call `onEffectTrigger` 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
@@ -1076,7 +774,7 @@ declare function getActivationLog(): Omit<ActivationRecord, "batchId">[];
  *
  * effect(() => {
  *   // Register a tracker to see what triggers this effect
- *   trackEffect((obj, evolution, prop) => {
+ *   onEffectTrigger((obj, evolution, prop) => {
  *     console.log(`Effect triggered by:`, {
  *       object: obj,
  *       change: evolution.type,
@@ -1089,15 +787,15 @@ declare function getActivationLog(): Omit<ActivationRecord, "batchId">[];
  * })
  *
  * state.count = 5
- * // Logs: Effect triggered by: { object: state, change: 'set', property: 'count' }
  * ```
  */
-declare function trackEffect(onTouch: EffectTracking): void;
+declare function onEffectTrigger(onTouch: EffectTracking, effect?: EffectTrigger): void;
+declare function onEffectThrow(onThrow: CatchFunction, effect?: EffectTrigger): 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;
+declare function addBatchCleanup(cleanup: EffectCleanup): void;
 /**
  * Semantic alias for `addBatchCleanup` - defers work to the end of the current reactive batch.
  *
@@ -1119,6 +817,14 @@ declare function addBatchCleanup(cleanup: ScopedCallback): void;
  * ```
  */
 declare const defer: typeof addBatchCleanup;
+/**
+ * Resets the reactive system to a consistent state.
+ * Call this after an unrecoverable error has set the system to "broken".
+ * This clears all batch state, effect dependency graphs, and watcher registrations.
+ * All existing effects become orphaned and must be recreated.
+ */
+declare function reset(): void;
+
 /**
  * Decorator that makes methods atomic - batches all effects triggered within the method
  */
@@ -1133,9 +839,9 @@ declare const atomic: LegacyPropertyDecorator<any> & ModernMethodDecorator<any>
  * @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 & {
-    [stopped]: boolean;
-    [cleanup$1]: () => void;
+declare const effect: ((fn: (access: EffectAccess) => EffectCloser | undefined | void | Promise<any>, effectOptions?: EffectOptions) => EffectCleanup) & {
+    readonly opaque: any;
+    named(name: string): any;
 };
 /**
  * Executes a function without tracking dependencies but maintains parent cleanup relationship
@@ -1149,7 +855,6 @@ declare function untracked<T>(fn: () => T): T;
  * @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
@@ -1189,69 +894,31 @@ declare function biDi<T>(received: (value: T) => void, value: {
 }): (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;
-};
-
 type Memoizable = object | any[] | symbol | ((...args: any[]) => any);
 declare function memoizeFunction<Result, Args extends Memoizable[]>(fn: (...args: Args) => Result): (...args: Args) => Result;
+/**
+ * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
+ *
+ * When used as a decorator on getters or methods, it caches the result and automatically
+ * invalidates the cache when reactive dependencies change.
+ *
+ * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @memoize
+ *   get fullName() {
+ *     return `${this.firstName} ${this.lastName}`
+ *   }
+ * }
+ *
+ * // Or as a function wrapper
+ * const expensive = memoize((obj: SomeObject) => {
+ *   return heavyComputation(obj)
+ * })
+ * ```
+ */
 declare const memoize: LegacyPropertyDecorator<any> & ModernMethodDecorator<any> & ModernGetterDecorator<any> & ModernAccessorDecorator<any> & typeof memoizeFunction;
 
 declare const immutables: Set<(tested: any) => boolean>;
@@ -1259,6 +926,31 @@ 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;
+/**
+ * Events emitted by the Register for CRUD operations
+ */
+interface RegisterEvents<T, K extends PropertyKey> {
+    /**
+     * Emitted when a new item is added to the register
+     */
+    add: (item: T, key: K, index: number) => void;
+    /**
+     * Emitted when an item is removed from the register
+     */
+    delete: (item: T, key: K, index: number) => void;
+    /**
+     * Emitted when an item's value is updated (same key, new value)
+     */
+    update: (oldItem: T, newItem: T, key: K, index: number) => void;
+    /**
+     * Emitted when an item's key changes (rekey operation)
+     */
+    rekey: (item: T, oldKey: K, newKey: K, index: number) => void;
+    /**
+     * Index signature for EventsBase compatibility
+     */
+    [key: string]: (...args: any[]) => void;
+}
 interface RegisterInstance<T> extends ArrayReadForward<T> {
     [index: number]: T;
 }
@@ -1269,6 +961,20 @@ declare const RegisterClass_base: new () => ArrayReadForward<any> & {
 declare class RegisterClass<T, K extends PropertyKey = PropertyKey> extends RegisterClass_base implements RegisterInstance<T> {
     #private;
     protected get [forwardArray](): readonly T[];
+    /**
+     * Register event listeners for CRUD operations
+     */
+    on(events: Partial<RegisterEvents<T, K>>): void;
+    on<EventType extends keyof RegisterEvents<T, K>>(event: EventType, cb: RegisterEvents<T, K>[EventType]): () => void;
+    /**
+     * Remove event listeners
+     */
+    off(events: Partial<RegisterEvents<T, K>>): void;
+    off<EventType extends keyof RegisterEvents<T, K>>(event: EventType, cb?: RegisterEvents<T, K>[EventType]): void;
+    /**
+     * Register a global hook that receives all events
+     */
+    hook(cb: <EventType extends keyof RegisterEvents<T, K>>(event: EventType, ...args: Parameters<RegisterEvents<T, K>[EventType]>) => void): () => void;
     constructor(keyFn: KeyFunction<T, K>, initial?: Iterable<T>);
     private ensureKey;
     private assertValidKey;
@@ -1318,6 +1024,28 @@ declare class RegisterClass<T, K extends PropertyKey = PropertyKey> extends Regi
 }
 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>;
+/**
+ * Creates a reactive Register - an ordered, array-like collection with stable key-based identity.
+ *
+ * Register combines array semantics (indexable access, ordering, iteration) with Map-like
+ * key-based lookups. Items with the same key share the same value instance, making it ideal
+ * for UI lists keyed by IDs or when you need to preserve identity across reorders.
+ *
+ * @param keyFn - Function that extracts the key from each item
+ * @param initial - Optional initial items to populate the register
+ * @returns A reactive Register instance
+ *
+ * @example
+ * ```typescript
+ * const users = register(
+ *   (user: User) => user.id,
+ *   [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ * )
+ *
+ * users.push({ id: 3, name: 'Charlie' })
+ * const bob = users.get(2) // Get by key
+ * ```
+ */
 declare function register<T, K extends PropertyKey = PropertyKey>(keyFn: KeyFunction<T, K>, initial?: Iterable<T>): Register<T, K>;
 
 /**
@@ -1409,7 +1137,7 @@ access: OrganizedAccess<Source, Key>,
 /**
  * The target object where organized data will be stored
  */
-target: Target) => ScopedCallback | undefined;
+target: Target) => EffectCloser | undefined;
 /**
  * The result type of the organized function, combining the target object with cleanup capability.
  * @template Target - The type of the target object
@@ -1487,49 +1215,61 @@ declare function organize<T>(target: object, property: PropertyKey, access: {
 }): () => boolean;
 
 /**
- * Result of a reactive scan, which is a reactive array of accumulated values
- * with an attached cleanup function.
+ * Options for the watch function
  */
-type ScanResult<Output> = readonly Output[] & {
-    [cleanup]: ScopedCallback;
-};
+interface WatchOptions {
+    /** Whether to call the callback immediately */
+    immediate?: boolean;
+    /** Whether to watch nested properties */
+    deep?: boolean;
+}
 /**
- * Perform a reactive scan over an array of items.
- *
- * This implementation is highly optimized for performance and fine-grained reactivity:
- * - **Incremental Updates**: Changes to an item only trigger re-computation from that
- *   point onwards in the result chain.
- * - **Move Optimization**: If items are moved within the array, their accumulated
- *   values are reused as long as their predecessor remains the same.
- * - **Duplicate Support**: Correctly handles multiple occurrences of the same object
- *   instance using an internal occurrence tracking mechanism.
- * - **Memory Efficient**: Uses `WeakMap` for caching intermediates, which are
- *   automatically cleared when source items are garbage collected.
- *
- * @example
- * ```typescript
- * const source = reactive([{ val: 1 }, { val: 2 }, { val: 3 }])
- * const sum = scan(source, (acc, item) => acc + item.val, 0)
- *
- * expect([...sum]).toEqual([1, 3, 6])
+ * 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: EffectAccess) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
+    deep?: false;
+}): EffectCleanup;
+/**
+ * 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: EffectAccess) => T, changed: (value: T, oldValue?: T) => void, options?: Omit<WatchOptions, 'deep'> & {
+    deep: true;
+}): EffectCleanup;
+/**
+ * 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): EffectCleanup;
+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;
+
+/**
+ * Reactively defines properties on a target object based on a descriptors record.
  *
- * // Modifying an item only re-computes subsequent sums
- * source[1].val = 10
- * expect([...sum]).toEqual([1, 11, 14])
- * ```
+ * It tracks the keys of the descriptors record and defines/updates/removes
+ * properties on the target object as they change.
  *
- * @param source The source array of objects (will be made reactive)
- * @param callback The accumulator function called with (accumulator, currentItem)
- * @param initialValue The starting value for the accumulation
- * @returns A reactive array of accumulated values, with a [cleanup] property to stop the tracking
+ * @param descriptors - A reactive record of property descriptors.
+ * @param target - The object to define properties on (defaults to a new object).
+ * @returns The target object with reactive property definitions.
  */
-declare function scan<Input extends object, Output>(source: readonly Input[], callback: (acc: Output, val: Input) => Output, initialValue: Output): ScanResult<Output>;
-declare function resolve<Output>(cb: () => Output[]): Output[] & {
-    [cleanup]: ScopedCallback;
-};
-
-declare const effectAggregator: ZoneAggregator;
-declare function getActiveEffect(): ScopedCallback;
+declare function describe<T extends object>(descriptors: Record<PropertyKey, PropertyDescriptor>, target?: T): T;
 
 /**
  * Object containing internal reactive system state for debugging and profiling
@@ -1560,11 +1300,7 @@ declare function cache(object: Object, propertyKey: PropertyKey, value: any): vo
  * @param descriptor - The descriptor properties to apply
  * @returns A class decorator that applies the descriptor to specified properties
  */
-declare function describe(descriptor: {
-    enumerable?: boolean;
-    configurable?: boolean;
-    writable?: boolean;
-}): <T>(...properties: (keyof T)[]) => GenericClassDecorator<T>;
+declare const descriptor: any;
 /**
  * Decorator that marks methods, properties, or classes as deprecated
  * Provides warning messages when deprecated items are used
@@ -1635,8 +1371,9 @@ declare function named<T extends Function>(name: string, fn: T): T;
 
 type Restorer = () => () => void;
 type Hook = () => Restorer;
+declare const hooks: Set<Hook>;
 declare const asyncHooks: {
-    addHook(_hook: Hook): () => void;
+    addHook(hook: Hook): () => void;
     /**
      * [Hack] Sanitize a promise (or value) to prevent context leaks.
      * Default: Identity function.
@@ -1651,5 +1388,5 @@ declare const asyncHooks: {
  */
 declare const asyncHook: (hook: Hook) => () => void;
 
-export { AZone, ArrayReadForward, DecoratorError, Destroyable, DestructionError, Eventful, FoolProof, Indexable, IterableWeakMap, IterableWeakSet, ReactiveBase, ReactiveError, ReactiveErrorCode, Register, Zone, ZoneAggregator, ZoneHistory, addBatchCleanup, allocated, allocatedValues, arrayEquals, asyncHook, asyncHooks, asyncZone, atomic, biDi, buildReactivityGraph, cache, cached, callOnGC, chainPromise, cleanedBy, cleanup, contentRef, debounce, decorator, deepCompare, deepWatch, defer, deprecated, derived, describe, destructor, effect, effectAggregator, enableDevTools, forwardArray, getActivationLog, getActiveEffect, getActiveProjection, getAt, getState, immutables, isCached, isConstructor, isDevtoolsEnabled, isNonReactive, isOwnAccessor, isReactive, legacyDecorator, memoize, mixin, modernDecorator, named, organize, organized, profileInfo, project, reactive, options as reactiveOptions, register, registerEffectForDebug, registerNativeReactivity, registerObjectForDebug, renamed, resolve, root, scan, setAt, setEffectName, setObjectName, tag, throttle, touched, touched1, trackEffect, unreactive, untracked, unwrap, watch, zip };
-export type { ContextManager, Decorator, DecoratorDescription, DecoratorFactory, DependencyAccess, EventsBase, Evolution, FunctionWrapper, GenericClassDecorator, Hook, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactivityGraph, Restorer, ScanResult, ScopedCallback };
+export { ArrayReadForward, DecoratorError, EffectAccess as DependencyAccess, Destroyable, DestructionError, EffectCleanup, EffectOptions, EffectTrigger, Eventful, Evolution, FoolProof, Indexable, IterableWeakMap, IterableWeakSet, ReactiveBase, Register, ScopedCallback, ZoneAggregator, addBatchCleanup, allocated, allocatedValues, arrayEquals, asyncHook, asyncHooks, atomic, attend, biDi, cache, cached, callOnGC, chainPromise, cleanedBy, cleanup, contentRef, debounce, decorator, deepCompare, deepWatch, defer, deprecated, derived, describe, descriptor, destructor, effect, effectAggregator, forwardArray, getActivationLog, getActiveEffect, getActiveProjection, getAt, getState, hooks, immutables, isCached, isConstructor, isNonReactive, isOwnAccessor, isReactive, legacyDecorator, lift, memoize, mixin, modernDecorator, named, onEffectThrow, onEffectTrigger, organize, organized, profileInfo, project, reactive, register, registerNativeReactivity, renamed, reset, root, scan, setAt, tag, throttle, touched, touched1, unreactive, untracked, unwrap, watch, zip };
+export type { ContextManager, Decorator, DecoratorDescription, DecoratorFactory, EventsBase, GenericClassDecorator, Hook, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, Restorer, ScanResult };