mutts 1.0.8 → 1.0.10

package/dist/chunks/proxy-Dtg-bJ3T.cjs

@@ -0,0 +1,3763 @@
+'use strict';
+
+var asyncCore = require('./async-core-CRLKP3l-.cjs');
+
+/**
+ * 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 asyncCore.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());
+asyncCore.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
+exports.effectToReactiveObjects = new WeakMap();
+// Track effects per reactive object and property
+exports.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() {
+    exports.effectToReactiveObjects = new WeakMap();
+    exports.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
+ */
+exports.ReactiveErrorCode = void 0;
+(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";
+})(exports.ReactiveErrorCode || (exports.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 = exports.watchers.get(obj);
+    if (!objectWatchers) {
+        objectWatchers = new Map();
+        exports.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 = exports.effectToReactiveObjects.get(currentActiveEffect);
+    if (effectObjects) {
+        effectObjects.add(obj);
+    }
+    else {
+        exports.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: exports.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: exports.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: exports.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: exports.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: exports.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 = exports.effectToReactiveObjects.get(runEffect);
+            if (effectObjects) {
+                for (const reactiveObj of effectObjects) {
+                    const objectWatchers = exports.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) {
+                            exports.watchers.delete(reactiveObj);
+                        }
+                    }
+                }
+                exports.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 = exports.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 = exports.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 = exports.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 = exports.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: exports.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,
+});
+
+exports.AZone = AZone;
+exports.DecoratorError = DecoratorError;
+exports.FoolProof = FoolProof;
+exports.IterableWeakMap = IterableWeakMap;
+exports.IterableWeakSet = IterableWeakSet;
+exports.ReactiveBase = ReactiveBase;
+exports.ReactiveError = ReactiveError;
+exports.Zone = Zone;
+exports.ZoneAggregator = ZoneAggregator;
+exports.ZoneHistory = ZoneHistory;
+exports.__classPrivateFieldGet = __classPrivateFieldGet;
+exports.__classPrivateFieldSet = __classPrivateFieldSet;
+exports.__esDecorate = __esDecorate;
+exports.__runInitializers = __runInitializers;
+exports.__setFunctionName = __setFunctionName;
+exports.addBatchCleanup = addBatchCleanup;
+exports.addUnreactiveProps = addUnreactiveProps;
+exports.allProps = allProps;
+exports.arrayEquals = arrayEquals;
+exports.asyncZone = asyncZone;
+exports.atom = atom;
+exports.atomic = atomic;
+exports.biDi = biDi;
+exports.caught = caught;
+exports.cleanedBy = cleanedBy;
+exports.cleanup = cleanup;
+exports.contentRef = contentRef;
+exports.createFlavor = createFlavor;
+exports.decorator = decorator;
+exports.deepCompare = deepCompare;
+exports.deepWatchers = deepWatchers;
+exports.defer = defer;
+exports.dependant = dependant;
+exports.effect = effect;
+exports.effectAggregator = effectAggregator;
+exports.effectMarker = effectMarker;
+exports.effectToDeepWatchedObjects = effectToDeepWatchedObjects;
+exports.flavorOptions = flavorOptions;
+exports.flavored = flavored;
+exports.formatCleanupReason = formatCleanupReason;
+exports.getActivationLog = getActivationLog;
+exports.getActiveEffect = getActiveEffect;
+exports.getEffectNode = getEffectNode;
+exports.getRoot = getRoot;
+exports.getState = getState;
+exports.immutables = immutables;
+exports.isConstructor = isConstructor;
+exports.isNonReactive = isNonReactive;
+exports.isObject = isObject;
+exports.isReactive = isReactive;
+exports.keysOf = keysOf;
+exports.legacyDecorator = legacyDecorator;
+exports.markWithRoot = markWithRoot;
+exports.metaProtos = metaProtos;
+exports.mixin = mixin;
+exports.modernDecorator = modernDecorator;
+exports.named = named;
+exports.nonReactiveClass = nonReactiveClass;
+exports.nonReactiveObjects = nonReactiveObjects;
+exports.notifyPropertyChange = notifyPropertyChange;
+exports.objectParents = objectParents;
+exports.objectToProxy = objectToProxy;
+exports.objectsWithDeepWatchers = objectsWithDeepWatchers;
+exports.onEffectThrow = onEffectThrow;
+exports.optionCall = optionCall;
+exports.options = options;
+exports.proxyToObject = proxyToObject;
+exports.reactive = reactive;
+exports.registerDeepWatcher = registerDeepWatcher;
+exports.reset = reset;
+exports.root = root;
+exports.rootFunctionSymbol = rootFunctionSymbol;
+exports.setDebugHooks = setDebugHooks;
+exports.stopped = stopped;
+exports.tag = tag;
+exports.touched = touched;
+exports.touched1 = touched1;
+exports.unreactiveProps = unreactiveProps;
+exports.untracked = untracked;
+exports.unwrap = unwrap;
+exports.wrapProtos = wrapProtos;
+exports.zip = zip;
+//# sourceMappingURL=proxy-Dtg-bJ3T.cjs.map