mutts 1.0.2 → 1.0.3

package/dist/chunks/index-HNVqPzjz.js

@@ -0,0 +1,4891 @@
+'use strict';
+
+var decorator = require('./decorator-DLvrD0UF.js');
+var indexable = require('../indexable.js');
+var _tslib = require('./_tslib-BgjropY9.js');
+
+/// <reference lib="esnext.collection" />
+var _a, _b;
+/**
+ * Uses weak references but still may iterate through them
+ * Note: The behavior is highly dependant on the garbage collector - some entries are perhaps deemed to be collected: don't resuscitate them
+ */
+class IterableWeakMap {
+    constructor(entries) {
+        this.uuids = new WeakMap();
+        this.refs = {};
+        this[_a] = 'IterableWeakMap';
+        // Create a FinalizationRegistry to clean up refs when keys are garbage collected
+        this.registry = new FinalizationRegistry((uuid) => {
+            delete this.refs[uuid];
+        });
+        if (entries)
+            for (const [k, v] of entries)
+                this.set(k, v);
+    }
+    createIterator(cb) {
+        const { refs } = this;
+        return (function* () {
+            for (const uuid of Object.keys(refs)) {
+                const [keyRef, value] = refs[uuid];
+                const key = keyRef.deref();
+                if (key)
+                    yield cb(key, value);
+                else
+                    delete refs[uuid];
+            }
+            return undefined;
+        })();
+    }
+    clear() {
+        // Unregister all keys from the FinalizationRegistry
+        for (const uuid of Object.keys(this.refs)) {
+            const key = this.refs[uuid][0].deref();
+            if (key)
+                this.registry.unregister(key);
+        }
+        this.uuids = new WeakMap();
+        this.refs = {};
+    }
+    delete(key) {
+        const uuid = this.uuids.get(key);
+        if (!uuid)
+            return false;
+        delete this.refs[uuid];
+        this.uuids.delete(key);
+        this.registry.unregister(key);
+        return true;
+    }
+    forEach(callbackfn, thisArg) {
+        for (const [k, v] of this)
+            callbackfn.call(thisArg ?? this, v, k, thisArg ?? this);
+    }
+    get(key) {
+        const uuid = this.uuids.get(key);
+        if (!uuid)
+            return undefined;
+        return this.refs[uuid][1];
+    }
+    has(key) {
+        return this.uuids.has(key);
+    }
+    set(key, value) {
+        let uuid = this.uuids.get(key);
+        if (uuid) {
+            this.refs[uuid][1] = value;
+        }
+        else {
+            uuid = crypto.randomUUID();
+            this.uuids.set(key, uuid);
+            this.refs[uuid] = [new WeakRef(key), value];
+            // Register key for cleanup when garbage collected
+            this.registry.register(key, uuid, key);
+        }
+        return this;
+    }
+    get size() {
+        return [...this].length;
+    }
+    entries() {
+        return this.createIterator((key, value) => [key, value]);
+    }
+    keys() {
+        return this.createIterator((key, _value) => key);
+    }
+    values() {
+        return this.createIterator((_key, value) => value);
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+}
+_a = Symbol.toStringTag;
+/**
+ * Uses weak references but still may iterate through them
+ * Note: The behavior is highly dependant on the garbage collector - some entries are perhaps deemed to be collected: don't resuscitate them
+ */
+class IterableWeakSet {
+    constructor(entries) {
+        this.uuids = new WeakMap();
+        this.refs = {};
+        this[_b] = 'IterableWeakSet';
+        // Create a FinalizationRegistry to clean up refs when values are garbage collected
+        this.registry = new FinalizationRegistry((uuid) => {
+            delete this.refs[uuid];
+        });
+        if (entries)
+            for (const k of entries)
+                this.add(k);
+    }
+    createIterator(cb) {
+        const { refs } = this;
+        return (function* () {
+            for (const uuid of Object.keys(refs)) {
+                const key = refs[uuid].deref();
+                if (key)
+                    yield cb(key);
+                else
+                    delete refs[uuid];
+            }
+            return undefined;
+        })();
+    }
+    clear() {
+        // Unregister all values from the FinalizationRegistry
+        for (const uuid of Object.keys(this.refs)) {
+            const value = this.refs[uuid].deref();
+            if (value)
+                this.registry.unregister(value);
+        }
+        this.uuids = new WeakMap();
+        this.refs = {};
+    }
+    add(value) {
+        let uuid = this.uuids.get(value);
+        if (!uuid) {
+            uuid = crypto.randomUUID();
+            this.uuids.set(value, uuid);
+            this.refs[uuid] = new WeakRef(value);
+            // Register value for cleanup when garbage collected
+            this.registry.register(value, uuid, value);
+        }
+        return this;
+    }
+    delete(value) {
+        const uuid = this.uuids.get(value);
+        if (!uuid)
+            return false;
+        delete this.refs[uuid];
+        this.uuids.delete(value);
+        this.registry.unregister(value);
+        return true;
+    }
+    forEach(callbackfn, thisArg) {
+        for (const value of this)
+            callbackfn.call(thisArg ?? this, value, value, thisArg ?? this);
+    }
+    has(value) {
+        return this.uuids.has(value);
+    }
+    get size() {
+        return [...this].length;
+    }
+    entries() {
+        return this.createIterator((key) => [key, key]);
+    }
+    keys() {
+        return this.createIterator((key) => key);
+    }
+    values() {
+        return this.createIterator((key) => key);
+    }
+    [Symbol.iterator]() {
+        return this.keys();
+    }
+    union(other) {
+        const others = {
+            [Symbol.iterator]() {
+                return other.keys();
+            },
+        };
+        const that = this;
+        return new Set((function* () {
+            yield* that;
+            for (const value of others)
+                if (!that.has(value))
+                    yield value;
+        })());
+    }
+    intersection(other) {
+        const that = this;
+        return new Set((function* () {
+            for (const value of that)
+                if (other.has(value))
+                    yield value;
+        })());
+    }
+    difference(other) {
+        const that = this;
+        return new Set((function* () {
+            for (const value of that)
+                if (!other.has(value))
+                    yield value;
+        })());
+    }
+    symmetricDifference(other) {
+        const others = {
+            [Symbol.iterator]() {
+                return other.keys();
+            },
+        };
+        const that = this;
+        return new Set((function* () {
+            for (const value of that)
+                if (!other.has(value))
+                    yield value;
+            for (const value of others)
+                if (!that.has(value))
+                    yield value;
+        })());
+    }
+    isSubsetOf(other) {
+        for (const value of this)
+            if (!other.has(value))
+                return false;
+        return true;
+    }
+    isSupersetOf(other) {
+        const others = {
+            [Symbol.iterator]() {
+                return other.keys();
+            },
+        };
+        for (const value of others)
+            if (!this.has(value))
+                return false;
+        return true;
+    }
+    isDisjointFrom(other) {
+        for (const value of this)
+            if (other.has(value))
+                return false;
+        return true;
+    }
+}
+_b = Symbol.toStringTag;
+
+/**
+ * Creates a mixin that can be used both as a class (extends) and as a function (mixin)
+ *
+ * This function supports:
+ * - Using mixins as base classes: `class MyClass extends MyMixin`
+ * - Using mixins as functions: `class MyClass extends MyMixin(SomeBase)`
+ * - Composing mixins: `const Composed = MixinA(MixinB)`
+ * - Type-safe property inference for all patterns
+ *
+ * @param mixinFunction - The function that creates the mixin
+ * @param unwrapFunction - Optional function to unwrap reactive objects for method calls
+ * @returns A mixin that can be used both as a class and as a function
+ */
+function mixin(mixinFunction, unwrapFunction) {
+    /**
+     * Cache for mixin results to ensure the same base class always returns the same mixed class
+     */
+    const mixinCache = new WeakMap();
+    // Apply the mixin to Object as the base class
+    const MixedBase = mixinFunction(Object);
+    mixinCache.set(Object, MixedBase);
+    // Create the proxy that handles both constructor and function calls
+    return new Proxy(MixedBase, {
+        // Handle `MixinClass(SomeBase)` - use as mixin function
+        apply(_target, _thisArg, args) {
+            if (args.length === 0) {
+                throw new Error('Mixin requires a base class');
+            }
+            const baseClass = args[0];
+            if (typeof baseClass !== 'function') {
+                throw new Error('Mixin requires a constructor function');
+            }
+            // Check if it's a valid constructor or a mixin
+            if (!decorator.isConstructor(baseClass) &&
+                !(baseClass && typeof baseClass === 'function' && baseClass.prototype)) {
+                throw new Error('Mixin requires a valid constructor');
+            }
+            // Check cache first
+            const cached = mixinCache.get(baseClass);
+            if (cached) {
+                return cached;
+            }
+            let usedBase = baseClass;
+            if (unwrapFunction) {
+                // Create a proxied base class that handles method unwrapping
+                const ProxiedBaseClass = class extends baseClass {
+                };
+                // Proxy the prototype methods to handle unwrapping
+                const originalPrototype = baseClass.prototype;
+                const proxiedPrototype = new Proxy(originalPrototype, {
+                    get(target, prop, receiver) {
+                        const value = decorator.ReflectGet(target, prop, receiver);
+                        // Only wrap methods that are likely to access private fields
+                        // Skip symbols and special properties that the reactive system needs
+                        if (typeof value === 'function' &&
+                            typeof prop === 'string' &&
+                            !['constructor', 'toString', 'valueOf'].includes(prop)) {
+                            // Return a wrapped version that uses unwrapped context
+                            return function (...args) {
+                                // Use the unwrapping function if provided, otherwise use this
+                                const context = unwrapFunction(this);
+                                return value.apply(context, args);
+                            };
+                        }
+                        return value;
+                    },
+                });
+                // Set the proxied prototype
+                Object.setPrototypeOf(ProxiedBaseClass.prototype, proxiedPrototype);
+                usedBase = ProxiedBaseClass;
+            }
+            // Create the mixed class using the proxied base class
+            const mixedClass = mixinFunction(usedBase);
+            // Cache the result
+            mixinCache.set(baseClass, mixedClass);
+            return mixedClass;
+        },
+    });
+}
+
+// biome-ignore-all lint/suspicious/noConfusingVoidType: Type 'void' is not assignable to type 'ScopedCallback | undefined'.
+// Argument of type '() => void' is not assignable to parameter of type '(dep: DependencyFunction) => ScopedCallback | undefined'.
+// Track native reactivity
+const nativeReactive = Symbol('native-reactive');
+/**
+ * Symbol to mark individual objects as non-reactive
+ */
+const nonReactiveMark = Symbol('non-reactive');
+/**
+ * Symbol to mark class properties as non-reactive
+ */
+const unreactiveProperties = Symbol('unreactive-properties');
+/**
+ * Symbol for prototype forwarding in reactive objects
+ */
+const prototypeForwarding = Symbol('prototype-forwarding');
+/**
+ * Symbol representing all properties in reactive tracking
+ */
+const allProps = Symbol('all-props');
+// Symbol to mark functions with their root function
+const rootFunction = Symbol('root-function');
+/**
+ * Structured error codes for machine-readable diagnosis
+ */
+var ReactiveErrorCode;
+(function (ReactiveErrorCode) {
+    ReactiveErrorCode["CycleDetected"] = "CYCLE_DETECTED";
+    ReactiveErrorCode["MaxDepthExceeded"] = "MAX_DEPTH_EXCEEDED";
+    ReactiveErrorCode["MaxReactionExceeded"] = "MAX_REACTION_EXCEEDED";
+    ReactiveErrorCode["WriteInComputed"] = "WRITE_IN_COMPUTED";
+    ReactiveErrorCode["TrackingError"] = "TRACKING_ERROR";
+})(ReactiveErrorCode || (ReactiveErrorCode = {}));
+/**
+ * Error class for reactive system errors
+ */
+class ReactiveError extends Error {
+    constructor(message, debugInfo) {
+        super(message);
+        this.debugInfo = debugInfo;
+        this.name = 'ReactiveError';
+    }
+}
+// biome-ignore-start lint/correctness/noUnusedFunctionParameters: Interface declaration with empty defaults
+/**
+ * Global options for the reactive system
+ */
+const options = {
+    /**
+     * Debug purpose: called when an effect is entered
+     * @param effect - The effect that is entered
+     */
+    enter: (_effect) => { },
+    /**
+     * Debug purpose: called when an effect is left
+     * @param effect - The effect that is left
+     */
+    leave: (_effect) => { },
+    /**
+     * 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, _caller) => { },
+    /**
+     * Debug purpose: called when an effect chain is started
+     * @param target - The effect that is being triggered
+     */
+    beginChain: (_targets) => { },
+    /**
+     * Debug purpose: called when an effect chain is ended
+     */
+    endChain: () => { },
+    garbageCollected: (_fn) => { },
+    /**
+     * 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, _evolution, _props, _deps) => { },
+    /**
+     * 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, _runningChain) => { },
+    /**
+     * Debug purpose: maximum effect chain (like call stack max depth)
+     * Used to prevent infinite loops
+     * @default 100
+     */
+    maxEffectChain: 100,
+    /**
+     * Debug purpose: maximum effect reaction (like call stack max depth)
+     * Used to prevent infinite loops
+     * @default 'throw'
+     */
+    maxEffectReaction: 'throw',
+    /**
+     * 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',
+    /**
+     * Maximum depth for deep watching traversal
+     * Used to prevent infinite recursion in circular references
+     * @default 100
+     */
+    maxDeepWatchDepth: 100,
+    /**
+     * Only react on instance members modification (not inherited properties)
+     * For instance, do not track class methods
+     * @default true
+     */
+    instanceMembers: true,
+    /**
+     * Ignore accessors (getters and setters) and only track direct properties
+     * @default true
+     */
+    ignoreAccessors: true,
+    /**
+     * 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: true,
+    /**
+     * 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: 'cancel',
+    // biome-ignore lint/suspicious/noConsole: This is the whole point here
+    warn: (...args) => console.warn(...args),
+    /**
+     * Configuration for the introspection system
+     */
+    introspection: {
+        /**
+         * Whether to keep a history of mutations for debugging
+         * @default false
+         */
+        enableHistory: false,
+        /**
+         * Number of mutations to keep in history
+         * @default 50
+         */
+        historySize: 50,
+    },
+    /**
+     * 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: true,
+        /**
+         * Hook setInterval to preserve effect context
+         * @default true
+         */
+        setInterval: true,
+        /**
+         * Hook requestAnimationFrame (runs in untracked context when hooked)
+         * @default true
+         */
+        requestAnimationFrame: true,
+        /**
+         * Hook queueMicrotask to preserve effect context
+         * @default true
+         */
+        queueMicrotask: true,
+    },
+};
+
+/**
+ * Effect context stack for nested tracking (front = active, next = parent)
+ */
+const stack = [];
+function captureEffectStack() {
+    return stack.slice();
+}
+function isRunning(effect) {
+    const rootEffect = getRoot(effect);
+    // Check if the effect is directly in the stack
+    const rootIndex = stack.indexOf(rootEffect);
+    if (rootIndex !== -1) {
+        return stack.slice(0, rootIndex + 1).reverse();
+    }
+    // Check if any effect in the stack is a descendant of this effect
+    // (i.e., walk up the parent chain from each stack effect to see if we reach this effect)
+    for (let i = 0; i < stack.length; i++) {
+        const stackEffect = stack[i];
+        let current = stackEffect;
+        const visited = new WeakSet();
+        const ancestorChain = [];
+        // TODO: That's perhaps a lot of computations for an `assert`
+        // Walk up the parent chain to find if this effect is an ancestor
+        while (current && !visited.has(current)) {
+            visited.add(current);
+            const currentRoot = getRoot(current);
+            ancestorChain.push(currentRoot);
+            if (currentRoot === rootEffect) {
+                // Found a descendant - build the full chain from ancestor to active
+                // The ancestorChain contains [descendant, parent, ..., ancestor] (walking up)
+                // We need [ancestor (effect), ..., parent, descendant, ...stack from descendant to active]
+                const chainFromAncestor = ancestorChain.reverse(); // [ancestor, ..., descendant]
+                // Prepend the actual effect we're checking (in case current is a wrapper)
+                if (chainFromAncestor[0] !== rootEffect) {
+                    chainFromAncestor.unshift(rootEffect);
+                }
+                // Append the rest of the stack from the descendant to the active effect
+                const stackFromDescendant = stack.slice(0, i + 1).reverse(); // [descendant, ..., active]
+                // Remove duplicate descendant (it's both at end of chainFromAncestor and start of stackFromDescendant)
+                if (chainFromAncestor.length > 0 && stackFromDescendant.length > 0) {
+                    stackFromDescendant.shift(); // Remove duplicate descendant
+                }
+                return [...chainFromAncestor, ...stackFromDescendant];
+            }
+            current = effectParent.get(current);
+        }
+    }
+    return false;
+}
+function withEffectStack(snapshot, fn) {
+    const previousStack = stack.slice();
+    assignStack(snapshot);
+    try {
+        return fn();
+    }
+    finally {
+        assignStack(previousStack);
+    }
+}
+function getActiveEffect() {
+    return stack[0];
+}
+/**
+ * Executes a function with a specific effect context
+ * @param effect - The effect to use as context
+ * @param fn - The function to execute
+ * @param keepParent - Whether to keep the parent effect context
+ * @returns The result of the function
+ */
+function withEffect(effect, fn) {
+    // console.log('[Mutts] withEffect', effect ? 'Active' : 'NULL');
+    if (getRoot(effect) === getRoot(getActiveEffect()))
+        return fn();
+    stack.unshift(effect);
+    try {
+        return fn();
+    }
+    finally {
+        const recoveredEffect = stack.shift();
+        if (recoveredEffect !== effect)
+            throw new ReactiveError('[reactive] Effect stack mismatch');
+    }
+}
+function assignStack(values) {
+    stack.length = 0;
+    stack.push(...values);
+}
+
+const objectToProxy = new WeakMap();
+const proxyToObject = new WeakMap();
+function storeProxyRelationship(target, proxy) {
+    objectToProxy.set(target, proxy);
+    proxyToObject.set(proxy, target);
+}
+function getExistingProxy(target) {
+    return objectToProxy.get(target);
+}
+function trackProxyObject(proxy, target) {
+    proxyToObject.set(proxy, target);
+}
+function unwrap(obj) {
+    let current = obj;
+    while (current && typeof current === 'object' && current !== null && proxyToObject.has(current)) {
+        current = proxyToObject.get(current);
+    }
+    return current;
+}
+function isReactive(obj) {
+    return proxyToObject.has(obj);
+}
+
+// Track which effects are watching which reactive objects for cleanup
+const effectToReactiveObjects = new WeakMap();
+// Track effects per reactive object and property
+const watchers = new WeakMap();
+// runEffect -> set<stop>
+const effectChildren = new WeakMap();
+// Track parent effect relationships for hierarchy traversal (used in deep touch filtering)
+const effectParent = new WeakMap();
+/**
+ * Marks a function with its root function for effect tracking
+ * @param fn - The function to mark
+ * @param root - The root function
+ * @returns The marked function
+ */
+function markWithRoot(fn, root) {
+    // Mark fn with the new root
+    return Object.defineProperty(fn, rootFunction, {
+        value: getRoot(root),
+        writable: false,
+    });
+}
+/**
+ * Gets the root function of a function for effect tracking
+ * @param fn - The function to get the root of
+ * @returns The root function
+ */
+function getRoot(fn) {
+    return fn?.[rootFunction] || fn;
+}
+// Flag to disable dependency tracking for the current active effect (not globally)
+const trackingDisabledEffects = new WeakSet();
+let globalTrackingDisabled = false;
+function getTrackingDisabled() {
+    const active = getActiveEffect();
+    if (!active)
+        return globalTrackingDisabled;
+    return trackingDisabledEffects.has(getRoot(active));
+}
+function setTrackingDisabled(value) {
+    const active = getActiveEffect();
+    if (!active) {
+        globalTrackingDisabled = value;
+        return;
+    }
+    const root = getRoot(active);
+    if (value)
+        trackingDisabledEffects.add(root);
+    else
+        trackingDisabledEffects.delete(root);
+}
+/**
+ * Marks a property as a dependency of the current effect
+ * @param obj - The object containing the property
+ * @param prop - The property name (defaults to allProps)
+ */
+function dependant(obj, prop = allProps) {
+    obj = unwrap(obj);
+    const currentActiveEffect = getActiveEffect();
+    // Early return if no active effect, tracking disabled, or invalid prop
+    if (!currentActiveEffect ||
+        getTrackingDisabled() ||
+        (typeof prop === 'symbol' && prop !== allProps))
+        return;
+    registerDependency(obj, prop, currentActiveEffect);
+}
+function registerDependency(obj, prop, currentActiveEffect) {
+    let objectWatchers = watchers.get(obj);
+    if (!objectWatchers) {
+        objectWatchers = new Map();
+        watchers.set(obj, objectWatchers);
+    }
+    let deps = objectWatchers.get(prop);
+    if (!deps) {
+        deps = new Set();
+        objectWatchers.set(prop, deps);
+    }
+    deps.add(currentActiveEffect);
+    // Track which reactive objects this effect is watching
+    const effectObjects = effectToReactiveObjects.get(currentActiveEffect);
+    if (effectObjects) {
+        effectObjects.add(obj);
+    }
+    else {
+        effectToReactiveObjects.set(currentActiveEffect, new Set([obj]));
+    }
+}
+
+/**
+ * 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.)
+ */
+const EXTERNAL_SOURCE = Symbol('external-source');
+let devtoolsEnabled = false;
+// Registry for debugging (populated lazily when DevTools are enabled)
+const debugEffectRegistry = new Set();
+const debugObjectRegistry = new Set();
+// Human-friendly names
+const effectNames = new WeakMap();
+const objectNames = new WeakMap();
+let effectCounter = 0;
+let objectCounter = 0;
+const triggerGraph = new Map();
+function ensureEffectName(effect) {
+    let name = effectNames.get(effect);
+    if (!name) {
+        const root = getRoot(effect);
+        name = root?.name?.trim() || `effect_${++effectCounter}`;
+        effectNames.set(effect, name);
+    }
+    return name;
+}
+function ensureObjectName(obj) {
+    let name = objectNames.get(obj);
+    if (!name) {
+        const ctorName = obj?.constructor?.name;
+        const base = ctorName && ctorName !== 'Object' ? ctorName : 'object';
+        name = `${base}_${++objectCounter}`;
+        objectNames.set(obj, name);
+    }
+    return name;
+}
+function describeProp(obj, prop) {
+    const objectName = ensureObjectName(obj);
+    if (prop === allProps)
+        return `${objectName}.*`;
+    if (typeof prop === 'symbol')
+        return `${objectName}.${prop.description ?? prop.toString()}`;
+    return `${objectName}.${String(prop)}`;
+}
+function addEffectToRegistry(effect) {
+    if (!effect || debugEffectRegistry.has(effect))
+        return;
+    debugEffectRegistry.add(effect);
+    const deps = effectToReactiveObjects.get(effect);
+    if (deps) {
+        for (const obj of deps) {
+            documentObject(obj);
+        }
+    }
+}
+function documentObject(obj) {
+    if (!debugObjectRegistry.has(obj)) {
+        dbRegisterObject(obj);
+    }
+}
+function dbRegisterObject(obj) {
+    debugObjectRegistry.add(obj);
+    ensureObjectName(obj);
+}
+function ensureParentChains(effects) {
+    const queue = Array.from(effects);
+    for (let i = 0; i < queue.length; i++) {
+        const effect = queue[i];
+        const parent = effectParent.get(effect);
+        if (parent && !effects.has(parent)) {
+            effects.add(parent);
+            queue.push(parent);
+        }
+    }
+}
+function ensureTriggerContainers(source) {
+    let targetMap = triggerGraph.get(source);
+    if (!targetMap) {
+        targetMap = new Map();
+        triggerGraph.set(source, targetMap);
+    }
+    return targetMap;
+}
+function ensureTriggerRecord(source, target, label, obj, prop, evolution) {
+    const targetMap = ensureTriggerContainers(source);
+    let labelMap = targetMap.get(target);
+    if (!labelMap) {
+        labelMap = new Map();
+        targetMap.set(target, labelMap);
+    }
+    let record = labelMap.get(label);
+    if (!record) {
+        record = { label, object: obj, prop, evolution, count: 0, lastTriggered: Date.now() };
+        labelMap.set(label, record);
+    }
+    return record;
+}
+/**
+ * Assign a debug-friendly name to an effect (shown in DevTools)
+ */
+function setEffectName(effect, name) {
+    effectNames.set(effect, name);
+}
+/**
+ * Assign a debug-friendly name to a reactive object
+ */
+function setObjectName(obj, name) {
+    objectNames.set(obj, name);
+    debugObjectRegistry.add(obj);
+}
+/**
+ * Register an effect so it appears in the DevTools graph
+ */
+function registerEffectForDebug(effect) {
+    if (!effect || !devtoolsEnabled)
+        return;
+    addEffectToRegistry(effect);
+}
+/**
+ * Register a reactive object so it appears in the DevTools graph
+ */
+function registerObjectForDebug(obj) {
+    if (!devtoolsEnabled)
+        return;
+    documentObject(obj);
+}
+/**
+ * Records a cause → consequence relationship between effects.
+ * @param source - The effect performing the write (undefined if external/user input)
+ * @param target - The effect that re-ran because of the write
+ * @param obj - The reactive object that changed
+ * @param prop - The property that changed
+ * @param evolution - The type of change (set/add/del/bunch)
+ */
+function recordTriggerLink(source, target, obj, prop, evolution) {
+    if (options.introspection.enableHistory) {
+        addToMutationHistory(source, target, obj, prop, evolution);
+    }
+    if (!devtoolsEnabled)
+        return;
+    addEffectToRegistry(target);
+    if (source)
+        addEffectToRegistry(source);
+    const descriptor = describeProp(obj, prop);
+    const record = ensureTriggerRecord(source ?? EXTERNAL_SOURCE, target, descriptor, obj, prop, evolution);
+    record.count += 1;
+    record.lastTriggered = Date.now();
+    documentObject(obj);
+}
+/**
+ * Traces back the chain of triggers that led to a specific effect
+ * @param effect The effect to trace back
+ * @param limit Max depth
+ */
+function getTriggerChain(effect, limit = 5) {
+    const chain = [];
+    let current = effect;
+    for (let i = 0; i < limit; i++) {
+        // Find who triggered 'current'
+        // We need to reverse search the triggerGraph (source -> target)
+        // This is expensive O(Edges) but okay for error reporting
+        let foundSource;
+        let foundReason = '';
+        search: for (const [source, targetMap] of triggerGraph) {
+            for (const [target, labelMap] of targetMap) {
+                if (target === current) {
+                    // Found a source! Use the most recent trigger record
+                    let lastTime = 0;
+                    for (const record of labelMap.values()) {
+                        if (record.lastTriggered > lastTime) {
+                            lastTime = record.lastTriggered;
+                            foundReason = record.label;
+                            foundSource = source === EXTERNAL_SOURCE ? undefined : source;
+                        }
+                    }
+                    if (foundSource || foundReason)
+                        break search;
+                }
+            }
+        }
+        if (foundSource) {
+            chain.push(`${ensureEffectName(foundSource)} -> (${foundReason}) -> ${ensureEffectName(current)}`);
+            current = foundSource;
+        }
+        else if (foundReason) {
+            chain.push(`External -> (${foundReason}) -> ${ensureEffectName(current)}`);
+            break;
+        }
+        else {
+            break;
+        }
+    }
+    return chain.reverse();
+}
+function buildEffectNodes(allEffects) {
+    const nodes = [];
+    const nodeByEffect = new Map();
+    const ordered = Array.from(allEffects);
+    for (const effect of ordered) {
+        const label = ensureEffectName(effect);
+        const node = {
+            id: `effect_${nodes.length}`,
+            label,
+            type: 'effect',
+            depth: 0,
+            debugName: label,
+        };
+        nodes.push(node);
+        nodeByEffect.set(effect, node);
+    }
+    const depthCache = new Map();
+    const computeDepth = (effect) => {
+        if (!effect)
+            return 0;
+        const cached = depthCache.get(effect);
+        if (cached !== undefined)
+            return cached;
+        const parent = effectParent.get(effect);
+        const depth = computeDepth(parent) + (parent ? 1 : 0);
+        depthCache.set(effect, depth);
+        return depth;
+    };
+    for (const [effect, node] of nodeByEffect) {
+        node.depth = computeDepth(effect);
+        const parent = effectParent.get(effect);
+        if (parent) {
+            const parentNode = nodeByEffect.get(parent);
+            if (parentNode) {
+                node.parentId = parentNode.id;
+            }
+        }
+    }
+    return { nodes, nodeByEffect };
+}
+/**
+ * Builds a graph representing current reactive state (effects, objects, and trigger edges)
+ */
+function buildReactivityGraph() {
+    const nodes = [];
+    const edges = [];
+    const nodeIds = new Map();
+    const allEffects = new Set(debugEffectRegistry);
+    ensureParentChains(allEffects);
+    const { nodes: effectNodes, nodeByEffect } = buildEffectNodes(allEffects);
+    for (const node of effectNodes)
+        nodes.push(node);
+    for (const [effect, node] of nodeByEffect) {
+        nodeIds.set(effect, node.id);
+    }
+    // Object nodes (optional, used for dependency inspection)
+    for (const obj of debugObjectRegistry) {
+        const id = `object_${nodes.length}`;
+        nodes.push({ id, label: ensureObjectName(obj), type: 'state', debugName: objectNames.get(obj) });
+        nodeIds.set(obj, id);
+    }
+    // External source node (user/system outside of effects)
+    if (triggerGraph.has(EXTERNAL_SOURCE)) {
+        const externalId = `effect_external`;
+        nodes.push({ id: externalId, label: 'External', type: 'external', depth: 0 });
+        nodeIds.set(EXTERNAL_SOURCE, externalId);
+    }
+    // Dependency edges (effect → object)
+    for (const effect of allEffects) {
+        const effectId = nodeIds.get(effect);
+        if (!effectId)
+            continue;
+        const deps = effectToReactiveObjects.get(effect);
+        if (!deps)
+            continue;
+        for (const obj of deps) {
+            const objId = nodeIds.get(obj);
+            if (!objId)
+                continue;
+            edges.push({
+                id: `${effectId}->${objId}`,
+                source: effectId,
+                target: objId,
+                type: 'dependency',
+                label: 'depends',
+            });
+        }
+    }
+    // Cause edges (effect/object/prop → effect)
+    for (const [source, targetMap] of triggerGraph) {
+        for (const [targetEffect, labelMap] of targetMap) {
+            const targetId = nodeIds.get(targetEffect);
+            if (!targetId)
+                continue;
+            const sourceId = nodeIds.get(source);
+            if (!sourceId)
+                continue;
+            for (const record of labelMap.values()) {
+                edges.push({
+                    id: `${sourceId}->${targetId}:${record.label}`,
+                    source: sourceId,
+                    target: targetId,
+                    type: 'cause',
+                    label: record.count > 1 ? `${record.label} (${record.count})` : record.label,
+                    count: record.count,
+                });
+            }
+        }
+    }
+    return {
+        nodes,
+        edges,
+        meta: {
+            generatedAt: Date.now(),
+            devtoolsEnabled,
+        },
+    };
+}
+/**
+ * Enables the DevTools bridge and exposes the debug API on window.
+ * Call as early as possible in development builds.
+ */
+function enableDevTools() {
+    if (typeof window === 'undefined')
+        return;
+    if (devtoolsEnabled)
+        return;
+    devtoolsEnabled = true;
+    // @ts-expect-error - global window extension
+    window.__MUTTS_DEVTOOLS__ = {
+        getGraph: buildReactivityGraph,
+        setEffectName,
+        setObjectName,
+        registerEffect: registerEffectForDebug,
+        registerObject: registerObjectForDebug,
+    };
+}
+function isDevtoolsEnabled() {
+    return devtoolsEnabled;
+}
+const mutationHistory = [];
+let mutationCounter = 0;
+function addToMutationHistory(source, target, obj, prop, evolution) {
+    const record = {
+        id: ++mutationCounter,
+        timestamp: Date.now(),
+        source: source ? ensureEffectName(source) : 'External',
+        target: ensureEffectName(target),
+        objectName: ensureObjectName(obj),
+        prop: String(prop),
+        type: evolution.type,
+    };
+    mutationHistory.push(record);
+    if (mutationHistory.length > options.introspection.historySize) {
+        mutationHistory.shift();
+    }
+}
+
+/**
+ * Zone-like async context preservation for reactive effects
+ *
+ * Automatically preserves effect context across async boundaries:
+ * - Promise methods: .then(), .catch(), .finally()
+ * - Timers: setTimeout(), setInterval()
+ * - Animation: requestAnimationFrame() (if available) - runs in untracked context
+ * - Microtasks: queueMicrotask() (if available)
+ *
+ * **IMPORTANT:** This module is opt-in via `reactiveOptions.asyncMode` (truthy = enabled, false = disabled).
+ * By default, async zone is ENABLED with 'cancel' mode.
+ *
+ * When disabled (asyncMode = false), use `tracked()` manually in async callbacks.
+ * When enabled (asyncMode = 'cancel' | 'queue' | 'ignore'), async entry points are wrapped ONCE.
+ */
+let zoneHooked = false;
+// Store original Promise methods at module load time (before any wrapping)
+// This ensures we always have the true originals, even if wrapping happens multiple times
+const originalPromiseThen = Object.getOwnPropertyDescriptor(Promise.prototype, 'then')?.value || Promise.prototype.then;
+const originalPromiseCatch = Object.getOwnPropertyDescriptor(Promise.prototype, 'catch')?.value || Promise.prototype.catch;
+const originalPromiseFinally = Object.getOwnPropertyDescriptor(Promise.prototype, 'finally')?.value || Promise.prototype.finally;
+// Store original timer functions at module load time
+const originalSetTimeout = globalThis.setTimeout;
+const originalSetInterval = globalThis.setInterval;
+const originalRequestAnimationFrame = typeof globalThis.requestAnimationFrame !== 'undefined'
+    ? globalThis.requestAnimationFrame
+    : undefined;
+const originalQueueMicrotask = typeof globalThis.queueMicrotask !== 'undefined' ? globalThis.queueMicrotask : undefined;
+// Store batch function to avoid circular dependency
+let batchFn;
+/**
+ * Check the asyncMode option and hook Promise.prototype once if enabled
+ * Called lazily on first effect creation
+ * asyncMode being truthy enables async zone, false disables it
+ *
+ * @param batch - Optional batch function injection from effects.ts to avoid circular dependency
+ */
+function ensureZoneHooked(batch) {
+    if (batch)
+        batchFn = batch;
+    if (zoneHooked || !options.asyncMode)
+        return;
+    hookZone();
+    zoneHooked = true;
+}
+/**
+ * Hook Promise.prototype methods to preserve effect context
+ */
+function hookZone() {
+    // biome-ignore lint/suspicious/noThenProperty: Intentional wrapping for zone functionality
+    Promise.prototype.then = function (onFulfilled, onRejected) {
+        const capturedStack = captureEffectStack();
+        return originalPromiseThen.call(this, wrapCallback(onFulfilled, capturedStack), wrapCallback(onRejected, capturedStack));
+    };
+    Promise.prototype.catch = function (onRejected) {
+        const capturedStack = captureEffectStack();
+        return originalPromiseCatch.call(this, wrapCallback(onRejected, capturedStack));
+    };
+    Promise.prototype.finally = function (onFinally) {
+        const capturedStack = captureEffectStack();
+        return originalPromiseFinally.call(this, wrapCallback(onFinally, capturedStack));
+    };
+    // Hook setTimeout - preserve original function properties for Node.js compatibility
+    const wrappedSetTimeout = ((callback, delay, ...args) => {
+        const capturedStack = options.zones.setTimeout ? captureEffectStack() : undefined;
+        return originalSetTimeout.apply(globalThis, [
+            wrapCallback(callback, capturedStack),
+            delay,
+            ...args,
+        ]);
+    });
+    Object.assign(wrappedSetTimeout, originalSetTimeout);
+    globalThis.setTimeout = wrappedSetTimeout;
+    // Hook setInterval - preserve original function properties for Node.js compatibility
+    const wrappedSetInterval = ((callback, delay, ...args) => {
+        const capturedStack = options.zones.setInterval ? captureEffectStack() : undefined;
+        return originalSetInterval.apply(globalThis, [
+            wrapCallback(callback, capturedStack),
+            delay,
+            ...args,
+        ]);
+    });
+    Object.assign(wrappedSetInterval, originalSetInterval);
+    globalThis.setInterval = wrappedSetInterval;
+    // Hook requestAnimationFrame if available
+    if (originalRequestAnimationFrame) {
+        globalThis.requestAnimationFrame = ((callback) => {
+            const capturedStack = options.zones.requestAnimationFrame ? captureEffectStack() : undefined;
+            return originalRequestAnimationFrame.call(globalThis, wrapCallback(callback, capturedStack));
+        });
+    }
+    // Hook queueMicrotask if available
+    if (originalQueueMicrotask) {
+        globalThis.queueMicrotask = ((callback) => {
+            const capturedStack = options.zones.queueMicrotask ? captureEffectStack() : undefined;
+            originalQueueMicrotask.call(globalThis, wrapCallback(callback, capturedStack));
+        });
+    }
+}
+/**
+ * Wraps a callback to restore effect context and ensure batching
+ */
+function wrapCallback(callback, capturedStack) {
+    if (!callback)
+        return undefined;
+    // If no stack to restore and no batch function, direct call (optimization)
+    if ((!capturedStack || !capturedStack.length) && !batchFn) {
+        return callback;
+    }
+    return ((...args) => {
+        const execute = () => {
+            if (capturedStack?.length) {
+                return withEffectStack(capturedStack, () => callback(...args));
+            }
+            return callback(...args);
+        };
+        if (batchFn) {
+            return batchFn(execute, 'immediate');
+        }
+        return execute();
+    });
+}
+/**
+ * Manually enable/disable the zone (for testing)
+ */
+function setZoneEnabled(enabled) {
+    if (enabled && !zoneHooked) {
+        hookZone();
+        zoneHooked = true;
+    }
+    else if (!enabled && zoneHooked) {
+        // Restore original Promise methods
+        // biome-ignore lint/suspicious/noThenProperty: Restoring original methods
+        Promise.prototype.then = originalPromiseThen;
+        Promise.prototype.catch = originalPromiseCatch;
+        Promise.prototype.finally = originalPromiseFinally;
+        // Restore original timer functions
+        globalThis.setTimeout = originalSetTimeout;
+        globalThis.setInterval = originalSetInterval;
+        if (originalRequestAnimationFrame) {
+            globalThis.requestAnimationFrame = originalRequestAnimationFrame;
+        }
+        if (originalQueueMicrotask) {
+            globalThis.queueMicrotask = originalQueueMicrotask;
+        }
+        zoneHooked = false;
+    }
+}
+/**
+ * Check if zone is currently hooked
+ */
+function isZoneEnabled() {
+    return zoneHooked;
+}
+
+/**
+ * Finds a cycle in a sequence of functions by looking for the first repetition
+ */
+function findCycleInChain(roots) {
+    const seen = new Map();
+    for (let i = 0; i < roots.length; i++) {
+        const root = roots[i];
+        if (seen.has(root)) {
+            return roots.slice(seen.get(root));
+        }
+        seen.set(root, i);
+    }
+    return null;
+}
+/**
+ * Formats a list of function roots into a readable trace
+ */
+function formatRoots(roots, limit = 20) {
+    const names = roots.map((r) => r.name || '<anonymous>');
+    if (names.length <= limit)
+        return names.join(' → ');
+    const start = names.slice(0, 5);
+    const end = names.slice(-10);
+    return `${start.join(' → ')} ... (${names.length - 15} more) ... ${end.join(' → ')}`;
+}
+/**
+ * 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' }
+ * ```
+ */
+function trackEffect(onTouch) {
+    const activeEffect = getActiveEffect();
+    if (!activeEffect)
+        throw new Error('Not in an effect');
+    if (!effectTrackers.has(activeEffect))
+        effectTrackers.set(activeEffect, new Set([onTouch]));
+    else
+        effectTrackers.get(activeEffect).add(onTouch);
+}
+const effectTrackers = new WeakMap();
+const opaqueEffects = new WeakSet();
+// Dependency graph: tracks which effects trigger which other effects
+// Uses roots (Function) as keys for consistency
+const effectTriggers = new WeakMap();
+const effectTriggeredBy = new WeakMap();
+// Transitive closures: track all indirect relationships
+// causesClosure: for each effect, all effects that trigger it (directly or indirectly)
+// consequencesClosure: for each effect, all effects that it triggers (directly or indirectly)
+const causesClosure = new WeakMap();
+const consequencesClosure = new WeakMap();
+// Debug: Capture where an effect was created
+const effectCreationStacks = new WeakMap();
+/**
+ * Gets or creates an IterableWeakSet for a closure map
+ */
+function getOrCreateClosure(closure, root) {
+    let set = closure.get(root);
+    if (!set) {
+        set = new IterableWeakSet();
+        closure.set(root, set);
+    }
+    return set;
+}
+/**
+ * Adds an edge to the dependency graph: callerRoot → targetRoot
+ * Also maintains transitive closures
+ * @param callerRoot - Root function of the effect that triggers
+ * @param targetRoot - Root function of the effect being triggered
+ */
+function addGraphEdge(callerRoot, targetRoot) {
+    // Skip if edge already exists
+    const triggers = effectTriggers.get(callerRoot);
+    if (triggers?.has(targetRoot)) {
+        return; // Edge already exists
+    }
+    // Add to forward graph: callerRoot → targetRoot
+    if (!triggers) {
+        const newTriggers = new IterableWeakSet();
+        newTriggers.add(targetRoot);
+        effectTriggers.set(callerRoot, newTriggers);
+    }
+    else {
+        triggers.add(targetRoot);
+    }
+    // Add to reverse graph: targetRoot ← callerRoot
+    let triggeredBy = effectTriggeredBy.get(targetRoot);
+    if (!triggeredBy) {
+        triggeredBy = new IterableWeakSet();
+        effectTriggeredBy.set(targetRoot, triggeredBy);
+    }
+    triggeredBy.add(callerRoot);
+    // Update transitive closures
+    // When U→V is added, we need to propagate the relationship:
+    // 1. Add U to causesClosure(V) and V to consequencesClosure(U) (direct relationship)
+    // 2. For each X in causesClosure(U): add V to consequencesClosure(X) and X to causesClosure(V)
+    // 3. For each Y in consequencesClosure(V): add U to causesClosure(Y) and Y to consequencesClosure(U)
+    // Note: Self-loops (U→U) are not added to closures - if an effect appears in its own closure,
+    // it means there's an indirect cycle that should be detected
+    // Self-loops are explicitly ignored - an effect reading and writing the same property
+    // (e.g., obj.prop++) should not create a dependency relationship or appear in closures
+    if (callerRoot === targetRoot) {
+        return;
+    }
+    const uConsequences = getOrCreateClosure(consequencesClosure, callerRoot);
+    const vCauses = getOrCreateClosure(causesClosure, targetRoot);
+    // 1. Add direct relationship
+    uConsequences.add(targetRoot);
+    vCauses.add(callerRoot);
+    // 2. For each X in causesClosure(U): X→U→V means X→V
+    const uCausesSet = causesClosure.get(callerRoot);
+    if (uCausesSet) {
+        for (const x of uCausesSet) {
+            // Skip if this would create a self-loop
+            if (x === targetRoot)
+                continue;
+            const xConsequences = getOrCreateClosure(consequencesClosure, x);
+            xConsequences.add(targetRoot);
+            vCauses.add(x);
+        }
+    }
+    // 3. For each Y in consequencesClosure(V): U→V→Y means U→Y
+    const vConsequencesSet = consequencesClosure.get(targetRoot);
+    if (vConsequencesSet) {
+        for (const y of vConsequencesSet) {
+            // Skip if this would create a self-loop
+            if (y === callerRoot)
+                continue;
+            const yCauses = getOrCreateClosure(causesClosure, y);
+            yCauses.add(callerRoot);
+            uConsequences.add(y);
+        }
+    }
+    // 4. Cross-product: for each X in causesClosure(U) and Y in consequencesClosure(V): X→Y
+    if (uCausesSet && vConsequencesSet) {
+        for (const x of uCausesSet) {
+            const xConsequences = getOrCreateClosure(consequencesClosure, x);
+            for (const y of vConsequencesSet) {
+                // Skip if this would create a self-loop
+                if (x === y)
+                    continue;
+                xConsequences.add(y);
+                const yCauses = getOrCreateClosure(causesClosure, y);
+                yCauses.add(x);
+            }
+        }
+    }
+}
+/**
+ * Checks if there's a path from start to end in the dependency graph, excluding a specific node
+ * Uses BFS to find any path that doesn't go through the excluded node
+ * @param start - Starting node
+ * @param end - Target node
+ * @param exclude - Node to exclude from the path
+ * @returns true if a path exists without going through the excluded node
+ */
+function hasPathExcluding(start, end, exclude) {
+    if (start === end)
+        return true;
+    if (start === exclude)
+        return false;
+    const visited = new Set();
+    const queue = [start];
+    visited.add(start);
+    visited.add(exclude); // Pre-mark excluded node as visited to skip it
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const triggers = effectTriggers.get(current);
+        if (!triggers)
+            continue;
+        for (const next of triggers) {
+            if (next === end)
+                return true;
+            if (!visited.has(next)) {
+                visited.add(next);
+                queue.push(next);
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Removes all edges involving the given effect from the dependency graph
+ * Also cleans up transitive closures by propagating cleanup to all affected effects
+ * Called when an effect is stopped/cleaned up
+ * @param effect - The effect being cleaned up
+ */
+function cleanupEffectFromGraph(effect) {
+    const root = getRoot(effect);
+    // Get closures before removing direct edges (needed for propagation)
+    const rootCauses = causesClosure.get(root);
+    const rootConsequences = consequencesClosure.get(root);
+    // Remove from effectTriggers (outgoing edges)
+    const triggers = effectTriggers.get(root);
+    if (triggers) {
+        // Remove this root from all targets' effectTriggeredBy sets
+        for (const targetRoot of triggers) {
+            const triggeredBy = effectTriggeredBy.get(targetRoot);
+            triggeredBy?.delete(root);
+        }
+        effectTriggers.delete(root);
+    }
+    // Remove from effectTriggeredBy (incoming edges)
+    const triggeredBy = effectTriggeredBy.get(root);
+    if (triggeredBy) {
+        // Remove this root from all sources' effectTriggers sets
+        for (const sourceRoot of triggeredBy) {
+            const triggers = effectTriggers.get(sourceRoot);
+            triggers?.delete(root);
+        }
+        effectTriggeredBy.delete(root);
+    }
+    // Propagate closure cleanup to all affected effects
+    // When removing B from A → B → C:
+    // - Remove B from causesClosure(C) and consequencesClosure(A)
+    // - For each X in causesClosure(B): remove C from consequencesClosure(X) if B was the only path
+    // - For each Y in consequencesClosure(B): remove A from causesClosure(Y) if B was the only path
+    // - Remove transitive relationships that depended on B
+    if (rootCauses) {
+        // For each X that triggers root: remove root from X's consequences
+        // Only remove root's consequences if no alternate path exists
+        for (const causeRoot of rootCauses) {
+            const causeConsequences = consequencesClosure.get(causeRoot);
+            if (causeConsequences) {
+                // Remove root itself (it's being cleaned up)
+                causeConsequences.delete(root);
+                // Only remove consequences of root if there's no alternate path from causeRoot to them
+                if (rootConsequences) {
+                    for (const consequence of rootConsequences) {
+                        // Check if causeRoot can still reach consequence without going through root
+                        if (!hasPathExcluding(causeRoot, consequence, root)) {
+                            causeConsequences.delete(consequence);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (rootConsequences) {
+        // For each Y that root triggers: remove root from Y's causes
+        // Only remove root's causes if no alternate path exists
+        for (const consequenceRoot of rootConsequences) {
+            const consequenceCauses = causesClosure.get(consequenceRoot);
+            if (consequenceCauses) {
+                // Remove root itself (it's being cleaned up)
+                consequenceCauses.delete(root);
+                // Only remove causes of root if there's no alternate path from them to consequenceRoot
+                if (rootCauses) {
+                    for (const cause of rootCauses) {
+                        // Check if cause can still reach consequenceRoot without going through root
+                        if (!hasPathExcluding(cause, consequenceRoot, root)) {
+                            consequenceCauses.delete(cause);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Cross-product cleanup: for each X in causesClosure(B) and Y in consequencesClosure(B),
+    // remove X→Y if B was the only path connecting them
+    if (rootCauses && rootConsequences) {
+        for (const x of rootCauses) {
+            const xConsequences = consequencesClosure.get(x);
+            if (xConsequences) {
+                for (const y of rootConsequences) {
+                    // Check if there's still a path from X to Y without going through root
+                    // Use BFS to find any path that doesn't include root
+                    if (!hasPathExcluding(x, y, root)) {
+                        xConsequences.delete(y);
+                        const yCauses = causesClosure.get(y);
+                        yCauses?.delete(x);
+                    }
+                }
+            }
+        }
+    }
+    // Finally, delete the closures for this effect
+    causesClosure.delete(root);
+    consequencesClosure.delete(root);
+}
+// Track currently executing effects to prevent re-execution
+// These are all the effects triggered under `activeEffect`
+let batchQueue;
+const batchCleanups = new Set();
+/**
+ * Computes and caches in-degrees for all effects in the batch
+ * Called once when batch starts or when new effects are added
+ */
+function computeAllInDegrees(batch) {
+    const activeEffect = getActiveEffect();
+    const activeRoot = activeEffect ? getRoot(activeEffect) : null;
+    // Reset all in-degrees
+    batch.inDegrees.clear();
+    for (const [root] of batch.all) {
+        let inDegree = 0;
+        const causes = causesClosure.get(root);
+        if (causes) {
+            for (const causeRoot of causes) {
+                // Only count if it's in the batch and not the active/self effect
+                if (batch.all.has(causeRoot) && causeRoot !== activeRoot && causeRoot !== root) {
+                    inDegree++;
+                }
+            }
+        }
+        batch.inDegrees.set(root, inDegree);
+    }
+}
+/**
+ * Decrements in-degrees of all effects that depend on the executed effect
+ * Called after an effect is executed to update the cached in-degrees
+ */
+function decrementInDegreesForExecuted(batch, executedRoot) {
+    // Get all effects that this executed effect triggers
+    const consequences = consequencesClosure.get(executedRoot);
+    if (!consequences)
+        return;
+    for (const consequenceRoot of consequences) {
+        // Only update if it's still in the batch
+        if (batch.all.has(consequenceRoot)) {
+            const currentDegree = batch.inDegrees.get(consequenceRoot) ?? 0;
+            if (currentDegree > 0) {
+                batch.inDegrees.set(consequenceRoot, currentDegree - 1);
+            }
+        }
+    }
+}
+/**
+ * Computes the in-degree (number of dependencies) for an effect in the current batch
+ * Uses causesClosure to count all effects (directly or indirectly) that trigger this effect
+ * @param root - Root function of the effect
+ * @param batchEffects - Map of all effects in current batch (todos - effects that still need execution)
+ * @returns Number of effects in batch that trigger this effect (directly or indirectly)
+ *
+ * TODO: Optimization - For large graphs with small batches, iterating over all causes in the closure
+ * can be expensive. Consider maintaining a separate "batch causes" set or caching in-degrees.
+ */
+/* function computeInDegreeInBatch(
+    root: Function,
+    batchEffects: Map<Function, ScopedCallback>
+): number {
+    let inDegree = 0
+    const activeEffect = getActiveEffect()
+    const activeRoot = activeEffect ? getRoot(activeEffect) : null
+
+    // Count effects in batch that trigger this effect (directly or indirectly)
+    // Using causesClosure which contains all transitive causes
+    // Note: batchEffects only contains effects that still need execution (todos),
+    // so we don't need to check if causes have been executed - they're not in the map if executed
+    const causes = causesClosure.get(root)
+    if (causes) {
+        for (const causeRoot of causes) {
+            // Only count if it's in the batch (still needs execution)
+            // BUT: don't count the currently executing effect (active effect)
+            // This handles the case where an effect is triggered during another effect's execution
+            // Note: Self-loops are ignored - they should not appear in closures, but we check to be safe
+            if (batchEffects.has(causeRoot) && causeRoot !== activeRoot && causeRoot !== root) {
+                inDegree++
+            }
+        }
+    }
+
+    return inDegree
+}
+
+/**
+ * Finds a path from startRoot to endRoot in the dependency graph
+ * Uses DFS to find the path through direct edges
+ * @param startRoot - Starting effect root
+ * @param endRoot - Target effect root
+ * @param visited - Set of visited nodes (for recursion)
+ * @param path - Current path being explored
+ * @returns Path from startRoot to endRoot, or empty array if no path exists
+ */
+function findPath(startRoot, endRoot, visited = new Set(), path = []) {
+    if (startRoot === endRoot) {
+        return [...path, endRoot];
+    }
+    if (visited.has(startRoot)) {
+        return [];
+    }
+    visited.add(startRoot);
+    const newPath = [...path, startRoot];
+    const triggers = effectTriggers.get(startRoot);
+    if (triggers) {
+        for (const targetRoot of triggers) {
+            const result = findPath(targetRoot, endRoot, visited, newPath);
+            if (result.length > 0) {
+                return result;
+            }
+        }
+    }
+    return [];
+}
+/**
+ * Gets the cycle path when adding an edge would create a cycle
+ * @param callerRoot - Root of the effect that triggers
+ * @param targetRoot - Root of the effect being triggered
+ * @returns Array of effect roots forming the cycle, or empty array if no cycle
+ */
+function getCyclePathForEdge(callerRoot, targetRoot) {
+    // Find path from targetRoot back to callerRoot (this is the existing path)
+    // Then adding callerRoot -> targetRoot completes the cycle
+    const path = findPath(targetRoot, callerRoot);
+    if (path.length > 0) {
+        // The cycle is: callerRoot -> targetRoot -> ... -> callerRoot
+        return [callerRoot, ...path];
+    }
+    return [];
+}
+/**
+ * Checks if adding an edge would create a cycle
+ * Uses causesClosure to check if callerRoot is already a cause of targetRoot
+ * Self-loops (callerRoot === targetRoot) are explicitly ignored and return false
+ * @param callerRoot - Root of the effect that triggers
+ * @param targetRoot - Root of the effect being triggered
+ * @returns true if adding this edge would create a cycle
+ */
+function wouldCreateCycle(callerRoot, targetRoot) {
+    // Self-loops are explicitly ignored - an effect reading and writing the same property
+    // (e.g., obj.prop++) should not create a dependency relationship
+    if (callerRoot === targetRoot) {
+        return false;
+    }
+    // Check if targetRoot already triggers callerRoot (directly or indirectly)
+    // This would create a cycle: callerRoot -> targetRoot -> ... -> callerRoot
+    // Using consequencesClosure: if targetRoot triggers callerRoot, then callerRoot is in consequencesClosure(targetRoot)
+    const targetConsequences = consequencesClosure.get(targetRoot);
+    if (targetConsequences?.has(callerRoot)) {
+        return true; // Cycle detected: targetRoot -> ... -> callerRoot, and we're adding callerRoot -> targetRoot
+    }
+    return false;
+}
+/**
+ * Adds an effect to the batch queue
+ * @param effect - The effect to add
+ * @param caller - The active effect that triggered this one (optional)
+ * @param immediate - If true, don't create edges in the dependency graph
+ */
+function addToBatch(effect, caller, immediate) {
+    if (!batchQueue)
+        return;
+    const root = getRoot(effect);
+    // 1. Add to batch first (needed for cycle detection)
+    batchQueue.all.set(root, effect);
+    // 2. Add to global graph (if caller exists and not immediate) - USE ROOTS ONLY
+    // When immediate is true, don't create edges - the effect is not considered as a consequence
+    if (caller && !immediate) {
+        const callerRoot = getRoot(caller);
+        // Check for cycle BEFORE adding edge
+        // We check if adding callerRoot -> root would create a cycle
+        // This means checking if root already triggers callerRoot (directly or transitively)
+        if (wouldCreateCycle(callerRoot, root)) {
+            // Cycle detected! Get the full cycle path for debugging
+            const cyclePath = getCyclePathForEdge(callerRoot, root);
+            const cycleMessage = cyclePath.length > 0
+                ? `Cycle detected: ${cyclePath.map((r) => r.name || r.toString()).join(' → ')}`
+                : `Cycle detected: ${callerRoot.name || callerRoot.toString()} → ${root.name || root.toString()} (and back)`;
+            const cycleHandling = options.cycleHandling;
+            // In strict mode, we throw immediately on detection
+            if (cycleHandling === 'strict') {
+                batchQueue.all.delete(root);
+                const causalChain = getTriggerChain(effect);
+                const creationStack = effectCreationStacks.get(root);
+                throw new ReactiveError(`[reactive] Strict Cycle Prevention: ${cycleMessage}`, {
+                    code: ReactiveErrorCode.CycleDetected,
+                    cycle: cyclePath.map((r) => r.name || r.toString()),
+                    details: cycleMessage,
+                    causalChain,
+                    creationStack,
+                });
+            }
+            switch (cycleHandling) {
+                case 'throw': {
+                    // Remove from batch before throwing
+                    batchQueue.all.delete(root);
+                    const causalChain = getTriggerChain(effect);
+                    const creationStack = effectCreationStacks.get(root);
+                    throw new ReactiveError(`[reactive] ${cycleMessage}`, {
+                        code: ReactiveErrorCode.CycleDetected,
+                        cycle: cyclePath.map((r) => r.name || r.toString()),
+                        details: cycleMessage,
+                        causalChain,
+                        creationStack,
+                    });
+                }
+                case 'warn':
+                    options.warn(`[reactive] ${cycleMessage}`);
+                    // Don't add the edge, break the cycle
+                    batchQueue.all.delete(root);
+                    return;
+                case 'break':
+                    // Silently break cycle, don't add the edge
+                    batchQueue.all.delete(root);
+                    return;
+            }
+        }
+        addGraphEdge(callerRoot, root); // Add to persistent graph using roots
+    }
+}
+/**
+ * Adds a cleanup function to be called when the current batch of effects completes
+ * @param cleanup - The cleanup function to add
+ */
+function addBatchCleanup(cleanup) {
+    if (!batchQueue)
+        cleanup();
+    else
+        batchCleanups.add(cleanup);
+}
+/**
+ * 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)
+ *   })
+ * })
+ * ```
+ */
+const defer = addBatchCleanup;
+/**
+ * Gets a cycle path for debugging
+ * Uses DFS to find cycles in the batch
+ * @param batchQueue - The batch queue
+ * @returns Array of effect roots forming a cycle
+ */
+function getCyclePath(batchQueue) {
+    // If all effects have in-degree > 0, there must be a cycle
+    // Use DFS to find it
+    const visited = new Set();
+    const recursionStack = new Set();
+    const path = [];
+    for (const [root] of batchQueue.all) {
+        if (visited.has(root))
+            continue;
+        const cycle = findCycle(root, visited, recursionStack, path, batchQueue);
+        if (cycle.length > 0) {
+            return cycle;
+        }
+    }
+    return [];
+}
+function findCycle(root, visited, recursionStack, path, batchQueue) {
+    if (recursionStack.has(root)) {
+        // Found a cycle! Return the path from the cycle start to root
+        const cycleStart = path.indexOf(root);
+        return path.slice(cycleStart).concat([root]);
+    }
+    if (visited.has(root)) {
+        return [];
+    }
+    visited.add(root);
+    recursionStack.add(root);
+    path.push(root);
+    // Follow edges to effects in the batch
+    // Use direct edges (effectTriggers) for cycle detection
+    const triggers = effectTriggers.get(root);
+    if (triggers) {
+        for (const targetRoot of triggers) {
+            if (batchQueue.all.has(targetRoot)) {
+                const cycle = findCycle(targetRoot, visited, recursionStack, path, batchQueue);
+                if (cycle.length > 0) {
+                    return cycle;
+                }
+            }
+        }
+    }
+    path.pop();
+    recursionStack.delete(root);
+    return [];
+}
+/**
+ * Executes the next effect in dependency order (using cached in-degrees)
+ * Finds an effect with in-degree 0 and executes it
+ * @returns The return value of the executed effect, or null if batch is complete
+ */
+function executeNext(effectuatedRoots) {
+    // Find an effect with in-degree 0 using cached values
+    let nextEffect = null;
+    let nextRoot = null;
+    // Find an effect with in-degree 0 (no dependencies in batch that still need execution)
+    // Using cached in-degrees for O(n) lookup instead of O(n²)
+    for (const [root, effect] of batchQueue.all) {
+        const inDegree = batchQueue.inDegrees.get(root) ?? 0;
+        if (inDegree === 0) {
+            nextEffect = effect;
+            nextRoot = root;
+            break;
+        }
+    }
+    if (!nextEffect) {
+        // No effect with in-degree 0 - there must be a cycle
+        // If all effects have dependencies, it means there's a circular dependency
+        if (batchQueue.all.size > 0) {
+            let cycle = getCyclePath(batchQueue);
+            // If we couldn't find a cycle path using direct edges, try using closures
+            // (transitive relationships) - if all effects have in-degree > 0, there must be a cycle
+            if (cycle.length === 0) {
+                // Try to find a cycle using consequencesClosure (transitive relationships)
+                // Note: Self-loops are ignored - we only look for cycles between different effects
+                for (const [root] of batchQueue.all) {
+                    const consequences = consequencesClosure.get(root);
+                    if (consequences) {
+                        // Check if any consequence in the batch also has root as a consequence
+                        for (const consequence of consequences) {
+                            // Skip self-loops - they are ignored
+                            if (consequence === root)
+                                continue;
+                            if (batchQueue.all.has(consequence)) {
+                                const consequenceConsequences = consequencesClosure.get(consequence);
+                                if (consequenceConsequences?.has(root)) {
+                                    // Found cycle: root -> consequence -> root
+                                    cycle = [root, consequence, root];
+                                    break;
+                                }
+                            }
+                        }
+                        if (cycle.length > 0)
+                            break;
+                    }
+                }
+            }
+            const cycleMessage = cycle.length > 0
+                ? `Cycle detected: ${cycle.map((r) => r.name || '<anonymous>').join(' → ')}`
+                : 'Cycle detected in effect batch - all effects have dependencies that prevent execution';
+            const cycleHandling = options.cycleHandling;
+            switch (cycleHandling) {
+                case 'throw':
+                    throw new ReactiveError(`[reactive] ${cycleMessage}`);
+                case 'warn': {
+                    options.warn(`[reactive] ${cycleMessage}`);
+                    // Break the cycle by executing one effect anyway
+                    const firstEffect = batchQueue.all.values().next().value;
+                    if (firstEffect) {
+                        const firstRoot = getRoot(firstEffect);
+                        batchQueue.all.delete(firstRoot);
+                        batchQueue.inDegrees.delete(firstRoot);
+                        return firstEffect();
+                    }
+                    break;
+                }
+                case 'break': {
+                    // Silently break cycle
+                    const firstEffect2 = batchQueue.all.values().next().value;
+                    if (firstEffect2) {
+                        const firstRoot2 = getRoot(firstEffect2);
+                        batchQueue.all.delete(firstRoot2);
+                        batchQueue.inDegrees.delete(firstRoot2);
+                        return firstEffect2();
+                    }
+                    break;
+                }
+            }
+        }
+        return null; // Batch complete
+    }
+    effectuatedRoots.push(getRoot(nextEffect));
+    // Execute the effect
+    const result = nextEffect();
+    // Remove from batch and update in-degrees of dependents
+    batchQueue.all.delete(nextRoot);
+    batchQueue.inDegrees.delete(nextRoot);
+    decrementInDegreesForExecuted(batchQueue, nextRoot);
+    return result;
+}
+// Track which sub-effects have been executed to prevent infinite loops
+// These are all the effects triggered under `activeEffect` and all their sub-effects
+function batch(effect, immediate) {
+    if (!Array.isArray(effect))
+        effect = [effect];
+    const roots = effect.map(getRoot);
+    if (batchQueue) {
+        // Nested batch - add to existing
+        options?.chain(roots, getRoot(getActiveEffect()));
+        const caller = getActiveEffect();
+        for (let i = 0; i < effect.length; i++) {
+            addToBatch(effect[i], caller, immediate === 'immediate');
+        }
+        if (immediate) {
+            // Execute immediately (before batch returns)
+            for (let i = 0; i < effect.length; i++) {
+                try {
+                    effect[i]();
+                }
+                finally {
+                    const root = getRoot(effect[i]);
+                    batchQueue.all.delete(root);
+                }
+            }
+        }
+        // Otherwise, effects will be picked up in next executeNext() call
+    }
+    else {
+        // New batch - initialize
+        options.beginChain(roots);
+        batchQueue = {
+            all: new Map(),
+            inDegrees: new Map(),
+        };
+        // Add initial effects
+        const caller = getActiveEffect();
+        for (let i = 0; i < effect.length; i++) {
+            addToBatch(effect[i], caller, immediate === 'immediate');
+        }
+        const effectuatedRoots = [];
+        computeAllInDegrees(batchQueue);
+        if (immediate) {
+            // Execute immediately (before batch returns)
+            const firstReturn = {};
+            try {
+                for (let i = 0; i < effect.length; i++) {
+                    try {
+                        const rv = effect[i]();
+                        if (rv !== undefined && !('value' in firstReturn))
+                            firstReturn.value = rv;
+                    }
+                    finally {
+                        const root = getRoot(effect[i]);
+                        batchQueue.all.delete(root);
+                    }
+                }
+                // After immediate execution, execute any effects that were triggered during execution
+                // This is important for @atomic decorator - effects triggered inside should still run
+                while (batchQueue.all.size > 0) {
+                    if (effectuatedRoots.length > options.maxEffectChain) {
+                        const cycle = findCycleInChain(effectuatedRoots);
+                        const trace = formatRoots(effectuatedRoots);
+                        const message = cycle
+                            ? `Max effect chain reached (cycle detected: ${formatRoots(cycle)})`
+                            : `Max effect chain reached (trace: ${trace})`;
+                        const queuedRoots = batchQueue ? Array.from(batchQueue.all.keys()) : [];
+                        const queued = queuedRoots.map((r) => r.name || '<anonymous>');
+                        const debugInfo = {
+                            code: ReactiveErrorCode.MaxDepthExceeded,
+                            effectuatedRoots,
+                            cycle,
+                            trace,
+                            maxEffectChain: options.maxEffectChain,
+                            queued: queued.slice(0, 50),
+                            queuedCount: queued.length,
+                            // Try to get causation for the last effect
+                            causalChain: effectuatedRoots.length > 0
+                                ? getTriggerChain(batchQueue.all.get(effectuatedRoots[effectuatedRoots.length - 1]))
+                                : [],
+                        };
+                        switch (options.maxEffectReaction) {
+                            case 'throw':
+                                throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                            case 'debug':
+                                // biome-ignore lint/suspicious/noDebugger: This is the whole point here
+                                debugger;
+                                throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                            case 'warn':
+                                options.warn(`[reactive] ${message} (queued: ${queued.slice(0, 10).join(', ')}${queued.length > 10 ? ', …' : ''})`);
+                                break;
+                        }
+                    }
+                    if (!batchQueue || batchQueue.all.size === 0)
+                        break;
+                    const rv = executeNext(effectuatedRoots);
+                    // If executeNext() returned null but batch is not empty, it means a cycle was detected
+                    // and an error was thrown, so we won't reach here
+                    if (rv !== undefined && !('value' in firstReturn))
+                        firstReturn.value = rv;
+                }
+                const cleanups = Array.from(batchCleanups);
+                batchCleanups.clear();
+                for (const cleanup of cleanups)
+                    cleanup();
+                return firstReturn.value;
+            }
+            finally {
+                batchQueue = undefined;
+                options.endChain();
+            }
+        }
+        else {
+            // Execute in dependency order
+            const firstReturn = {};
+            try {
+                while (batchQueue.all.size > 0) {
+                    if (effectuatedRoots.length > options.maxEffectChain) {
+                        const cycle = findCycleInChain(effectuatedRoots);
+                        const trace = formatRoots(effectuatedRoots);
+                        const message = cycle
+                            ? `Max effect chain reached (cycle detected: ${formatRoots(cycle)})`
+                            : `Max effect chain reached (trace: ${trace})`;
+                        const queuedRoots = batchQueue ? Array.from(batchQueue.all.keys()) : [];
+                        const queued = queuedRoots.map((r) => r.name || '<anonymous>');
+                        const debugInfo = {
+                            code: ReactiveErrorCode.MaxDepthExceeded,
+                            effectuatedRoots,
+                            cycle,
+                            trace,
+                            maxEffectChain: options.maxEffectChain,
+                            queued: queued.slice(0, 50),
+                            queuedCount: queued.length,
+                            // Try to get causation for the last effect
+                            causalChain: effectuatedRoots.length > 0
+                                ? getTriggerChain(batchQueue.all.get(effectuatedRoots[effectuatedRoots.length - 1]))
+                                : [],
+                        };
+                        switch (options.maxEffectReaction) {
+                            case 'throw':
+                                throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                            case 'debug':
+                                // biome-ignore lint/suspicious/noDebugger: This is the whole point here
+                                debugger;
+                                throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                            case 'warn':
+                                options.warn(`[reactive] ${message} (queued: ${queued.slice(0, 10).join(', ')}${queued.length > 10 ? ', …' : ''})`);
+                                break;
+                        }
+                    }
+                    const rv = executeNext(effectuatedRoots);
+                    // executeNext() returns null when batch is complete or cycle detected (throws error)
+                    // But functions can legitimately return null, so we check batchQueue.all.size instead
+                    if (batchQueue.all.size === 0) {
+                        // Batch complete
+                        break;
+                    }
+                    // If executeNext() returned null but batch is not empty, it means a cycle was detected
+                    // and an error was thrown, so we won't reach here
+                    if (rv !== undefined && !('value' in firstReturn))
+                        firstReturn.value = rv;
+                    // Note: executeNext() already removed it from batchQueue, so we track by count
+                }
+                const cleanups = Array.from(batchCleanups);
+                batchCleanups.clear();
+                for (const cleanup of cleanups)
+                    cleanup();
+                return firstReturn.value;
+            }
+            finally {
+                batchQueue = undefined;
+                options.endChain();
+            }
+        }
+    }
+}
+/**
+ * Decorator that makes methods atomic - batches all effects triggered within the method
+ */
+const atomic = decorator.decorator({
+    method(original) {
+        return function (...args) {
+            return batch(markWithRoot(() => original.apply(this, args), original), 'immediate');
+        };
+    },
+    default(original) {
+        return function (...args) {
+            return batch(markWithRoot(() => original.apply(this, args), original), 'immediate');
+        };
+    },
+});
+const fr = new FinalizationRegistry((f) => f());
+/**
+ * @param fn - The effect function to run - provides the cleaner
+ * @returns The cleanup function
+ */
+/**
+ * Creates a reactive effect that automatically re-runs when dependencies change
+ * @param fn - The effect function that provides dependencies and may return a cleanup function or Promise
+ * @param options - Options for effect execution
+ * @returns A cleanup function to stop the effect
+ */
+function effect(
+//biome-ignore lint/suspicious/noConfusingVoidType: We have to
+fn, effectOptions) {
+    // Ensure zone is hooked if asyncZone option is enabled (lazy initialization)
+    // Inject batch function to allow atomic game loops in requestAnimationFrame
+    ensureZoneHooked(batch);
+    // Use per-effect asyncMode or fall back to global option
+    const asyncMode = effectOptions?.asyncMode ?? options.asyncMode ?? 'cancel';
+    if (options.introspection.enableHistory) {
+        const stack = new Error().stack;
+        if (stack) {
+            // Clean up the stack trace to remove internal frames
+            const cleanStack = stack.split('\n').slice(2).join('\n');
+            effectCreationStacks.set(getRoot(fn), cleanStack);
+        }
+    }
+    let cleanup = null;
+    // capture the parent effect at creation time for ascend
+    const parentsForAscend = captureEffectStack();
+    const tracked = markWithRoot((cb) => withEffect(runEffect, cb), fn);
+    const ascend = (cb) => withEffectStack(parentsForAscend, cb);
+    let effectStopped = false;
+    let hasReacted = false;
+    let runningPromise = null;
+    let cancelPrevious = null;
+    function runEffect() {
+        // Clear previous dependencies
+        if (cleanup) {
+            const prevCleanup = cleanup;
+            cleanup = null;
+            withEffect(undefined, () => prevCleanup());
+        }
+        // Handle async modes when effect is retriggered
+        if (runningPromise) {
+            if (asyncMode === 'cancel' && cancelPrevious) {
+                // Cancel previous execution
+                cancelPrevious();
+                cancelPrevious = null;
+                runningPromise = null;
+            }
+            else if (asyncMode === 'ignore') {
+                // Ignore new execution while async work is running
+                return;
+            }
+            // Note: 'queue' mode not yet implemented
+        }
+        // The effect has been stopped after having been planned
+        if (effectStopped)
+            return;
+        options.enter(getRoot(fn));
+        let reactionCleanup;
+        let result;
+        try {
+            result = withEffect(runEffect, () => fn({ tracked, ascend, reaction: hasReacted }));
+            if (result &&
+                typeof result !== 'function' &&
+                (typeof result !== 'object' || !('then' in result)))
+                throw new ReactiveError(`[reactive] Effect returned a non-function value: ${result}`);
+            // Check if result is a Promise (async effect)
+            if (result && typeof result === 'object' && typeof result.then === 'function') {
+                const originalPromise = result;
+                // Create a cancellation promise that we can reject
+                let cancelReject = null;
+                const cancelPromise = new Promise((_, reject) => {
+                    cancelReject = reject;
+                });
+                const cancelError = new ReactiveError('[reactive] Effect canceled due to dependency change');
+                // Race between the actual promise and cancellation
+                // If canceled, the race rejects, which will propagate through any promise chain
+                runningPromise = Promise.race([originalPromise, cancelPromise]);
+                // Store the cancellation function
+                cancelPrevious = () => {
+                    if (cancelReject) {
+                        cancelReject(cancelError);
+                    }
+                };
+                // Wrap the original promise chain so cancellation propagates
+                // This ensures that when we cancel, the original promise's .catch() handlers are triggered
+                // We do this by rejecting the race promise, which makes the original promise chain see the rejection
+                // through the zone-wrapped .then()/.catch() handlers
+            }
+            else {
+                // Synchronous result - treat as cleanup function
+                reactionCleanup = result;
+            }
+        }
+        finally {
+            hasReacted = true;
+            options.leave(fn);
+        }
+        // Create cleanup function for next run
+        cleanup = () => {
+            cleanup = null;
+            reactionCleanup?.();
+            // Remove this effect from all reactive objects it's watching
+            const effectObjects = effectToReactiveObjects.get(runEffect);
+            if (effectObjects) {
+                for (const reactiveObj of effectObjects) {
+                    const objectWatchers = watchers.get(reactiveObj);
+                    if (objectWatchers) {
+                        for (const [prop, deps] of objectWatchers.entries()) {
+                            deps.delete(runEffect);
+                            if (deps.size === 0) {
+                                objectWatchers.delete(prop);
+                            }
+                        }
+                        if (objectWatchers.size === 0) {
+                            watchers.delete(reactiveObj);
+                        }
+                    }
+                }
+                effectToReactiveObjects.delete(runEffect);
+            }
+            // Invoke all child stops (recursive via subEffectCleanup calling its own mainCleanup)
+            const children = effectChildren.get(runEffect);
+            if (children) {
+                for (const childCleanup of children)
+                    childCleanup();
+                effectChildren.delete(runEffect);
+            }
+        };
+    }
+    // Mark the runEffect callback with the original function as its root
+    markWithRoot(runEffect, fn);
+    // Register strict mode if enabled
+    if (effectOptions?.opaque) {
+        opaqueEffects.add(runEffect);
+    }
+    if (isDevtoolsEnabled()) {
+        registerEffectForDebug(runEffect);
+    }
+    batch(runEffect, 'immediate');
+    const parent = parentsForAscend[0];
+    // Store parent relationship for hierarchy traversal
+    effectParent.set(runEffect, parent);
+    // Only ROOT effects are registered for GC cleanup and zone tracking
+    const isRootEffect = !parent;
+    const stopEffect = () => {
+        if (effectStopped)
+            return;
+        effectStopped = true;
+        // Cancel any running async work
+        if (cancelPrevious) {
+            cancelPrevious();
+            cancelPrevious = null;
+            runningPromise = null;
+        }
+        cleanup?.();
+        // Clean up dependency graph edges
+        cleanupEffectFromGraph(runEffect);
+        fr.unregister(stopEffect);
+    };
+    if (isRootEffect) {
+        const callIfCollected = () => stopEffect();
+        fr.register(callIfCollected, () => {
+            stopEffect();
+            options.garbageCollected(fn);
+        }, stopEffect);
+        return callIfCollected;
+    }
+    // Register this effect to be stopped when the parent effect is cleaned up
+    let children = effectChildren.get(parent);
+    if (!children) {
+        children = new Set();
+        effectChildren.set(parent, children);
+    }
+    const subEffectCleanup = () => {
+        children.delete(subEffectCleanup);
+        if (children.size === 0) {
+            effectChildren.delete(parent);
+        }
+        // Execute this child effect cleanup (which triggers its own mainCleanup)
+        stopEffect();
+    };
+    children.add(subEffectCleanup);
+    return subEffectCleanup;
+}
+/**
+ * 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
+ */
+function untracked(fn) {
+    // Store current tracking state and temporarily disable it
+    // This prevents the parent effect from tracking dependencies during fn execution
+    const wasTrackingDisabled = getTrackingDisabled();
+    setTrackingDisabled(true);
+    try {
+        return fn();
+    }
+    finally {
+        // Restore tracking state
+        setTrackingDisabled(wasTrackingDisabled);
+    }
+}
+/**
+ * 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
+ */
+function root(fn) {
+    let rv;
+    withEffect(undefined, () => {
+        rv = fn();
+    });
+    return rv;
+}
+function biDi(received, get, set) {
+    if (typeof get !== 'function') {
+        set = get.set;
+        get = get.get;
+    }
+    const root = getRoot(received);
+    effect(markWithRoot(() => {
+        received(get());
+    }, root));
+    return atomic((value) => {
+        set(value);
+        if (batchQueue?.all.has(root)) {
+            // Remove the effect from the batch queue so it doesn't execute
+            // This prevents circular updates in bidirectional bindings
+            batchQueue.all.delete(root);
+        }
+    });
+}
+
+// Track which objects contain which other objects (back-references)
+const objectParents = new WeakMap();
+// Track which objects have deep watchers
+const objectsWithDeepWatchers = new WeakSet();
+// Track deep watchers per object
+const deepWatchers = new WeakMap();
+// Track which effects are doing deep watching
+const effectToDeepWatchedObjects = new WeakMap();
+/**
+ * Add a back-reference from child to parent
+ */
+function addBackReference(child, parent, prop) {
+    let parents = objectParents.get(child);
+    if (!parents) {
+        parents = new Set();
+        objectParents.set(child, parents);
+    }
+    parents.add({ parent, prop });
+}
+/**
+ * Remove a back-reference from child to parent
+ */
+function removeBackReference(child, parent, prop) {
+    const parents = objectParents.get(child);
+    if (parents) {
+        for (const entry of parents) {
+            if (entry.parent === parent && entry.prop === prop) {
+                parents.delete(entry);
+                break;
+            }
+        }
+        if (parents.size === 0) {
+            objectParents.delete(child);
+        }
+    }
+}
+/**
+ * Check if an object needs back-references (has deep watchers or parents with deep watchers)
+ */
+function needsBackReferences(obj) {
+    // Fast path: check if object itself has deep watchers
+    if (objectsWithDeepWatchers.has(obj))
+        return true;
+    // Slow path: check if any parent has deep watchers (recursive)
+    return hasParentWithDeepWatchers(obj);
+}
+/**
+ * Bubble up changes through the back-reference chain
+ */
+function bubbleUpChange(changedObject, evolution) {
+    const parents = objectParents.get(changedObject);
+    if (!parents)
+        return;
+    for (const { parent } of parents) {
+        // Trigger deep watchers on parent
+        const parentDeepWatchers = deepWatchers.get(parent);
+        if (parentDeepWatchers)
+            for (const watcher of parentDeepWatchers)
+                batch(watcher);
+        // Continue bubbling up
+        bubbleUpChange(parent);
+    }
+}
+function hasParentWithDeepWatchers(obj) {
+    const parents = objectParents.get(obj);
+    if (!parents)
+        return false;
+    for (const { parent } of parents) {
+        if (objectsWithDeepWatchers.has(parent))
+            return true;
+        if (hasParentWithDeepWatchers(parent))
+            return true;
+    }
+    return false;
+}
+
+const states = new WeakMap();
+function addState(obj, evolution) {
+    obj = unwrap(obj);
+    const next = {};
+    const state = getState(obj);
+    if (state)
+        Object.assign(state, { evolution, next });
+    states.set(obj, next);
+}
+/**
+ * Gets the current state of a reactive object for evolution tracking
+ * @param obj - The reactive object
+ * @returns The current state object
+ */
+function getState(obj) {
+    obj = unwrap(obj);
+    let state = states.get(obj);
+    if (!state) {
+        state = {};
+        states.set(obj, state);
+    }
+    return state;
+}
+function collectEffects(obj, evolution, effects, objectWatchers, ...keyChains) {
+    const sourceEffect = getActiveEffect();
+    for (const keys of keyChains)
+        for (const key of keys) {
+            const deps = objectWatchers.get(key);
+            if (deps)
+                for (const effect of deps) {
+                    const runningChain = isRunning(effect);
+                    if (runningChain) {
+                        options.skipRunningEffect(effect, runningChain);
+                        continue;
+                    }
+                    effects.add(effect);
+                    const trackers = effectTrackers.get(effect);
+                    recordTriggerLink(sourceEffect, effect, obj, key, evolution);
+                    if (trackers) {
+                        for (const tracker of trackers)
+                            tracker(obj, evolution, key);
+                        trackers.delete(effect);
+                    }
+                }
+        }
+}
+/**
+ * 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
+ */
+function touched1(obj, evolution, prop) {
+    touched(obj, evolution, [prop]);
+}
+/**
+ * Triggers effects for property changes
+ * @param obj - The object that changed
+ * @param evolution - The type of change
+ * @param props - The properties that changed
+ */
+function touched(obj, evolution, props) {
+    obj = unwrap(obj);
+    addState(obj, evolution);
+    const objectWatchers = watchers.get(obj);
+    if (objectWatchers) {
+        // Note: we have to collect effects to remove duplicates in the specific case when no batch is running
+        const effects = new Set();
+        if (props)
+            collectEffects(obj, evolution, effects, objectWatchers, [allProps], props);
+        else
+            collectEffects(obj, evolution, effects, objectWatchers, objectWatchers.keys());
+        options.touched(obj, evolution, props, effects);
+        batch(Array.from(effects));
+    }
+    // Bubble up changes if this object has deep watchers
+    if (objectsWithDeepWatchers.has(obj)) {
+        bubbleUpChange(obj);
+    }
+}
+/**
+ * Triggers only opaque effects for property changes
+ * Used by deep-touch to ensure opaque listeners are notified even when deep optimization is active
+ */
+function touchedOpaque(obj, evolution, prop) {
+    obj = unwrap(obj);
+    const objectWatchers = watchers.get(obj);
+    if (!objectWatchers)
+        return;
+    const deps = objectWatchers.get(prop);
+    if (!deps)
+        return;
+    const effects = new Set();
+    const sourceEffect = getActiveEffect();
+    for (const effect of deps) {
+        if (!opaqueEffects.has(effect))
+            continue;
+        const runningChain = isRunning(effect);
+        if (runningChain) {
+            options.skipRunningEffect(effect, runningChain);
+            continue;
+        }
+        effects.add(effect);
+        const trackers = effectTrackers.get(effect);
+        recordTriggerLink(sourceEffect, effect, obj, prop, evolution);
+        if (trackers) {
+            for (const tracker of trackers)
+                tracker(obj, evolution, prop);
+            trackers.delete(effect);
+        }
+    }
+    if (effects.size > 0) {
+        options.touched(obj, evolution, [prop], effects);
+        batch(Array.from(effects));
+    }
+}
+
+const nonReactiveObjects = new WeakSet();
+const immutables = new Set();
+const absent = Symbol('absent');
+function markNonReactive(...obj) {
+    for (const o of obj) {
+        try {
+            Object.defineProperty(o, nonReactiveMark, {
+                value: true,
+                writable: false,
+                enumerable: false,
+                configurable: false,
+            });
+        }
+        catch { }
+        if (!(nonReactiveMark in o))
+            nonReactiveObjects.add(o);
+    }
+    return obj[0];
+}
+function nonReactiveClass(...cls) {
+    for (const c of cls)
+        if (c)
+            c.prototype[nonReactiveMark] = true;
+    return cls[0];
+}
+function isNonReactive(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return true;
+    if (nonReactiveObjects.has(obj))
+        return true;
+    if (obj[nonReactiveMark])
+        return true;
+    for (const fn of immutables)
+        if (fn(obj))
+            return true;
+    return false;
+}
+function registerNativeReactivity(originalClass, reactiveClass) {
+    originalClass.prototype[nativeReactive] = reactiveClass;
+    nonReactiveClass(reactiveClass);
+}
+nonReactiveClass(Date, RegExp, Error, Promise, Function);
+if (typeof window !== 'undefined') {
+    markNonReactive(window, document);
+    nonReactiveClass(Node, Element, HTMLElement, EventTarget);
+}
+
+function isObject$1(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isObjectLike(value) {
+    return isObject$1(value);
+}
+function getPrototypeToken(value) {
+    if (!isObjectLike(value))
+        return undefined;
+    if (Array.isArray(value))
+        return Array.prototype;
+    try {
+        return value.constructor;
+    }
+    catch {
+        return undefined;
+    }
+}
+function shouldRecurseTouch(oldValue, newValue) {
+    if (oldValue === newValue)
+        return false;
+    if (!isObjectLike(oldValue) || !isObjectLike(newValue))
+        return false;
+    if (isNonReactive(oldValue) || isNonReactive(newValue))
+        return false;
+    return getPrototypeToken(oldValue) === getPrototypeToken(newValue);
+}
+/**
+ * Centralized function to handle property change notifications with optional recursive touch
+ * @param targetObj - The object whose property changed
+ * @param prop - The property that changed
+ * @param oldValue - The old value (before change)
+ * @param newValue - The new value (after change)
+ * @param hadProperty - Whether the property existed before (for add vs set)
+ */
+function notifyPropertyChange(targetObj, prop, oldValue, newValue, hadProperty) {
+    const evolution = { type: hadProperty ? 'set' : 'add', prop };
+    if (options.recursiveTouching &&
+        oldValue !== undefined &&
+        shouldRecurseTouch(oldValue, newValue)) {
+        const unwrappedObj = unwrap(targetObj);
+        const origin = { obj: unwrappedObj, prop };
+        // Deep touch: only notify nested property changes with origin filtering
+        // Don't notify direct property change - the whole point is to avoid parent effects re-running
+        dispatchNotifications(recursiveTouch(oldValue, newValue, new WeakMap(), [], origin));
+        // Notify opaque listeners (like memoize) that always want to know about identity changes
+        touchedOpaque(targetObj, evolution, prop);
+    }
+    else {
+        touched1(targetObj, evolution, prop);
+    }
+}
+function hasVisitedPair(visited, oldObj, newObj) {
+    let mapped = visited.get(oldObj);
+    if (!mapped) {
+        mapped = new WeakSet();
+        visited.set(oldObj, mapped);
+    }
+    if (mapped.has(newObj))
+        return true;
+    mapped.add(newObj);
+    return false;
+}
+function collectObjectKeys(obj) {
+    const keys = new Set(Reflect.ownKeys(obj));
+    let proto = Object.getPrototypeOf(obj);
+    // Continue walking while prototype exists and doesn't have its own constructor
+    // This stops at Object.prototype (has own constructor) and class prototypes (have own constructor)
+    // but continues for data prototypes (Object.create({}), Object.create(instance), etc.)
+    while (proto && !Object.hasOwn(proto, 'constructor')) {
+        for (const key of Reflect.ownKeys(proto))
+            keys.add(key);
+        proto = Object.getPrototypeOf(proto);
+    }
+    return keys;
+}
+function recursiveTouch(oldValue, newValue, visited = new WeakMap(), notifications = [], origin) {
+    if (!shouldRecurseTouch(oldValue, newValue))
+        return notifications;
+    if (!isObjectLike(oldValue) || !isObjectLike(newValue))
+        return notifications;
+    if (hasVisitedPair(visited, oldValue, newValue))
+        return notifications;
+    if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+        diffArrayElements(oldValue, newValue, visited, notifications, origin);
+        return notifications;
+    }
+    diffObjectProperties(oldValue, newValue, visited, notifications, origin);
+    return notifications;
+}
+function diffArrayElements(oldArray, newArray, _visited, notifications, origin) {
+    const local = [];
+    const oldLength = oldArray.length;
+    const newLength = newArray.length;
+    const max = Math.max(oldLength, newLength);
+    for (let index = 0; index < max; index++) {
+        const hasOld = index < oldLength;
+        const hasNew = index < newLength;
+        if (hasOld && !hasNew) {
+            local.push({ target: oldArray, evolution: { type: 'del', prop: index }, prop: index, origin });
+            continue;
+        }
+        if (!hasOld && hasNew) {
+            local.push({ target: oldArray, evolution: { type: 'add', prop: index }, prop: index, origin });
+            continue;
+        }
+        if (!hasOld || !hasNew)
+            continue;
+        const oldEntry = unwrap(oldArray[index]);
+        const newEntry = unwrap(newArray[index]);
+        if (!Object.is(oldEntry, newEntry)) {
+            local.push({ target: oldArray, evolution: { type: 'set', prop: index }, prop: index, origin });
+        }
+    }
+    if (oldLength !== newLength)
+        local.push({
+            target: oldArray,
+            evolution: { type: 'set', prop: 'length' },
+            prop: 'length',
+            origin,
+        });
+    notifications.push(...local);
+}
+function diffObjectProperties(oldObj, newObj, visited, notifications, origin) {
+    const oldKeys = collectObjectKeys(oldObj);
+    const newKeys = collectObjectKeys(newObj);
+    const local = [];
+    for (const key of oldKeys)
+        if (!newKeys.has(key))
+            local.push({ target: oldObj, evolution: { type: 'del', prop: key }, prop: key, origin });
+    for (const key of newKeys)
+        if (!oldKeys.has(key))
+            local.push({ target: oldObj, evolution: { type: 'add', prop: key }, prop: key, origin });
+    for (const key of newKeys) {
+        if (!oldKeys.has(key))
+            continue;
+        const oldEntry = unwrap(oldObj[key]);
+        const newEntry = unwrap(newObj[key]);
+        if (shouldRecurseTouch(oldEntry, newEntry)) {
+            recursiveTouch(oldEntry, newEntry, visited, notifications, origin);
+        }
+        else if (!Object.is(oldEntry, newEntry)) {
+            local.push({ target: oldObj, evolution: { type: 'set', prop: key }, prop: key, origin });
+        }
+    }
+    notifications.push(...local);
+}
+/**
+ * Checks if an effect or any of its ancestors is in the allowed set
+ */
+function hasAncestorInSet(effect, allowedSet) {
+    let current = effect;
+    const visited = new WeakSet();
+    while (current && !visited.has(current)) {
+        visited.add(current);
+        if (allowedSet.has(current))
+            return true;
+        current = effectParent.get(current);
+    }
+    return false;
+}
+function dispatchNotifications(notifications) {
+    if (!notifications.length)
+        return;
+    const combinedEffects = new Set();
+    // Extract origin from first notification (all should have the same origin from a single deep touch)
+    const origin = notifications[0]?.origin;
+    let allowedEffects;
+    // If origin exists, compute allowed effects (those that depend on origin.obj[origin.prop])
+    if (origin) {
+        allowedEffects = new Set();
+        const originWatchers = watchers.get(origin.obj);
+        if (originWatchers) {
+            const originEffects = new Set();
+            collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, [allProps], [origin.prop]);
+            for (const effect of originEffects)
+                allowedEffects.add(effect);
+        }
+        // If no allowed effects, skip all notifications (no one should be notified)
+        if (allowedEffects.size === 0)
+            return;
+    }
+    for (const { target, evolution, prop } of notifications) {
+        if (!isObjectLike(target))
+            continue;
+        const obj = unwrap(target);
+        addState(obj, evolution);
+        const objectWatchers = watchers.get(obj);
+        let currentEffects;
+        const propsArray = [prop];
+        if (objectWatchers) {
+            currentEffects = new Set();
+            collectEffects(obj, evolution, currentEffects, objectWatchers, [allProps], propsArray);
+            // Filter effects by ancestor chain if origin exists
+            // Include effects that either directly depend on origin or have an ancestor that does
+            if (origin && allowedEffects) {
+                const filteredEffects = new Set();
+                for (const effect of currentEffects) {
+                    // Check if effect itself is allowed OR has an ancestor that is allowed
+                    if (allowedEffects.has(effect) || hasAncestorInSet(effect, allowedEffects)) {
+                        filteredEffects.add(effect);
+                    }
+                }
+                currentEffects = filteredEffects;
+            }
+            for (const effect of currentEffects)
+                combinedEffects.add(effect);
+        }
+        options.touched(obj, evolution, propsArray, currentEffects);
+        if (objectsWithDeepWatchers.has(obj))
+            bubbleUpChange(obj);
+    }
+    if (combinedEffects.size)
+        batch([...combinedEffects]);
+}
+
+const hasReentry = [];
+const reactiveHandlers = {
+    [Symbol.toStringTag]: 'MutTs Reactive',
+    get(obj, prop, receiver) {
+        if (prop === nonReactiveMark)
+            return false;
+        const unwrappedObj = unwrap(obj);
+        // Check if this property is marked as unreactive
+        if (unwrappedObj[unreactiveProperties]?.has(prop) || typeof prop === 'symbol')
+            return decorator.ReflectGet(obj, prop, receiver);
+        // Special-case: array wrappers use prototype forwarding + numeric accessors.
+        // With options.instanceMembers=true, inherited reads are normally not tracked, which breaks
+        // reactivity for array indices/length (they appear inherited on the proxy).
+        const isArrayCase = prototypeForwarding in obj &&
+            // biome-ignore lint/suspicious/useIsArray: This is the whole point here
+            obj[prototypeForwarding] instanceof Array &&
+            typeof prop === 'string' &&
+            (prop === 'length' || !Number.isNaN(Number(prop)));
+        if (isArrayCase) {
+            dependant(obj, prop === 'length' ? 'length' : Number(prop));
+        }
+        // Check if property exists and if it's an own property (cached for later use)
+        const hasProp = Reflect.has(receiver, prop);
+        const isOwnProp = hasProp && Object.hasOwn(receiver, prop);
+        const isInheritedAccess = hasProp && !isOwnProp;
+        // For accessor properties, check the unwrapped object to see if it's an accessor
+        // This ensures ignoreAccessors works correctly even after operations like Object.setPrototypeOf
+        const shouldIgnoreAccessor = options.ignoreAccessors &&
+            isOwnProp &&
+            (decorator.isOwnAccessor(receiver, prop) || decorator.isOwnAccessor(unwrappedObj, prop));
+        // Depend if...
+        if (!hasProp ||
+            (!(options.instanceMembers && isInheritedAccess && obj instanceof Object) &&
+                !shouldIgnoreAccessor))
+            dependant(obj, prop);
+        // Watch the whole prototype chain when requested or for null-proto objects
+        if (isInheritedAccess && (!options.instanceMembers || !(obj instanceof Object))) {
+            let current = reactiveObject(Object.getPrototypeOf(obj));
+            while (current && current !== Object.prototype) {
+                dependant(current, prop);
+                if (Object.hasOwn(current, prop))
+                    break;
+                current = reactiveObject(Object.getPrototypeOf(current));
+            }
+        }
+        const value = decorator.ReflectGet(obj, prop, receiver);
+        if (typeof value === 'object' && value !== null) {
+            const reactiveValue = reactiveObject(value);
+            // Only create back-references if this object needs them
+            if (needsBackReferences(obj)) {
+                addBackReference(reactiveValue, obj, prop);
+            }
+            return reactiveValue;
+        }
+        return value;
+    },
+    set(obj, prop, value, receiver) {
+        // Read old value directly from unwrapped object to avoid triggering dependency tracking
+        const unwrappedObj = unwrap(obj);
+        const unwrappedReceiver = unwrap(receiver);
+        // Check if this property is marked as unreactive
+        if (unwrappedObj[unreactiveProperties]?.has(prop) || unwrappedObj !== unwrappedReceiver)
+            return decorator.ReflectSet(obj, prop, value, receiver);
+        // Really specific case for when Array is forwarder, in order to let it manage the reactivity
+        const isArrayCase = prototypeForwarding in obj &&
+            // biome-ignore lint/suspicious/useIsArray: This is the whole point here
+            obj[prototypeForwarding] instanceof Array &&
+            (!Number.isNaN(Number(prop)) || prop === 'length');
+        const newValue = unwrap(value);
+        if (isArrayCase) {
+            obj[prop] = newValue;
+            return true;
+        }
+        // Read old value, using withEffect(undefined, ...) for getter-only accessors to avoid
+        // breaking memoization dependency tracking during SET operations
+        let oldVal = absent;
+        if (Reflect.has(unwrappedReceiver, prop)) {
+            // Check descriptor on both receiver and target to handle proxy cases
+            const receiverDesc = Object.getOwnPropertyDescriptor(unwrappedReceiver, prop);
+            const targetDesc = Object.getOwnPropertyDescriptor(unwrappedObj, prop);
+            const desc = receiverDesc || targetDesc;
+            // If it's a getter-only accessor (has getter but no setter), read without tracking
+            // to avoid breaking memoization invalidation when the getter calls memoized functions
+            if (desc?.get && !desc?.set) {
+                oldVal = withEffect(undefined, () => Reflect.get(unwrappedObj, prop, unwrappedReceiver));
+            }
+            else {
+                oldVal = Reflect.get(unwrappedObj, prop, unwrappedReceiver);
+            }
+        }
+        if (objectsWithDeepWatchers.has(obj)) {
+            if (typeof oldVal === 'object' && oldVal !== null) {
+                removeBackReference(oldVal, obj, prop);
+            }
+            if (typeof newValue === 'object' && newValue !== null) {
+                const reactiveValue = reactiveObject(newValue);
+                addBackReference(reactiveValue, obj, prop);
+            }
+        }
+        if (oldVal !== newValue) {
+            // For getter-only accessors, Reflect.set() may fail, but we still return true
+            // to avoid throwing errors. Only proceed with change notifications if set succeeded.
+            if (decorator.ReflectSet(obj, prop, newValue, receiver)) {
+                notifyPropertyChange(obj, prop, oldVal, newValue, oldVal !== absent);
+            }
+        }
+        return true;
+    },
+    has(obj, prop) {
+        if (hasReentry.includes(obj))
+            throw new ReactiveError(`[reactive] Circular dependency detected in 'has' check for property '${String(prop)}'`, {
+                code: ReactiveErrorCode.CycleDetected,
+                cycle: [], // We don't have the full cycle here, but we know it involves obj
+            });
+        hasReentry.push(obj);
+        dependant(obj, prop);
+        const rv = Reflect.has(obj, prop);
+        hasReentry.pop();
+        return rv;
+    },
+    deleteProperty(obj, prop) {
+        if (!Object.hasOwn(obj, prop))
+            return false;
+        const oldVal = obj[prop];
+        // Remove back-references if this object has deep watchers
+        if (objectsWithDeepWatchers.has(obj) && typeof oldVal === 'object' && oldVal !== null) {
+            removeBackReference(oldVal, obj, prop);
+        }
+        delete obj[prop];
+        touched1(obj, { type: 'del', prop }, prop);
+        // Bubble up changes if this object has deep watchers
+        if (objectsWithDeepWatchers.has(obj)) {
+            bubbleUpChange(obj);
+        }
+        return true;
+    },
+    getPrototypeOf(obj) {
+        if (prototypeForwarding in obj)
+            return obj[prototypeForwarding];
+        return Object.getPrototypeOf(obj);
+    },
+    setPrototypeOf(obj, proto) {
+        if (prototypeForwarding in obj)
+            return false;
+        Object.setPrototypeOf(obj, proto);
+        return true;
+    },
+    ownKeys(obj) {
+        dependant(obj, allProps);
+        return Reflect.ownKeys(obj);
+    },
+};
+const reactiveClasses = new WeakSet();
+// Create the ReactiveBase mixin
+/**
+ * Base mixin for reactive classes that provides proper constructor reactivity
+ * Solves constructor reactivity issues in complex inheritance trees
+ */
+const ReactiveBase = mixin((base) => {
+    class ReactiveMixin extends base {
+        constructor(...args) {
+            super(...args);
+            // Only apply reactive transformation if the class is marked with @reactive
+            // This allows the mixin to work properly with method inheritance
+            // biome-ignore lint/correctness/noConstructorReturn: This is the whole point here
+            return reactiveClasses.has(new.target) ? reactive(this) : this;
+        }
+    }
+    return ReactiveMixin;
+});
+function reactiveObject(anyTarget) {
+    if (!anyTarget || typeof anyTarget !== 'object')
+        return anyTarget;
+    const target = anyTarget;
+    // If target is already a proxy, return it
+    if (isNonReactive(target))
+        return target;
+    const isProxy = proxyToObject.has(target);
+    if (isProxy)
+        return target;
+    // If we already have a proxy for this object, return it (optimized: get returns undefined if not found)
+    const existing = getExistingProxy(target);
+    if (existing !== undefined)
+        return existing;
+    const proxied = nativeReactive in target && !(target instanceof target[nativeReactive])
+        ? new target[nativeReactive](target)
+        : target;
+    if (proxied !== target)
+        trackProxyObject(proxied, target);
+    const proxy = new Proxy(proxied, reactiveHandlers);
+    // Store the relationships
+    storeProxyRelationship(target, proxy);
+    return proxy;
+}
+/**
+ * Main decorator for making classes reactive
+ * Automatically makes class instances reactive when created
+ */
+const reactive = decorator.decorator({
+    class(original) {
+        if (original.prototype instanceof ReactiveBase) {
+            reactiveClasses.add(original);
+            return original;
+        }
+        class Reactive extends original {
+            constructor(...args) {
+                super(...args);
+                if (new.target !== Reactive && !reactiveClasses.has(new.target))
+                    options.warn(`${original.name} has been inherited by ${this.constructor.name} that is not reactive.
+@reactive decorator must be applied to the leaf class OR classes have to extend ReactiveBase.`);
+                // biome-ignore lint/correctness/noConstructorReturn: This is the whole point here
+                return reactive(this);
+            }
+        }
+        Object.defineProperty(Reactive, 'name', {
+            value: `Reactive<${original.name}>`,
+        });
+        return Reactive;
+    },
+    get(original) {
+        return reactiveObject(original);
+    },
+    default: reactiveObject,
+});
+
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * 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
+ */
+function deepWatch(target, callback, { immediate = false } = {}) {
+    if (target === null || target === undefined)
+        return undefined;
+    if (typeof target !== 'object')
+        throw new Error('Target of deep watching must be an object');
+    // Create a wrapper callback that matches ScopedCallback signature
+    const wrappedCallback = markWithRoot(() => callback(target), callback);
+    // Use the existing effect system to register dependencies
+    return effect(() => {
+        // Mark the target object as having deep watchers
+        objectsWithDeepWatchers.add(target);
+        // Track which objects this effect is watching for cleanup
+        let effectObjects = effectToDeepWatchedObjects.get(wrappedCallback);
+        if (!effectObjects) {
+            effectObjects = new Set();
+            effectToDeepWatchedObjects.set(wrappedCallback, effectObjects);
+        }
+        effectObjects.add(target);
+        // Traverse the object graph and register dependencies
+        // This will re-run every time the effect runs, ensuring we catch all changes
+        const visited = new WeakSet();
+        function traverseAndTrack(obj, depth = 0) {
+            // Prevent infinite recursion and excessive depth
+            if (!obj || visited.has(obj) || !isObject(obj) || depth > options.maxDeepWatchDepth)
+                return;
+            // Do not traverse into unreactive objects
+            if (isNonReactive(obj))
+                return;
+            visited.add(obj);
+            // Mark this object as having deep watchers
+            objectsWithDeepWatchers.add(obj);
+            effectObjects.add(obj);
+            // Traverse all properties to register dependencies
+            // unwrap to avoid kicking dependency
+            for (const key in unwrap(obj)) {
+                if (Object.hasOwn(obj, key)) {
+                    // Access the property to register dependency
+                    const value = obj[key];
+                    // Make the value reactive if it's an object
+                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+            }
+            // Also handle array indices and length
+            // biome-ignore lint/suspicious/useIsArray: Check for both native arrays and reactive arrays
+            if (Array.isArray(obj) || obj instanceof Array) {
+                // Access array length to register dependency on length changes
+                const length = obj.length;
+                // Access all current array elements to register dependencies
+                for (let i = 0; i < length; i++) {
+                    // Access the array element to register dependency
+                    const value = obj[i];
+                    // Make the value reactive if it's an object
+                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+            }
+            // Handle Set values (deep watch values only, not keys since Sets don't have separate keys)
+            else if (obj instanceof Set) {
+                // Access all Set values to register dependencies
+                for (const value of obj) {
+                    // Make the value reactive if it's an object
+                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+            }
+            // Handle Map values (deep watch values only, not keys)
+            else if (obj instanceof Map) {
+                // Access all Map values to register dependencies
+                for (const [_key, value] of obj) {
+                    // Make the value reactive if it's an object
+                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+            }
+            // Note: WeakSet and WeakMap cannot be iterated, so we can't deep watch their contents
+            // They will only trigger when the collection itself is replaced
+        }
+        // Traverse the target object to register all dependencies
+        // This will register dependencies on all current properties and array elements
+        traverseAndTrack(target);
+        // Only call the callback if immediate is true or if it's not the first run
+        if (immediate)
+            callback(target);
+        immediate = true;
+        // Return a cleanup function that properly removes deep watcher tracking
+        return () => {
+            // Get the objects this effect was watching
+            const effectObjects = effectToDeepWatchedObjects.get(wrappedCallback);
+            if (effectObjects) {
+                // Remove deep watcher tracking from all objects this effect was watching
+                for (const obj of effectObjects) {
+                    // Check if this object still has other deep watchers
+                    const watchers = deepWatchers.get(obj);
+                    if (watchers) {
+                        // Remove this effect's callback from the watchers
+                        watchers.delete(wrappedCallback);
+                        // If no more watchers, remove the object from deep watchers tracking
+                        if (watchers.size === 0) {
+                            deepWatchers.delete(obj);
+                            objectsWithDeepWatchers.delete(obj);
+                        }
+                    }
+                    else {
+                        // No watchers found, remove from deep watchers tracking
+                        objectsWithDeepWatchers.delete(obj);
+                    }
+                }
+                // Clean up the tracking data
+                effectToDeepWatchedObjects.delete(wrappedCallback);
+            }
+        };
+    });
+}
+
+/**
+ * Symbol for accessing the cleanup function on cleaned objects
+ */
+const cleanup = Symbol('cleanup');
+//#region watch
+const unsetYet = Symbol('unset-yet');
+function watch(value, //object | ((dep: DependencyAccess) => object),
+changed, options = {}) {
+    return typeof value === 'function'
+        ? watchCallBack(value, changed, options)
+        : typeof value === 'object' && value !== null
+            ? watchObject(value, changed, options)
+            : (() => {
+                throw new Error('watch: value must be a function or an object');
+            })();
+}
+function watchObject(value, changed, { immediate = false, deep = false } = {}) {
+    const myParentEffect = getActiveEffect();
+    if (deep)
+        return deepWatch(value, changed, { immediate });
+    return effect(markWithRoot(function watchObjectEffect() {
+        dependant(value);
+        if (immediate)
+            withEffect(myParentEffect, () => changed(value));
+        immediate = true;
+    }, changed));
+}
+function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
+    const myParentEffect = getActiveEffect();
+    let oldValue = unsetYet;
+    let deepCleanup;
+    const cbCleanup = effect(markWithRoot(function watchCallBackEffect(access) {
+        const newValue = value(access);
+        if (oldValue !== newValue)
+            withEffect(myParentEffect, markWithRoot(() => {
+                if (oldValue === unsetYet) {
+                    if (immediate)
+                        changed(newValue);
+                }
+                else
+                    changed(newValue, oldValue);
+                oldValue = newValue;
+                if (deep) {
+                    if (deepCleanup)
+                        deepCleanup();
+                    deepCleanup = deepWatch(newValue, markWithRoot((value) => changed(value, value), changed));
+                }
+            }, changed));
+    }, value));
+    return () => {
+        cbCleanup();
+        if (deepCleanup)
+            deepCleanup();
+    };
+}
+//#endregion
+//#region nonReactive
+/**
+ * Mark an object as non-reactive. This object and all its properties will never be made reactive.
+ * @param obj - The object to mark as non-reactive
+ */
+function deepNonReactive(obj) {
+    obj = unwrap(obj);
+    if (isNonReactive(obj))
+        return obj;
+    try {
+        Object.defineProperty(obj, nonReactiveMark, {
+            value: true,
+            writable: false,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    catch { }
+    if (!(nonReactiveMark in obj))
+        nonReactiveObjects.add(obj);
+    //for (const key in obj) deepNonReactive(obj[key])
+    return obj;
+}
+function unreactiveApplication(arg1, ...args) {
+    return typeof arg1 === 'object'
+        ? deepNonReactive(arg1)
+        : ((original) => {
+            // Copy the parent's unreactive properties if they exist
+            original.prototype[unreactiveProperties] = new Set(original.prototype[unreactiveProperties] || []);
+            // Add all arguments (including the first one)
+            original.prototype[unreactiveProperties].add(arg1);
+            for (const arg of args)
+                original.prototype[unreactiveProperties].add(arg);
+            return original; // Return the class
+        });
+}
+/**
+ * Decorator that marks classes or properties as non-reactive
+ * Prevents objects from being made reactive
+ */
+const unreactive = decorator.decorator({
+    class(original) {
+        // Called without arguments, mark entire class as non-reactive
+        nonReactiveClass(original);
+    },
+    default: unreactiveApplication,
+});
+//#endregion
+function cleanedBy(obj, cleanupFn) {
+    return Object.defineProperty(obj, cleanup, {
+        value: cleanupFn,
+        writable: false,
+        enumerable: false,
+        configurable: true,
+    });
+}
+//#region greedy caching
+/**
+ * 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
+ */
+function derived(compute) {
+    const rv = { value: undefined };
+    return cleanedBy(rv, untracked(() => effect(markWithRoot(function derivedEffect(access) {
+        rv.value = compute(access);
+    }, compute))));
+}
+
+/**
+ * Converts an iterator to a generator that yields reactive values
+ */
+function* makeReactiveIterator(iterator) {
+    let result = iterator.next();
+    while (!result.done) {
+        yield reactive(result.value);
+        result = iterator.next();
+    }
+}
+/**
+ * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
+ */
+function* makeReactiveEntriesIterator(iterator) {
+    let result = iterator.next();
+    while (!result.done) {
+        const [key, value] = result.value;
+        yield [reactive(key), reactive(value)];
+        result = iterator.next();
+    }
+}
+
+const native$2 = Symbol('native');
+const isArray = Array.isArray;
+Array.isArray = ((value) => isArray(value) ||
+    // biome-ignore lint/suspicious/useIsArray: We are defining it
+    (value &&
+        typeof value === 'object' &&
+        prototypeForwarding in value &&
+        Array.isArray(value[prototypeForwarding])));
+class ReactiveBaseArray {
+    // Safe array access with negative indices
+    at(index) {
+        const actualIndex = index < 0 ? this[native$2].length + index : index;
+        dependant(this, actualIndex);
+        if (actualIndex < 0 || actualIndex >= this[native$2].length)
+            return undefined;
+        return reactive(this[native$2][actualIndex]);
+    }
+    // Immutable versions of mutator methods
+    toReversed() {
+        dependant(this);
+        return reactive(this[native$2].toReversed());
+    }
+    toSorted(compareFn) {
+        dependant(this);
+        return reactive(this[native$2].toSorted(compareFn));
+    }
+    toSpliced(start, deleteCount, ...items) {
+        dependant(this);
+        return deleteCount === undefined
+            ? this[native$2].toSpliced(start)
+            : this[native$2].toSpliced(start, deleteCount, ...items);
+    }
+    with(index, value) {
+        dependant(this);
+        return reactive(this[native$2].with(index, value));
+    }
+    // Iterator methods with reactivity tracking
+    entries() {
+        dependant(this);
+        return makeReactiveEntriesIterator(this[native$2].entries());
+    }
+    keys() {
+        dependant(this, 'length');
+        return this[native$2].keys();
+    }
+    values() {
+        dependant(this);
+        return makeReactiveIterator(this[native$2].values());
+    }
+    [Symbol.iterator]() {
+        dependant(this);
+        const nativeIterator = this[native$2][Symbol.iterator]();
+        return {
+            next() {
+                const result = nativeIterator.next();
+                if (result.done) {
+                    return result;
+                }
+                return { value: reactive(result.value), done: false };
+            },
+        };
+    }
+    indexOf(searchElement, fromIndex) {
+        dependant(this);
+        const unwrappedSearch = unwrap(searchElement);
+        // Check both wrapped and unwrapped versions since array may contain either
+        const index = this[native$2].indexOf(unwrappedSearch, fromIndex);
+        if (index !== -1)
+            return index;
+        // If not found with unwrapped, try with wrapped (in case array contains wrapped version)
+        return this[native$2].indexOf(searchElement, fromIndex);
+    }
+    lastIndexOf(searchElement, fromIndex) {
+        dependant(this);
+        const unwrappedSearch = unwrap(searchElement);
+        // Check both wrapped and unwrapped versions since array may contain either
+        const index = this[native$2].lastIndexOf(unwrappedSearch, fromIndex);
+        if (index !== -1)
+            return index;
+        // If not found with unwrapped, try with wrapped (in case array contains wrapped version)
+        return this[native$2].lastIndexOf(searchElement, fromIndex);
+    }
+    includes(searchElement, fromIndex) {
+        dependant(this);
+        const unwrappedSearch = unwrap(searchElement);
+        // Check both wrapped and unwrapped versions since array may contain either
+        return (this[native$2].includes(unwrappedSearch, fromIndex) ||
+            this[native$2].includes(searchElement, fromIndex));
+    }
+    find(predicateOrElement, thisArg) {
+        dependant(this);
+        if (typeof predicateOrElement === 'function') {
+            const predicate = predicateOrElement;
+            return reactive(this[native$2].find((value, index, array) => predicate.call(thisArg, reactive(value), index, array), thisArg));
+        }
+        const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
+        const index = this[native$2].indexOf(predicateOrElement, fromIndex);
+        if (index === -1)
+            return undefined;
+        return reactive(this[native$2][index]);
+    }
+    findIndex(predicateOrElement, thisArg) {
+        dependant(this);
+        if (typeof predicateOrElement === 'function') {
+            const predicate = predicateOrElement;
+            return this[native$2].findIndex((value, index, array) => predicate.call(thisArg, reactive(value), index, array), thisArg);
+        }
+        const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
+        return this[native$2].indexOf(predicateOrElement, fromIndex);
+    }
+    flat() {
+        dependant(this);
+        return reactive(this[native$2].flat());
+    }
+    flatMap(callbackfn, thisArg) {
+        dependant(this);
+        return reactive(this[native$2].flatMap(callbackfn, thisArg));
+    }
+    filter(callbackfn, thisArg) {
+        dependant(this);
+        return reactive(this[native$2].filter((item, index, array) => callbackfn(reactive(item), index, array), thisArg));
+    }
+    map(callbackfn, thisArg) {
+        dependant(this);
+        return reactive(this[native$2].map((item, index, array) => callbackfn(reactive(item), index, array), thisArg));
+    }
+    reduce(callbackfn, initialValue) {
+        dependant(this);
+        const result = initialValue === undefined
+            ? this[native$2].reduce(callbackfn)
+            : this[native$2].reduce(callbackfn, initialValue);
+        return reactive(result);
+    }
+    reduceRight(callbackfn, initialValue) {
+        dependant(this);
+        const result = initialValue !== undefined
+            ? this[native$2].reduceRight(callbackfn, initialValue)
+            : this[native$2].reduceRight(callbackfn);
+        return reactive(result);
+    }
+    slice(start, end) {
+        for (const i of range(start || 0, end || this[native$2].length - 1))
+            dependant(this, i);
+        return start === undefined
+            ? this[native$2].slice()
+            : end === undefined
+                ? this[native$2].slice(start)
+                : this[native$2].slice(start, end);
+    }
+    concat(...items) {
+        dependant(this);
+        return reactive(this[native$2].concat(...items));
+    }
+    join(separator) {
+        dependant(this);
+        return this[native$2].join(separator);
+    }
+    forEach(callbackfn, thisArg) {
+        dependant(this);
+        this[native$2].forEach((value, index, array) => {
+            callbackfn.call(thisArg, reactive(value), index, array);
+        });
+    }
+    // TODO: re-implement for fun dependencies? (eg - every only check the first ones until it find some),
+    // no need to make it dependant on indexes after the found one
+    every(callbackfn, thisArg) {
+        dependant(this);
+        return this[native$2].every((value, index, array) => callbackfn.call(thisArg, reactive(value), index, array), thisArg);
+    }
+    some(callbackfn, thisArg) {
+        dependant(this);
+        return this[native$2].some((value, index, array) => callbackfn.call(thisArg, reactive(value), index, array), thisArg);
+    }
+}
+function* index(i, { length = true } = {}) {
+    if (length)
+        yield 'length';
+    yield i;
+}
+function* range(a, b, { length = false } = {}) {
+    const start = Math.min(a, b);
+    const end = Math.max(a, b);
+    if (length)
+        yield 'length';
+    for (let i = start; i <= end; i++)
+        yield i;
+}
+/**
+ * Reactive wrapper around JavaScript's Array class with full array method support
+ * Tracks length changes, individual index operations, and collection-wide operations
+ */
+class ReactiveArray extends indexable.Indexable(ReactiveBaseArray, {
+    get(i) {
+        dependant(this, i);
+        return reactive(this[native$2][i]);
+    },
+    set(i, value) {
+        const added = i >= this[native$2].length;
+        this[native$2][i] = value;
+        touched(this, { type: 'set', prop: i }, index(i, { length: added }));
+    },
+    getLength() {
+        dependant(this, 'length');
+        return this[native$2].length;
+    },
+    setLength(value) {
+        const oldLength = this[native$2].length;
+        try {
+            this[native$2].length = value;
+        }
+        finally {
+            touched(this, { type: 'set', prop: 'length' }, range(oldLength, value, { length: true }));
+        }
+    },
+}) {
+    constructor(original) {
+        super();
+        Object.defineProperties(this, {
+            // We have to make it double, as [native] must be `unique symbol` - impossible through import
+            [native$2]: { value: original },
+            [prototypeForwarding]: { value: original },
+        });
+    }
+    push(...items) {
+        const oldLength = this[native$2].length;
+        try {
+            return this[native$2].push(...items);
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'push' }, range(oldLength, oldLength + items.length - 1, { length: true }));
+        }
+    }
+    pop() {
+        if (this[native$2].length === 0)
+            return undefined;
+        try {
+            return reactive(this[native$2].pop());
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'pop' }, index(this[native$2].length));
+        }
+    }
+    shift() {
+        if (this[native$2].length === 0)
+            return undefined;
+        try {
+            return reactive(this[native$2].shift());
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'shift' }, range(0, this[native$2].length + 1, { length: true }));
+        }
+    }
+    unshift(...items) {
+        try {
+            return this[native$2].unshift(...items);
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'unshift' }, range(0, this[native$2].length - items.length, { length: true }));
+        }
+    }
+    splice(start, deleteCount, ...items) {
+        const oldLength = this[native$2].length;
+        if (deleteCount === undefined)
+            deleteCount = oldLength - start;
+        try {
+            if (deleteCount === undefined)
+                return reactive(this[native$2].splice(start));
+            return reactive(this[native$2].splice(start, deleteCount, ...items));
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'splice' }, 
+            // TODO: edge cases
+            deleteCount === items.length
+                ? range(start, start + deleteCount)
+                : range(start, oldLength + Math.max(items.length - deleteCount, 0), {
+                    length: true,
+                }));
+        }
+    }
+    reverse() {
+        try {
+            return this[native$2].reverse();
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'reverse' }, range(0, this[native$2].length - 1));
+        }
+    }
+    sort(compareFn) {
+        compareFn = compareFn || ((a, b) => a.toString().localeCompare(b.toString()));
+        try {
+            return this[native$2].sort((a, b) => compareFn(reactive(a), reactive(b)));
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'sort' }, range(0, this[native$2].length - 1));
+        }
+    }
+    fill(value, start, end) {
+        try {
+            if (start === undefined)
+                return this[native$2].fill(value);
+            if (end === undefined)
+                return this[native$2].fill(value, start);
+            return this[native$2].fill(value, start, end);
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'fill' }, range(0, this[native$2].length - 1));
+        }
+    }
+    copyWithin(target, start, end) {
+        try {
+            if (end === undefined)
+                return this[native$2].copyWithin(target, start);
+            return this[native$2].copyWithin(target, start, end);
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'copyWithin' }, 
+            // TODO: calculate the range properly
+            range(0, this[native$2].length - 1));
+        }
+        // Touch all affected indices with a single allProps call
+    }
+}
+
+// TODO: Lazy reactivity ?
+class ReadOnlyError extends Error {
+}
+/**
+ * Reactive wrapper around JavaScript's Array class with full array method support
+ * Tracks length changes, individual index operations, and collection-wide operations
+ */
+class ReactiveReadOnlyArrayClass extends indexable.Indexable(ReactiveBaseArray, {
+    get(i) {
+        dependant(this, i);
+        return reactive(this[native$2][i]);
+    },
+    set(i, _value) {
+        throw new ReadOnlyError(`Setting index ${i} on a read-only array`);
+    },
+    getLength() {
+        dependant(this, 'length');
+        return this[native$2].length;
+    },
+    setLength(value) {
+        throw new ReadOnlyError(`Setting length to ${value} on a read-only array`);
+    },
+}) {
+    constructor(original) {
+        super();
+        Object.defineProperties(this, {
+            // We have to make it double, as [native] must be `unique symbol` - impossible through import
+            [native$2]: { value: original },
+            [prototypeForwarding]: { value: original },
+        });
+    }
+    push(..._items) {
+        throw new ReadOnlyError(`Pushing items to a read-only array`);
+    }
+    pop() {
+        throw new ReadOnlyError(`Popping from a read-only array`);
+    }
+    shift() {
+        throw new ReadOnlyError(`Shifting from a read-only array`);
+    }
+    unshift(..._items) {
+        throw new ReadOnlyError(`Unshifting items to a read-only array`);
+    }
+    splice(_start, _deleteCount, ..._items) {
+        throw new ReadOnlyError(`Splice from a read-only array`);
+    }
+    reverse() {
+        throw new ReadOnlyError(`Reversing a read-only array`);
+    }
+    sort(_compareFn) {
+        throw new ReadOnlyError(`Sorting a read-only array`);
+    }
+    fill(_value, _start, _end) {
+        throw new ReadOnlyError(`Filling a read-only array`);
+    }
+    copyWithin(_target, _start, _end) {
+        throw new ReadOnlyError(`Copying within a read-only array`);
+    }
+}
+const ReactiveReadOnlyArray = reactive(ReactiveReadOnlyArrayClass);
+function mapped(inputs, compute, resize) {
+    const result = [];
+    const resultReactive = new ReactiveReadOnlyArray(result);
+    const cleanups = [];
+    function input(index) {
+        return effect(function computedIndexedMapInputEffect() {
+            result[index] = compute(inputs[index], index, resultReactive);
+            touched1(resultReactive, { type: 'set', prop: index }, index);
+        });
+    }
+    const cleanupLength = effect(function computedMapLengthEffect({ ascend }) {
+        const length = inputs.length;
+        const resultLength = untracked(() => result.length);
+        resize?.(length, resultLength);
+        touched1(resultReactive, { type: 'set', prop: 'length' }, 'length');
+        if (length < resultLength) {
+            const toCleanup = cleanups.splice(length);
+            for (const cleanup of toCleanup)
+                cleanup();
+            result.length = length;
+        }
+        else if (length > resultLength)
+            // the input effects will be registered as the call's children, so they will remain not cleaned with this effect on length
+            ascend(function computedMapNewElements() {
+                for (let i = resultLength; i < length; i++)
+                    cleanups.push(input(i));
+            });
+    });
+    return cleanedBy(resultReactive, () => {
+        for (const cleanup of cleanups)
+            cleanup();
+        cleanups.length = 0;
+        cleanupLength();
+    });
+}
+function reduced(inputs, compute) {
+    const result = [];
+    const resultReactive = new ReactiveReadOnlyArray(result);
+    const cleanupFactor = effect(function computedReducedFactorEffect() {
+        const factor = {};
+        result.length = 0;
+        for (const input of inputs)
+            result.push(...compute(input, factor));
+        touched(resultReactive, { type: 'invalidate', prop: 'reduced' });
+    });
+    return cleanedBy(resultReactive, cleanupFactor);
+}
+
+const memoizedRegistry = new WeakMap();
+function getBranch(tree, key) {
+    tree.branches ?? (tree.branches = new WeakMap());
+    let branch = tree.branches.get(key);
+    if (!branch) {
+        branch = {};
+        tree.branches.set(key, branch);
+    }
+    return branch;
+}
+function memoizeFunction(fn) {
+    const fnRoot = getRoot(fn);
+    const existing = memoizedRegistry.get(fnRoot);
+    if (existing)
+        return existing;
+    const cacheRoot = {};
+    const memoized = markWithRoot((...args) => {
+        const localArgs = args; //: Args = maxArgs !== undefined ? (args.slice(0, maxArgs) as Args) : args
+        if (localArgs.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg))))
+            throw new Error('memoize expects non-null object arguments');
+        let node = cacheRoot;
+        for (const arg of localArgs) {
+            node = getBranch(node, arg);
+        }
+        dependant(node, 'memoize');
+        if ('result' in node)
+            return node.result;
+        // Create memoize internal effect to track dependencies and invalidate cache
+        // Use untracked to prevent the effect creation from being affected by parent effects
+        node.cleanup = root(() => effect(markWithRoot(() => {
+            // Execute the function and track its dependencies
+            // The function execution will automatically track dependencies on reactive objects
+            node.result = fn(...localArgs);
+            return () => {
+                // When dependencies change, clear the cache and notify consumers
+                delete node.result;
+                touched1(node, { type: 'invalidate', prop: localArgs }, 'memoize');
+            };
+        }, fnRoot), { opaque: true }));
+        return node.result;
+    }, fn);
+    memoizedRegistry.set(fnRoot, memoized);
+    memoizedRegistry.set(memoized, memoized);
+    return memoized;
+}
+const memoize = decorator.decorator({
+    getter(original, propertyKey) {
+        const memoized = memoizeFunction(markWithRoot(decorator.renamed((that) => {
+            return original.call(that);
+        }, `${String(this.constructor.name)}.${String(propertyKey)}`), original));
+        return function () {
+            return memoized(this);
+        };
+    },
+    method(original, name) {
+        const memoized = memoizeFunction(markWithRoot(decorator.renamed((that, ...args) => {
+            return original.call(that, ...args);
+        }, `${String(this.constructor.name)}.${String(name)}`), original));
+        return function (...args) {
+            return memoized(this, ...args);
+        };
+    },
+    default: memoizeFunction,
+});
+
+// Helper to work around TypeScript limitation: base class expressions cannot reference class type parameters
+function getRegisterBase() {
+    class RegisterBase extends indexable.Indexable(indexable.ArrayReadForward, {
+        get(index) {
+            return this[indexable.getAt](index);
+        },
+        set(index, value) {
+            this[indexable.setAt](index, value);
+        },
+        getLength() {
+            return this.length;
+        },
+        setLength(value) {
+            this.length = value;
+        },
+    }) {
+        toArray() {
+            return Array.from(this);
+        }
+    }
+    return RegisterBase;
+}
+let RegisterClass = (() => {
+    var _RegisterClass_instances, _RegisterClass_keyFn, _RegisterClass_keys, _RegisterClass_values, _RegisterClass_usage, _RegisterClass_valueInfo, _RegisterClass_keyEffects, _RegisterClass_ascend, _RegisterClass_rekeyValue;
+    let _classDecorators = [unreactive];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = getRegisterBase();
+    _classThis = class extends _classSuper {
+        get [(_RegisterClass_keyFn = new WeakMap(), _RegisterClass_keys = new WeakMap(), _RegisterClass_values = new WeakMap(), _RegisterClass_usage = new WeakMap(), _RegisterClass_valueInfo = new WeakMap(), _RegisterClass_keyEffects = new WeakMap(), _RegisterClass_ascend = new WeakMap(), _RegisterClass_instances = new WeakSet(), indexable.forwardArray)]() {
+            return this.toArray();
+        }
+        constructor(keyFn, initial) {
+            super();
+            _RegisterClass_instances.add(this);
+            _RegisterClass_keyFn.set(this, void 0);
+            _RegisterClass_keys.set(this, void 0);
+            _RegisterClass_values.set(this, void 0);
+            _RegisterClass_usage.set(this, new Map());
+            _RegisterClass_valueInfo.set(this, new Map());
+            _RegisterClass_keyEffects.set(this, new Set());
+            _RegisterClass_ascend.set(this, void 0);
+            /* Moved below initialization */
+            let ascendGet;
+            effect(({ ascend }) => {
+                ascendGet = ascend;
+            });
+            _tslib.__classPrivateFieldSet(this, _RegisterClass_ascend, ascendGet, "f");
+            if (typeof keyFn !== 'function')
+                throw new Error('Register requires a key function');
+            _tslib.__classPrivateFieldSet(this, _RegisterClass_keyFn, keyFn, "f");
+            _tslib.__classPrivateFieldSet(this, _RegisterClass_keys, reactive([]), "f");
+            _tslib.__classPrivateFieldSet(this, _RegisterClass_values, reactive(new Map()), "f");
+            Object.defineProperties(this, {
+                [prototypeForwarding]: { value: _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f") },
+            });
+            if (initial)
+                this.push(...initial);
+        }
+        ensureKey(value) {
+            let info = _tslib.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (info)
+                return info.key;
+            info = { key: undefined };
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").set(value, info);
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_ascend, "f").call(this, () => {
+                const stop = effect(({ reaction }) => {
+                    const nextKey = _tslib.__classPrivateFieldGet(this, _RegisterClass_keyFn, "f").call(this, value);
+                    this.assertValidKey(nextKey);
+                    const previousKey = info.key;
+                    if (reaction && previousKey !== undefined && !Object.is(nextKey, previousKey))
+                        _tslib.__classPrivateFieldGet(this, _RegisterClass_instances, "m", _RegisterClass_rekeyValue).call(this, value, previousKey, nextKey);
+                    info.key = nextKey;
+                });
+                info.stop = stop;
+                _tslib.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").add(stop);
+            });
+            if (info.key === undefined)
+                throw new Error('Register key function must return a property key');
+            return info.key;
+        }
+        assertValidKey(key) {
+            const type = typeof key;
+            if (type !== 'string' && type !== 'number' && type !== 'symbol')
+                throw new Error('Register key function must return a property key');
+        }
+        setKeyValue(key, value) {
+            const existing = _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+            if (existing !== undefined && existing !== value)
+                this.cleanupValue(existing);
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+        }
+        cleanupValue(value) {
+            const info = _tslib.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (!info)
+                return;
+            const stop = info.stop;
+            if (stop) {
+                info.stop = undefined;
+                _tslib.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").delete(stop);
+                stop();
+            }
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").delete(value);
+        }
+        disposeKeyEffects() {
+            for (const value of Array.from(_tslib.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").keys()))
+                this.cleanupValue(value);
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").clear();
+        }
+        incrementUsage(key) {
+            const count = _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key) ?? 0;
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count + 1);
+        }
+        decrementUsage(key) {
+            const count = _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key);
+            if (!count)
+                return;
+            if (count <= 1) {
+                const value = _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(key);
+                _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").delete(key);
+                if (value !== undefined)
+                    this.cleanupValue(value);
+            }
+            else {
+                _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count - 1);
+            }
+        }
+        normalizeIndex(index, allowEnd = false) {
+            const length = this.length;
+            let resolved = index;
+            if (resolved < 0)
+                resolved = Math.max(length + resolved, 0);
+            if (resolved > length) {
+                if (allowEnd)
+                    resolved = length;
+                else
+                    throw new RangeError('Index out of bounds');
+            }
+            if (!allowEnd && resolved === length)
+                throw new RangeError('Index out of bounds');
+            return resolved;
+        }
+        assignAt(index, key, value) {
+            const oldKey = _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
+            if (oldKey !== undefined && Object.is(oldKey, key)) {
+                this.setKeyValue(key, value);
+                return;
+            }
+            if (oldKey !== undefined)
+                this.decrementUsage(oldKey);
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index] = key;
+            this.incrementUsage(key);
+            this.setKeyValue(key, value);
+        }
+        insertKeyValue(index, key, value) {
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 0, key);
+            this.incrementUsage(key);
+            this.setKeyValue(key, value);
+        }
+        rebuildFrom(values) {
+            this.disposeKeyEffects();
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(0, _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length);
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
+            for (const value of values) {
+                const key = this.ensureKey(value);
+                _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").push(key);
+                this.incrementUsage(key);
+                _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+            }
+        }
+        get length() {
+            return _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length;
+        }
+        [(_RegisterClass_rekeyValue = function _RegisterClass_rekeyValue(value, oldKey, newKey) {
+            if (Object.is(oldKey, newKey))
+                return;
+            const existingValue = _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(newKey);
+            if (existingValue !== undefined && existingValue !== value)
+                throw new Error(`Register key collision for key ${String(newKey)}`);
+            const count = _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(oldKey);
+            if (!count)
+                return;
+            const existingCount = _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(newKey) ?? 0;
+            this.setKeyValue(newKey, value);
+            for (let i = 0; i < _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length; i++)
+                if (Object.is(_tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i], oldKey))
+                    _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i] = newKey;
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(newKey, existingCount + count);
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(oldKey);
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").delete(oldKey);
+            const updatedInfo = _tslib.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (updatedInfo)
+                updatedInfo.key = newKey;
+        }, indexable.getAt)](index) {
+            const key = _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
+            return key === undefined ? undefined : _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+        }
+        [indexable.setAt](index, value) {
+            const key = this.ensureKey(value);
+            if (index === this.length) {
+                this.insertKeyValue(index, key, value);
+                return;
+            }
+            const normalized = this.normalizeIndex(index);
+            this.assignAt(normalized, key, value);
+        }
+        push(...items) {
+            for (const item of items) {
+                const key = this.ensureKey(item);
+                this.insertKeyValue(this.length, key, item);
+            }
+            return this.length;
+        }
+        pop() {
+            if (!this.length)
+                return undefined;
+            return this.removeAt(this.length - 1);
+        }
+        shift() {
+            if (!this.length)
+                return undefined;
+            return this.removeAt(0);
+        }
+        unshift(...items) {
+            let index = 0;
+            for (const item of items) {
+                const key = this.ensureKey(item);
+                this.insertKeyValue(index++, key, item);
+            }
+            return this.length;
+        }
+        splice(start, deleteCount, ...items) {
+            const normalizedStart = this.normalizeIndex(start, true);
+            const maxDeletions = this.length - normalizedStart;
+            const actualDelete = Math.min(deleteCount === undefined ? maxDeletions : Math.max(deleteCount, 0), maxDeletions);
+            const keysToInsert = [];
+            for (const item of items)
+                keysToInsert.push(this.ensureKey(item));
+            const removedKeys = _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(normalizedStart, actualDelete, ...keysToInsert);
+            const removedValues = [];
+            for (const key of removedKeys) {
+                if (key === undefined)
+                    continue;
+                const value = _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                this.decrementUsage(key);
+                removedValues.push(value);
+            }
+            for (let i = 0; i < keysToInsert.length; i++) {
+                const key = keysToInsert[i];
+                const value = items[i];
+                this.incrementUsage(key);
+                this.setKeyValue(key, value);
+            }
+            return removedValues;
+        }
+        clear() {
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length = 0;
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
+            this.disposeKeyEffects();
+        }
+        get(key) {
+            return _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+        }
+        set(key, value) {
+            if (_tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
+                this.setKeyValue(key, value);
+        }
+        remove(key) {
+            let index = this.indexOfKey(key);
+            while (index !== -1) {
+                this.removeAt(index);
+                index = this.indexOfKey(key);
+            }
+        }
+        removeAt(index) {
+            const [key] = _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 1);
+            if (key === undefined)
+                return undefined;
+            const value = _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+            this.decrementUsage(key);
+            return value;
+        }
+        /**
+         * 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) {
+            const decisions = new Map();
+            for (const [index, key] of _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").entries()) {
+                if (decisions.has(key)) {
+                    if (!decisions.get(key))
+                        this.removeAt(index);
+                    continue;
+                }
+                const value = _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                const shouldKeep = predicate(value);
+                decisions.set(key, shouldKeep);
+                if (!shouldKeep)
+                    this.removeAt(index);
+            }
+        }
+        hasKey(key) {
+            return _tslib.__classPrivateFieldGet(this, _RegisterClass_usage, "f").has(key);
+        }
+        indexOfKey(key) {
+            return _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
+        }
+        mapKeys() {
+            return _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").keys();
+        }
+        update(...values) {
+            for (const value of values) {
+                const key = this.ensureKey(value);
+                if (_tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
+                    this.setKeyValue(key, value);
+            }
+        }
+        upsert(insert, ...values) {
+            for (const value of values) {
+                const key = this.ensureKey(value);
+                if (_tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
+                    this.setKeyValue(key, value);
+                else
+                    insert(value);
+            }
+        }
+        entries() {
+            const self = this;
+            function* iterator() {
+                for (let i = 0; i < _tslib.__classPrivateFieldGet(self, _RegisterClass_keys, "f").length; i++) {
+                    const val = _tslib.__classPrivateFieldGet(self, _RegisterClass_values, "f").get(_tslib.__classPrivateFieldGet(self, _RegisterClass_keys, "f")[i]);
+                    if (val !== undefined)
+                        yield [i, val];
+                }
+            }
+            return iterator();
+        }
+        [Symbol.iterator]() {
+            const self = this;
+            function* iterator() {
+                for (const key of _tslib.__classPrivateFieldGet(self, _RegisterClass_keys, "f")) {
+                    const value = _tslib.__classPrivateFieldGet(self, _RegisterClass_values, "f").get(key);
+                    if (value !== undefined)
+                        yield value;
+                }
+            }
+            return iterator();
+        }
+        toString() {
+            return `[Register length=${this.length}]`;
+        }
+        at(index) {
+            const resolved = index < 0 ? this.length + index : index;
+            if (resolved < 0 || resolved >= this.length)
+                return undefined;
+            return this[indexable.getAt](resolved);
+        }
+        reverse() {
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").reverse();
+            return this;
+        }
+        sort(compareFn) {
+            const fwdCompareFn = compareFn
+                ? (a, b) => compareFn(_tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(a), _tslib.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(b))
+                : undefined;
+            _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f").sort(fwdCompareFn);
+            return this;
+        }
+        fill(value, start = 0, end = this.length) {
+            const values = this.toArray();
+            values.fill(value, start, end);
+            this.rebuildFrom(values);
+            return this;
+        }
+        copyWithin(target, start, end) {
+            const values = this.toArray();
+            values.copyWithin(target, start, end);
+            this.rebuildFrom(values);
+            return this;
+        }
+    };
+    _tslib.__setFunctionName(_classThis, "RegisterClass");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        _tslib.__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        _tslib.__runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return _classThis;
+})();
+const Register = RegisterClass;
+function register(keyFn, initial) {
+    return new RegisterClass(keyFn, initial);
+}
+
+function defineAccessValue(access) {
+    Object.defineProperty(access, 'value', {
+        get: access.get,
+        set: access.set,
+        configurable: true,
+        enumerable: true,
+    });
+}
+function makeCleanup(target, effectMap, onDispose) {
+    return cleanedBy(target, () => {
+        onDispose();
+        for (const stop of effectMap.values())
+            stop?.();
+        effectMap.clear();
+    });
+}
+function projectArray(source, apply) {
+    const observedSource = reactive(source);
+    const target = reactive([]);
+    const indexEffects = new Map();
+    function normalizeTargetLength(length) {
+        decorator.ReflectSet(target, 'length', length, target);
+    }
+    function disposeIndex(index) {
+        const stopEffect = indexEffects.get(index);
+        if (stopEffect) {
+            indexEffects.delete(index);
+            stopEffect();
+            Reflect.deleteProperty(target, index);
+        }
+    }
+    const cleanupLength = effect(function projectArrayLengthEffect({ ascend }) {
+        const length = observedSource.length;
+        normalizeTargetLength(length);
+        const existing = Array.from(indexEffects.keys());
+        for (let i = 0; i < length; i++) {
+            if (indexEffects.has(i))
+                continue;
+            ascend(() => {
+                const index = i;
+                const stop = effect(function projectArrayIndexEffect() {
+                    const previous = untracked(() => target[index]);
+                    const accessBase = {
+                        key: index,
+                        source: observedSource,
+                        get: () => decorator.ReflectGet(observedSource, index, observedSource),
+                        set: (value) => decorator.ReflectSet(observedSource, index, value, observedSource),
+                        old: previous,
+                    };
+                    defineAccessValue(accessBase);
+                    const produced = apply(accessBase, target);
+                    target[index] = produced;
+                });
+                indexEffects.set(i, stop);
+            });
+        }
+        for (const index of existing)
+            if (index >= length)
+                disposeIndex(index);
+    });
+    return makeCleanup(target, indexEffects, () => cleanupLength());
+}
+function projectRegister(source, apply) {
+    const observedSource = reactive(source);
+    const rawTarget = new Map();
+    const target = reactive(rawTarget);
+    const keyEffects = new Map();
+    function disposeKey(key) {
+        const stopEffect = keyEffects.get(key);
+        if (stopEffect) {
+            stopEffect();
+            keyEffects.delete(key);
+            target.delete(key);
+        }
+    }
+    const cleanupKeys = effect(function projectRegisterEffect({ ascend }) {
+        const keys = new Set();
+        for (const key of observedSource.mapKeys())
+            keys.add(key);
+        for (const key of keys) {
+            if (keyEffects.has(key))
+                continue;
+            ascend(() => {
+                const stop = effect(function projectRegisterKeyEffect() {
+                    const previous = untracked(() => target.get(key));
+                    const accessBase = {
+                        key,
+                        source: observedSource,
+                        get: () => observedSource.get(key),
+                        set: (value) => {
+                            observedSource.set(key, value);
+                            return true;
+                        },
+                        old: previous,
+                    };
+                    defineAccessValue(accessBase);
+                    const produced = apply(accessBase, target);
+                    target.set(key, produced);
+                });
+                keyEffects.set(key, stop);
+            });
+        }
+        for (const key of Array.from(keyEffects.keys()))
+            if (!keys.has(key))
+                disposeKey(key);
+    });
+    return makeCleanup(target, keyEffects, () => cleanupKeys());
+}
+function projectRecord(source, apply) {
+    const observedSource = reactive(source);
+    const target = reactive({});
+    const keyEffects = new Map();
+    function disposeKey(key) {
+        const stopEffect = keyEffects.get(key);
+        if (stopEffect) {
+            stopEffect();
+            keyEffects.delete(key);
+            Reflect.deleteProperty(target, key);
+        }
+    }
+    const cleanupKeys = effect(function projectRecordEffect({ ascend }) {
+        const keys = new Set();
+        for (const key in observedSource)
+            keys.add(key);
+        const observed = Reflect.ownKeys(observedSource);
+        for (const key of observed)
+            keys.add(key);
+        for (const key of keys) {
+            if (keyEffects.has(key))
+                continue;
+            ascend(() => {
+                const stop = effect(function projectRecordKeyEffect() {
+                    const sourceKey = key;
+                    const previous = untracked(() => target[key]);
+                    const accessBase = {
+                        key: sourceKey,
+                        source: observedSource,
+                        get: () => decorator.ReflectGet(observedSource, sourceKey, observedSource),
+                        set: (value) => decorator.ReflectSet(observedSource, sourceKey, value, observedSource),
+                        old: previous,
+                    };
+                    defineAccessValue(accessBase);
+                    const produced = apply(accessBase, target);
+                    target[sourceKey] = produced;
+                });
+                keyEffects.set(key, stop);
+            });
+        }
+        for (const key of Array.from(keyEffects.keys()))
+            if (!keys.has(key))
+                disposeKey(key);
+    });
+    return makeCleanup(target, keyEffects, () => cleanupKeys());
+}
+function projectMap(source, apply) {
+    const observedSource = reactive(source);
+    const rawTarget = new Map();
+    const target = reactive(rawTarget);
+    const keyEffects = new Map();
+    function disposeKey(key) {
+        const stopEffect = keyEffects.get(key);
+        if (stopEffect) {
+            stopEffect();
+            keyEffects.delete(key);
+            target.delete(key);
+        }
+    }
+    const cleanupKeys = effect(function projectMapEffect({ ascend }) {
+        const keys = new Set();
+        for (const key of observedSource.keys())
+            keys.add(key);
+        for (const key of keys) {
+            if (keyEffects.has(key))
+                continue;
+            ascend(() => {
+                const stop = effect(function projectMapKeyEffect() {
+                    const previous = untracked(() => target.get(key));
+                    const accessBase = {
+                        key,
+                        source: observedSource,
+                        get: () => observedSource.get(key),
+                        set: (value) => {
+                            observedSource.set(key, value);
+                            return true;
+                        },
+                        old: previous,
+                    };
+                    defineAccessValue(accessBase);
+                    const produced = apply(accessBase, target);
+                    target.set(key, produced);
+                });
+                keyEffects.set(key, stop);
+            });
+        }
+        for (const key of Array.from(keyEffects.keys()))
+            if (!keys.has(key))
+                disposeKey(key);
+    });
+    return makeCleanup(target, keyEffects, () => cleanupKeys());
+}
+function projectCore(source, apply) {
+    if (Array.isArray(source))
+        return projectArray(source, apply);
+    if (source instanceof Map)
+        return projectMap(source, apply);
+    if (source instanceof Register)
+        return projectRegister(source, apply);
+    if (source && (source.constructor === Object || source.constructor === undefined))
+        return projectRecord(source, apply);
+    throw new Error('Unsupported source type');
+}
+const project = Object.assign(projectCore, {
+    array: projectArray,
+    register: projectRegister,
+    record: projectRecord,
+    map: projectMap,
+});
+
+/**
+ * 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]();
+ * });
+ */
+function organized(source, apply, baseTarget = {}) {
+    const observedSource = reactive(source);
+    const target = reactive(baseTarget);
+    const keyEffects = new Map();
+    function disposeKey(key) {
+        const stopEffect = keyEffects.get(key);
+        if (stopEffect) {
+            keyEffects.delete(key);
+            stopEffect();
+        }
+    }
+    const cleanupKeys = effect(function organizedKeysEffect({ ascend }) {
+        //const keys = Reflect.ownKeys(observedSource) as PropertyKey[]
+        const keys = new Set();
+        for (const key in observedSource)
+            keys.add(key);
+        for (const key of keys) {
+            if (keyEffects.has(key))
+                continue;
+            ascend(() => {
+                const stop = effect(function organizedKeyEffect() {
+                    const sourceKey = key;
+                    const accessBase = {
+                        key: sourceKey,
+                        get: () => decorator.ReflectGet(observedSource, sourceKey, observedSource),
+                        set: (value) => decorator.ReflectSet(observedSource, sourceKey, value, observedSource),
+                    };
+                    Object.defineProperty(accessBase, 'value', {
+                        get: accessBase.get,
+                        set: accessBase.set,
+                        configurable: true,
+                        enumerable: true,
+                    });
+                    return apply(accessBase, target);
+                });
+                keyEffects.set(key, stop);
+            });
+        }
+        for (const key of Array.from(keyEffects.keys()))
+            if (!keys.has(key))
+                disposeKey(key);
+    });
+    return cleanedBy(target, () => {
+        cleanupKeys();
+        for (const key of Array.from(keyEffects.keys()))
+            disposeKey(key);
+    });
+}
+/**
+ * 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
+ */
+function organize(target, property, access) {
+    Object.defineProperty(target, property, {
+        get: access.get,
+        set: access.set,
+        configurable: true,
+        enumerable: true,
+    });
+    touched1(target, { type: 'set', prop: property }, property);
+    return () => delete target[property];
+}
+
+const native$1 = Symbol('native');
+/**
+ * Reactive wrapper around JavaScript's WeakMap class
+ * Only tracks individual key operations, no size tracking (WeakMap limitation)
+ */
+class ReactiveWeakMap {
+    constructor(original) {
+        Object.defineProperties(this, {
+            [native$1]: { value: original },
+            [prototypeForwarding]: { value: original },
+            content: { value: Symbol('content') },
+            [Symbol.toStringTag]: { value: 'ReactiveWeakMap' },
+        });
+    }
+    // Implement WeakMap interface methods with reactivity
+    delete(key) {
+        const hadKey = this[native$1].has(key);
+        const result = this[native$1].delete(key);
+        if (hadKey)
+            touched1(this.content, { type: 'del', prop: key }, key);
+        return result;
+    }
+    get(key) {
+        dependant(this.content, key);
+        return reactive(this[native$1].get(key));
+    }
+    has(key) {
+        dependant(this.content, key);
+        return this[native$1].has(key);
+    }
+    set(key, value) {
+        const hadKey = this[native$1].has(key);
+        const oldValue = this[native$1].get(key);
+        const reactiveValue = reactive(value);
+        this[native$1].set(key, reactiveValue);
+        if (!hadKey || oldValue !== reactiveValue) {
+            notifyPropertyChange(this.content, key, oldValue, reactiveValue, hadKey);
+        }
+        return this;
+    }
+}
+/**
+ * Reactive wrapper around JavaScript's Map class
+ * Tracks size changes, individual key operations, and collection-wide operations
+ */
+class ReactiveMap {
+    constructor(original) {
+        Object.defineProperties(this, {
+            [native$1]: { value: original },
+            [prototypeForwarding]: { value: original },
+            content: { value: Symbol('content') },
+            [Symbol.toStringTag]: { value: 'ReactiveMap' },
+        });
+    }
+    // Implement Map interface methods with reactivity
+    get size() {
+        dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
+        return this[native$1].size;
+    }
+    clear() {
+        const hadEntries = this[native$1].size > 0;
+        this[native$1].clear();
+        if (hadEntries) {
+            const evolution = { type: 'bunch', method: 'clear' };
+            // Clear triggers all effects since all keys are affected
+            touched1(this, evolution, 'size');
+            touched(this.content, evolution);
+        }
+    }
+    entries() {
+        dependant(this.content);
+        return makeReactiveEntriesIterator(this[native$1].entries());
+    }
+    forEach(callbackfn, thisArg) {
+        dependant(this.content);
+        this[native$1].forEach(callbackfn, thisArg);
+    }
+    keys() {
+        dependant(this.content);
+        return this[native$1].keys();
+    }
+    values() {
+        dependant(this.content);
+        return makeReactiveIterator(this[native$1].values());
+    }
+    [Symbol.iterator]() {
+        dependant(this.content);
+        const nativeIterator = this[native$1][Symbol.iterator]();
+        return {
+            next() {
+                const result = nativeIterator.next();
+                if (result.done) {
+                    return result;
+                }
+                return {
+                    value: [result.value[0], reactive(result.value[1])],
+                    done: false,
+                };
+            },
+        };
+    }
+    // Implement Map methods with reactivity
+    delete(key) {
+        const hadKey = this[native$1].has(key);
+        const result = this[native$1].delete(key);
+        if (hadKey) {
+            const evolution = { type: 'del', prop: key };
+            touched1(this.content, evolution, key);
+            touched1(this, evolution, 'size');
+        }
+        return result;
+    }
+    get(key) {
+        dependant(this.content, key);
+        return reactive(this[native$1].get(key));
+    }
+    has(key) {
+        dependant(this.content, key);
+        return this[native$1].has(key);
+    }
+    set(key, value) {
+        const hadKey = this[native$1].has(key);
+        const oldValue = this[native$1].get(key);
+        const reactiveValue = reactive(value);
+        this[native$1].set(key, reactiveValue);
+        if (!hadKey || oldValue !== reactiveValue) {
+            notifyPropertyChange(this.content, key, oldValue, reactiveValue, hadKey);
+            // Also notify size change for Map (WeakMap doesn't track size)
+            const evolution = { type: hadKey ? 'set' : 'add', prop: key };
+            touched1(this, evolution, 'size');
+        }
+        return this;
+    }
+}
+
+const native = Symbol('native');
+/**
+ * Reactive wrapper around JavaScript's WeakSet class
+ * Only tracks individual value operations, no size tracking (WeakSet limitation)
+ */
+class ReactiveWeakSet {
+    constructor(original) {
+        Object.defineProperties(this, {
+            [native]: { value: original },
+            [prototypeForwarding]: { value: original },
+            content: { value: Symbol('content') },
+            [Symbol.toStringTag]: { value: 'ReactiveWeakSet' },
+        });
+    }
+    add(value) {
+        const had = this[native].has(value);
+        this[native].add(value);
+        if (!had) {
+            // touch the specific value and the collection view
+            touched1(this.content, { type: 'add', prop: value }, value);
+            // no size/allProps for WeakSet
+        }
+        return this;
+    }
+    delete(value) {
+        const had = this[native].has(value);
+        const res = this[native].delete(value);
+        if (had)
+            touched1(this.content, { type: 'del', prop: value }, value);
+        return res;
+    }
+    has(value) {
+        dependant(this.content, value);
+        return this[native].has(value);
+    }
+}
+/**
+ * Reactive wrapper around JavaScript's Set class
+ * Tracks size changes, individual value operations, and collection-wide operations
+ */
+class ReactiveSet {
+    constructor(original) {
+        Object.defineProperties(this, {
+            [native]: { value: original },
+            [prototypeForwarding]: { value: original },
+            content: { value: Symbol('content') },
+            [Symbol.toStringTag]: { value: 'ReactiveSet' },
+        });
+    }
+    get size() {
+        // size depends on the wrapper instance, like Map counterpart
+        dependant(this, 'size');
+        return this[native].size;
+    }
+    add(value) {
+        const had = this[native].has(value);
+        const reactiveValue = reactive(value);
+        this[native].add(reactiveValue);
+        if (!had) {
+            const evolution = { type: 'add', prop: reactiveValue };
+            // touch for value-specific and aggregate dependencies
+            touched1(this.content, evolution, reactiveValue);
+            touched1(this, evolution, 'size');
+        }
+        return this;
+    }
+    clear() {
+        const hadEntries = this[native].size > 0;
+        this[native].clear();
+        if (hadEntries) {
+            const evolution = { type: 'bunch', method: 'clear' };
+            touched1(this, evolution, 'size');
+            touched(this.content, evolution);
+        }
+    }
+    delete(value) {
+        const had = this[native].has(value);
+        const res = this[native].delete(value);
+        if (had) {
+            const evolution = { type: 'del', prop: value };
+            touched1(this.content, evolution, value);
+            touched1(this, evolution, 'size');
+        }
+        return res;
+    }
+    has(value) {
+        dependant(this.content, value);
+        return this[native].has(value);
+    }
+    entries() {
+        dependant(this.content);
+        return makeReactiveEntriesIterator(this[native].entries());
+    }
+    forEach(callbackfn, thisArg) {
+        dependant(this.content);
+        this[native].forEach(callbackfn, thisArg);
+    }
+    keys() {
+        dependant(this.content);
+        return makeReactiveIterator(this[native].keys());
+    }
+    values() {
+        dependant(this.content);
+        return makeReactiveIterator(this[native].values());
+    }
+    [Symbol.iterator]() {
+        dependant(this.content);
+        const nativeIterator = this[native][Symbol.iterator]();
+        return {
+            next() {
+                const result = nativeIterator.next();
+                if (result.done) {
+                    return result;
+                }
+                return { value: reactive(result.value), done: false };
+            },
+        };
+    }
+}
+
+// Register native collection types to use specialized reactive wrappers
+registerNativeReactivity(WeakMap, ReactiveWeakMap);
+registerNativeReactivity(Map, ReactiveMap);
+registerNativeReactivity(WeakSet, ReactiveWeakSet);
+registerNativeReactivity(Set, ReactiveSet);
+registerNativeReactivity(Array, ReactiveArray);
+/**
+ * Object containing internal reactive system state for debugging and profiling
+ */
+const profileInfo = {
+    objectToProxy,
+    proxyToObject,
+    effectToReactiveObjects,
+    watchers,
+    objectParents,
+    objectsWithDeepWatchers,
+    deepWatchers,
+    effectToDeepWatchedObjects,
+    nonReactiveObjects,
+};
+
+exports.IterableWeakMap = IterableWeakMap;
+exports.IterableWeakSet = IterableWeakSet;
+exports.ReactiveBase = ReactiveBase;
+exports.ReactiveError = ReactiveError;
+exports.ReadOnlyError = ReadOnlyError;
+exports.Register = Register;
+exports.addBatchCleanup = addBatchCleanup;
+exports.atomic = atomic;
+exports.biDi = biDi;
+exports.buildReactivityGraph = buildReactivityGraph;
+exports.cleanedBy = cleanedBy;
+exports.cleanup = cleanup;
+exports.deepWatch = deepWatch;
+exports.defer = defer;
+exports.derived = derived;
+exports.effect = effect;
+exports.enableDevTools = enableDevTools;
+exports.getActiveEffect = getActiveEffect;
+exports.getState = getState;
+exports.immutables = immutables;
+exports.isDevtoolsEnabled = isDevtoolsEnabled;
+exports.isNonReactive = isNonReactive;
+exports.isReactive = isReactive;
+exports.isZoneEnabled = isZoneEnabled;
+exports.mapped = mapped;
+exports.memoize = memoize;
+exports.mixin = mixin;
+exports.options = options;
+exports.organize = organize;
+exports.organized = organized;
+exports.profileInfo = profileInfo;
+exports.project = project;
+exports.reactive = reactive;
+exports.reduced = reduced;
+exports.register = register;
+exports.registerEffectForDebug = registerEffectForDebug;
+exports.registerNativeReactivity = registerNativeReactivity;
+exports.registerObjectForDebug = registerObjectForDebug;
+exports.root = root;
+exports.setEffectName = setEffectName;
+exports.setObjectName = setObjectName;
+exports.setZoneEnabled = setZoneEnabled;
+exports.touched = touched;
+exports.touched1 = touched1;
+exports.trackEffect = trackEffect;
+exports.unreactive = unreactive;
+exports.untracked = untracked;
+exports.unwrap = unwrap;
+exports.watch = watch;
+//# sourceMappingURL=index-HNVqPzjz.js.map