mutts 1.0.2 → 1.0.4

package/dist/chunks/index-79Kk8D6e.esm.js

@@ -0,0 +1,4857 @@
+import { i as isConstructor, R as ReflectGet, d as decorator, b as ReflectSet, c as isOwnAccessor, r as renamed } from './decorator-DqiszP7i.esm.js';
+import { Indexable, setAt, getAt, ArrayReadForward, forwardArray } from '../indexable.esm.js';
+import { a as __setFunctionName, b as __esDecorate, c as __runInitializers, d as __classPrivateFieldSet, _ as __classPrivateFieldGet } from './_tslib-Mzh1rNsX.esm.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 (!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 = 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) {
+            const firstReturn = {};
+            // Execute immediately (before batch returns)
+            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);
+                }
+            }
+            return firstReturn.value;
+        }
+        // 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 {
+                // Outer loop: continue while there are effects OR cleanups pending.
+                // This ensures effects triggered by cleanups are not lost.
+                while (batchQueue.all.size > 0 || batchCleanups.size > 0) {
+                    // Inner loop: execute all pending effects
+                    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
+                    }
+                    // Process cleanups. If they trigger new effects, the outer loop will catch them.
+                    if (batchCleanups.size > 0) {
+                        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({
+    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 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 &&
+            (isOwnAccessor(receiver, prop) || 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;
+                let next = reactiveObject(Object.getPrototypeOf(current));
+                if (next === current) {
+                    next = reactiveObject(Object.getPrototypeOf(unwrap(current)));
+                }
+                current = next;
+            }
+        }
+        const value = 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 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 (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({
+    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({
+    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(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(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({
+    getter(original, propertyKey) {
+        const memoized = memoizeFunction(markWithRoot(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(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(ArrayReadForward, {
+        get(index) {
+            return this[getAt](index);
+        },
+        set(index, value) {
+            this[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(), 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;
+            });
+            __classPrivateFieldSet(this, _RegisterClass_ascend, ascendGet, "f");
+            if (typeof keyFn !== 'function')
+                throw new Error('Register requires a key function');
+            __classPrivateFieldSet(this, _RegisterClass_keyFn, keyFn, "f");
+            __classPrivateFieldSet(this, _RegisterClass_keys, reactive([]), "f");
+            __classPrivateFieldSet(this, _RegisterClass_values, reactive(new Map()), "f");
+            Object.defineProperties(this, {
+                [prototypeForwarding]: { value: __classPrivateFieldGet(this, _RegisterClass_keys, "f") },
+            });
+            if (initial)
+                this.push(...initial);
+        }
+        ensureKey(value) {
+            let info = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (info)
+                return info.key;
+            info = { key: undefined };
+            __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").set(value, info);
+            __classPrivateFieldGet(this, _RegisterClass_ascend, "f").call(this, () => {
+                const stop = effect(({ reaction }) => {
+                    const nextKey = __classPrivateFieldGet(this, _RegisterClass_keyFn, "f").call(this, value);
+                    this.assertValidKey(nextKey);
+                    const previousKey = info.key;
+                    if (reaction && previousKey !== undefined && !Object.is(nextKey, previousKey))
+                        __classPrivateFieldGet(this, _RegisterClass_instances, "m", _RegisterClass_rekeyValue).call(this, value, previousKey, nextKey);
+                    info.key = nextKey;
+                });
+                info.stop = stop;
+                __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 = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+            if (existing !== undefined && existing !== value)
+                this.cleanupValue(existing);
+            __classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+        }
+        cleanupValue(value) {
+            const info = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (!info)
+                return;
+            const stop = info.stop;
+            if (stop) {
+                info.stop = undefined;
+                __classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").delete(stop);
+                stop();
+            }
+            __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").delete(value);
+        }
+        disposeKeyEffects() {
+            for (const value of Array.from(__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").keys()))
+                this.cleanupValue(value);
+            __classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").clear();
+        }
+        incrementUsage(key) {
+            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key) ?? 0;
+            __classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count + 1);
+        }
+        decrementUsage(key) {
+            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key);
+            if (!count)
+                return;
+            if (count <= 1) {
+                const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                __classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(key);
+                __classPrivateFieldGet(this, _RegisterClass_values, "f").delete(key);
+                if (value !== undefined)
+                    this.cleanupValue(value);
+            }
+            else {
+                __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 = __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
+            if (oldKey !== undefined && Object.is(oldKey, key)) {
+                this.setKeyValue(key, value);
+                return;
+            }
+            if (oldKey !== undefined)
+                this.decrementUsage(oldKey);
+            __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index] = key;
+            this.incrementUsage(key);
+            this.setKeyValue(key, value);
+        }
+        insertKeyValue(index, key, value) {
+            __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 0, key);
+            this.incrementUsage(key);
+            this.setKeyValue(key, value);
+        }
+        rebuildFrom(values) {
+            this.disposeKeyEffects();
+            __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(0, __classPrivateFieldGet(this, _RegisterClass_keys, "f").length);
+            __classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
+            __classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
+            for (const value of values) {
+                const key = this.ensureKey(value);
+                __classPrivateFieldGet(this, _RegisterClass_keys, "f").push(key);
+                this.incrementUsage(key);
+                __classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+            }
+        }
+        get length() {
+            return __classPrivateFieldGet(this, _RegisterClass_keys, "f").length;
+        }
+        [(_RegisterClass_rekeyValue = function _RegisterClass_rekeyValue(value, oldKey, newKey) {
+            if (Object.is(oldKey, newKey))
+                return;
+            const existingValue = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(newKey);
+            if (existingValue !== undefined && existingValue !== value)
+                throw new Error(`Register key collision for key ${String(newKey)}`);
+            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(oldKey);
+            if (!count)
+                return;
+            const existingCount = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(newKey) ?? 0;
+            this.setKeyValue(newKey, value);
+            for (let i = 0; i < __classPrivateFieldGet(this, _RegisterClass_keys, "f").length; i++)
+                if (Object.is(__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i], oldKey))
+                    __classPrivateFieldGet(this, _RegisterClass_keys, "f")[i] = newKey;
+            __classPrivateFieldGet(this, _RegisterClass_usage, "f").set(newKey, existingCount + count);
+            __classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(oldKey);
+            __classPrivateFieldGet(this, _RegisterClass_values, "f").delete(oldKey);
+            const updatedInfo = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (updatedInfo)
+                updatedInfo.key = newKey;
+        }, getAt)](index) {
+            const key = __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
+            return key === undefined ? undefined : __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+        }
+        [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 = __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(normalizedStart, actualDelete, ...keysToInsert);
+            const removedValues = [];
+            for (const key of removedKeys) {
+                if (key === undefined)
+                    continue;
+                const value = __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() {
+            __classPrivateFieldGet(this, _RegisterClass_keys, "f").length = 0;
+            __classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
+            __classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
+            this.disposeKeyEffects();
+        }
+        get(key) {
+            return __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+        }
+        set(key, value) {
+            if (__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] = __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 1);
+            if (key === undefined)
+                return undefined;
+            const value = __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 __classPrivateFieldGet(this, _RegisterClass_keys, "f").entries()) {
+                if (decisions.has(key)) {
+                    if (!decisions.get(key))
+                        this.removeAt(index);
+                    continue;
+                }
+                const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                const shouldKeep = predicate(value);
+                decisions.set(key, shouldKeep);
+                if (!shouldKeep)
+                    this.removeAt(index);
+            }
+        }
+        hasKey(key) {
+            return __classPrivateFieldGet(this, _RegisterClass_usage, "f").has(key);
+        }
+        indexOfKey(key) {
+            return __classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
+        }
+        mapKeys() {
+            return __classPrivateFieldGet(this, _RegisterClass_values, "f").keys();
+        }
+        update(...values) {
+            for (const value of values) {
+                const key = this.ensureKey(value);
+                if (__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 (__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 < __classPrivateFieldGet(self, _RegisterClass_keys, "f").length; i++) {
+                    const val = __classPrivateFieldGet(self, _RegisterClass_values, "f").get(__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 __classPrivateFieldGet(self, _RegisterClass_keys, "f")) {
+                    const value = __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[getAt](resolved);
+        }
+        reverse() {
+            __classPrivateFieldGet(this, _RegisterClass_keys, "f").reverse();
+            return this;
+        }
+        sort(compareFn) {
+            const fwdCompareFn = compareFn
+                ? (a, b) => compareFn(__classPrivateFieldGet(this, _RegisterClass_values, "f").get(a), __classPrivateFieldGet(this, _RegisterClass_values, "f").get(b))
+                : undefined;
+            __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;
+        }
+    };
+    __setFunctionName(_classThis, "RegisterClass");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        __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 });
+        __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) {
+        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: () => ReflectGet(observedSource, index, observedSource),
+                        set: (value) => 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: () => ReflectGet(observedSource, sourceKey, observedSource),
+                        set: (value) => 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: () => ReflectGet(observedSource, sourceKey, observedSource),
+                        set: (value) => 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,
+};
+
+export { derived as A, unreactive as B, watch as C, mapped as D, reduced as E, memoize as F, immutables as G, isNonReactive as H, IterableWeakMap as I, registerNativeReactivity as J, project as K, isReactive as L, ReactiveBase as M, reactive as N, unwrap as O, organize as P, organized as Q, ReadOnlyError as R, Register as S, register as T, options as U, ReactiveError as V, isZoneEnabled as W, setZoneEnabled as X, IterableWeakSet as a, touched1 as b, buildReactivityGraph as c, registerObjectForDebug as d, enableDevTools as e, setObjectName as f, getState as g, deepWatch as h, isDevtoolsEnabled as i, addBatchCleanup as j, atomic as k, batch as l, mixin as m, biDi as n, defer as o, profileInfo as p, effect as q, registerEffectForDebug as r, setEffectName as s, touched as t, getActiveEffect as u, root as v, trackEffect as w, untracked as x, cleanedBy as y, cleanup as z };
+//# sourceMappingURL=index-79Kk8D6e.esm.js.map