mutts 1.0.8 → 1.0.9

package/dist/chunks/index-VTO-b2vR.cjs

@@ -0,0 +1,4461 @@
+'use strict';
+
+var asyncCore = require('./async-core-CRLKP3l-.cjs');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+/**
+ * Combines multiple arrays into an array of tuples, stopping at the shortest array length
+ * @param args - Arrays to zip together
+ * @returns Array of tuples containing elements from each input array
+ */
+function zip(...args) {
+    if (!args.length)
+        return [];
+    const minLength = Math.min(...args.map((arr) => arr.length));
+    const result = [];
+    for (let i = 0; i < minLength; i++) {
+        const tuple = args.map((arr) => arr[i]);
+        result.push(tuple);
+    }
+    return result;
+}
+/**
+ * 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 (a === b)
+        return true;
+    if (!Array.isArray(a) || !Array.isArray(b))
+        return false;
+    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 ')));
+}
+/**
+ * Renames a function with a new name
+ * @param fct - The function to rename
+ * @param name - The new name for the function
+ * @returns The function with the new name
+ */
+function renamed(fct, name) {
+    return Object.defineProperties(fct, {
+        name: {
+            value: name,
+        },
+    });
+}
+const FoolProof = {
+    get(obj, prop, receiver) {
+        // Check if Node is available and obj is an instance of Node
+        if (typeof Node !== 'undefined' && obj instanceof Node)
+            return obj[prop];
+        return Reflect.get(obj, prop, receiver);
+    },
+    set(obj, prop, value, receiver) {
+        // Check if Node is available and obj is an instance of Node
+        if (typeof Node !== 'undefined' && 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;
+}
+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);
+}
+function tag(name, obj) {
+    Object.defineProperties(obj, {
+        [Symbol.toStringTag]: {
+            value: name,
+            writable: false,
+            configurable: false,
+        },
+        toString: {
+            value: () => name,
+            writable: false,
+            configurable: false,
+        },
+    });
+    return obj;
+}
+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.
+ * Useful when the last argument is an options object that should be merged.
+ *
+ * @param fn - The base flavored function
+ * @param defaultOptions - Options to merge with the provided options
+ * @returns A new flavored function with merged options
+ *
+ * @example
+ * ```typescript
+ * const opaqueEffect = flavorOptions(effect, { opaque: true })
+ * const namedEffect = flavorOptions(effect, { name: 'myEffect' })
+ * ```
+ */
+function flavorOptions(fn, defaultOptions, name) {
+    const fct = function flavorOptionsWrapper(...args) {
+        const lastArg = args[args.length - 1];
+        const mergedArgs = lastArg !== undefined && typeof lastArg === 'object'
+            ? [...args.slice(0, -1), { ...defaultOptions, ...lastArg }]
+            : [...args, defaultOptions];
+        return fn.apply(this, mergedArgs);
+    };
+    if (name)
+        named(name, fct);
+    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;
+};
+
+// biome-ignore-all lint/suspicious/noConfusingVoidType: Type 'void' is not assignable to type 'ScopedCallback | undefined'.
+// Argument of type '() => void' is not assignable to parameter of type '(dep: DependencyFunction) => ScopedCallback | undefined'.
+// Track native reactivity
+const nativeReactive = Symbol('native-reactive');
+/**
+ * Symbol to mark individual objects as non-reactive
+ */
+const nonReactiveMark = Symbol('non-reactive');
+/**
+ * Symbol to mark class properties as non-reactive
+ */
+const unreactiveProperties = Symbol('unreactive-properties');
+/**
+ * Symbol representing all properties in reactive tracking
+ */
+const allProps = Symbol('all-props');
+/**
+ * Symbol for accessing projection information on reactive objects
+ */
+const projectionInfo = Symbol('projection-info');
+/**
+ * Symbol to check if an effect is stopped
+ */
+const stopped = Symbol('stopped');
+/**
+ * Symbol to access effect cleanup function
+ */
+const cleanup = Symbol('cleanup');
+// Symbol to mark functions with their root function
+const rootFunction = Symbol('root-function');
+/**
+ * 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),
+    /**
+     * Configuration for the introspection system
+     */
+    introspection: {
+        /**
+         * Whether to keep a history of mutations for debugging
+         * @default false
+         */
+        enableHistory: false,
+        /**
+         * Number of mutations to keep in history
+         * @default 50
+         */
+        historySize: 50,
+    },
+    /**
+     * Configuration for zone hooks - control which async APIs are hooked
+     * Each option controls whether the corresponding async API is wrapped to preserve effect context
+     * Only applies when asyncMode is enabled (truthy)
+     * @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);
+    }
+}
+
+// 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));
+    // Mark fn with the new root
+    return Object.defineProperty(fn, rootFunction, {
+        value: getRoot(root),
+        writable: false,
+    });
+}
+/**
+ * Gets the root function of a function for effect tracking
+ * @param fn - The function to get the root of
+ * @returns The root function
+ */
+function getRoot(fn) {
+    while (fn && rootFunction in fn)
+        fn = fn[rootFunction];
+    return fn;
+}
+
+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);
+    };
+});
+
+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(() => {
+                oldCleanup();
+                cleanupFn();
+            }, {
+                [stopped]: { get: () => oldCleanup[stopped] || cleanupFn[stopped] },
+            })
+            : cleanupFn,
+        writable: false,
+        enumerable: false,
+        configurable: true,
+    });
+}
+//#region greedy caching
+/**
+ * Creates a derived value that automatically recomputes when dependencies change
+ * @param compute - Function that computes the derived value
+ * @returns Object with value and cleanup function
+ */
+function derived(compute) {
+    const rv = { value: undefined };
+    return cleanedBy(rv, untracked(() => effect(function derivedEffect(access) {
+        rv.value = compute(access);
+    })));
+}
+
+const effectMarker = {
+    enter: 'effect:enter',
+    leave: 'effect:leave'
+};
+/**
+ * Parses a single stack line into a structured frame.
+ * @param line - A line from Error.stack
+ */
+function parseStackLine(line) {
+    // Node.js format: "    at functionName (file:line:column)"
+    // or "    at file:line:column"
+    const nodeMatch = line.match(/^\s*at\s+(?:(.+?)\s+\()?(?:(.+?):(\d+):(\d+))\)?$/);
+    // Browser format (Firefox/Safari): "functionName@file:line:column" or "file:line:column"
+    // Chrome/Edge use Node-like format but without "at" sometimes or with different prefixes
+    const browserMatch = line.match(/(?:(.+?)(?:\@|\(?))?(?:(.+?):(\d+):(\d+))(?:\@|\)?)$/);
+    const match = nodeMatch || browserMatch;
+    if (!match)
+        return null;
+    const [, functionName = 'anonymous', fileName, lineNumber, columnNumber] = match;
+    return {
+        functionName: functionName.trim(),
+        fileName,
+        lineNumber: parseInt(lineNumber, 10),
+        columnNumber: parseInt(columnNumber, 10),
+        raw: line.trim(),
+    };
+}
+let internalFile;
+/**
+ * Gets the current call stack
+ * @param skipFrames - Number of frames to skip
+ * @param error - Optional error to use as source of stack
+ */
+function getStackFrame(error = new Error()) {
+    if (!error.stack)
+        return [];
+    const lines = error.stack.split('\n');
+    const lastLine = lines.findIndex((line) => line.includes(effectMarker.enter));
+    if (lastLine !== -1)
+        lines.splice(lastLine);
+    const firstLine = lines.findLastIndex((line) => line.includes(effectMarker.leave));
+    if (firstLine !== -1)
+        lines.splice(0, firstLine + 1);
+    else {
+        // Dynamically identify the library's internal files if not already done
+        if (!internalFile && lines[1]) {
+            const selfFrame = parseStackLine(lines[1]);
+            if (selfFrame) {
+                internalFile = selfFrame.fileName;
+            }
+        }
+        // Determine the "base" directory of the library to skip other internal files
+        // We look for "src" or "dist" to be more specific than just the project root
+        const srcIndex = internalFile ? internalFile.lastIndexOf('/src/') : -1;
+        const distIndex = internalFile ? internalFile.lastIndexOf('/dist/') : -1;
+        internalFile ? (srcIndex !== -1 ? internalFile.substring(0, srcIndex + 5) :
+            (distIndex !== -1 ? internalFile.substring(0, distIndex + 6) :
+                internalFile.substring(0, internalFile.lastIndexOf('/') + 1))) : undefined;
+        let l;
+        for (l = 1; l < lines.length; l++) {
+            const frame = parseStackLine(lines[l]);
+            if (!frame)
+                continue;
+            // Robust skipping: if we are still in the internal area, skip it.
+            const isInternal = /Lineage$/.test(frame.functionName) ||
+                frame.functionName === 'eval' ||
+                [`getStackFrame`, `captureLineage`].includes(frame.functionName);
+            if (!isInternal)
+                break;
+        }
+        lines.splice(0, l);
+    }
+    return lines.map(parseStackLine).filter(Boolean);
+}
+/**
+ * Traces the lineage of the current execution through nested effects
+ * @param effect - Starting effect (defaults to active effect)
+ */
+function getLineage(effect) {
+    const currentEffect = effect ?? getActiveEffect();
+    const currentStack = getStackFrame(); // Robustly skips internal mutts frames
+    const segments = [];
+    if (!currentEffect) {
+        segments.push({
+            effectName: 'root',
+            stack: filterNodeModules(currentStack),
+        });
+        return segments;
+    }
+    let current = currentEffect;
+    let lastStack = currentStack;
+    while (current) {
+        const rootFn = getRoot(current);
+        if (!rootFn.name)
+            debugger;
+        const effectName = rootFn.name || 'anonymous';
+        const filteredStack = filterNodeModules(lastStack);
+        segments.push({
+            effectName,
+            stack: filteredStack,
+        });
+        // Move to parent
+        const node = getEffectNode(current);
+        const parent = node.parent;
+        const creationStack = getEffectNode(current).creationStack;
+        if (parent) {
+            current = parent;
+            lastStack = creationStack ?? [];
+        }
+        else if (creationStack) {
+            segments.push({
+                effectName: 'root',
+                stack: filterNodeModules(creationStack),
+            });
+            break;
+        }
+        else {
+            break;
+        }
+    }
+    return segments;
+}
+/**
+ * Filters out node_modules frames and groups them
+ * @param frames - Array of stack frames
+ */
+function filterNodeModules(frames) {
+    const result = [];
+    let inNodeModules = false;
+    for (const frame of frames) {
+        const isNodeModule = frame.fileName.includes('/node_modules/');
+        if (isNodeModule && !inNodeModules) {
+            // Start of node_modules block
+            inNodeModules = true;
+            result.push({
+                functionName: '...node_modules...',
+                fileName: '[filtered]',
+                lineNumber: 0,
+                columnNumber: 0,
+                raw: '    at ...node_modules...'
+            });
+        }
+        else if (!isNodeModule && inNodeModules) {
+            // End of node_modules block
+            inNodeModules = false;
+            result.push(frame);
+        }
+        else if (!isNodeModule) {
+            // Regular frame
+            result.push(frame);
+        }
+        // Skip frames inside node_modules
+    }
+    return result;
+}
+/**
+ * Formats lineage segments into a single stack-like string
+ * @param segments - Lineage segments
+ */
+function formatLineage(segments) {
+    const result = [];
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        if (i > 0) {
+            result.push(` --- effect: ${segments[i - 1].effectName} ---`);
+        }
+        for (const frame of segment.stack) {
+            result.push(`    ${frame.raw}`);
+        }
+    }
+    return result.join('\n');
+}
+/**
+ * Logs lineage segments to console with grouping
+ * @param segments - Lineage segments
+ */
+function nodeLineage(segments) {
+    console.groupCollapsed(`🦴 Effect Lineage Trace (${segments.length} segment${segments.length === 1 ? '' : 's'})`);
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        // Add segment header
+        const isLast = i === segments.length - 1;
+        const prefix = i === 0 ? '📍' : isLast ? '└─' : '├─';
+        console.groupCollapsed(`${prefix} Effect: ${segment.effectName}`);
+        // Add stack frames
+        for (let j = 0; j < segment.stack.length; j++) {
+            const frame = segment.stack[j];
+            const isLastFrame = j === segment.stack.length - 1;
+            const framePrefix = isLastFrame ? '└─' : '├─';
+            if (frame.functionName === '...node_modules...') {
+                console.log(`%c${framePrefix} ${frame.functionName}`, 'color: #888; font-style: italic;');
+            }
+            else {
+                const fnStyle = frame.functionName === 'anonymous' ? 'color: #888;' : 'color: #1a7f37; font-weight: bold;';
+                const fileStyle = 'color: #0550ae;';
+                console.log(`%c${framePrefix} %c${frame.functionName} %c(${frame.fileName}:${frame.lineNumber}:${frame.columnNumber})`, 'color: #888;', fnStyle, fileStyle);
+            }
+        }
+        console.groupEnd();
+    }
+    console.groupEnd();
+}
+/**
+ * Legacy version of nodeLineage that returns a formatted string (useful for comparison or logs)
+ * @param segments - Lineage segments
+ * @deprecated TODO: remove me and all the code running around
+ */
+function nodeLineageLegacy(segments) {
+    // ANSI color codes for Node.js terminal
+    const colors = {
+        reset: '\x1b[0m',
+        bright: '\x1b[1m',
+        dim: '\x1b[2m',
+        green: '\x1b[32m',
+        yellow: '\x1b[33m',
+        blue: '\x1b[34m',
+        magenta: '\x1b[35m',
+        cyan: '\x1b[36m',
+        gray: '\x1b[90m',
+    };
+    const result = [];
+    result.push(`${colors.bright}${colors.cyan}🦴 Effect Lineage Trace (${segments.length} segments)${colors.reset}`);
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i];
+        const isLast = i === segments.length - 1;
+        const prefix = i === 0 ? '📍' : isLast ? '└─' : '├─';
+        const connector = isLast ? '  ' : '│ ';
+        result.push(`${colors.gray}${connector}${colors.reset}${colors.bright}${colors.magenta}${prefix} Effect: ${segment.effectName}${colors.reset}`);
+        for (let j = 0; j < segment.stack.length; j++) {
+            const frame = segment.stack[j];
+            const framePrefix = j === segment.stack.length - 1 ? '   └─' : '   ├─';
+            if (frame.functionName === '...node_modules...') {
+                result.push(`${colors.gray}   ${connector}${colors.reset}${colors.dim}${framePrefix} ${colors.yellow}${frame.functionName}${colors.reset}`);
+            }
+            else {
+                const fnColor = frame.functionName === 'anonymous' ? colors.gray : colors.green;
+                result.push(`${colors.gray}   ${connector}${colors.reset}${colors.dim}${framePrefix}${colors.reset} ${fnColor}${frame.functionName}${colors.reset} ${colors.gray}(${colors.reset}${colors.blue}${frame.fileName}:${frame.lineNumber}:${frame.columnNumber}${colors.reset}${colors.gray})${colors.reset}`);
+            }
+        }
+        if (i < segments.length - 1)
+            result.push('');
+    }
+    return result.join('\n');
+}
+/**
+ * Captures and logs lineage to console
+ */
+function captureNodeLineage() {
+    nodeLineage(getLineage());
+}
+/**
+ * Custom formatter for Chrome DevTools to render lineage data nicely.
+ */
+const lineageFormatter = {
+    header: (obj) => {
+        if (obj && obj.__isLineage__) {
+            // Try to detect DevTools theme - default to dark colors if uncertain
+            const isDark = typeof window !== 'undefined' && window.matchMedia?.('(prefers-color-scheme: dark)').matches;
+            const headerColor = isDark ? '#cd9d5d' : '#704214';
+            return [
+                'span',
+                { style: `color: ${headerColor}; font-weight: bold;` },
+                `🦴 Effect Lineage (${obj.segments.length} segments)`,
+            ];
+        }
+        return null;
+    },
+    hasBody: (obj) => obj && obj.__isLineage__,
+    body: (obj) => {
+        if (!obj || !obj.__isLineage__)
+            return null;
+        const segments = obj.segments;
+        // Try to detect DevTools theme
+        const isDark = typeof window !== 'undefined' && window.matchMedia?.('(prefers-color-scheme: dark)').matches;
+        const colors = isDark ? {
+            frameText: '#ccc',
+            functionName: '#ffffff',
+            segmentBg: '#2d2d2d',
+        } : {
+            frameText: '#555',
+            functionName: '#222',
+            segmentBg: '#eee',
+        };
+        const children = segments.map((segment, i) => {
+            const frames = segment.stack.map((frame) => [
+                'div',
+                { style: `margin-left: 20px; color: ${colors.frameText}; font-family: monospace; font-size: 11px;` },
+                ['span', { style: `color: ${colors.functionName};` }, `at ${frame.functionName} `],
+                ['span', {}, `${frame.fileName}:${frame.lineNumber}:${frame.columnNumber}`],
+            ]);
+            const segmentHeader = [
+                'div',
+                { style: `margin-top: 5px; padding: 2px 5px; background: ${colors.segmentBg}; border-radius: 3px; font-weight: bold;` },
+                i === 0 ? `📍 Current: ${segment.effectName}` : `↖ Effect: ${segment.effectName}`,
+            ];
+            return ['div', {}, segmentHeader, ...frames];
+        });
+        return ['div', { style: 'padding: 5px; line-height: 1.4;' }, ...children];
+    },
+};
+/**
+ * Wraps lineage data in a way that the Chrome Formatter can recognize.
+ */
+function wrapLineageForDebug(segments) {
+    return {
+        __isLineage__: true,
+        segments,
+        toString: () => formatLineage(segments),
+    };
+}
+
+// Track which objects contain which other objects (back-references)
+const objectParents = new WeakMap();
+// Track which objects have deep watchers
+const objectsWithDeepWatchers = new WeakSet();
+// Track deep watchers per object
+const deepWatchers = new WeakMap();
+// Track which effects are doing deep watching
+const effectToDeepWatchedObjects = new WeakMap();
+/**
+ * Add a back-reference from child to parent
+ */
+function addBackReference(child, parent, prop) {
+    let parents = objectParents.get(child);
+    if (!parents) {
+        parents = new Set();
+        objectParents.set(child, parents);
+    }
+    parents.add({ parent, prop });
+}
+/**
+ * Remove a back-reference from child to parent
+ */
+function removeBackReference(child, parent, prop) {
+    const parents = objectParents.get(child);
+    if (parents) {
+        for (const entry of parents) {
+            if (entry.parent === parent && entry.prop === prop) {
+                parents.delete(entry);
+                break;
+            }
+        }
+        if (parents.size === 0) {
+            objectParents.delete(child);
+        }
+    }
+}
+/**
+ * Check if an object needs back-references (has deep watchers or parents with deep watchers)
+ */
+function needsBackReferences(obj) {
+    // Fast path: check if object itself has deep watchers
+    if (objectsWithDeepWatchers.has(obj))
+        return true;
+    // Slow path: check if any parent has deep watchers (recursive)
+    return hasParentWithDeepWatchers(obj);
+}
+/**
+ * Bubble up changes through the back-reference chain
+ */
+function bubbleUpChange(changedObject, evolution) {
+    const parents = objectParents.get(changedObject);
+    if (!parents)
+        return;
+    for (const { parent } of parents) {
+        // Trigger deep watchers on parent
+        const parentDeepWatchers = deepWatchers.get(parent);
+        if (parentDeepWatchers)
+            for (const watcher of parentDeepWatchers)
+                batch(watcher);
+        // Continue bubbling up
+        bubbleUpChange(parent);
+    }
+}
+function hasParentWithDeepWatchers(obj) {
+    const parents = objectParents.get(obj);
+    if (!parents)
+        return false;
+    for (const { parent } of parents) {
+        if (objectsWithDeepWatchers.has(parent))
+            return true;
+        if (hasParentWithDeepWatchers(parent))
+            return true;
+    }
+    return false;
+}
+
+const objectToProxy = new WeakMap();
+const proxyToObject = new WeakMap();
+function storeProxyRelationship(target, proxy) {
+    objectToProxy.set(target, proxy);
+    proxyToObject.set(proxy, target);
+}
+function getExistingProxy(target) {
+    return objectToProxy.get(target);
+}
+function trackProxyObject(proxy, target) {
+    proxyToObject.set(proxy, target);
+}
+function unwrap(obj) {
+    let current = obj;
+    while (current && typeof current === 'object' && current !== null && proxyToObject.has(current)) {
+        current = proxyToObject.get(current);
+    }
+    return current;
+}
+function isReactive(obj) {
+    return proxyToObject.has(obj);
+}
+
+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);
+            // console.log(`[DEBUG] collectEffects: checking ${String(key)}. Found deps: ${deps ? deps.size : 'none'}`)
+            if (deps)
+                for (const effect of deps) {
+                    // console.log(`[DEBUG] collectEffects: found dependency ${effect.name || 'anonymous'} for ${String(key)}`)
+                    const runningChain = isRunning(effect);
+                    if (runningChain) {
+                        optionCall('skipRunningEffect', effect);
+                        continue;
+                    }
+                    if (!effects.has(effect)) {
+                        effects.add(effect);
+                        if (!hasBatched(effect))
+                            recordActivation(effect, obj, evolution, key);
+                    }
+                    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 Set();
+        if (props)
+            collectEffects(obj, evolution, effects, objectWatchers, [allProps], props);
+        else
+            collectEffects(obj, evolution, effects, objectWatchers, objectWatchers.keys());
+        optionCall('touched', obj, evolution, props, effects);
+        batch(Array.from(effects));
+    }
+    // Bubble up changes if this object has deep watchers
+    if (objectsWithDeepWatchers.has(obj)) {
+        bubbleUpChange(obj);
+    }
+}
+/**
+ * Triggers only opaque effects for property changes
+ * Used by deep-touch to ensure opaque listeners are notified even when deep optimization is active
+ */
+function touchedOpaque(obj, evolution, prop) {
+    obj = unwrap(obj);
+    const objectWatchers = exports.watchers.get(obj);
+    if (!objectWatchers)
+        return;
+    const deps = objectWatchers.get(prop);
+    if (!deps)
+        return;
+    const effects = new Set();
+    const sourceEffect = getActiveEffect();
+    for (const effect of deps) {
+        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);
+        recordTriggerLink(sourceEffect, effect, obj, prop, evolution);
+    }
+    if (effects.size > 0) {
+        optionCall('touched', obj, evolution, [prop], effects);
+        batch(Array.from(effects));
+    }
+}
+
+const nonReactiveObjects = new WeakSet();
+const immutables = new Set();
+const absent = Symbol('absent');
+function markNonReactive(...obj) {
+    for (const o of obj) {
+        try {
+            Object.defineProperty(o, nonReactiveMark, {
+                value: true,
+                writable: false,
+                enumerable: false,
+                configurable: false,
+            });
+        }
+        catch { }
+        if (!(nonReactiveMark in o))
+            nonReactiveObjects.add(o);
+    }
+    return obj[0];
+}
+function nonReactiveClass(...cls) {
+    for (const c of cls)
+        if (c)
+            c.prototype[nonReactiveMark] = true;
+    return cls[0];
+}
+function isNonReactive(obj) {
+    if (obj === null || typeof obj !== 'object')
+        return true;
+    if (nonReactiveObjects.has(obj))
+        return true;
+    if (obj[nonReactiveMark])
+        return true;
+    for (const fn of immutables)
+        if (fn(obj))
+            return true;
+    return false;
+}
+function registerNativeReactivity(originalClass, reactiveClass) {
+    originalClass.prototype[nativeReactive] = reactiveClass;
+    nonReactiveClass(reactiveClass);
+}
+nonReactiveClass(Date, RegExp, Error, Promise, Function);
+if (typeof window !== 'undefined') {
+    markNonReactive(window, document);
+    nonReactiveClass(Node, Element, HTMLElement, EventTarget);
+}
+
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isObjectLike(value) {
+    return isObject(value);
+}
+function getPrototypeToken(value) {
+    if (!isObjectLike(value))
+        return undefined;
+    if (Array.isArray(value))
+        return Array.prototype;
+    try {
+        return value.constructor;
+    }
+    catch {
+        return undefined;
+    }
+}
+function shouldRecurseTouch(oldValue, newValue) {
+    if (oldValue === newValue)
+        return false;
+    if (!isObjectLike(oldValue) || !isObjectLike(newValue))
+        return false;
+    if (isNonReactive(oldValue) || isNonReactive(newValue))
+        return false;
+    return getPrototypeToken(oldValue) === getPrototypeToken(newValue);
+}
+/**
+ * Centralized function to handle property change notifications with optional recursive touch
+ * @param targetObj - The object whose property changed
+ * @param prop - The property that changed
+ * @param oldValue - The old value (before change)
+ * @param newValue - The new value (after change)
+ * @param hadProperty - Whether the property existed before (for add vs set)
+ */
+function notifyPropertyChange(targetObj, prop, oldValue, newValue, hadProperty) {
+    const evolution = { type: hadProperty ? 'set' : 'add', prop };
+    if (options.recursiveTouching &&
+        oldValue !== undefined &&
+        shouldRecurseTouch(oldValue, newValue)) {
+        const unwrappedObj = unwrap(targetObj);
+        const origin = { obj: unwrappedObj, prop };
+        // Deep touch: only notify nested property changes with origin filtering
+        // Don't notify direct property change - the whole point is to avoid parent effects re-running
+        dispatchNotifications(recursiveTouch(oldValue, newValue, new WeakMap(), [], origin));
+        // Notify opaque listeners (like memoize) that always want to know about identity changes
+        touchedOpaque(targetObj, evolution, prop);
+    }
+    else {
+        touched1(targetObj, evolution, prop);
+    }
+}
+function hasVisitedPair(visited, oldObj, newObj) {
+    let mapped = visited.get(oldObj);
+    if (!mapped) {
+        mapped = new WeakSet();
+        visited.set(oldObj, mapped);
+    }
+    if (mapped.has(newObj))
+        return true;
+    mapped.add(newObj);
+    return false;
+}
+function collectObjectKeys(obj) {
+    const keys = new Set(Reflect.ownKeys(obj));
+    let proto = Object.getPrototypeOf(obj);
+    // Continue walking while prototype exists and doesn't have its own constructor
+    // This stops at Object.prototype (has own constructor) and class prototypes (have own constructor)
+    // but continues for data prototypes (Object.create({}), Object.create(instance), etc.)
+    while (proto && !Object.hasOwn(proto, 'constructor')) {
+        for (const key of Reflect.ownKeys(proto))
+            keys.add(key);
+        proto = Object.getPrototypeOf(proto);
+    }
+    return keys;
+}
+function recursiveTouch(oldValue, newValue, visited = new WeakMap(), notifications = [], origin) {
+    if (!shouldRecurseTouch(oldValue, newValue))
+        return notifications;
+    if (!isObjectLike(oldValue) || !isObjectLike(newValue))
+        return notifications;
+    if (hasVisitedPair(visited, oldValue, newValue))
+        return notifications;
+    if (Array.isArray(oldValue) && Array.isArray(newValue)) {
+        diffArrayElements(oldValue, newValue, visited, notifications, origin);
+        return notifications;
+    }
+    diffObjectProperties(oldValue, newValue, visited, notifications, origin);
+    return notifications;
+}
+function diffArrayElements(oldArray, newArray, _visited, notifications, origin) {
+    const local = [];
+    const oldLength = oldArray.length;
+    const newLength = newArray.length;
+    const max = Math.max(oldLength, newLength);
+    for (let index = 0; index < max; index++) {
+        const hasOld = index < oldLength;
+        const hasNew = index < newLength;
+        if (hasOld && !hasNew) {
+            local.push({ target: oldArray, evolution: { type: 'del', prop: index }, prop: index, origin });
+            continue;
+        }
+        if (!hasOld && hasNew) {
+            local.push({ target: oldArray, evolution: { type: 'add', prop: index }, prop: index, origin });
+            continue;
+        }
+        if (!hasOld || !hasNew)
+            continue;
+        const oldEntry = unwrap(oldArray[index]);
+        const newEntry = unwrap(newArray[index]);
+        if (!Object.is(oldEntry, newEntry)) {
+            local.push({ target: oldArray, evolution: { type: 'set', prop: index }, prop: index, origin });
+        }
+    }
+    if (oldLength !== newLength)
+        local.push({
+            target: oldArray,
+            evolution: { type: 'set', prop: 'length' },
+            prop: 'length',
+            origin,
+        });
+    notifications.push(...local);
+}
+function diffObjectProperties(oldObj, newObj, visited, notifications, origin) {
+    const oldKeys = collectObjectKeys(oldObj);
+    const newKeys = collectObjectKeys(newObj);
+    const local = [];
+    for (const key of oldKeys)
+        if (!newKeys.has(key))
+            local.push({ target: oldObj, evolution: { type: 'del', prop: key }, prop: key, origin });
+    for (const key of newKeys)
+        if (!oldKeys.has(key))
+            local.push({ target: oldObj, evolution: { type: 'add', prop: key }, prop: key, origin });
+    for (const key of newKeys) {
+        if (!oldKeys.has(key))
+            continue;
+        const oldEntry = unwrap(oldObj[key]);
+        const newEntry = unwrap(newObj[key]);
+        if (shouldRecurseTouch(oldEntry, newEntry)) {
+            recursiveTouch(oldEntry, newEntry, visited, notifications, origin);
+        }
+        else if (!Object.is(oldEntry, newEntry)) {
+            local.push({ target: oldObj, evolution: { type: 'set', prop: key }, prop: key, origin });
+        }
+    }
+    notifications.push(...local);
+}
+/**
+ * Checks if an effect or any of its ancestors is in the allowed set
+ */
+function hasAncestorInSet(effect, allowedSet) {
+    let current = effect;
+    const visited = new WeakSet();
+    while (current && !visited.has(current)) {
+        visited.add(current);
+        if (allowedSet.has(current))
+            return true;
+        const node = getEffectNode(current);
+        current = node.parent;
+    }
+    return false;
+}
+function dispatchNotifications(notifications) {
+    if (!notifications.length)
+        return;
+    const combinedEffects = new Set();
+    // Extract origin from first notification (all should have the same origin from a single deep touch)
+    const origin = notifications[0]?.origin;
+    let allowedEffects;
+    // If origin exists, compute allowed effects (those that depend on origin.obj[origin.prop])
+    if (origin) {
+        allowedEffects = new Set();
+        const originWatchers = exports.watchers.get(origin.obj);
+        if (originWatchers) {
+            const originEffects = new Set();
+            collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, [allProps], [origin.prop]);
+            for (const effect of originEffects)
+                allowedEffects.add(effect);
+        }
+        // If no allowed effects, skip all notifications (no one should be notified)
+        if (allowedEffects.size === 0)
+            return;
+    }
+    for (const { target, evolution, prop } of notifications) {
+        if (!isObjectLike(target))
+            continue;
+        const obj = unwrap(target);
+        addState(obj, evolution);
+        const objectWatchers = exports.watchers.get(obj);
+        let currentEffects;
+        const propsArray = [prop];
+        if (objectWatchers) {
+            // console.log(`[DEBUG] dispatchNotifications: processing ${obj.constructor.name} (has watchers)`)
+            currentEffects = new Set();
+            collectEffects(obj, evolution, currentEffects, objectWatchers, [allProps], propsArray);
+            // Filter effects by ancestor chain if origin exists
+            // Include effects that either directly depend on origin or have an ancestor that does
+            if (origin && allowedEffects) {
+                const filteredEffects = new Set();
+                for (const effect of currentEffects) {
+                    // Check if effect itself is allowed OR has an ancestor that is allowed
+                    if (allowedEffects.has(effect) || hasAncestorInSet(effect, allowedEffects)) {
+                        filteredEffects.add(effect);
+                    }
+                }
+                currentEffects = filteredEffects;
+            }
+            for (const effect of currentEffects)
+                combinedEffects.add(effect);
+        }
+        optionCall('touched', obj, evolution, propsArray, currentEffects);
+        if (objectsWithDeepWatchers.has(obj))
+            bubbleUpChange(obj);
+    }
+    if (combinedEffects.size)
+        batch([...combinedEffects]);
+}
+
+/**
+ * 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))
+        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]));
+    }
+}
+
+const metaProtos = new WeakMap();
+const hasReentry = [];
+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);
+            }
+        }
+        if (prop === nonReactiveMark)
+            return false;
+        const unwrappedObj = unwrap(obj);
+        // Check if this property is marked as unreactive
+        if (unwrappedObj[unreactiveProperties]?.has(prop) || typeof prop === 'symbol')
+            return FoolProof.get(obj, prop, receiver);
+        // Check if property exists and if it's an own property (cached for later use)
+        const hasProp = Reflect.has(receiver, prop);
+        const isOwnProp = hasProp && Object.hasOwn(receiver, prop);
+        const isInheritedAccess = hasProp && !isOwnProp;
+        // For accessor properties, check the unwrapped object to see if it's an accessor
+        // This ensures ignoreAccessors works correctly even after operations like Object.setPrototypeOf
+        const shouldIgnoreAccessor = options.ignoreAccessors &&
+            isOwnProp &&
+            (isOwnAccessor(receiver, prop) || isOwnAccessor(unwrappedObj, prop));
+        // Depend if...
+        if (!hasProp ||
+            (!(options.instanceMembers && isInheritedAccess && obj instanceof Object) &&
+                !shouldIgnoreAccessor))
+            dependant(obj, prop);
+        // Watch the whole prototype chain when requested or for null-proto objects
+        if (isInheritedAccess && (!options.instanceMembers || !(obj instanceof Object))) {
+            let current = reactiveObject(Object.getPrototypeOf(obj));
+            while (current && current !== Object.prototype) {
+                dependant(current, prop);
+                if (Object.hasOwn(current, prop))
+                    break;
+                let next = reactiveObject(Object.getPrototypeOf(current));
+                if (next === current) {
+                    next = reactiveObject(Object.getPrototypeOf(unwrap(current)));
+                }
+                current = next;
+            }
+        }
+        const value = 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) {
+        // Read old value directly from unwrapped object to avoid triggering dependency tracking
+        const unwrappedObj = unwrap(obj);
+        const unwrappedReceiver = unwrap(receiver);
+        // Check if this property is marked as unreactive
+        if (unwrappedObj[unreactiveProperties]?.has(prop) || unwrappedObj !== unwrappedReceiver)
+            return 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;
+        if (Reflect.has(unwrappedReceiver, prop)) {
+            // Check descriptor on both receiver and target to handle proxy cases
+            const receiverDesc = Object.getOwnPropertyDescriptor(unwrappedReceiver, prop);
+            const targetDesc = Object.getOwnPropertyDescriptor(unwrappedObj, prop);
+            const desc = receiverDesc || targetDesc;
+            // We *need* to use `receiver` and not `unwrappedObj` here, otherwise we break
+            // the dependency tracking for memoized getters
+            if (desc?.get && !desc?.set) {
+                oldVal = untracked(() => Reflect.get(unwrappedObj, prop, receiver));
+            }
+            else {
+                oldVal = untracked(() => Reflect.get(unwrappedObj, 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)) {
+                notifyPropertyChange(obj, prop, oldVal, newValue, oldVal !== absent);
+            }
+        }
+        return true;
+    },
+    has(obj, prop) {
+        if (hasReentry.includes(obj))
+            throw new ReactiveError(`[reactive] Circular dependency detected in 'has' check for property '${String(prop)}'`, {
+                code: exports.ReactiveErrorCode.CycleDetected,
+                cycle: [], // We don't have the full cycle here, but we know it involves obj
+            });
+        hasReentry.push(obj);
+        dependant(obj, prop);
+        const rv = Reflect.has(obj, prop);
+        hasReentry.pop();
+        return rv;
+    },
+    deleteProperty(obj, prop) {
+        if (!Object.hasOwn(obj, prop))
+            return false;
+        const oldVal = obj[prop];
+        // Remove back-references if this object has deep watchers
+        if (objectsWithDeepWatchers.has(obj) && typeof oldVal === 'object' && oldVal !== null) {
+            removeBackReference(oldVal, obj, prop);
+        }
+        delete obj[prop];
+        touched1(obj, { type: 'del', prop }, prop);
+        // Bubble up changes if this object has deep watchers
+        if (objectsWithDeepWatchers.has(obj)) {
+            bubbleUpChange(obj);
+        }
+        return true;
+    },
+    ownKeys(obj) {
+        dependant(obj, allProps);
+        return Reflect.ownKeys(obj);
+    },
+};
+const reactiveClasses = new WeakSet();
+// Create the ReactiveBase mixin
+/**
+ * Base mixin for reactive classes that provides proper constructor reactivity
+ * Solves constructor reactivity issues in complex inheritance trees
+ */
+const ReactiveBase = mixin((base) => {
+    class ReactiveMixin extends base {
+        constructor(...args) {
+            super(...args);
+            // Only apply reactive transformation if the class is marked with @reactive
+            // This allows the mixin to work properly with method inheritance
+            // biome-ignore lint/correctness/noConstructorReturn: This is the whole point here
+            return reactiveClasses.has(new.target) ? reactive(this) : this;
+        }
+    }
+    return ReactiveMixin;
+});
+function reactiveObject(anyTarget) {
+    if (!anyTarget || typeof anyTarget !== 'object')
+        return anyTarget;
+    const target = anyTarget;
+    // If target is already a proxy, return it
+    if (isNonReactive(target))
+        return target;
+    const isProxy = proxyToObject.has(target);
+    if (isProxy)
+        return target;
+    // If we already have a proxy for this object, return it (optimized: get returns undefined if not found)
+    const existing = getExistingProxy(target);
+    if (existing !== undefined)
+        return existing;
+    const proxied = nativeReactive in target && !(target instanceof target[nativeReactive])
+        ? new target[nativeReactive](target)
+        : target;
+    if (proxied !== target)
+        trackProxyObject(proxied, target);
+    const proxy = new Proxy(proxied, reactiveHandlers);
+    // Store the relationships
+    storeProxyRelationship(target, proxy);
+    return proxy;
+}
+/**
+ * Main decorator for making classes reactive
+ * Automatically makes class instances reactive when created
+ */
+const reactive = decorator({
+    class(original) {
+        if (original.prototype instanceof ReactiveBase) {
+            reactiveClasses.add(original);
+            return original;
+        }
+        class Reactive extends original {
+            constructor(...args) {
+                super(...args);
+                if (new.target !== Reactive && !reactiveClasses.has(new.target))
+                    options.warn(`${original.name} has been inherited by ${this.constructor.name} that is not reactive.
+@reactive decorator must be applied to the leaf class OR classes have to extend ReactiveBase.`);
+                // biome-ignore lint/correctness/noConstructorReturn: This is the whole point here
+                return reactive(this);
+            }
+        }
+        Object.defineProperty(Reactive, 'name', {
+            value: `Reactive<${original.name}>`,
+        });
+        return Reactive;
+    },
+    get(original) {
+        return reactiveObject(original);
+    },
+    default: reactiveObject,
+});
+
+/**
+ * Displays a floating reactive panel in the browser showing the lineage of triggered effects.
+ */
+function showLineagePanel() {
+    if (typeof document === 'undefined')
+        return;
+    // Detect color scheme preference
+    const isDarkMode = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+    // Color schemes
+    const colors = isDarkMode ? {
+        panelBg: 'rgba(30, 30, 30, 0.95)',
+        panelBorder: '#444',
+        headerBg: '#8B4513',
+        headerText: '#ffffff',
+        closeBtn: '#ffffff',
+        placeholderText: '#999',
+        segmentBorder: '#8B4513',
+        titleText: '#ffffff',
+        frameText: '#ccc',
+        atText: '#888',
+        linkText: '#58a6ff',
+    } : {
+        panelBg: 'rgba(255, 255, 255, 0.95)',
+        panelBorder: '#ddd',
+        headerBg: '#704214',
+        headerText: '#ffffff',
+        closeBtn: '#ffffff',
+        placeholderText: '#666',
+        segmentBorder: '#704214',
+        titleText: '#222',
+        frameText: '#555',
+        atText: '#999',
+        linkText: '#005cc5',
+    };
+    const state = reactive({
+        activeLineage: [],
+        isVisible: true,
+    });
+    // Track the last triggered effect
+    /* TODO: this is really not how effect triggers work - `onEffectTrigger` is called when "this effect" (here nothing) is triggered
+    What we could try is to add events or such in zones... but it's really cosmetic and the whole panel is buggy - not worth doing yet (260206).
+    onEffectTrigger((_obj, _evol, _prop, effectTrigger) => {
+        state.activeLineage = getLineage(effectTrigger)
+    })*/
+    // UI Creation
+    const panel = document.createElement('div');
+    panel.id = 'mutts-lineage-panel';
+    Object.assign(panel.style, {
+        position: 'fixed',
+        bottom: '20px',
+        right: '20px',
+        width: '400px',
+        maxHeight: '80vh',
+        backgroundColor: colors.panelBg,
+        backdropFilter: 'blur(10px)',
+        border: `1px solid ${colors.panelBorder}`,
+        borderRadius: '12px',
+        boxShadow: '0 10px 25px rgba(0,0,0,0.15)',
+        zIndex: '999999',
+        fontFamily: 'Inter, system-ui, sans-serif',
+        fontSize: '12px',
+        display: 'flex',
+        flexDirection: 'column',
+        overflow: 'hidden',
+        transition: 'opacity 0.3s, transform 0.3s',
+    });
+    const header = document.createElement('div');
+    Object.assign(header.style, {
+        padding: '12px 16px',
+        background: colors.headerBg,
+        color: colors.headerText,
+        fontWeight: '600',
+        display: 'flex',
+        justifyContent: 'space-between',
+        alignItems: 'center',
+        cursor: 'grab',
+    });
+    header.innerHTML = '<span><span style="font-size: 14px; margin-right: 5px;">🦴</span> Mutts Lineage</span>';
+    const closeBtn = document.createElement('button');
+    closeBtn.innerText = '×';
+    Object.assign(closeBtn.style, {
+        background: 'none',
+        border: 'none',
+        color: colors.closeBtn,
+        fontSize: '20px',
+        cursor: 'pointer',
+        padding: '0 5px',
+    });
+    closeBtn.onclick = () => {
+        state.isVisible = false;
+    };
+    header.appendChild(closeBtn);
+    panel.appendChild(header);
+    const content = document.createElement('div');
+    Object.assign(content.style, {
+        padding: '16px',
+        overflowY: 'auto',
+        flex: '1',
+    });
+    panel.appendChild(content);
+    document.body.appendChild(panel);
+    // Reactivity: Update Visibility
+    effect(() => {
+        panel.style.opacity = state.isVisible ? '1' : '0';
+        panel.style.pointerEvents = state.isVisible ? 'all' : 'none';
+        panel.style.transform = state.isVisible ? 'translateY(0)' : 'translateY(20px)';
+    });
+    // Reactivity: Update Content
+    effect(() => {
+        if (state.activeLineage.length === 0) {
+            content.innerHTML = `<div style="color: ${colors.placeholderText}; font-style: italic; text-align: center; margin-top: 20px;">No effect triggered yet...</div>`;
+            return;
+        }
+        content.innerHTML = '';
+        state.activeLineage.forEach((segment, i) => {
+            const segDiv = document.createElement('div');
+            Object.assign(segDiv.style, {
+                marginBottom: '16px',
+                borderLeft: `2px solid ${colors.segmentBorder}`,
+                paddingLeft: '12px',
+            });
+            const title = document.createElement('div');
+            Object.assign(title.style, {
+                fontWeight: 'bold',
+                marginBottom: '6px',
+                color: colors.titleText,
+            });
+            title.innerText = i === 0 ? `📍 Current: ${segment.effectName}` : `↖ Effect: ${segment.effectName}`;
+            segDiv.appendChild(title);
+            segment.stack.forEach(frame => {
+                const frameDiv = document.createElement('div');
+                Object.assign(frameDiv.style, {
+                    color: colors.frameText,
+                    marginBottom: '3px',
+                    fontSize: '11px',
+                    whiteSpace: 'nowrap',
+                    overflow: 'hidden',
+                    textOverflow: 'ellipsis',
+                    cursor: 'pointer',
+                });
+                frameDiv.title = frame.raw;
+                frameDiv.innerHTML = `<span style="color: ${colors.atText}">at</span> ${frame.functionName} <span style="color: ${colors.linkText}; text-decoration: underline;">(${frame.fileName.split('/').pop()}:${frame.lineNumber})</span>`;
+                segDiv.appendChild(frameDiv);
+            });
+            content.appendChild(segDiv);
+        });
+    });
+}
+
+/**
+ * Debug utilities for the reactivity system
+ * - Captures effect metadata (names, parent relationships)
+ * - Records cause → consequence edges with object/prop labels
+ * - Provides graph data for tooling (DevTools panel, etc.)
+ */
+/**
+ * Log an error with detailed context if error logging is enabled
+ */
+function logError(error, context, effect) {
+    if (!debugOptions.logErrors)
+        return;
+    const contextStr = context === 'throw' ? '🔴 Thrown' : '🟡 Caught';
+    console.group(`${contextStr} Error: ${error.message}`);
+    console.error('Error:', error);
+    // Try to get effect name if available
+    if (effect && typeof effect === 'object' && effect.name) {
+        console.log('Effect:', effect.name);
+    }
+    console.groupEnd();
+}
+// Log initialization for debugging
+const EXTERNAL_SOURCE = Symbol('external-source');
+let devtoolsEnabled = false;
+// Registry for debugging (populated lazily when DevTools are enabled)
+const debugEffectRegistry = new Set();
+const debugObjectRegistry = new Set();
+// Human-friendly names
+const effectNames = new WeakMap();
+const objectNames = new WeakMap();
+let effectCounter = 0;
+let objectCounter = 0;
+// Debug options system
+const debugOptions = {
+    /**
+     * Whether DevTools are enabled
+     */
+    get enabled() {
+        return devtoolsEnabled;
+    },
+    logErrors: false
+};
+const triggerGraph = new Map();
+function ensureEffectName(effect) {
+    let name = effectNames.get(effect);
+    if (!name) {
+        const root = getRoot(effect);
+        name = root?.name?.trim() || `effect_${++effectCounter}`;
+        effectNames.set(effect, name);
+    }
+    return name;
+}
+function ensureObjectName(obj) {
+    let name = objectNames.get(obj);
+    if (!name) {
+        const ctorName = obj?.constructor?.name;
+        const base = ctorName && ctorName !== 'Object' ? ctorName : 'object';
+        name = `${base}_${++objectCounter}`;
+        objectNames.set(obj, name);
+    }
+    return name;
+}
+function describeProp(obj, prop) {
+    const objectName = ensureObjectName(obj);
+    if (prop === allProps)
+        return `${objectName}.*`;
+    if (typeof prop === 'symbol')
+        return `${objectName}.${prop.description ?? prop.toString()}`;
+    return `${objectName}.${String(prop)}`;
+}
+function addEffectToRegistry(effect) {
+    if (!effect || debugEffectRegistry.has(effect))
+        return;
+    debugEffectRegistry.add(effect);
+    const deps = exports.effectToReactiveObjects.get(effect);
+    if (deps) {
+        for (const obj of deps) {
+            documentObject(obj);
+        }
+    }
+}
+function documentObject(obj) {
+    if (!debugObjectRegistry.has(obj)) {
+        dbRegisterObject(obj);
+    }
+}
+function dbRegisterObject(obj) {
+    debugObjectRegistry.add(obj);
+    ensureObjectName(obj);
+}
+function ensureParentChains(effects) {
+    const queue = Array.from(effects);
+    for (let i = 0; i < queue.length; i++) {
+        const effect = queue[i];
+        const parent = getEffectNode(effect).parent;
+        if (parent && !effects.has(parent)) {
+            effects.add(parent);
+            queue.push(parent);
+        }
+    }
+}
+function ensureTriggerContainers(source) {
+    let targetMap = triggerGraph.get(source);
+    if (!targetMap) {
+        targetMap = new Map();
+        triggerGraph.set(source, targetMap);
+    }
+    return targetMap;
+}
+function ensureTriggerRecord(source, target, label, obj, prop, evolution) {
+    const targetMap = ensureTriggerContainers(source);
+    let labelMap = targetMap.get(target);
+    if (!labelMap) {
+        labelMap = new Map();
+        targetMap.set(target, labelMap);
+    }
+    let record = labelMap.get(label);
+    if (!record) {
+        record = { label, object: obj, prop, evolution, count: 0, lastTriggered: Date.now() };
+        labelMap.set(label, record);
+    }
+    return record;
+}
+/**
+ * Assign a debug-friendly name to an effect (shown in DevTools)
+ */
+function setEffectName(effect, name) {
+    effectNames.set(effect, name);
+}
+/**
+ * Assign a debug-friendly name to a reactive object
+ */
+function setObjectName(obj, name) {
+    objectNames.set(obj, name);
+    debugObjectRegistry.add(obj);
+}
+/**
+ * Register an effect so it appears in the DevTools graph
+ */
+function registerEffectForDebug(effect) {
+    if (!effect || !devtoolsEnabled)
+        return;
+    addEffectToRegistry(effect);
+}
+/**
+ * Register a reactive object so it appears in the DevTools graph
+ */
+function registerObjectForDebug(obj) {
+    if (!devtoolsEnabled)
+        return;
+    documentObject(obj);
+}
+/**
+ * Records a cause → consequence relationship between effects.
+ * @param source - The effect performing the write (undefined if external/user input)
+ * @param target - The effect that re-ran because of the write
+ * @param obj - The reactive object that changed
+ * @param prop - The property that changed
+ * @param evolution - The type of change (set/add/del/bunch)
+ */
+function recordTriggerLink(source, target, obj, prop, evolution) {
+    raiseEffectTrackers(target, obj, evolution, prop);
+    if (options.introspection.enableHistory) {
+        addToMutationHistory(source, target, obj, prop, evolution);
+    }
+    if (!devtoolsEnabled)
+        return;
+    addEffectToRegistry(target);
+    if (source)
+        addEffectToRegistry(source);
+    const descriptor = describeProp(obj, prop);
+    const record = ensureTriggerRecord(source ?? EXTERNAL_SOURCE, target, descriptor, obj, prop, evolution);
+    record.count += 1;
+    record.lastTriggered = Date.now();
+    documentObject(obj);
+}
+/**
+ * Traces back the chain of triggers that led to a specific effect
+ * @param effect The effect to trace back
+ * @param limit Max depth
+ */
+function getTriggerChain(effect, limit = 5) {
+    const chain = [];
+    let current = effect;
+    for (let i = 0; i < limit; i++) {
+        // Find who triggered 'current'
+        // We need to reverse search the triggerGraph (source -> target)
+        // This is expensive O(Edges) but okay for error reporting
+        let foundSource;
+        let foundReason = '';
+        search: for (const [source, targetMap] of triggerGraph) {
+            for (const [target, labelMap] of targetMap) {
+                if (target === current) {
+                    // Found a source! Use the most recent trigger record
+                    let lastTime = 0;
+                    for (const record of labelMap.values()) {
+                        if (record.lastTriggered > lastTime) {
+                            lastTime = record.lastTriggered;
+                            foundReason = record.label;
+                            foundSource = source === EXTERNAL_SOURCE ? undefined : source;
+                        }
+                    }
+                    if (foundSource || foundReason)
+                        break search;
+                }
+            }
+        }
+        if (foundSource) {
+            chain.push(`${ensureEffectName(foundSource)} -> (${foundReason}) -> ${ensureEffectName(current)}`);
+            current = foundSource;
+        }
+        else if (foundReason) {
+            chain.push(`External -> (${foundReason}) -> ${ensureEffectName(current)}`);
+            break;
+        }
+        else {
+            break;
+        }
+    }
+    return chain.reverse();
+}
+function buildEffectNodes(allEffects) {
+    const nodes = [];
+    const nodeByEffect = new Map();
+    const ordered = Array.from(allEffects);
+    for (const effect of ordered) {
+        const label = ensureEffectName(effect);
+        const node = {
+            id: `effect_${nodes.length}`,
+            label,
+            type: 'effect',
+            depth: 0,
+            debugName: label,
+        };
+        nodes.push(node);
+        nodeByEffect.set(effect, node);
+    }
+    const depthCache = new Map();
+    const computeDepth = (effect) => {
+        if (!effect)
+            return 0;
+        const cached = depthCache.get(effect);
+        if (cached !== undefined)
+            return cached;
+        const parent = getEffectNode(effect).parent;
+        const depth = computeDepth(parent) + (parent ? 1 : 0);
+        depthCache.set(effect, depth);
+        return depth;
+    };
+    for (const [effect, node] of nodeByEffect) {
+        node.depth = computeDepth(effect);
+        const parent = getEffectNode(effect).parent;
+        if (parent) {
+            const parentNode = nodeByEffect.get(parent);
+            if (parentNode) {
+                node.parentId = parentNode.id;
+            }
+        }
+    }
+    return { nodes, nodeByEffect };
+}
+/**
+ * Builds a graph representing current reactive state (effects, objects, and trigger edges)
+ */
+function buildReactivityGraph() {
+    const nodes = [];
+    const edges = [];
+    const nodeIds = new Map();
+    const allEffects = new Set(debugEffectRegistry);
+    ensureParentChains(allEffects);
+    const { nodes: effectNodes, nodeByEffect } = buildEffectNodes(allEffects);
+    for (const node of effectNodes)
+        nodes.push(node);
+    for (const [effect, node] of nodeByEffect) {
+        nodeIds.set(effect, node.id);
+    }
+    // Object nodes (optional, used for dependency inspection)
+    for (const obj of debugObjectRegistry) {
+        const id = `object_${nodes.length}`;
+        nodes.push({ id, label: ensureObjectName(obj), type: 'state', debugName: objectNames.get(obj) });
+        nodeIds.set(obj, id);
+    }
+    // External source node (user/system outside of effects)
+    if (triggerGraph.has(EXTERNAL_SOURCE)) {
+        const externalId = `effect_external`;
+        nodes.push({ id: externalId, label: 'External', type: 'external', depth: 0 });
+        nodeIds.set(EXTERNAL_SOURCE, externalId);
+    }
+    // Dependency edges (effect → object)
+    for (const effect of allEffects) {
+        const effectId = nodeIds.get(effect);
+        if (!effectId)
+            continue;
+        const deps = exports.effectToReactiveObjects.get(effect);
+        if (!deps)
+            continue;
+        for (const obj of deps) {
+            const objId = nodeIds.get(obj);
+            if (!objId)
+                continue;
+            edges.push({
+                id: `${effectId}->${objId}`,
+                source: effectId,
+                target: objId,
+                type: 'dependency',
+                label: 'depends',
+            });
+        }
+    }
+    // Cause edges (effect/object/prop → effect)
+    for (const [source, targetMap] of triggerGraph) {
+        for (const [targetEffect, labelMap] of targetMap) {
+            const targetId = nodeIds.get(targetEffect);
+            if (!targetId)
+                continue;
+            const sourceId = nodeIds.get(source);
+            if (!sourceId)
+                continue;
+            for (const record of labelMap.values()) {
+                edges.push({
+                    id: `${sourceId}->${targetId}:${record.label}`,
+                    source: sourceId,
+                    target: targetId,
+                    type: 'cause',
+                    label: record.count > 1 ? `${record.label} (${record.count})` : record.label,
+                    count: record.count,
+                });
+            }
+        }
+    }
+    return {
+        nodes,
+        edges,
+        meta: {
+            generatedAt: Date.now(),
+            devtoolsEnabled,
+        },
+    };
+}
+/**
+ * Enables the DevTools bridge and exposes the debug API on window/global.
+ * Call as early as possible in development builds.
+ */
+function enableDevTools() {
+    const globalScope = (typeof globalThis !== 'undefined'
+        ? globalThis
+        : typeof window !== 'undefined'
+            ? window
+            : typeof global !== 'undefined'
+                ? global
+                : undefined);
+    if (!globalScope)
+        return;
+    if (devtoolsEnabled)
+        return;
+    devtoolsEnabled = true;
+    globalScope.__MUTTS_DEVTOOLS__ = {
+        getGraph: buildReactivityGraph,
+        nodeLineage(tag) {
+            nodeLineage(getLineage());
+            return '🦴 Effect Lineage Trace' + (tag ? ` (${tag})` : '');
+        },
+        nodeLineageLegacy() {
+            console.groupCollapsed('nodeLineageLegacy');
+            console.log(nodeLineageLegacy(getLineage()));
+            console.groupEnd();
+        },
+        get browserLineage() {
+            return wrapLineageForDebug(getLineage());
+        },
+        getLineage,
+        captureLineage: getStackFrame,
+        formatLineage,
+        showLineagePanel,
+        setEffectName,
+        setObjectName,
+        registerEffect: registerEffectForDebug,
+        registerObject: registerObjectForDebug,
+        // Debug options for controlling runtime behavior
+        debug: debugOptions
+    };
+    // @ts-ignore - devtoolsFormatters is a Chrome-specific array
+    if (globalScope.devtoolsFormatters) {
+        globalScope.devtoolsFormatters.push(lineageFormatter);
+    }
+    else {
+        globalScope.devtoolsFormatters = [lineageFormatter];
+    }
+}
+function forceEnableGraphTracking() {
+    devtoolsEnabled = true;
+}
+function isDevtoolsEnabled() {
+    return devtoolsEnabled;
+}
+// --- Introspection API ---
+/**
+ * Returns the raw dependency graph data structure.
+ * This is useful for programmatic analysis of the reactive system.
+ */
+function getDependencyGraph() {
+    return {
+        nodes: buildReactivityGraph().nodes,
+        edges: buildReactivityGraph().edges,
+    };
+}
+/**
+ * Returns a list of effects that depend on the given object.
+ */
+function getDependents(obj) {
+    const dependents = [];
+    // Scan the trigger graph for effects triggered by this object
+    // This is O(E) where E is the number of edges, might need optimization for large graphs
+    // but acceptable for introspection
+    for (const [_source, targetMap] of triggerGraph) {
+        for (const [targetEffect, labelMap] of targetMap) {
+            for (const record of labelMap.values()) {
+                if (record.object === obj) {
+                    dependents.push(targetEffect);
+                }
+            }
+        }
+    }
+    // Also check direct dependencies (dependency graph)
+    // We don't have a direct obj -> effect map without walking all effects
+    // unless we use `watchers` from tracking.ts but that's internal
+    return [...new Set(dependents)];
+}
+/**
+ * Returns a list of objects that the given effect depends on.
+ */
+function getDependencies(effect) {
+    const deps = exports.effectToReactiveObjects.get(effect);
+    return deps ? Array.from(deps) : [];
+}
+const mutationHistory = [];
+let mutationCounter = 0;
+function addToMutationHistory(source, target, obj, prop, evolution) {
+    const record = {
+        id: ++mutationCounter,
+        timestamp: Date.now(),
+        source: source ? ensureEffectName(source) : 'External',
+        target: ensureEffectName(target),
+        objectName: ensureObjectName(obj),
+        prop: String(prop),
+        type: evolution.type,
+    };
+    mutationHistory.push(record);
+    if (mutationHistory.length > options.introspection.historySize) {
+        mutationHistory.shift();
+    }
+}
+/**
+ * Get the recent mutation history
+ */
+function getMutationHistory() {
+    return [...mutationHistory];
+}
+// --- Auto DevTools Initialization ---
+// Automatically enable devtools in development environments
+/**
+ * Checks if we're in a development environment
+ * Detection order:
+ * 1. process.env.NODE_ENV (Node.js)
+ * 2. import.meta.env.DEV (Vite)
+ * 3. import.meta.env.PROD === false (Vite alternative)
+ * 4. Assumes development if none of the above are set (safe default)
+ */
+function isDevelopmentMode() {
+    // Check for explicit production flag first
+    if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'production') {
+        return false;
+    }
+    // Check for Vite's DEV flag
+    if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-VTO-b2vR.cjs', document.baseURI).href)) }) !== 'undefined') {
+        const meta = ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-VTO-b2vR.cjs', document.baseURI).href)) });
+        if (meta.env?.PROD === true) {
+            return false;
+        }
+        if (meta.env?.DEV === true) {
+            return true;
+        }
+    }
+    // Check for custom global override
+    if (typeof globalThis !== 'undefined' && '__MUTTS_DEV_MODE__' in globalThis) {
+        return globalThis.__MUTTS_DEV_MODE__ !== false;
+    }
+    // Default to development (safer to enable in dev than disable in prod)
+    return true;
+}
+// Auto-enable devtools when the module loads in development
+if (isDevelopmentMode() && !devtoolsEnabled) {
+    enableDevTools();
+    // Optional: Log that devtools were enabled (only in development)
+    if (typeof console !== 'undefined' && console.info) {
+        // Do not log these in when mode === 'test'
+        console.info('🦴 Mutts DevTools enabled automatically in development mode');
+    }
+}
+
+/**
+ * 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 || 'anonymous';
+        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: effectName,
+            });
+        }
+        options.warn(`[reactive] ${message}`);
+    }
+}
+/**
+ * Registers a debug callback that is called when the current effect is triggered by a dependency change
+ *
+ * This function is useful for debugging purposes as it pin-points exactly which reactive property
+ * change triggered the effect. The callback receives information about:
+ * - The object that changed
+ * - The type of change (evolution)
+ * - The specific property that changed
+ *
+ * **Note:** The tracker callback is automatically removed after being called once. If you need
+ * to track multiple triggers, call `onEffectTrigger` again within the effect.
+ *
+ * @param onTouch - Callback function that receives (obj, evolution, prop) when the effect is triggered
+ * @throws {Error} If called outside of an effect context
+ *
+ * @example
+ * ```typescript
+ * const state = reactive({ count: 0, name: 'John' })
+ *
+ * effect(() => {
+ *   // Register a tracker to see what triggers this effect
+ *   onEffectTrigger((obj, evolution, prop) => {
+ *     console.log(`Effect triggered by:`, {
+ *       object: obj,
+ *       change: evolution.type,
+ *       property: prop
+ *     })
+ *   })
+ *
+ *   // Access reactive properties
+ *   console.log(state.count, state.name)
+ * })
+ *
+ * state.count = 5
+ * ```
+ */
+function onEffectTrigger(onTouch, effect) {
+    effect ?? (effect = getActiveEffect());
+    if (!effect)
+        throw new Error('Tracking an effect trigger while not in an effect');
+    const node = getEffectNode(effect);
+    if (!node.trackers)
+        node.trackers = [onTouch];
+    else
+        node.trackers.push(onTouch);
+}
+function raiseEffectTrackers(effect, obj, evolution, prop) {
+    const node = getEffectNode(effect);
+    const trackers = node.trackers;
+    if (trackers) {
+        for (const tracker of trackers)
+            tracker(obj, evolution, prop, effect);
+    }
+}
+function onEffectThrow(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);
+}
+// 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`
+let batchQueue;
+function hasBatched(effect) {
+    return batchQueue?.all.has(getRoot(effect));
+}
+const batchCleanups = new Set();
+/**
+ * Computes and caches in-degrees for all effects in the batch
+ * Called once when batch starts or when new effects are added
+ */
+function computeAllInDegrees(batch) {
+    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) {
+    const node = getEffectNode(effect);
+    node.cleanup?.();
+    // If the effect was stopped during cleanup (e.g. lazy memoization), don't add it to the batch
+    if (node.stopped) {
+        // console.log(`[DEBUG] addToBatch: ${effect.name} is stopped`)
+        return;
+    }
+    if (!batchQueue) {
+        // console.log(`[DEBUG] addToBatch: no batchQueue`)
+        return;
+    }
+    const root = getRoot(effect);
+    // 1. Add to batch first (needed for cycle detection)
+    if (options.cycleHandling === 'production') {
+        // Production mode: FIFO (delete and re-add to move to end)
+        if (batchQueue.all.has(root)) {
+            batchQueue.all.delete(root);
+        }
+        batchQueue.all.set(root, effect);
+    }
+    else {
+        // Dev/Debug mode: Set if not present (preserve order?)
+        // actually, we might want to update it?
+        // For now, simple set
+        if (batchQueue.all.has(root)) {
+            // console.log(`[DEBUG] ${root.name} already in batch`)
+            return;
+        }
+        batchQueue.all.set(root, effect);
+        // console.log(`[DEBUG] ${root.name} added to batch`)
+    }
+    // batchQueue.all.set(root, effect)
+    // console.log(`[DEBUG] addToBatch: ${root.name} added to batch`)
+    if (caller && !immediate && 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)`;
+            batchQueue.all.delete(root);
+            const causalChain = getTriggerChain(effect);
+            const creationStack = getEffectNode(effect).creationStack;
+            throw new ReactiveError(`[reactive] ${cycleMessage}`, {
+                code: exports.ReactiveErrorCode.CycleDetected,
+                cycle: cyclePath.map((r) => r.name || r.toString()),
+                details: cycleMessage,
+                causalChain,
+                creationStack,
+            });
+        }
+        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) {
+    if (!batchQueue)
+        cleanup();
+    else
+        batchCleanups.add(cleanup);
+}
+/**
+ * Semantic alias for `addBatchCleanup` - defers work to the end of the current reactive batch.
+ *
+ * Use this when an effect needs to perform an action that would modify state the effect depends on,
+ * which would create a reactive cycle. The deferred callback runs after all effects complete.
+ *
+ * @param callback - The callback to defer until after the current batch completes
+ *
+ * @example
+ * ```typescript
+ * effect(() => {
+ *   processData()
+ *
+ *   // Defer to avoid cycle (createMovement modifies state this effect reads)
+ *   defer(() => {
+ *     createMovement(data)
+ *   })
+ * })
+ * ```
+ */
+const defer = addBatchCleanup;
+/**
+ * Gets a cycle path for debugging
+ * Uses DFS to find cycles in the batch
+ * @param batchQueue - The batch queue
+ * @returns Array of effect roots forming a cycle
+ */
+function getCyclePath(batchQueue) {
+    // If all effects have in-degree > 0, there must be a cycle
+    // Use DFS to find it
+    const visited = new Set();
+    const recursionStack = new Set();
+    const path = [];
+    for (const [root] of batchQueue.all) {
+        if (visited.has(root))
+            continue;
+        const cycle = findCycle(root, visited, recursionStack, path, batchQueue);
+        if (cycle.length > 0) {
+            return cycle;
+        }
+    }
+    return [];
+}
+function findCycle(root, visited, recursionStack, path, batchQueue) {
+    if (recursionStack.has(root)) {
+        // Found a cycle! Return the path from the cycle start to root
+        const cycleStart = path.indexOf(root);
+        return path.slice(cycleStart).concat([root]);
+    }
+    if (visited.has(root)) {
+        return [];
+    }
+    visited.add(root);
+    recursionStack.add(root);
+    path.push(root);
+    // Follow edges to effects in the batch
+    // Use direct edges (effectTriggers) for cycle detection
+    const triggers = effectTriggers.get(root);
+    if (triggers) {
+        for (const targetRoot of triggers) {
+            if (batchQueue.all.has(targetRoot)) {
+                const cycle = findCycle(targetRoot, visited, recursionStack, path, batchQueue);
+                if (cycle.length > 0) {
+                    return cycle;
+                }
+            }
+        }
+    }
+    path.pop();
+    recursionStack.delete(root);
+    return [];
+}
+/**
+ * Executes the next effect in dependency order (using cached in-degrees)
+ * Finds an effect with in-degree 0 and executes it
+ * @returns The return value of the executed effect, or null if batch is complete
+ */
+function executeNext(effectuatedRoots) {
+    // Find an effect with in-degree 0 using cached values
+    let nextEffect = null;
+    let nextRoot = null;
+    if (options.cycleHandling === 'production') {
+        // In flat mode, we just take the first effect in the queue (FIFO)
+        const first = batchQueue.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 batchQueue.all) {
+            const inDegree = batchQueue.inDegrees.get(root) ?? 0;
+            // console.log(`[DEBUG] executeNext: checking ${root.name}, inDegree: ${inDegree}`)
+            if (inDegree === 0) {
+                nextEffect = effect;
+                nextRoot = root;
+                break;
+            }
+        }
+    }
+    if (!nextEffect) {
+        // No effect with in-degree 0 - there must be a cycle
+        // If all effects have dependencies, it means there's a circular dependency
+        if (batchQueue.all.size > 0) {
+            let cycle = getCyclePath(batchQueue);
+            // If we couldn't find a cycle path using direct edges, try using closures
+            // (transitive relationships) - if all effects have in-degree > 0, there must be a cycle
+            if (cycle.length === 0) {
+                // Try to find a cycle using consequencesClosure (transitive relationships)
+                // Note: Self-loops are ignored - we only look for cycles between different effects
+                for (const [root] of batchQueue.all) {
+                    const consequences = consequencesClosure.get(root);
+                    if (consequences) {
+                        // Check if any consequence in the batch also has root as a consequence
+                        for (const consequence of consequences) {
+                            // Skip self-loops - they are ignored
+                            if (consequence === root)
+                                continue;
+                            if (batchQueue.all.has(consequence)) {
+                                const consequenceConsequences = consequencesClosure.get(consequence);
+                                if (consequenceConsequences?.has(root)) {
+                                    // Found cycle: root -> consequence -> root
+                                    cycle = [root, consequence, root];
+                                    break;
+                                }
+                            }
+                        }
+                        if (cycle.length > 0)
+                            break;
+                    }
+                }
+            }
+            const cycleMessage = cycle.length > 0
+                ? `Cycle detected: ${cycle.map((r) => r.name || '<anonymous>').join(' → ')}`
+                : 'Cycle detected in effect batch - all effects have dependencies that prevent execution';
+            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
+    const result = nextEffect();
+    // Remove from batch and update in-degrees of dependents
+    batchQueue.all.delete(nextRoot);
+    batchQueue.inDegrees.delete(nextRoot);
+    decrementInDegreesForExecuted(batchQueue, nextRoot);
+    return result;
+}
+// Track which sub-effects have been executed to prevent infinite loops
+// These are all the effects triggered under `activeEffect` and all their sub-effects
+function batch(effect, immediate) {
+    if (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);
+    try {
+        if (batchQueue) {
+            // Nested batch - add to existing
+            options?.chain(roots, getRoot(getActiveEffect()));
+            const caller = getActiveEffect();
+            for (let i = 0; i < effect.length; i++)
+                addToBatch(effect[i], caller, immediate === 'immediate');
+            if (immediate) {
+                const firstReturn = {};
+                // Execute immediately (before batch returns)
+                for (let i = 0; i < effect.length; i++) {
+                    try {
+                        const rv = effect[i]();
+                        if (rv !== undefined && !('value' in firstReturn))
+                            firstReturn.value = rv;
+                    }
+                    finally {
+                        const root = getRoot(effect[i]);
+                        batchQueue.all.delete(root);
+                    }
+                }
+                return firstReturn.value;
+            }
+            // Otherwise, effects will be picked up in next executeNext() call
+        }
+        else {
+            // New batch - initialize
+            if (!activationRegistry)
+                activationRegistry = new Map();
+            else
+                throw new Error('Batch already in progress');
+            optionCall('beginChain', roots);
+            batchQueue = {
+                all: new Map(),
+                inDegrees: new Map(),
+            };
+            const caller = getActiveEffect();
+            const effectuatedRoots = [];
+            const firstReturn = {};
+            let success = false;
+            try {
+                if (immediate) {
+                    // Execute initial effects in providing order
+                    for (let i = 0; i < effect.length; i++) {
+                        try {
+                            const rv = effect[i]();
+                            if (rv !== undefined && !('value' in firstReturn))
+                                firstReturn.value = rv;
+                        }
+                        finally {
+                            batchQueue.all.delete(getRoot(effect[i]));
+                        }
+                    }
+                }
+                else {
+                    // Add initial effects to batch and compute dependencies
+                    const len = effect.length;
+                    for (let i = 0; i < len; i++) {
+                        addToBatch(effect[i], caller, false);
+                    }
+                    computeAllInDegrees(batchQueue);
+                }
+                // Process the batch
+                while (batchQueue.all.size > 0 || batchCleanups.size > 0) {
+                    if (batchQueue.all.size > 0) {
+                        if (effectuatedRoots.length > options.maxEffectChain) {
+                            const cycle = findCycleInChain(effectuatedRoots);
+                            const trace = formatRoots(effectuatedRoots);
+                            const message = cycle
+                                ? `Max effect chain reached (cycle detected: ${formatRoots(cycle)})`
+                                : `Max effect chain reached (trace: ${trace})`;
+                            const queuedRoots = batchQueue ? Array.from(batchQueue.all.keys()) : [];
+                            const queued = queuedRoots.map((r) => r.name || '<anonymous>');
+                            const debugInfo = {
+                                code: exports.ReactiveErrorCode.MaxDepthExceeded,
+                                effectuatedRoots,
+                                cycle,
+                                trace,
+                                maxEffectChain: options.maxEffectChain,
+                                queued: queued.slice(0, 50),
+                                queuedCount: queued.length,
+                                // Try to get causation for the last effect
+                                causalChain: effectuatedRoots.length > 0
+                                    ? getTriggerChain(batchQueue.all.get(effectuatedRoots[effectuatedRoots.length - 1]))
+                                    : [],
+                            };
+                            switch (options.maxEffectReaction) {
+                                case 'throw':
+                                    throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                                case 'debug':
+                                    // biome-ignore lint/suspicious/noDebugger: This is the whole point here
+                                    debugger;
+                                    throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                                case 'warn':
+                                    options.warn(`[reactive] ${message} (queued: ${queued.slice(0, 10).join(', ')}${queued.length > 10 ? ', …' : ''})`);
+                                    break;
+                            }
+                        }
+                        const rv = executeNext(effectuatedRoots);
+                        if (rv !== undefined && !('value' in firstReturn))
+                            firstReturn.value = rv;
+                    }
+                    else {
+                        // Process cleanups. If they trigger more effects, they will be caught in the next iteration.
+                        const cleanups = Array.from(batchCleanups);
+                        batchCleanups.clear();
+                        for (const cleanup of cleanups)
+                            cleanup();
+                        // In immediate mode, we traditionally don't process recursive effects from cleanups.
+                        // If we want to keep that behavior: if (immediate) break
+                    }
+                }
+                success = true;
+            }
+            finally {
+                if (!success)
+                    panicThrow();
+                activationRegistry = undefined;
+                batchQueue = undefined;
+                batchCleanups.clear();
+                optionCall('endChain');
+            }
+            return firstReturn.value;
+        }
+    }
+    finally {
+    }
+}
+function panicThrow() {
+    broken = true;
+}
+/**
+ * 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;
+    batchQueue = undefined;
+    batchCleanups.clear();
+    effectTriggers = new WeakMap();
+    effectTriggeredBy = new WeakMap();
+    causesClosure = new WeakMap();
+    consequencesClosure = new WeakMap();
+    resetRegistry();
+    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');
+        };
+    },
+});
+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(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());
+            }
+            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;
+        optionCall('enter', getRoot(fn));
+        let reactionCleanup;
+        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)));
+            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;
+        }
+        finally {
+            access.reaction = true;
+        }
+        // Create cleanup function for next run
+        node.cleanup = () => {
+            node.cleanup = undefined;
+            reactionCleanup?.();
+            reactionCleanup = undefined;
+            delete node.trackers;
+            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) {
+                for (const childCleanup of children)
+                    childCleanup();
+                delete node.children;
+            }
+        };
+        // Define bubbling thrower
+        thrower = (error) => {
+            const catches = node.catchers;
+            if (catches)
+                while (caught < catches.length) {
+                    reactionCleanup?.(error);
+                    reactionCleanup = undefined;
+                    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 (isDevtoolsEnabled()) {
+        const stack = getStackFrame(); // Robustly skips internal mutts frames
+        if (stack.length > 0) {
+            node.creationStack = stack;
+        }
+    }
+    const tracked = named(effectMarker.leave, 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 (isDevtoolsEnabled()) {
+        registerEffectForDebug(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 = () => {
+        if (effectStopped)
+            return;
+        effectStopped = true;
+        node.stopped = true;
+        // Cancel any running async work
+        if (cancelPrevious) {
+            cancelPrevious();
+            cancelPrevious = null;
+            runningPromise = null;
+        }
+        try {
+            node.cleanup?.();
+        }
+        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(() => stopEffect());
+        fr.register(callIfCollected, () => {
+            stopEffect();
+            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(() => {
+            children.delete(subEffectCleanup);
+            // Execute this child effect cleanup (which triggers its own mainCleanup)
+            stopEffect();
+        });
+        children.add(subEffectCleanup);
+        return subEffectCleanup;
+    }
+    // Should not be reachable given isRootEffect check, but for type safety
+    return augmentedRv(stopEffect);
+}, {
+    get opaque() {
+        return flavorOptions(this, { opaque: true }, 'opaque');
+    },
+    named(name) {
+        return flavorOptions(this, { 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);
+        })
+        : () => { };
+}
+
+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.arrayEquals = arrayEquals;
+exports.asyncZone = asyncZone;
+exports.atomic = atomic;
+exports.biDi = biDi;
+exports.buildReactivityGraph = buildReactivityGraph;
+exports.captureNodeLineage = captureNodeLineage;
+exports.cleanedBy = cleanedBy;
+exports.cleanup = cleanup;
+exports.contentRef = contentRef;
+exports.createFlavor = createFlavor;
+exports.debugOptions = debugOptions;
+exports.decorator = decorator;
+exports.deepCompare = deepCompare;
+exports.deepWatchers = deepWatchers;
+exports.defer = defer;
+exports.dependant = dependant;
+exports.derived = derived;
+exports.effect = effect;
+exports.effectAggregator = effectAggregator;
+exports.effectMarker = effectMarker;
+exports.effectToDeepWatchedObjects = effectToDeepWatchedObjects;
+exports.enableDevTools = enableDevTools;
+exports.flavorOptions = flavorOptions;
+exports.flavored = flavored;
+exports.forceEnableGraphTracking = forceEnableGraphTracking;
+exports.formatLineage = formatLineage;
+exports.getActivationLog = getActivationLog;
+exports.getActiveEffect = getActiveEffect;
+exports.getDependencies = getDependencies;
+exports.getDependencyGraph = getDependencyGraph;
+exports.getDependents = getDependents;
+exports.getLineage = getLineage;
+exports.getMutationHistory = getMutationHistory;
+exports.getRoot = getRoot;
+exports.getStackFrame = getStackFrame;
+exports.getState = getState;
+exports.getTriggerChain = getTriggerChain;
+exports.immutables = immutables;
+exports.isConstructor = isConstructor;
+exports.isDevtoolsEnabled = isDevtoolsEnabled;
+exports.isNonReactive = isNonReactive;
+exports.isOwnAccessor = isOwnAccessor;
+exports.isReactive = isReactive;
+exports.legacyDecorator = legacyDecorator;
+exports.lineageFormatter = lineageFormatter;
+exports.logError = logError;
+exports.markWithRoot = markWithRoot;
+exports.metaProtos = metaProtos;
+exports.mixin = mixin;
+exports.modernDecorator = modernDecorator;
+exports.named = named;
+exports.nodeLineage = nodeLineage;
+exports.nodeLineageLegacy = nodeLineageLegacy;
+exports.nonReactiveClass = nonReactiveClass;
+exports.nonReactiveMark = nonReactiveMark;
+exports.nonReactiveObjects = nonReactiveObjects;
+exports.notifyPropertyChange = notifyPropertyChange;
+exports.objectParents = objectParents;
+exports.objectToProxy = objectToProxy;
+exports.objectsWithDeepWatchers = objectsWithDeepWatchers;
+exports.onEffectThrow = onEffectThrow;
+exports.onEffectTrigger = onEffectTrigger;
+exports.optionCall = optionCall;
+exports.options = options;
+exports.parseStackLine = parseStackLine;
+exports.projectionInfo = projectionInfo;
+exports.proxyToObject = proxyToObject;
+exports.reactive = reactive;
+exports.recordTriggerLink = recordTriggerLink;
+exports.registerEffectForDebug = registerEffectForDebug;
+exports.registerNativeReactivity = registerNativeReactivity;
+exports.registerObjectForDebug = registerObjectForDebug;
+exports.renamed = renamed;
+exports.reset = reset;
+exports.root = root;
+exports.rootFunction = rootFunction;
+exports.setEffectName = setEffectName;
+exports.setObjectName = setObjectName;
+exports.showLineagePanel = showLineagePanel;
+exports.stopped = stopped;
+exports.tag = tag;
+exports.touched = touched;
+exports.touched1 = touched1;
+exports.unreactiveProperties = unreactiveProperties;
+exports.untracked = untracked;
+exports.unwrap = unwrap;
+exports.wrapLineageForDebug = wrapLineageForDebug;
+exports.zip = zip;
+//# sourceMappingURL=index-VTO-b2vR.cjs.map