mutts 1.0.8 → 1.0.10

package/dist/chunks/proxy-r7lARftl.esm.js

@@ -0,0 +1,3701 @@
+// Queue for hooks registered before the environment is ready (circular dependency fix)
+const hooks = new Set();
+const asyncHooks = {
+    addHook(hook) {
+        hooks.add(hook);
+        return () => hooks.delete(hook);
+    },
+    /**
+     * [Hack] Sanitize a promise (or value) to prevent context leaks.
+     * Default: Identity function.
+     * Browser: Uses Macrotask wrapping to break microtask chains.
+     */
+    sanitizePromise(p) {
+        return p;
+    },
+};
+/**
+ * Register a hook that will be called whenever an asynchronous operation is initiated.
+ * The hook should return a restorer function which will be called just before the async callback runs.
+ * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
+ */
+const asyncHook = (hook) => asyncHooks.addHook(hook);
+
+/**
+ * Yields tuples containing elements from each input array, stopping at the longest array length
+ * @param args - Arrays to zip together
+ * @returns Generator yielding tuples containing elements from each input array
+ */
+function* zip(...args) {
+    if (!args.length)
+        return [];
+    const maxLength = Math.max(...args.map((arr) => arr.length));
+    for (let i = 0; i < maxLength; i++) {
+        const tuple = args.map((arr) => arr[i]);
+        yield tuple;
+    }
+}
+/**
+ * Checks if two arrays are strictly equal (shallow comparison)
+ * @param a - First value
+ * @param b - Second value
+ * @returns True if arrays are equal or values are strictly equal
+ */
+function arrayEquals(a, b) {
+    if (!Array.isArray(a) || !Array.isArray(b))
+        return false;
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+const nativeConstructors = new Set([
+    Object,
+    Array,
+    Date,
+    Function,
+    Set,
+    Map,
+    WeakMap,
+    WeakSet,
+    Promise,
+    Error,
+    TypeError,
+    ReferenceError,
+    SyntaxError,
+    RangeError,
+    URIError,
+    EvalError,
+    Reflect,
+    Proxy,
+    RegExp,
+    String,
+    Number,
+    Boolean,
+]);
+/**
+ * Checks if a function is a constructor (class or constructor function)
+ * @param fn - The function to check
+ * @returns True if the function is a constructor
+ */
+function isConstructor(fn) {
+    return (fn &&
+        typeof fn === 'function' &&
+        (nativeConstructors.has(fn) || fn.toString?.().startsWith('class ')));
+}
+/**
+ * Checks if a value is an object
+ * @param value - The value to check
+ * @returns True if the value is an object
+ */
+function isObject(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !(value instanceof Date ||
+            value instanceof RegExp ||
+            value instanceof Error ||
+            value instanceof Set ||
+            value instanceof Map ||
+            value instanceof WeakSet ||
+            value instanceof WeakMap ||
+            value instanceof Promise ||
+            value instanceof Function));
+}
+const hasNode = typeof Node !== 'undefined';
+const FoolProof = {
+    get(obj, prop, receiver) {
+        if (hasNode && obj instanceof Node)
+            return obj[prop];
+        return Reflect.get(obj, prop, receiver);
+    },
+    set(obj, prop, value, receiver) {
+        if (hasNode && obj instanceof Node) {
+            obj[prop] = value;
+            return true;
+        }
+        if (!(obj instanceof Object) && !Reflect.has(obj, prop)) {
+            Object.defineProperty(obj, prop, {
+                value,
+                configurable: true,
+                writable: true,
+                enumerable: true,
+            });
+            return true;
+        }
+        return Reflect.set(obj, prop, value, receiver);
+    },
+};
+function isOwnAccessor(obj, prop) {
+    const opd = Object.getOwnPropertyDescriptor(obj, prop);
+    return !!(opd?.get || opd?.set);
+}
+/**
+ * Deeply compares two values.
+ * For objects, compares prototypes with === and then own properties recursively.
+ * Uses a cache to handle circular references.
+ * @param a - First value
+ * @param b - Second value
+ * @param cache - Map for circular reference protection (internal use)
+ * @returns True if values are deeply equal
+ */
+function deepCompare(a, b, cache = new Map()) {
+    if (a === b)
+        return true;
+    if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
+        return a === b;
+    }
+    // Prototype check
+    const protoA = Object.getPrototypeOf(a);
+    const protoB = Object.getPrototypeOf(b);
+    if (protoA !== protoB) {
+        console.warn(`[deepCompare] prototype mismatch:`, {
+            nameA: a?.constructor?.name,
+            nameB: b?.constructor?.name,
+        });
+        return false;
+    }
+    // Circular reference protection
+    let compared = cache.get(a);
+    if (compared?.has(b))
+        return true;
+    if (!compared) {
+        compared = new Set();
+        cache.set(a, compared);
+    }
+    compared.add(b);
+    // Handle specific object types
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b)) {
+            console.warn(`[deepCompare] B is not an array`);
+            return false;
+        }
+        if (a.length !== b.length) {
+            console.warn(`[deepCompare] array length mismatch:`, { lenA: a.length, lenB: b.length });
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (!deepCompare(a[i], b[i], cache)) {
+                console.warn(`[deepCompare] array element mismatch at index ${i}`);
+                return false;
+            }
+        }
+        return true;
+    }
+    if (a instanceof Date) {
+        const match = b instanceof Date && a.getTime() === b.getTime();
+        if (!match)
+            console.warn(`[deepCompare] Date mismatch`);
+        return match;
+    }
+    if (a instanceof RegExp) {
+        const match = b instanceof RegExp && a.toString() === b.toString();
+        if (!match)
+            console.warn(`[deepCompare] RegExp mismatch`);
+        return match;
+    }
+    if (a instanceof Set) {
+        if (!(b instanceof Set) || a.size !== b.size) {
+            console.warn(`[deepCompare] Set size mismatch`);
+            return false;
+        }
+        for (const val of a) {
+            let found = false;
+            for (const bVal of b) {
+                if (deepCompare(val, bVal, cache)) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                console.warn(`[deepCompare] missing Set element`);
+                return false;
+            }
+        }
+        return true;
+    }
+    if (a instanceof Map) {
+        if (!(b instanceof Map) || a.size !== b.size) {
+            console.warn(`[deepCompare] Map size mismatch`);
+            return false;
+        }
+        for (const [key, val] of a) {
+            if (!b.has(key)) {
+                let foundMatch = false;
+                for (const [bKey, bVal] of b) {
+                    if (deepCompare(key, bKey, cache) && deepCompare(val, bVal, cache)) {
+                        foundMatch = true;
+                        break;
+                    }
+                }
+                if (!foundMatch) {
+                    console.warn(`[deepCompare] missing Map key`);
+                    return false;
+                }
+            }
+            else {
+                if (!deepCompare(val, b.get(key), cache)) {
+                    console.warn(`[deepCompare] Map value mismatch for key`);
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    // Compare own properties
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) {
+        console.warn(`[deepCompare] keys length mismatch:`, {
+            lenA: keysA.length,
+            lenB: keysB.length,
+            keysA,
+            keysB,
+            a,
+            b,
+        });
+        return false;
+    }
+    for (const key of keysA) {
+        if (!Object.hasOwn(b, key)) {
+            console.warn(`[deepCompare] missing key ${String(key)} in B`);
+            return false;
+        }
+        if (!deepCompare(a[key], b[key], cache)) {
+            console.warn(`[deepCompare] value mismatch for key ${String(key)}:`, {
+                valA: a[key],
+                valB: b[key],
+            });
+            return false;
+        }
+    }
+    return true;
+}
+// Internal use: Used for reactive sets/maps to differentiate between different reactive containers: `x.get('aKey')` vs. `x['aKey']`
+const contentRefs = new WeakMap();
+function contentRef(container) {
+    if (!contentRefs.has(container))
+        contentRefs.set(container, Object.seal(Object.create(null, {
+            contentOf: { value: container, writable: false, configurable: false },
+        })));
+    return contentRefs.get(container);
+}
+/**
+ * Tags an object with a name
+ * @param name - The name to tag the object with
+ * @param obj - The object to tag
+ * @returns The object with the tag
+ */
+function tag(name, obj) {
+    Object.defineProperties(obj, {
+        [Symbol.toStringTag]: {
+            value: name,
+            writable: false,
+            configurable: true,
+        },
+        toString: {
+            value: () => name,
+            writable: false,
+            configurable: true,
+        },
+    });
+    return obj;
+}
+/**
+ * Renames a function with a new name
+ * @param name - The new name for the function
+ * @param fn - The function to rename
+ * @returns The function with the new name
+ */
+function named(name, fn) {
+    Object.defineProperty(fn, 'name', {
+        value: fn.name ? `${fn.name}::${name}` : name,
+        writable: false,
+        configurable: true,
+    });
+    return fn;
+}
+
+// biome-ignore-all lint/suspicious/noConfusingVoidType: We *love* voids
+// Standardized decorator system that works with both Legacy and Modern decorators
+/**
+ * Error thrown when decorator operations fail
+ */
+class DecoratorError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DecoratorException';
+    }
+}
+/**
+ * Creates a decorator that works with Legacy decorator proposals
+ * @param description - The decorator description object
+ * @returns A decorator function compatible with Legacy decorators
+ */
+function legacyDecorator(description) {
+    return function (target, propertyKey, descriptor, ...args) {
+        if (propertyKey === undefined) {
+            if (isConstructor(target)) {
+                if (!('class' in description))
+                    throw new Error('Decorator cannot be applied to a class');
+                return description.class(target);
+            }
+        }
+        else if (typeof target === 'object' && ['string', 'symbol'].includes(typeof propertyKey)) {
+            if (!descriptor)
+                throw new Error('Decorator cannot be applied to a field');
+            else if (typeof descriptor === 'object' && 'configurable' in descriptor) {
+                if ('get' in descriptor || 'set' in descriptor) {
+                    if (!('getter' in description || 'setter' in description))
+                        throw new Error('Decorator cannot be applied to a getter or setter');
+                    if ('getter' in description) {
+                        const newGetter = description.getter(descriptor.get, target, propertyKey);
+                        if (newGetter)
+                            descriptor.get = newGetter;
+                    }
+                    if ('setter' in description) {
+                        const newSetter = description.setter(descriptor.set, target, propertyKey);
+                        if (newSetter)
+                            descriptor.set = newSetter;
+                    }
+                    return descriptor;
+                }
+                else if (typeof descriptor.value === 'function') {
+                    if (!('method' in description))
+                        throw new Error('Decorator cannot be applied to a method');
+                    const newMethod = description.method(descriptor.value, target, propertyKey);
+                    if (newMethod)
+                        descriptor.value = newMethod;
+                    return descriptor;
+                }
+            }
+        }
+        if (!('default' in description))
+            throw new Error('Decorator do not have a default implementation');
+        return description.default.call(this, target, propertyKey, descriptor, ...args);
+    };
+}
+/**
+ * Creates a decorator that works with Modern decorator proposals
+ * @param description - The decorator description object
+ * @returns A decorator function compatible with Modern decorators
+ */
+function modernDecorator(description) {
+    /*return function (target: any, context?: DecoratorContext, ...args: any[]) {*/
+    return function (target, context, ...args) {
+        if (!context?.kind || typeof context.kind !== 'string') {
+            if (!('default' in description))
+                throw new Error('Decorator do not have a default implementation');
+            return description.default.call(this, target, context, ...args);
+        }
+        switch (context.kind) {
+            case 'class':
+                if (!('class' in description))
+                    throw new Error('Decorator cannot be applied to a class');
+                return description.class(target);
+            case 'field':
+                throw new Error('Decorator cannot be applied to a field');
+            case 'getter':
+                if (!('getter' in description))
+                    throw new Error('Decorator cannot be applied to a getter');
+                return description.getter(target, target, context.name);
+            case 'setter':
+                if (!('setter' in description))
+                    throw new Error('Decorator cannot be applied to a setter');
+                return description.setter(target, target, context.name);
+            case 'method':
+                if (!('method' in description))
+                    throw new Error('Decorator cannot be applied to a method');
+                return description.method(target, target, context.name);
+            case 'accessor': {
+                if (!('getter' in description || 'setter' in description))
+                    throw new Error('Decorator cannot be applied to a getter or setter');
+                const rv = {};
+                if ('getter' in description) {
+                    const newGetter = description.getter(target.get, target, context.name);
+                    if (newGetter)
+                        rv.get = newGetter;
+                }
+                if ('setter' in description) {
+                    const newSetter = description.setter(target.set, target, context.name);
+                    if (newSetter)
+                        rv.set = newSetter;
+                }
+                return rv;
+            }
+            //return description.accessor?.(target, context.name, target)
+        }
+    };
+}
+/**
+ * Detects if the decorator is being called in modern (Modern) or legacy (Legacy) mode
+ * based on the arguments passed to the decorator function
+ */
+function detectDecoratorMode(_target, contextOrKey, _descriptor) {
+    // Modern decorators have a context object as the second parameter
+    // Legacy decorators have a string/symbol key as the second parameter
+    if (typeof contextOrKey === 'object' &&
+        contextOrKey !== null &&
+        typeof contextOrKey.kind === 'string') {
+        return 'modern';
+    }
+    return 'legacy';
+}
+/**
+ * Main decorator factory that automatically detects and works with both Legacy and Modern decorator proposals
+ * @param description - The decorator description object
+ * @returns A decorator that works in both Legacy and Modern environments
+ */
+const decorator = (description) => {
+    const modern = modernDecorator(description);
+    const legacy = legacyDecorator(description);
+    return ((target, contextOrKey, ...args) => {
+        const mode = detectDecoratorMode(target, contextOrKey, args[0]);
+        return mode === 'modern'
+            ? modern(target, contextOrKey, ...args)
+            : legacy(target, contextOrKey, ...args);
+    });
+};
+
+/**
+ * Creates a flavored (extensible) version of a function with chainable property modifiers.
+ *
+ * Each property defined in `flavors` returns a new flavored function that transforms
+ * how the original function is called. This enables a fluent API where properties
+ * create specialized variants of the base function.
+ *
+ * @param fn - The base function to flavor
+ * @param flavors - Object defining the flavor properties (getters or methods)
+ * @returns A proxy of the function with the flavor properties attached
+ *
+ * @example
+ * ```typescript
+ * function greet(name: string, options?: { loud?: boolean }) {
+ *   const greeting = `Hello, ${name}!`
+ *   return options?.loud ? greeting.toUpperCase() : greeting
+ * }
+ *
+ * const flavoredGreet = flavored(greet, {
+ *   get loud() {
+ *     return createFlavor(this, (name, opts) => [name, { ...opts, loud: true }])
+ *   }
+ * })
+ *
+ * flavoredGreet('World') // "Hello, World!"
+ * flavoredGreet.loud('World') // "HELLO, WORLD!"
+ * ```
+ */
+/**
+ * Creates a flavored (extensible) version of a function with chainable property modifiers.
+ */
+function flavored(fn, flavors) {
+    fn.flavors = flavors;
+    return new Proxy(fn, {
+        get(target, prop, receiver) {
+            if (prop in flavors) {
+                return Reflect.get(flavors, prop, receiver);
+            }
+            return target[prop];
+        },
+    });
+}
+/**
+ * Creates a new flavored function that transforms arguments before calling the base.
+ *
+ * @param fn - The base flavored function
+ * @param transform - Function that receives the original arguments and returns transformed arguments
+ * @returns A new flavored function with the transformation applied
+ *
+ * @example
+ * ```typescript
+ * const loudGreet = createFlavor(greet, (name, opts) => [name, { ...opts, loud: true }])
+ * ```
+ */
+function createFlavor(fn, transform, name) {
+    const fct = function flavorWrapper(...args) {
+        return fn.apply(this, transform(...args));
+    };
+    if (name)
+        named(name, fct);
+    return flavored(fct, fn.flavors || {});
+}
+/**
+ * Creates a new flavored function that merges options objects at a specific index.
+ * By default, uses the function's arity (length) as the index for options.
+ *
+ * @param fn - The base flavored function
+ * @param defaultOptions - Options to merge
+ * @param optionsIndex - Optional explicit index for options (defaults to fn.length)
+ * @param name - Optional name for the wrapper
+ * @returns A new flavored function
+ */
+function flavorOptions(fn, defaultOptions, opts = {}) {
+    // If the function is already flavorOptions-wrapped, it might have an index stored
+    const targetIndex = opts.optionsIndex ?? fn.optionsIndex ?? fn.length;
+    const fct = function flavorOptionsWrapper(...args) {
+        const newArgs = [...args];
+        // Ensure we have enough arguments to reach the options index
+        while (newArgs.length <= targetIndex) {
+            newArgs.push(undefined);
+        }
+        const currentOptions = newArgs[targetIndex];
+        const isObject = currentOptions !== null &&
+            typeof currentOptions === 'object' &&
+            !Array.isArray(currentOptions);
+        newArgs[targetIndex] = isObject
+            ? { ...defaultOptions, ...currentOptions }
+            : defaultOptions;
+        return fn.apply(this, newArgs);
+    };
+    if (opts.name)
+        named(`${fn.name}.${opts.name}`, fct);
+    // Preserve arity and options track
+    Object.defineProperty(fct, 'length', { value: fn.length });
+    fct.optionsIndex = targetIndex;
+    return flavored(fct, fn.flavors || {});
+}
+
+/// <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 = FoolProof.get(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;
+        },
+    });
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+}
+function __runInitializers(thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+}
+function __setFunctionName(f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+}
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const debugHooks = {
+    isDevtoolsEnabled: () => false,
+    registerEffect: () => { },
+    getTriggerChain: () => [],
+    captureStack: () => [],
+    captureLineage: () => new Error().stack,
+    formatStack: (stack) => [stack],
+    recordTriggerLink: () => { },
+};
+function setDebugHooks(hooks) {
+    Object.assign(debugHooks, hooks);
+}
+
+var _ZoneAggregator_zones;
+function isu(z) {
+    return z;
+}
+class AZone {
+    enter(value) {
+        const prev = this.active;
+        this.active = value;
+        return prev;
+    }
+    leave(entered) {
+        this.active = entered;
+    }
+    with(value, fn) {
+        const entered = this.enter(value);
+        let res;
+        try {
+            res = fn();
+        }
+        finally {
+            this.leave(entered);
+        }
+        // [HACK]: Sanitization
+        // See BROWSER_ASYNC_POLYFILL.md
+        return asyncHooks.sanitizePromise(res);
+    }
+    root(fn) {
+        const prev = this.enter();
+        try {
+            return fn();
+        }
+        finally {
+            this.leave(prev);
+        }
+    }
+    get zoned() {
+        const active = this.active;
+        return named(`${this}@${active}`, (fn) => this.with(active, fn));
+    }
+}
+class Zone extends AZone {
+}
+class ZoneHistory extends AZone {
+    has(value) {
+        return this.history.has(value);
+    }
+    some(predicate) {
+        for (const value of this.history)
+            if (predicate(value))
+                return true;
+        return false;
+    }
+    constructor(controlled = new Zone()) {
+        super();
+        this.controlled = controlled;
+        this.history = new Set();
+        const self = this;
+        this.present = Object.create(controlled, Object.getOwnPropertyDescriptors({
+            get active() {
+                return controlled.active;
+            },
+            set active(value) {
+                controlled.active = value;
+            },
+            enter(value) {
+                if (value && self.history.has(value))
+                    throw new Error('ZoneHistory: re-entering historical zone');
+                if (value !== undefined)
+                    self.history.add(value);
+                return { added: value, entered: isu(controlled).enter(value) };
+            },
+            leave(entered) {
+                if (entered.added !== undefined)
+                    self.history.delete(entered.added);
+                return isu(controlled).leave(entered.entered);
+            },
+        }));
+    }
+    get active() {
+        return { present: this.controlled.active, history: new Set(this.history) };
+    }
+    set active(value) {
+        this.history = value?.history ? new Set(value.history) : new Set();
+        this.controlled.active = value?.present;
+    }
+}
+class ZoneAggregator extends AZone {
+    constructor(...zones) {
+        super();
+        _ZoneAggregator_zones.set(this, new Set());
+        for (const z of zones)
+            __classPrivateFieldGet(this, _ZoneAggregator_zones, "f").add(z);
+    }
+    get active() {
+        const rv = new Map();
+        for (const z of __classPrivateFieldGet(this, _ZoneAggregator_zones, "f"))
+            if (z.active !== undefined)
+                rv.set(z, z.active);
+        return rv;
+    }
+    set active(value) {
+        for (const z of __classPrivateFieldGet(this, _ZoneAggregator_zones, "f"))
+            z.active = value?.get(z);
+    }
+    enter(value) {
+        const entered = new Map();
+        for (const z of __classPrivateFieldGet(this, _ZoneAggregator_zones, "f")) {
+            const v = value?.get(z);
+            entered.set(z, isu(z).enter(v));
+        }
+        return entered;
+    }
+    leave(entered) {
+        for (const z of __classPrivateFieldGet(this, _ZoneAggregator_zones, "f"))
+            isu(z).leave(entered.get(z));
+    }
+    add(z) {
+        __classPrivateFieldGet(this, _ZoneAggregator_zones, "f").add(z);
+    }
+    delete(z) {
+        __classPrivateFieldGet(this, _ZoneAggregator_zones, "f").delete(z);
+    }
+    clear() {
+        __classPrivateFieldGet(this, _ZoneAggregator_zones, "f").clear();
+    }
+}
+_ZoneAggregator_zones = new WeakMap();
+const asyncZone = tag('async', new ZoneAggregator());
+asyncHooks.addHook(() => {
+    const zone = asyncZone.active;
+    return () => {
+        const prev = asyncZone.active;
+        asyncZone.active = zone;
+        return () => {
+            asyncZone.active = prev;
+        };
+    };
+});
+
+// Symbol for storing root function on the function itself
+const rootFunctionSymbol = Symbol('root-function');
+// Track which effects are watching which reactive objects for cleanup
+let effectToReactiveObjects = new WeakMap();
+// Track effects per reactive object and property
+let watchers = new WeakMap();
+// Track effect metadata and relationships
+let effectNodes = new WeakMap();
+function getEffectNode(effect) {
+    let node = effectNodes.get(effect);
+    if (!node) {
+        node = {};
+        effectNodes.set(effect, node);
+    }
+    return node;
+}
+// Track reverse mapping to ensure unicity: One Root -> One Function
+let reverseRoots = new WeakMap();
+function resetRegistry() {
+    effectToReactiveObjects = new WeakMap();
+    watchers = new WeakMap();
+    effectNodes = new WeakMap();
+    reverseRoots = new WeakMap();
+}
+/**
+ * Marks a function with its root function for effect tracking
+ * Enforces strict unicity: A root function can only identify ONE function.
+ * @param fn - The function to mark
+ * @param root - The root function
+ * @returns The marked function
+ */
+function markWithRoot(fn, root) {
+    // Check for collision
+    const existingRef = reverseRoots.get(root);
+    const existing = existingRef?.deref();
+    if (existing && existing !== fn) {
+        const rootName = root.name || 'anonymous';
+        const existingName = existing.name || 'anonymous';
+        const fnName = fn.name || 'anonymous';
+        throw new Error(`[reactive] Abusive Shared Root detected: Root '${rootName}' is already identifying function '${existingName}'. ` +
+            `Cannot reuse it for '${fnName}'. Shared roots cause lost updates and broken identity logic.`);
+    }
+    // Always update the map so subsequent checks find this one
+    // (Last writer wins for the check)
+    reverseRoots.set(root, new WeakRef(fn));
+    // Store root mapping as symbol property on the function
+    fn[rootFunctionSymbol] = getRoot(root);
+    return fn;
+}
+/**
+ * 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) {
+    while (fn) {
+        const r = fn[rootFunctionSymbol];
+        if (!r)
+            break;
+        fn = r;
+    }
+    return fn;
+}
+
+const effectMarker = {
+    enter: 'effect:enter',
+    leave: 'effect:leave',
+};
+function formatTrigger({ obj, evolution, dependency, touch }) {
+    const detail = evolution.type === 'bunch' ? evolution.method : String(evolution.prop);
+    const parts = [`${evolution.type} ${detail} on`, obj];
+    if (dependency) {
+        parts.push('\n  Dependency created at:');
+        parts.push(...debugHooks.formatStack(dependency));
+    }
+    if (touch) {
+        parts.push('\n  Touched from:');
+        parts.push(...debugHooks.formatStack(touch));
+    }
+    return parts;
+}
+/**
+ * Console-friendly description of a `CleanupReason`.
+ * Returns an array of arguments to spread into `console.log` / `console.warn`,
+ * mixing strings and raw object references so the console can render them as inspectable values.
+ *
+ * @example
+ * ```typescript
+ * effect(({ reaction }) => {
+ *   if (reaction !== true) console.log(...formatCleanupReason(reaction))
+ * })
+ * ```
+ */
+function formatCleanupReason(reason, depth = 0) {
+    const indent = depth ? '  '.repeat(depth) : '';
+    switch (reason.type) {
+        case 'propChange': {
+            const parts = [`${indent}propChange:`];
+            for (let i = 0; i < reason.triggers.length; i++) {
+                if (i > 0)
+                    parts.push(',');
+                parts.push(...formatTrigger(reason.triggers[i]));
+            }
+            return parts;
+        }
+        case 'stopped':
+            return [`${indent}stopped`];
+        case 'gc':
+            return [`${indent}gc`];
+        case 'error':
+            return [`${indent}error:`, reason.error];
+        case 'lineage':
+            return [`${indent}lineage ←\n`, ...formatCleanupReason(reason.parent, depth + 1)];
+        case 'invalidate':
+            return [`${indent}invalidate ←\n`, ...formatCleanupReason(reason.cause, depth + 1)];
+        case 'multiple': {
+            const parts = [];
+            for (let i = 0; i < reason.reasons.length; i++) {
+                if (i > 0)
+                    parts.push('\n');
+                parts.push(...formatCleanupReason(reason.reasons[i], depth));
+            }
+            return parts;
+        }
+    }
+}
+/**
+ * Symbol representing all properties in reactive tracking
+ */
+const allProps = Symbol('all-props');
+/**
+ * Symbol for structure-only tracking (triggered on key add/delete, not value changes).
+ * Used by ownKeys proxy trap — Object.keys(), for..in, Map.keys() depend on this.
+ */
+const keysOf = Symbol('keys-of');
+/**
+ * Symbol to check if an effect is stopped
+ */
+const stopped = Symbol('stopped');
+/**
+ * Symbol to access effect cleanup function
+ */
+const cleanup = Symbol('cleanup');
+/**
+ * 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["BrokenEffects"] = "Broken effects";
+})(ReactiveErrorCode || (ReactiveErrorCode = {}));
+/**
+ * Error class for reactive system errors
+ */
+class ReactiveError extends Error {
+    constructor(message, debugInfo) {
+        super(message);
+        this.debugInfo = debugInfo;
+        this.name = 'ReactiveError';
+    }
+    get code() {
+        return this.debugInfo?.code;
+    }
+    get cause() {
+        return this.debugInfo?.cause;
+    }
+}
+// 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) => { },
+    /**
+     * Debug purpose: maximum effect chain (like call stack max depth)
+     * Used to prevent infinite loops
+     * @default 100
+     */
+    maxEffectChain: 100,
+    /**
+     * Maximum number of times an effect can be triggered by the same cause in a single batch
+     * Used to detect aggressive re-computation or infinite loops
+     * @default 10
+     */
+    maxTriggerPerBatch: 10,
+    /**
+     * Debug purpose: maximum effect reaction (like call stack max depth)
+     * Used to prevent infinite loops
+     * @default 'throw'
+     */
+    maxEffectReaction: 'throw',
+    /**
+     * Callback called when a memoization discrepancy is detected (debug only)
+     * When defined, memoized functions will run a second time (untracked) to verify consistency.
+     * If the untracked run returns a different value than the cached one, this callback is triggered.
+     *
+     * This is the primary tool for detecting missing reactive dependencies in computed values.
+     *
+     * @param cached - The value currently in the memoization cache
+     * @param fresh - The value obtained by re-running the function untracked
+     * @param fn - The memoized function itself
+     * @param args - Arguments passed to the function
+     *
+     * @example
+     * ```typescript
+     * reactiveOptions.onMemoizationDiscrepancy = (cached, fresh, fn, args) => {
+     *   throw new Error(`Memoization discrepancy in ${fn.name}!`);
+     * };
+     * ```
+     */
+    onMemoizationDiscrepancy: undefined,
+    /**
+     * How to handle cycles detected in effect batches.
+     *
+     * - `'production'` (Default): High-performance mode. Disables dependency graph maintenance and
+     *   Topological Sorting in favor of a simple FIFO queue. Use this for trustworthy, acyclic UI code.
+     *   Cycle detection is heuristic (uses maxEffectChain execution counts).
+     *
+     * - `'development'`: Maintains direct dependency graph for early cycle detection during edge creation.
+     *   Catches cycles before effects execute via DFS check when adding edges. Throws immediately with
+     *   basic path information. Good balance of debugging help with moderate overhead.
+     *
+     * - `'debug'`: Full diagnostic mode with transitive closures and topological sorting.
+     *   Provides detailed cycle path reporting. Highest overhead but most informative for bug hunting.
+     *
+     * @default 'production'
+     */
+    cycleHandling: 'development',
+    /**
+     * Internal flag used by memoization discrepancy detector to avoid counting calls in tests
+     * @warning Do not modify this flag manually, this flag is given by the engine
+     */
+    isVerificationRun: false,
+    /**
+     * 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),
+    /**
+     * Introspection and debug aids. Set to `null` to disable all debug overhead in production.
+     *
+     * - `gatherReasons`: collect `PropTrigger[]` for `CleanupReason` on effect re-runs (default `true`)
+     *   - `lineages`: what lineages to capture in PropTrigger (default `'touch'`)
+     * - `logErrors`: log errors with detailed context (default `true`)
+     * - `enableHistory`: keep a history of mutations (default `true`)
+     * - `historySize`: number of mutations to keep in history (default `50`)
+     *
+     * `enableDevTools()` sets `logErrors` to `true` automatically.
+     *
+     * @example
+     * ```typescript
+     * // Production: disable all introspection
+     * reactiveOptions.introspection = null
+     * ```
+     */
+    introspection: {
+        gatherReasons: { lineages: 'touch' },
+        logErrors: true,
+        enableHistory: true,
+        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)
+     * @deprecated Should take all when we made sure PIXI.create, Game.create, ... are -> .root()
+     */
+    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,
+    },
+};
+function optionCall(name, ...args) {
+    const fn = options[name];
+    if (typeof fn !== 'function')
+        return;
+    try {
+        ;
+        fn(...args);
+    }
+    catch (error) {
+        options.warn(`options.${name} threw`, error);
+    }
+}
+// --- Proxy State (Merged from proxy-state.ts) ---
+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 unwrap(obj) {
+    if (!obj || typeof obj !== 'object')
+        return obj;
+    return proxyToObject.get(obj) || obj;
+}
+function isReactive(obj) {
+    return proxyToObject.has(obj);
+}
+
+const effectHistory = tag('effectHistory', new ZoneHistory());
+tag('effectHistory.present', effectHistory.present);
+asyncZone.add(effectHistory);
+/**
+ * Aggregator for zones that need to be tracked along effects.
+ * ie. in each effect, the active zone of the given zoning will be the one active at effect's definition
+ */
+const effectAggregator = tag('effectAggregator', new ZoneAggregator(effectHistory.present));
+function isRunning(effect) {
+    const root = getRoot(effect);
+    return effectHistory.some((e) => getRoot(e) === root);
+}
+function getActiveEffect() {
+    return effectHistory.present.active;
+}
+/**
+ * ADD a cleanup function to an object using the cleanup symbol.
+ * The cleanup function will be called when the object needs to be disposed.
+ *
+ * Note: most of the time, you don't need to use this function directly.
+ * The main use if for the cleanup function to be stored with the object, as GC calls the cleanup function when the *function* is garbage collected.
+ *
+ * @param obj - The object to attach the cleanup function to
+ * @param cleanupFn - The cleanup function to attach
+ * @returns The object with the cleanup function attached
+ */
+function cleanedBy(obj, cleanupFn) {
+    const oldCleanup = obj[cleanup];
+    return Object.defineProperty(obj, cleanup, {
+        value: oldCleanup
+            ? Object.defineProperties((reason) => {
+                oldCleanup(reason);
+                cleanupFn(reason);
+            }, {
+                [stopped]: { get: () => oldCleanup[stopped] || cleanupFn[stopped] },
+            })
+            : cleanupFn,
+        writable: false,
+        enumerable: false,
+        configurable: true,
+    });
+}
+
+// Track dependency stacks per (obj, prop, effect)
+let dependencyStacks = new WeakMap();
+function resetTracking() {
+    dependencyStacks = new WeakMap();
+}
+function getDependencyStack(effect, obj, prop) {
+    const objStacks = dependencyStacks.get(obj);
+    if (!objStacks)
+        return undefined;
+    return objStacks.get(prop)?.get(effect) ?? objStacks.get(allProps)?.get(effect);
+}
+/**
+ * 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 || (typeof prop === 'symbol' && prop !== allProps && prop !== keysOf))
+        return;
+    if ('dependencyHook' in currentActiveEffect) {
+        // @ts-expect-error We declared it nowhere - it's okay as it's really internal and for edge-case debug purpose only
+        currentActiveEffect.dependencyHook(obj, prop);
+    }
+    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]));
+    }
+    // Store dependency stack if introspection is enabled
+    const gatherReasons = options.introspection?.gatherReasons;
+    if (gatherReasons) {
+        const lineageConfig = gatherReasons.lineages;
+        if (lineageConfig === 'dependency' || lineageConfig === 'both') {
+            let objStacks = dependencyStacks.get(obj);
+            if (!objStacks) {
+                objStacks = new Map();
+                dependencyStacks.set(obj, objStacks);
+            }
+            let propStacks = objStacks.get(prop);
+            if (!propStacks) {
+                propStacks = new Map();
+                objStacks.set(prop, propStacks);
+            }
+            propStacks.set(currentActiveEffect, debugHooks.captureLineage());
+        }
+    }
+}
+
+/**
+ * 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(' → ')}`;
+}
+// Nested map structure for efficient counting and batch cleanup
+// batchId -> effect root -> obj -> prop -> count
+let activationRegistry;
+const activationLog = new Array(100);
+/**
+ * Returns the activation log containing recent effect activations for debugging.
+ * The log is a circular buffer of the last 100 activations.
+ *
+ * @returns Array of activation records
+ */
+function getActivationLog() {
+    return activationLog;
+}
+function recordActivation(effect, obj, evolution, prop) {
+    const root = getRoot(effect);
+    if (!activationRegistry)
+        return;
+    let effectData = activationRegistry.get(root);
+    if (!effectData) {
+        effectData = new Map();
+        activationRegistry.set(root, effectData);
+    }
+    let objData = effectData.get(obj);
+    if (!objData) {
+        objData = new Map();
+        effectData.set(obj, objData);
+    }
+    const count = (objData.get(prop) ?? 0) + 1;
+    objData.set(prop, count);
+    // Keep a limited history for diagnostics
+    activationLog.unshift({
+        effect,
+        obj,
+        evolution,
+        prop,
+    });
+    activationLog.pop();
+    if (count >= options.maxTriggerPerBatch) {
+        const effectName = root.name;
+        const message = `Aggressive trigger detected: effect "${effectName}" triggered ${count} times in the batch by the same cause.`;
+        if (options.maxEffectReaction === 'throw') {
+            throw new ReactiveError(message, {
+                code: ReactiveErrorCode.MaxReactionExceeded,
+                count,
+                effect: root,
+            });
+        }
+        options.warn(`[reactive] ${message}`);
+    }
+}
+function caught(onThrow, effect) {
+    effect ?? (effect = getActiveEffect());
+    if (!effect)
+        throw new Error('Tracking an effect throw while not in an effect');
+    const node = getEffectNode(effect);
+    if (!node.catchers)
+        node.catchers = [onThrow];
+    else
+        node.catchers.push(onThrow);
+}
+/** @deprecated Use `caught` instead */
+const onEffectThrow = caught;
+// Dependency graph: tracks which effects trigger which other effects
+// Uses roots (Function) as keys for consistency
+let effectTriggers = new WeakMap();
+let 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)
+let causesClosure = new WeakMap();
+let consequencesClosure = new WeakMap();
+let broken = false;
+/**
+ * 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) {
+    if (options.cycleHandling === 'production')
+        return;
+    // Add to forward graph: callerRoot → targetRoot
+    const triggers = effectTriggers.get(callerRoot);
+    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?.size && vConsequencesSet?.size) {
+        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) {
+    if (options.cycleHandling === 'production')
+        return;
+    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`
+// Batch stack - handles nested batches by giving each its own queue
+const batchStack = [];
+function hasBatched(effect) {
+    const root = getRoot(effect);
+    return batchStack.some((bs) => bs.all.has(root));
+}
+// DEV: stack of currently-executing effects (push on enter, pop on leave)
+const executingStack = [];
+/**
+ * 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) {
+    if (options.cycleHandling === 'production')
+        return;
+    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);
+            }
+        }
+    }
+}
+/**
+ * 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
+ *
+ * **Note**: This is the primary optimization benefit of the transitive closure system.
+ * It allows detecting cycles in O(1) time before they are executed.
+ *
+ * @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, reason) {
+    const node = getEffectNode(effect);
+    const currentBatch = batchStack[batchStack.length - 1];
+    if (!currentBatch) {
+        return;
+    }
+    const root = getRoot(effect);
+    // Build reason from pending triggers if not provided
+    if (!reason && node.pendingTriggers) {
+        reason = { type: 'propChange', triggers: node.pendingTriggers };
+    }
+    node.pendingTriggers = undefined;
+    if (reason) {
+        const existing = node.nextReason;
+        if (!existing) {
+            node.nextReason = reason;
+        }
+        else {
+            const mergePropChange = (into, from) => {
+                if (into.type === 'propChange') {
+                    into.triggers.push(...from.triggers);
+                    return true;
+                }
+                if (into.type === 'multiple') {
+                    const target = into.reasons.find((r) => r.type === 'propChange');
+                    if (target) {
+                        target.triggers.push(...from.triggers);
+                        return true;
+                    }
+                }
+                return false;
+            };
+            if (reason.type === 'propChange') {
+                if (!mergePropChange(existing, reason)) {
+                    if (existing.type === 'multiple') {
+                        existing.reasons.push(reason);
+                    }
+                    else {
+                        node.nextReason = { type: 'multiple', reasons: [existing, reason] };
+                    }
+                }
+            }
+            else if (existing.type === 'multiple') {
+                existing.reasons.push(reason);
+            }
+            else {
+                node.nextReason = { type: 'multiple', reasons: [existing, reason] };
+            }
+        }
+    }
+    // 1. Add to batch first (needed for cycle detection)
+    // TODO: Check if it's the correct way to do (these different behavior in function of dev/production)
+    if (options.cycleHandling === 'production') {
+        // Production mode: FIFO (delete and re-add to move to end)
+        if (currentBatch.all.has(root)) {
+            currentBatch.all.delete(root);
+        }
+    }
+    else {
+        // Dev mode: skip if already queued — the existing entry will re-run
+        if (currentBatch.all.has(root)) {
+            return;
+        }
+    }
+    // If the effect was stopped during cleanup (e.g. lazy memoization), don't add it to the batch
+    if (node.stopped)
+        return;
+    currentBatch.all.set(root, effect);
+    if (caller && true && options.cycleHandling !== 'production') {
+        const callerRoot = getRoot(caller);
+        // const root = getRoot(effect) // Already have root
+        // Check for cycle BEFORE adding edge
+        if (wouldCreateCycle(callerRoot, root)) {
+            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)`;
+            currentBatch.all.delete(root);
+            const causalChain = debugHooks.getTriggerChain(effect);
+            const lineage = getEffectNode(effect).creationStack;
+            throw new ReactiveError(`[reactive] ${cycleMessage}`, {
+                code: ReactiveErrorCode.CycleDetected,
+                cycle: cyclePath.map((r) => r.name || r.toString()),
+                details: cycleMessage,
+                causalChain,
+                lineage,
+            });
+        }
+        addGraphEdge(callerRoot, root);
+    }
+}
+/**
+ * Adds a cleanup function to be called when the current batch of effects completes
+ * @param cleanup - The cleanup function to add
+ */
+function addBatchCleanup(cleanup) {
+    const currentBatch = batchStack[batchStack.length - 1];
+    if (!currentBatch)
+        cleanup();
+    else
+        currentBatch.deferreds.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 batch - The batch queue
+ * @returns Array of effect roots forming a cycle
+ */
+function getCyclePath(batch) {
+    // 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 batch.all) {
+        if (visited.has(root))
+            continue;
+        const cycle = findCycle(root, visited, recursionStack, path, batch);
+        if (cycle.length > 0) {
+            return cycle;
+        }
+    }
+    return [];
+}
+function findCycle(root, visited, recursionStack, path, batch) {
+    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 (batch.all.has(targetRoot)) {
+                const cycle = findCycle(targetRoot, visited, recursionStack, path, batch);
+                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) {
+    const currentBatch = batchStack[batchStack.length - 1];
+    if (!currentBatch)
+        return null;
+    // Find an effect with in-degree 0 using cached values
+    let nextEffect = null;
+    let nextRoot = null;
+    if (options.cycleHandling === 'production') {
+        // In flat mode, we just take the first effect in the queue (FIFO)
+        const first = currentBatch.all.entries().next().value;
+        if (first) {
+            [nextRoot, nextEffect] = first;
+        }
+    }
+    else {
+        // 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 currentBatch.all) {
+            const inDegree = currentBatch.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 (currentBatch.all.size > 0) {
+            let cycle = getCyclePath(currentBatch);
+            // 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 currentBatch.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 (currentBatch.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';
+            throw new ReactiveError(`[reactive] ${cycleMessage}`, {
+                code: ReactiveErrorCode.CycleDetected,
+                cycle: cycle.map((r) => r.name || r.toString()),
+                details: cycleMessage,
+            });
+        }
+        return null; // Batch complete
+    }
+    effectuatedRoots.push(getRoot(nextEffect));
+    // Execute the effect
+    executingStack.push(nextEffect);
+    let result;
+    try {
+        const node = getEffectNode(nextEffect);
+        const reason = node.nextReason;
+        if (node.cleanup) {
+            const cleanup = node.cleanup;
+            node.cleanup = undefined;
+            cleanup(reason);
+        }
+        result = nextEffect();
+    }
+    finally {
+        executingStack.pop();
+    }
+    // Remove from ALL batches in the stack and update in-degrees of dependents
+    for (let i = batchStack.length - 1; i >= 0; i--) {
+        const batch = batchStack[i];
+        if (batch.all.has(nextRoot)) {
+            batch.all.delete(nextRoot);
+            batch.inDegrees.delete(nextRoot);
+            decrementInDegreesForExecuted(batch, 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 (broken) {
+        throw new ReactiveError('[reactive] Reactive system is broken after an unrecoverable error. Call reset() to recover.', { code: ReactiveErrorCode.BrokenEffects });
+    }
+    if (!Array.isArray(effect))
+        effect = [effect];
+    const roots = effect.map(getRoot);
+    const isNewBatch = batchStack.length === 0;
+    if (isNewBatch) {
+        if (!activationRegistry)
+            activationRegistry = new Map();
+        else
+            throw new Error('Activation registry already exists');
+        optionCall('beginChain', roots);
+    }
+    const caller = getActiveEffect();
+    // Optimization: If nested and NOT immediate, just join the existing batch
+    if (!isNewBatch && !immediate) {
+        for (let i = 0; i < effect.length; i++) {
+            addToBatch(effect[i], caller);
+        }
+        return;
+    }
+    const currentBatch = {
+        all: new Map(),
+        inDegrees: new Map(),
+        deferreds: new Set(),
+    };
+    batchStack.push(currentBatch);
+    let success = false;
+    try {
+        const effectuatedRoots = [];
+        const firstReturn = {};
+        if (immediate) {
+            // Execute initial effects in providing order
+            for (let i = 0; i < effect.length; i++) {
+                executingStack.push(effect[i]);
+                try {
+                    const node = getEffectNode(effect[i]);
+                    const reason = node.nextReason;
+                    if (node.cleanup) {
+                        const cleanup = node.cleanup;
+                        node.cleanup = undefined;
+                        cleanup(reason);
+                    }
+                    const rv = effect[i]();
+                    if (rv !== undefined && !('value' in firstReturn))
+                        firstReturn.value = rv;
+                }
+                finally {
+                    executingStack.pop();
+                    currentBatch.all.delete(getRoot(effect[i]));
+                }
+            }
+        }
+        else {
+            // Add initial effects to batch and compute dependencies
+            for (let i = 0; i < effect.length; i++) {
+                addToBatch(effect[i], caller, false);
+            }
+            computeAllInDegrees(currentBatch);
+        }
+        // Process the current batch queue
+        while (currentBatch.all.size > 0 || currentBatch.deferreds.size > 0) {
+            if (currentBatch.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 = Array.from(currentBatch.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,
+                        causalChain: effectuatedRoots.length > 0
+                            ? debugHooks.getTriggerChain(currentBatch.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);
+                if (rv !== undefined && !('value' in firstReturn))
+                    firstReturn.value = rv;
+            }
+            else {
+                // Process deferreds for this batch.
+                const deferreds = Array.from(currentBatch.deferreds);
+                currentBatch.deferreds.clear();
+                for (const deferred of deferreds)
+                    deferred();
+            }
+        }
+        success = true;
+        return firstReturn.value;
+    }
+    finally {
+        if (!success && batchStack.length === 1) {
+            broken = true;
+        }
+        batchStack.pop();
+        if (batchStack.length === 0) {
+            activationRegistry = undefined;
+            optionCall('endChain');
+        }
+    }
+}
+/**
+ * Resets the reactive system to a consistent state.
+ * Call this after an unrecoverable error has set the system to "broken".
+ * This clears all batch state, effect dependency graphs, and watcher registrations.
+ * All existing effects become orphaned and must be recreated.
+ */
+function reset() {
+    broken = false;
+    activationRegistry = undefined;
+    batchStack.length = 0;
+    effectTriggers = new WeakMap();
+    effectTriggeredBy = new WeakMap();
+    causesClosure = new WeakMap();
+    consequencesClosure = new WeakMap();
+    resetRegistry();
+    resetTracking();
+    effectHistory.present.active = undefined;
+}
+// Inject batch function to allow atomic game loops in requestAnimationFrame/setTimeout/...
+// Note: Automatic batching of async callbacks (setTimeout, Promise.then, etc.) is NOT implemented.
+// Rationale: (1) asyncHooks.addHook API doesn't support knowing when callbacks complete (needed for batching),
+// (2) hooking all callback-creating functions adds overhead without guaranteed benefit,
+// (3) incomplete coverage in Node (async_hooks misses user-land patterns).
+// Solution: Use explicit @atomic decorator or manual batch() calls where optimization is needed.
+/**
+ * Decorator that makes methods atomic - batches all effects triggered within the method
+ */
+const atomic = decorator({
+    method(original) {
+        return function (...args) {
+            const atomicEffect = () => original.apply(this, args);
+            // Debug: helpful to have a name
+            Object.defineProperty(atomicEffect, 'name', { value: `atomic(${original.name})` });
+            return batch(atomicEffect, 'immediate');
+        };
+    },
+    default(original) {
+        return function (...args) {
+            const atomicEffect = () => original.apply(this, args);
+            // Debug: helpful to have a name
+            Object.defineProperty(atomicEffect, 'name', { value: `atomic(${original.name})` });
+            return batch(atomicEffect, 'immediate');
+        };
+    },
+});
+/**
+ * Runs `fn` atomically and **always immediately**, batching all reactive effects
+ * triggered inside it so they fire only once after `fn` completes.
+ *
+ * Unlike `atomic(fn)` which **wraps** a function for later invocation,
+ * `atom(fn)` **executes** the function right away.
+ *
+ * @example
+ * ```ts
+ * const state = reactive({ a: 0, b: 0 })
+ * effect(() => console.log(state.a, state.b)) // logs once after atom completes
+ *
+ * atom(() => {
+ *   state.a = 1
+ *   state.b = 2
+ * })
+ * ```
+ */
+function atom(fn) {
+    return batch(fn, '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
+ */
+const effect = named(effectMarker.leave, flavored(function effect(
+// biome-ignore lint/suspicious/noConfusingVoidType: Effect callbacks commonly return void
+fn, effectOptions = {}) {
+    if (effectOptions?.name)
+        Object.defineProperty(fn, 'name', { value: effectOptions.name });
+    // Use per-effect asyncMode or fall back to global option
+    const asyncMode = effectOptions?.asyncMode ?? options.asyncMode ?? 'cancel';
+    // Create the effect function - naming it for debug
+    const runEffect = () => {
+        const node = getEffectNode(runEffect);
+        // Clear previous dependencies
+        if (node.cleanup) {
+            const prevCleanup = node.cleanup;
+            node.cleanup = undefined;
+            try {
+                untracked(() => prevCleanup(node.nextReason || { type: 'stopped' }));
+            }
+            catch (error) {
+                // If we want to report them, we could use options.warn or similar
+                options.warn('Error during effect cleanup', error);
+            }
+        }
+        // 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;
+        let reactionCleanup;
+        function cleanupReaction(reason) {
+            const toCleanup = reactionCleanup;
+            reactionCleanup = undefined;
+            toCleanup?.(reason);
+        }
+        // Set reaction reason for the upcoming run
+        access.reaction = node.nextReason || access.reaction;
+        node.nextReason = undefined;
+        optionCall('enter', getRoot(fn));
+        let result;
+        let caught = 0;
+        // Default thrower (self)
+        let thrower = (error) => {
+            throw error;
+        };
+        node.forwardThrow = thrower;
+        let errorToThrow;
+        try {
+            result = tracked(named(effectMarker.enter, () => fn.call(null, access)));
+            access.reaction = true;
+            optionCall('leave', fn);
+            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
+                runningPromise = runningPromise.catch((error) => {
+                    // Propagate async errors to the effect's error handler
+                    // This ensures onEffectThrow handlers are triggered for async errors
+                    if (error !== cancelError) {
+                        thrower(error);
+                    }
+                    // If thrower didn't throw (handled), we absorb the error.
+                    // If thrower threw (unhandled), it propagates as a new unhandled rejection, which is correct.
+                });
+            }
+            else {
+                // Synchronous result - treat as cleanup function
+                reactionCleanup = result;
+            }
+        }
+        catch (error) {
+            // catcher:self`
+            errorToThrow = error;
+        }
+        // Create cleanup function for next run
+        node.cleanup = (reason) => {
+            node.cleanup = undefined;
+            cleanupReaction(reason);
+            delete node.catchers;
+            // 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 = node.children;
+            if (children) {
+                const childReason = reason
+                    ? reason.type === 'lineage'
+                        ? reason
+                        : { type: 'lineage', parent: reason }
+                    : { type: 'stopped' };
+                for (const childCleanup of children)
+                    childCleanup(childReason);
+                delete node.children;
+            }
+        };
+        // Define bubbling thrower
+        thrower = (error) => {
+            const catches = node.catchers;
+            const reason = { type: 'error', error };
+            if (catches)
+                while (caught < catches.length) {
+                    cleanupReaction(reason);
+                    try {
+                        reactionCleanup = catches[caught](error);
+                        return;
+                    }
+                    catch (e) {
+                        caught++;
+                    }
+                }
+            if (parent) {
+                const parentNode = getEffectNode(parent);
+                if (parentNode.forwardThrow)
+                    parentNode.forwardThrow(error);
+                else
+                    throw error;
+            }
+            else
+                throw error;
+        };
+        // Update the node's forwardThrow to the bubbling one
+        node.forwardThrow = thrower;
+        if (errorToThrow)
+            thrower(errorToThrow);
+    };
+    // Initialize metadata node
+    const node = getEffectNode(runEffect);
+    if (debugHooks.isDevtoolsEnabled()) {
+        const stack = debugHooks.captureStack(); // Robustly skips internal mutts frames
+        if (Array.isArray(stack) && stack.length > 0) {
+            node.creationStack = stack;
+        }
+    }
+    const tracked = effectHistory.present.with(runEffect, () => named(effectMarker.leave, effectAggregator.zoned));
+    const ascended = named(effectMarker.leave, effectHistory.zoned);
+    const parent = effectHistory.present.active;
+    // Set parent relationship in node
+    node.parent = parent;
+    // let thrower: CatchFunction | undefined // Moved inside runEffect
+    let effectStopped = false;
+    const access = {
+        tracked,
+        ascend: named(effectMarker.leave, (fn) => ascended(named(effectMarker.enter, () => fn.call(null)))),
+        //named(effectMarker.enter, (fn) => ascended(fn)),
+        reaction: false,
+    };
+    let runningPromise = null;
+    let cancelPrevious = null;
+    if (effectOptions?.dependencyHook) {
+        node.dependencyHook = effectOptions.dependencyHook;
+    }
+    // Mark the runEffect callback with the original function as its root
+    markWithRoot(runEffect, fn);
+    function augmentedRv(rv) {
+        return Object.defineProperties(rv, {
+            [stopped]: {
+                get: () => effectStopped,
+            },
+        });
+    }
+    // Register strict mode if enabled
+    if (effectOptions?.opaque) {
+        node.isOpaque = true;
+    }
+    if (debugHooks.isDevtoolsEnabled()) {
+        debugHooks.registerEffect(runEffect);
+    }
+    // Store parent relationship for hierarchy traversal - ALREADY DONE ABOVE via getEffectNode
+    batch(runEffect, 'immediate');
+    // Only ROOT effects are registered for GC cleanup and zone tracking
+    const isRootEffect = !parent;
+    const stopEffect = (reason) => {
+        if (effectStopped)
+            return;
+        effectStopped = true;
+        node.stopped = true;
+        // Cancel any running async work
+        if (cancelPrevious) {
+            cancelPrevious();
+            cancelPrevious = null;
+            runningPromise = null;
+        }
+        try {
+            node.cleanup?.(reason || { type: 'stopped' });
+        }
+        catch (error) {
+            // Cleanup errors should basically be ignored or at least not stop the world
+            // If we want to report them, we could use options.warn or similar
+            options.warn('Error during effect cleanup', error);
+        }
+        // Clean up dependency graph edges
+        cleanupEffectFromGraph(runEffect);
+        fr.unregister(stopEffect);
+    };
+    if (isRootEffect) {
+        const callIfCollected = augmentedRv((reason) => stopEffect(reason));
+        fr.register(callIfCollected, () => {
+            stopEffect({ type: 'gc' });
+            optionCall('garbageCollected', fn);
+        }, stopEffect);
+        return callIfCollected;
+    }
+    // Register this effect to be stopped when the parent effect is cleaned up
+    if (parent) {
+        const parentNode = getEffectNode(parent);
+        if (!parentNode.children) {
+            parentNode.children = new Set();
+        }
+        const children = parentNode.children;
+        const subEffectCleanup = augmentedRv((reason) => {
+            children.delete(subEffectCleanup);
+            // Execute this child effect cleanup (which triggers its own mainCleanup)
+            stopEffect(reason);
+        });
+        children.add(subEffectCleanup);
+        return subEffectCleanup;
+    }
+    // Should not be reachable given isRootEffect check, but for type safety
+    return augmentedRv((reason) => stopEffect(reason));
+}, {
+    get opaque() {
+        return flavorOptions(this, { opaque: true }, { name: 'opaque' });
+    },
+    named(name) {
+        return flavorOptions(this, { name }, { name: 'named' });
+    },
+}));
+/**
+ * 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) {
+    return effectHistory.present.root(fn);
+}
+/**
+ * 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) {
+    return effectHistory.root(fn);
+}
+function biDi(received, get, set) {
+    if (typeof get !== 'function') {
+        set = get.set;
+        get = get.get;
+    }
+    let programmaticallySetValue = Symbol();
+    effect(markWithRoot(() => {
+        const newValue = get();
+        if (unwrap(newValue) !== programmaticallySetValue)
+            received(newValue);
+    }, received));
+    return set
+        ? atomic((value) => {
+            programmaticallySetValue = unwrap(value);
+            set(value);
+        })
+        : () => { };
+}
+
+// Track which objects contain which other objects (back-references)
+const objectParents = new WeakMap();
+// Track which objects have deep watchers
+const objectsWithDeepWatchers = new WeakSet();
+let deepWatcherCount = 0;
+function registerDeepWatcher() {
+    deepWatcherCount++;
+}
+// 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: if no deep watchers exist anywhere, skip entirely
+    if (!deepWatcherCount)
+        return false; // fast path: no deep watchers anywhere
+    // 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, prop } of parents) {
+        // Trigger deep watchers on parent
+        const parentDeepWatchers = deepWatchers.get(parent);
+        if (parentDeepWatchers) {
+            if (options.introspection?.gatherReasons) {
+                const gatherReasons = options.introspection.gatherReasons;
+                const lineageConfig = gatherReasons.lineages;
+                let touchStack;
+                if (lineageConfig === 'touch' || lineageConfig === 'both') {
+                    touchStack = debugHooks.captureLineage();
+                }
+                for (const watcher of parentDeepWatchers) {
+                    const dependencyStack = lineageConfig === 'dependency' || lineageConfig === 'both'
+                        ? getDependencyStack(watcher, parent, allProps)
+                        : undefined;
+                    const node = getEffectNode(watcher);
+                    if (!node.pendingTriggers)
+                        node.pendingTriggers = [];
+                    node.pendingTriggers.push({
+                        obj: parent,
+                        evolution,
+                        dependency: dependencyStack,
+                        touch: touchStack,
+                    });
+                }
+            }
+            for (const watcher of parentDeepWatchers)
+                batch(watcher);
+        }
+        // Continue bubbling up
+        bubbleUpChange(parent, evolution);
+    }
+}
+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) {
+                        optionCall('skipRunningEffect', effect);
+                        continue;
+                    }
+                    if (!effects.has(effect)) {
+                        effects.set(effect, getDependencyStack(effect, obj, key));
+                        if (!hasBatched(effect))
+                            recordActivation(effect, obj, evolution, key);
+                    }
+                    debugHooks.recordTriggerLink(sourceEffect, effect, obj, key, evolution);
+                }
+            }
+        }
+}
+/**
+ * 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 Map();
+        const structural = !['set', 'invalidate'].includes(evolution.type);
+        const broad = structural ? [allProps, keysOf] : [allProps];
+        if (props)
+            collectEffects(obj, evolution, effects, objectWatchers, broad, props);
+        else
+            collectEffects(obj, evolution, effects, objectWatchers, objectWatchers.keys());
+        const triggers = Array.from(effects.keys());
+        optionCall('touched', obj, evolution, props, triggers);
+        // Store pending triggers for CleanupReason before batching
+        if (options.introspection?.gatherReasons) {
+            const gatherReasons = options.introspection.gatherReasons;
+            const lineageConfig = gatherReasons.lineages;
+            let touchStack;
+            if (lineageConfig === 'touch' || lineageConfig === 'both') {
+                touchStack = debugHooks.captureLineage();
+            }
+            for (const [effect, dependencyStack] of effects) {
+                const node = getEffectNode(effect);
+                if (!node.pendingTriggers)
+                    node.pendingTriggers = [];
+                node.pendingTriggers.push({
+                    obj,
+                    evolution,
+                    dependency: dependencyStack,
+                    touch: touchStack,
+                });
+            }
+        }
+        batch(triggers);
+    }
+    // Bubble up changes if this object has deep watchers
+    if (objectsWithDeepWatchers.has(obj)) {
+        bubbleUpChange(obj, evolution);
+    }
+}
+/**
+ * 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();
+    const gather = options.introspection?.gatherReasons;
+    if (gather) {
+        const lineageConfig = gather.lineages;
+        for (const effect of deps) {
+            const node = getEffectNode(effect);
+            if (!node.isOpaque)
+                continue;
+            const runningChain = isRunning(effect);
+            if (runningChain) {
+                optionCall('skipRunningEffect', effect);
+                continue;
+            }
+            effects.add(effect);
+            if (gather) {
+                let touchStack;
+                let dependencyStack;
+                if (lineageConfig === 'touch' || lineageConfig === 'both') {
+                    touchStack = debugHooks.captureLineage();
+                }
+                if (lineageConfig === 'dependency' || lineageConfig === 'both') {
+                    dependencyStack = getDependencyStack(effect, obj, prop);
+                }
+                if (!node.pendingTriggers)
+                    node.pendingTriggers = [];
+                node.pendingTriggers.push({
+                    obj,
+                    evolution,
+                    dependency: dependencyStack,
+                    touch: touchStack,
+                });
+            }
+            recordActivation(effect, obj, evolution, prop);
+            debugHooks.recordTriggerLink(sourceEffect, effect, obj, prop, evolution);
+        }
+    }
+    else {
+        // When not gathering reasons, process effects normally
+        for (const effect of deps) {
+            const node = getEffectNode(effect);
+            if (!node.isOpaque)
+                continue;
+            const runningChain = isRunning(effect);
+            if (runningChain) {
+                optionCall('skipRunningEffect', effect);
+                continue;
+            }
+            effects.add(effect);
+            recordActivation(effect, obj, evolution, prop);
+            debugHooks.recordTriggerLink(sourceEffect, effect, obj, prop, evolution);
+        }
+    }
+    if (effects.size > 0) {
+        optionCall('touched', obj, evolution, [prop], Array.from(effects));
+        batch(Array.from(effects));
+    }
+}
+
+const nonReactiveObjects = new WeakSet();
+const nonReactiveClasses = new WeakSet();
+const unreactiveProps = new WeakMap();
+let unreactivePropsCount = 0;
+function addUnreactiveProps(proto, set) {
+    unreactiveProps.set(proto, set);
+    unreactivePropsCount++;
+}
+/** Check if a property is marked unreactive on obj or any of its prototypes (trap-free) */
+function isUnreactiveProp(obj, prop) {
+    if (!unreactivePropsCount)
+        return false;
+    let target = obj;
+    while (target) {
+        if (unreactiveProps.get(target)?.has(prop))
+            return true;
+        target = Object.getPrototypeOf(target);
+    }
+    return false;
+}
+const immutables = new Set();
+const absent = Symbol('absent');
+function markNonReactive(...obj) {
+    for (const o of obj)
+        nonReactiveObjects.add(o);
+    return obj[0];
+}
+function nonReactiveClass(...cls) {
+    for (const c of cls)
+        if (c)
+            nonReactiveClasses.add(c.prototype);
+    return cls[0];
+}
+function isNonReactive(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return true;
+    if (nonReactiveObjects.has(obj))
+        return true;
+    // Walk the prototype chain on the raw object to check for non-reactive classes
+    let proto = Object.getPrototypeOf(obj);
+    while (proto) {
+        if (nonReactiveClasses.has(proto))
+            return true;
+        proto = Object.getPrototypeOf(proto);
+    }
+    for (const fn of immutables)
+        if (fn(obj))
+            return true;
+    return false;
+}
+nonReactiveClass(Date, RegExp, Error, Promise, Function);
+if (typeof window !== 'undefined') {
+    markNonReactive(window, document);
+    nonReactiveClass(Node, Element, HTMLElement, EventTarget, HTMLCollection, NodeList);
+}
+
+function getPrototypeToken(value) {
+    if (Array.isArray(value))
+        return Array.prototype;
+    if (typeof value !== 'object')
+        return undefined;
+    try {
+        return value.constructor;
+    }
+    catch {
+        return undefined;
+    }
+}
+function shouldRecurseTouch(oldValue, newValue) {
+    if (oldValue === newValue)
+        return false;
+    if ((typeof oldValue !== 'object' && !Array.isArray(oldValue)) ||
+        (typeof newValue !== 'object' && !Array.isArray(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(untracked(() => 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 ((typeof oldValue !== 'object' && !Array.isArray(oldValue)) ||
+        (typeof newValue !== 'object' && !Array.isArray(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;
+        const node = getEffectNode(current);
+        current = node.parent;
+    }
+    return false;
+}
+function dispatchNotifications(notifications) {
+    if (!notifications.length)
+        return;
+    const combinedEffects = new Set();
+    const effectCauses = new Map();
+    // 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 Map();
+            collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, [allProps], [origin.prop]);
+            for (const effect of originEffects.keys())
+                allowedEffects.add(effect);
+        }
+        // If no allowed effects, skip all notifications (no one should be notified)
+        if (allowedEffects.size === 0)
+            return;
+    }
+    for (const notification of notifications) {
+        const { target, evolution, prop } = notification;
+        if (typeof target !== 'object' && !Array.isArray(target))
+            continue;
+        const obj = unwrap(target);
+        addState(obj, evolution);
+        const objectWatchers = watchers.get(obj);
+        let currentEffects;
+        const propsArray = [prop];
+        if (objectWatchers) {
+            // console.log(`[DEBUG] dispatchNotifications: processing ${obj.constructor.name} (has watchers)`)
+            currentEffects = new Map();
+            const broad = evolution.type !== 'set' ? [allProps, keysOf] : [allProps];
+            collectEffects(obj, evolution, currentEffects, objectWatchers, broad, 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 Map();
+                for (const [effect, associated] of currentEffects) {
+                    // Check if effect itself is allowed OR has an ancestor that is allowed
+                    if (allowedEffects.has(effect) || hasAncestorInSet(effect, allowedEffects)) {
+                        filteredEffects.set(effect, associated);
+                    }
+                }
+                currentEffects = filteredEffects;
+            }
+            for (const effect of currentEffects.keys()) {
+                combinedEffects.add(effect);
+                let causes = effectCauses.get(effect);
+                if (!causes) {
+                    causes = [];
+                    effectCauses.set(effect, causes);
+                }
+                causes.push(notification);
+            }
+        }
+        if (currentEffects) {
+            optionCall('touched', obj, evolution, propsArray, Array.from(currentEffects.keys()));
+        }
+        if (objectsWithDeepWatchers.has(obj))
+            bubbleUpChange(obj, evolution);
+    }
+    if (combinedEffects.size) {
+        if (options.introspection?.gatherReasons) {
+            const gatherReasons = options.introspection.gatherReasons;
+            const lineageConfig = gatherReasons.lineages;
+            let touchStack;
+            if (lineageConfig === 'touch' || lineageConfig === 'both') {
+                touchStack = debugHooks.captureLineage();
+            }
+            for (const effect of combinedEffects) {
+                const node = getEffectNode(effect);
+                if (!node.pendingTriggers)
+                    node.pendingTriggers = [];
+                for (const { target, evolution, prop } of effectCauses.get(effect)) {
+                    const dependencyStack = lineageConfig === 'dependency' || lineageConfig === 'both'
+                        ? getDependencyStack(effect, unwrap(target), prop ?? allProps)
+                        : undefined;
+                    node.pendingTriggers.push({
+                        obj: unwrap(target),
+                        evolution,
+                        dependency: dependencyStack,
+                        touch: touchStack,
+                    });
+                }
+            }
+        }
+        batch([...combinedEffects]);
+    }
+}
+
+const metaProtos = new WeakMap();
+const wrapProtos = new WeakMap();
+const arrayLengths = new WeakMap();
+const hasReentry = new Set();
+const subsRegister = new WeakMap();
+// Sub-proxy registration for custom reactive behaviors
+const reactiveHandlers = {
+    [Symbol.toStringTag]: 'MutTs Reactive',
+    get(obj, prop, receiver) {
+        if (obj && typeof obj === 'object' && prop !== Symbol.toStringTag) {
+            const metaProto = metaProtos.get(obj.constructor);
+            if (metaProto && Object.hasOwn(metaProto, prop)) {
+                const desc = Object.getOwnPropertyDescriptor(metaProto, prop);
+                if (desc.get) {
+                    if (!Object.hasOwn(obj, prop))
+                        return desc.get.call(obj);
+                    // For own properties (e.g., array length): only override if writable/configurable
+                    const ownDesc = Object.getOwnPropertyDescriptor(obj, prop);
+                    if (ownDesc.configurable || ownDesc.writable || ownDesc.get)
+                        return desc.get.call(obj);
+                }
+                else if (!Object.hasOwn(obj, prop))
+                    return (...args) => desc.value.apply(obj, args);
+            }
+            const wrapProto = wrapProtos.get(obj.constructor);
+            if (wrapProto && Object.hasOwn(wrapProto, prop))
+                return wrapProto[prop];
+        }
+        // Symbols: fast-path — no reactivity tracking, no unreactive check needed
+        if (typeof prop === 'symbol')
+            return FoolProof.get(obj, prop, receiver);
+        // Check if this property is marked as unreactive (WeakMap lookup — no proxy traps)
+        if (isUnreactiveProp(obj, prop))
+            return FoolProof.get(obj, prop, receiver);
+        // Check if property exists using a trap-free walk to avoid triggering
+        // the has-trap cascade on prototype chains of reactive proxies.
+        const isOwnProp = Object.hasOwn(obj, prop);
+        let hasProp = isOwnProp;
+        let owner = isOwnProp ? obj : undefined;
+        if (!isOwnProp) {
+            let raw = Object.getPrototypeOf(obj);
+            while (raw && raw !== Object.prototype) {
+                if (Object.hasOwn(raw, prop)) {
+                    hasProp = true;
+                    owner = raw;
+                    break;
+                }
+                raw = Object.getPrototypeOf(raw);
+            }
+        }
+        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
+        // Skip for null-proto objects (pounce scopes) — they never have accessors
+        const shouldIgnoreAccessor = options.ignoreAccessors &&
+            isOwnProp &&
+            Object.getPrototypeOf(obj) !== null &&
+            (isOwnAccessor(receiver, prop) || isOwnAccessor(obj, prop));
+        // Depend if...
+        if (!hasProp ||
+            (!(options.instanceMembers && isInheritedAccess && obj instanceof Object) &&
+                !shouldIgnoreAccessor))
+            dependant(obj, prop);
+        // Two-Point Tracking: for inherited access on null-proto chains, only track
+        // the owning ancestor — not every intermediate level.  This relies on the
+        // "structural stability" contract: key presence in the chain is fixed at
+        // creation time, so intermediate levels never gain/lose shadowing properties.
+        if (isInheritedAccess && owner && (!options.instanceMembers || !(obj instanceof Object))) {
+            dependant(owner, prop);
+        }
+        // For arrays, use FoolProof.get (Indexer path) for numeric index reactivity.
+        // For all other objects, inline Reflect.get directly (skips 3 function calls).
+        const value = (subsRegister.get(obj)?.get || FoolProof.get)(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) {
+        const unwrappedReceiver = unwrap(receiver);
+        // Check if this property is marked as unreactive
+        if (isUnreactiveProp(obj, prop) || obj !== unwrappedReceiver)
+            return FoolProof.set(obj, prop, value, receiver);
+        const newValue = unwrap(value);
+        // metaProto setter dispatch (e.g., reactive array length)
+        if (obj && typeof obj === 'object' && prop !== Symbol.toStringTag) {
+            const metaProto = obj.constructor && metaProtos.get(obj.constructor);
+            if (metaProto && Object.hasOwn(metaProto, prop)) {
+                const desc = Object.getOwnPropertyDescriptor(metaProto, prop);
+                if (desc.set) {
+                    desc.set.call(obj, 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;
+        // TODO: Pffft... Find a way to "generalize" this case?
+        const isArrayLength = prop === 'length' && Array.isArray(obj);
+        if (Reflect.has(unwrappedReceiver, prop)) {
+            // We *need* to use `receiver` and not `obj` here, otherwise we break
+            // the dependency tracking for memoized getters
+            oldVal = isArrayLength
+                ? arrayLengths.get(obj) === newValue
+                    ? newValue
+                    : absent
+                : untracked(() => Reflect.get(obj, prop, receiver));
+        }
+        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 (FoolProof.set(obj, prop, newValue, receiver)) {
+                if (isArrayLength)
+                    arrayLengths.set(obj, newValue);
+                notifyPropertyChange(obj, prop, oldVal, newValue, oldVal !== absent);
+            }
+        }
+        return true;
+    },
+    has(obj, prop) {
+        if (hasReentry.has(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.add(obj);
+        dependant(obj, prop);
+        const rv = (subsRegister.get(obj)?.has || Reflect.has)(obj, prop);
+        hasReentry.delete(obj);
+        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, { type: 'del', prop });
+        }
+        return true;
+    },
+    ownKeys(obj) {
+        dependant(obj, keysOf);
+        return subsRegister.get(obj)?.ownKeys?.(obj) || Reflect.ownKeys(obj);
+    },
+    getOwnPropertyDescriptor(obj, prop) {
+        return subsRegister.get(obj)?.getOwnPropertyDescriptor?.(obj, prop) || Reflect.getOwnPropertyDescriptor(obj, prop);
+    },
+};
+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, subProxy) {
+    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;
+    if (subProxy)
+        subsRegister.set(target, subProxy);
+    const proxy = new Proxy(target, reactiveHandlers);
+    if (Array.isArray(target))
+        arrayLengths.set(target, target.length);
+    // 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,
+});
+
+export { touched1 as $, AZone as A, getActiveEffect as B, getState as C, DecoratorError as D, hooks as E, immutables as F, isConstructor as G, isNonReactive as H, IterableWeakMap as I, isObject as J, isReactive as K, legacyDecorator as L, mixin as M, modernDecorator as N, named as O, objectToProxy as P, onEffectThrow as Q, ReactiveBase as R, proxyToObject as S, reactive as T, options as U, reset as V, root as W, stopped as X, tag as Y, Zone as Z, touched as _, IterableWeakSet as a, untracked as a0, unwrap as a1, zip as a2, markWithRoot as a3, rootFunctionSymbol as a4, getRoot as a5, dependant as a6, optionCall as a7, keysOf as a8, __runInitializers as a9, __esDecorate as aa, FoolProof as ab, objectsWithDeepWatchers as ac, effectToDeepWatchedObjects as ad, deepWatchers as ae, registerDeepWatcher as af, nonReactiveClass as ag, unreactiveProps as ah, addUnreactiveProps as ai, nonReactiveObjects as aj, __setFunctionName as ak, __classPrivateFieldGet as al, __classPrivateFieldSet as am, contentRef as an, notifyPropertyChange as ao, metaProtos as ap, wrapProtos as aq, objectParents as ar, watchers as as, effectToReactiveObjects as at, effectMarker as au, getEffectNode as av, setDebugHooks as aw, allProps as ax, ReactiveError as b, ReactiveErrorCode as c, ZoneAggregator as d, ZoneHistory as e, addBatchCleanup as f, arrayEquals as g, asyncHook as h, asyncHooks as i, asyncZone as j, atom as k, atomic as l, biDi as m, caught as n, cleanedBy as o, cleanup as p, createFlavor as q, decorator as r, deepCompare as s, defer as t, effect as u, effectAggregator as v, flavorOptions as w, flavored as x, formatCleanupReason as y, getActivationLog as z };
+//# sourceMappingURL=proxy-r7lARftl.esm.js.map