mutts 1.0.8 → 1.0.9

package/dist/chunks/index-CtA2AWl3.esm.js

@@ -0,0 +1,4376 @@
+// Queue for hooks registered before the environment is ready (circular dependency fix)
+const hooks = new Set();
+const asyncHooks = {
+    addHook(hook) {
+        hooks.add(hook);
+        return () => hooks.delete(hook);
+    },
+    /**
+     * [Hack] Sanitize a promise (or value) to prevent context leaks.
+     * Default: Identity function.
+     * Browser: Uses Macrotask wrapping to break microtask chains.
+     */
+    sanitizePromise(p) {
+        return p;
+    },
+};
+/**
+ * Register a hook that will be called whenever an asynchronous operation is initiated.
+ * The hook should return a restorer function which will be called just before the async callback runs.
+ * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
+ */
+const asyncHook = (hook) => asyncHooks.addHook(hook);
+
+/**
+ * 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
+ */
+var ReactiveErrorCode;
+(function (ReactiveErrorCode) {
+    ReactiveErrorCode["CycleDetected"] = "CYCLE_DETECTED";
+    ReactiveErrorCode["MaxDepthExceeded"] = "MAX_DEPTH_EXCEEDED";
+    ReactiveErrorCode["MaxReactionExceeded"] = "MAX_REACTION_EXCEEDED";
+    ReactiveErrorCode["WriteInComputed"] = "WRITE_IN_COMPUTED";
+    ReactiveErrorCode["TrackingError"] = "TRACKING_ERROR";
+    ReactiveErrorCode["BrokenEffects"] = "BROKEN_EFFECTS";
+})(ReactiveErrorCode || (ReactiveErrorCode = {}));
+/**
+ * Error class for reactive system errors
+ */
+class ReactiveError extends Error {
+    constructor(message, debugInfo) {
+        super(message);
+        this.debugInfo = debugInfo;
+        this.name = 'ReactiveError';
+    }
+    get code() {
+        return this.debugInfo?.code;
+    }
+    get cause() {
+        return this.debugInfo?.cause;
+    }
+}
+// biome-ignore-start lint/correctness/noUnusedFunctionParameters: Interface declaration with empty defaults
+/**
+ * Global options for the reactive system
+ */
+const options = {
+    /**
+     * Debug purpose: called when an effect is entered
+     * @param effect - The effect that is entered
+     */
+    enter: (_effect) => { },
+    /**
+     * Debug purpose: called when an effect is left
+     * @param effect - The effect that is left
+     */
+    leave: (_effect) => { },
+    /**
+     * Debug purpose: called when an effect is chained
+     * @param target - The effect that is being triggered
+     * @param caller - The effect that is calling the target
+     */
+    chain: (_targets, _caller) => { },
+    /**
+     * Debug purpose: called when an effect chain is started
+     * @param target - The effect that is being triggered
+     */
+    beginChain: (_targets) => { },
+    /**
+     * Debug purpose: called when an effect chain is ended
+     */
+    endChain: () => { },
+    garbageCollected: (_fn) => { },
+    /**
+     * Debug purpose: called when an object is touched
+     * @param obj - The object that is touched
+     * @param evolution - The type of change
+     * @param props - The properties that changed
+     * @param deps - The dependencies that changed
+     */
+    touched: (_obj, _evolution, _props, _deps) => { },
+    /**
+     * Debug purpose: called when an effect is skipped because it's already running
+     * @param effect - The effect that is already running
+     * @param runningChain - The array of effects from the detected one to the currently running one
+     */
+    skipRunningEffect: (_effect) => { },
+    /**
+     * Debug purpose: maximum effect chain (like call stack max depth)
+     * Used to prevent infinite loops
+     * @default 100
+     */
+    maxEffectChain: 100,
+    /**
+     * Maximum number of times an effect can be triggered by the same cause in a single batch
+     * Used to detect aggressive re-computation or infinite loops
+     * @default 10
+     */
+    maxTriggerPerBatch: 10,
+    /**
+     * Debug purpose: maximum effect reaction (like call stack max depth)
+     * Used to prevent infinite loops
+     * @default 'throw'
+     */
+    maxEffectReaction: 'throw',
+    /**
+     * Callback called when a memoization discrepancy is detected (debug only)
+     * When defined, memoized functions will run a second time (untracked) to verify consistency.
+     * If the untracked run returns a different value than the cached one, this callback is triggered.
+     *
+     * This is the primary tool for detecting missing reactive dependencies in computed values.
+     *
+     * @param cached - The value currently in the memoization cache
+     * @param fresh - The value obtained by re-running the function untracked
+     * @param fn - The memoized function itself
+     * @param args - Arguments passed to the function
+     *
+     * @example
+     * ```typescript
+     * reactiveOptions.onMemoizationDiscrepancy = (cached, fresh, fn, args) => {
+     *   throw new Error(`Memoization discrepancy in ${fn.name}!`);
+     * };
+     * ```
+     */
+    onMemoizationDiscrepancy: undefined,
+    /**
+     * How to handle cycles detected in effect batches.
+     *
+     * - `'production'` (Default): High-performance mode. Disables dependency graph maintenance and
+     *   Topological Sorting in favor of a simple FIFO queue. Use this for trustworthy, acyclic UI code.
+     *   Cycle detection is heuristic (uses maxEffectChain execution counts).
+     *
+     * - `'development'`: Maintains direct dependency graph for early cycle detection during edge creation.
+     *   Catches cycles before effects execute via DFS check when adding edges. Throws immediately with
+     *   basic path information. Good balance of debugging help with moderate overhead.
+     *
+     * - `'debug'`: Full diagnostic mode with transitive closures and topological sorting.
+     *   Provides detailed cycle path reporting. Highest overhead but most informative for bug hunting.
+     *
+     * @default 'production'
+     */
+    cycleHandling: 'development',
+    /**
+     * Internal flag used by memoization discrepancy detector to avoid counting calls in tests
+     * @warning Do not modify this flag manually, this flag is given by the engine
+     */
+    isVerificationRun: false,
+    /**
+     * Maximum depth for deep watching traversal
+     * Used to prevent infinite recursion in circular references
+     * @default 100
+     */
+    maxDeepWatchDepth: 100,
+    /**
+     * Only react on instance members modification (not inherited properties)
+     * For instance, do not track class methods
+     * @default true
+     */
+    instanceMembers: true,
+    /**
+     * Ignore accessors (getters and setters) and only track direct properties
+     * @default true
+     */
+    ignoreAccessors: true,
+    /**
+     * Enable recursive touching when objects with the same prototype are replaced
+     * When enabled, replacing an object with another of the same prototype triggers
+     * recursive diffing instead of notifying parent effects
+     * @default true
+     */
+    recursiveTouching: true,
+    /**
+     * Default async execution mode for effects that return Promises
+     * - 'cancel': Cancel previous async execution when dependencies change (default, enables async zone)
+     * - 'queue': Queue next execution to run after current completes (enables async zone)
+     * - 'ignore': Ignore new executions while async work is running (enables async zone)
+     * - false: Disable async zone and async mode handling (effects run concurrently)
+     *
+     * **When truthy:** Enables async zone (Promise.prototype wrapping) for automatic context
+     * preservation in Promise callbacks. Warning: This modifies Promise.prototype globally.
+     * Only enable if no other library modifies Promise.prototype.
+     *
+     * **When false:** Async zone is disabled. Use `tracked()` manually in Promise callbacks.
+     *
+     * Can be overridden per-effect via EffectOptions
+     * @default 'cancel'
+     */
+    asyncMode: 'cancel',
+    // biome-ignore lint/suspicious/noConsole: This is the whole point here
+    warn: (...args) => console.warn(...args),
+    /**
+     * 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
+let effectToReactiveObjects = new WeakMap();
+// Track effects per reactive object and property
+let watchers = new WeakMap();
+// Track effect metadata and relationships
+let effectNodes = new WeakMap();
+function getEffectNode(effect) {
+    let node = effectNodes.get(effect);
+    if (!node) {
+        node = {};
+        effectNodes.set(effect, node);
+    }
+    return node;
+}
+// Track reverse mapping to ensure unicity: One Root -> One Function
+let reverseRoots = new WeakMap();
+function resetRegistry() {
+    effectToReactiveObjects = new WeakMap();
+    watchers = new WeakMap();
+    effectNodes = new WeakMap();
+    reverseRoots = new WeakMap();
+}
+/**
+ * Marks a function with its root function for effect tracking
+ * Enforces strict unicity: A root function can only identify ONE function.
+ * @param fn - The function to mark
+ * @param root - The root function
+ * @returns The marked function
+ */
+function markWithRoot(fn, root) {
+    // Check for collision
+    const existingRef = reverseRoots.get(root);
+    const existing = existingRef?.deref();
+    if (existing && existing !== fn) {
+        const rootName = root.name || 'anonymous';
+        const existingName = existing.name || 'anonymous';
+        const fnName = fn.name || 'anonymous';
+        throw new Error(`[reactive] Abusive Shared Root detected: Root '${rootName}' is already identifying function '${existingName}'. ` +
+            `Cannot reuse it for '${fnName}'. Shared roots cause lost updates and broken identity logic.`);
+    }
+    // Always update the map so subsequent checks find this one
+    // (Last writer wins for the check)
+    reverseRoots.set(root, new WeakRef(fn));
+    // 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 asyncHooks.sanitizePromise(res);
+    }
+    root(fn) {
+        const prev = this.enter();
+        try {
+            return fn();
+        }
+        finally {
+            this.leave(prev);
+        }
+    }
+    get zoned() {
+        const active = this.active;
+        return named(`${this}@${active}`, (fn) => this.with(active, fn));
+    }
+}
+class Zone extends AZone {
+}
+class ZoneHistory extends AZone {
+    has(value) {
+        return this.history.has(value);
+    }
+    some(predicate) {
+        for (const value of this.history)
+            if (predicate(value))
+                return true;
+        return false;
+    }
+    constructor(controlled = new Zone()) {
+        super();
+        this.controlled = controlled;
+        this.history = new Set();
+        const self = this;
+        this.present = Object.create(controlled, Object.getOwnPropertyDescriptors({
+            get active() {
+                return controlled.active;
+            },
+            set active(value) {
+                controlled.active = value;
+            },
+            enter(value) {
+                if (value && self.history.has(value))
+                    throw new Error('ZoneHistory: re-entering historical zone');
+                if (value !== undefined)
+                    self.history.add(value);
+                return { added: value, entered: isu(controlled).enter(value) };
+            },
+            leave(entered) {
+                if (entered.added !== undefined)
+                    self.history.delete(entered.added);
+                return isu(controlled).leave(entered.entered);
+            },
+        }));
+    }
+    get active() {
+        return { present: this.controlled.active, history: new Set(this.history) };
+    }
+    set active(value) {
+        this.history = value?.history ? new Set(value.history) : new Set();
+        this.controlled.active = value?.present;
+    }
+}
+class ZoneAggregator extends AZone {
+    constructor(...zones) {
+        super();
+        _ZoneAggregator_zones.set(this, new Set());
+        for (const z of zones)
+            __classPrivateFieldGet(this, _ZoneAggregator_zones, "f").add(z);
+    }
+    get active() {
+        const rv = new Map();
+        for (const z of __classPrivateFieldGet(this, _ZoneAggregator_zones, "f"))
+            if (z.active !== undefined)
+                rv.set(z, z.active);
+        return rv;
+    }
+    set active(value) {
+        for (const z of __classPrivateFieldGet(this, _ZoneAggregator_zones, "f"))
+            z.active = value?.get(z);
+    }
+    enter(value) {
+        const entered = new Map();
+        for (const z of __classPrivateFieldGet(this, _ZoneAggregator_zones, "f")) {
+            const v = value?.get(z);
+            entered.set(z, isu(z).enter(v));
+        }
+        return entered;
+    }
+    leave(entered) {
+        for (const z of __classPrivateFieldGet(this, _ZoneAggregator_zones, "f"))
+            isu(z).leave(entered.get(z));
+    }
+    add(z) {
+        __classPrivateFieldGet(this, _ZoneAggregator_zones, "f").add(z);
+    }
+    delete(z) {
+        __classPrivateFieldGet(this, _ZoneAggregator_zones, "f").delete(z);
+    }
+    clear() {
+        __classPrivateFieldGet(this, _ZoneAggregator_zones, "f").clear();
+    }
+}
+_ZoneAggregator_zones = new WeakMap();
+const asyncZone = tag('async', new ZoneAggregator());
+asyncHooks.addHook(() => {
+    const zone = asyncZone.active;
+    return () => {
+        const prev = asyncZone.active;
+        asyncZone.active = zone;
+        return () => (asyncZone.active = prev);
+    };
+});
+
+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 = 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 = 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 = watchers.get(origin.obj);
+        if (originWatchers) {
+            const originEffects = new Set();
+            collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, [allProps], [origin.prop]);
+            for (const effect of originEffects)
+                allowedEffects.add(effect);
+        }
+        // If no allowed effects, skip all notifications (no one should be notified)
+        if (allowedEffects.size === 0)
+            return;
+    }
+    for (const { target, evolution, prop } of notifications) {
+        if (!isObjectLike(target))
+            continue;
+        const obj = unwrap(target);
+        addState(obj, evolution);
+        const objectWatchers = watchers.get(obj);
+        let currentEffects;
+        const propsArray = [prop];
+        if (objectWatchers) {
+            // 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 = watchers.get(obj);
+    if (!objectWatchers) {
+        objectWatchers = new Map();
+        watchers.set(obj, objectWatchers);
+    }
+    let deps = objectWatchers.get(prop);
+    if (!deps) {
+        deps = new Set();
+        objectWatchers.set(prop, deps);
+    }
+    deps.add(currentActiveEffect);
+    // Track which reactive objects this effect is watching
+    const effectObjects = effectToReactiveObjects.get(currentActiveEffect);
+    if (effectObjects) {
+        effectObjects.add(obj);
+    }
+    else {
+        effectToReactiveObjects.set(currentActiveEffect, new Set([obj]));
+    }
+}
+
+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: 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 = 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 = 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 = 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 import.meta !== 'undefined') {
+        const meta = import.meta;
+        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: 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: 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: 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: 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: 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 = effectToReactiveObjects.get(runEffect);
+            if (effectObjects) {
+                for (const reactiveObj of effectObjects) {
+                    const objectWatchers = watchers.get(reactiveObj);
+                    if (objectWatchers) {
+                        for (const [prop, deps] of objectWatchers.entries()) {
+                            deps.delete(runEffect);
+                            if (deps.size === 0) {
+                                objectWatchers.delete(prop);
+                            }
+                        }
+                        if (objectWatchers.size === 0) {
+                            watchers.delete(reactiveObj);
+                        }
+                    }
+                }
+                effectToReactiveObjects.delete(runEffect);
+            }
+            // Invoke all child stops (recursive via subEffectCleanup calling its own mainCleanup)
+            const children = node.children;
+            if (children) {
+                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);
+        })
+        : () => { };
+}
+
+export { touched1 as $, AZone as A, getActiveEffect as B, getState as C, DecoratorError as D, immutables as E, FoolProof as F, isConstructor as G, isNonReactive as H, IterableWeakMap as I, isOwnAccessor as J, isReactive as K, legacyDecorator as L, mixin as M, modernDecorator as N, named as O, onEffectThrow as P, onEffectTrigger as Q, ReactiveBase as R, reactive as S, options as T, registerNativeReactivity as U, renamed as V, reset as W, root as X, tag as Y, Zone as Z, touched as _, asyncHooks as a, untracked as a0, unwrap as a1, zip as a2, markWithRoot as a3, rootFunction as a4, getRoot as a5, dependant as a6, optionCall as a7, __runInitializers as a8, __esDecorate as a9, formatLineage as aA, getDependencies as aB, getDependencyGraph as aC, getDependents as aD, getLineage as aE, getMutationHistory as aF, getStackFrame as aG, getTriggerChain as aH, isDevtoolsEnabled as aI, lineageFormatter as aJ, logError as aK, nodeLineage as aL, nodeLineageLegacy as aM, parseStackLine as aN, recordTriggerLink as aO, registerEffectForDebug as aP, registerObjectForDebug as aQ, setObjectName as aR, showLineagePanel as aS, wrapLineageForDebug as aT, objectsWithDeepWatchers as aa, effectToDeepWatchedObjects as ab, deepWatchers as ac, stopped as ad, nonReactiveClass as ae, unreactiveProperties as af, nonReactiveMark as ag, nonReactiveObjects as ah, __setFunctionName as ai, __classPrivateFieldGet as aj, __classPrivateFieldSet as ak, setEffectName as al, projectionInfo as am, notifyPropertyChange as an, metaProtos as ao, objectParents as ap, watchers as aq, effectToReactiveObjects as ar, proxyToObject as as, objectToProxy as at, buildReactivityGraph as au, captureNodeLineage as av, debugOptions as aw, effectMarker as ax, enableDevTools as ay, forceEnableGraphTracking as az, IterableWeakSet as b, ReactiveError as c, ReactiveErrorCode as d, ZoneAggregator as e, ZoneHistory as f, addBatchCleanup as g, hooks as h, arrayEquals as i, asyncHook as j, asyncZone as k, atomic as l, biDi as m, cleanedBy as n, cleanup as o, contentRef as p, createFlavor as q, decorator as r, deepCompare as s, defer as t, derived as u, effect as v, effectAggregator as w, flavorOptions as x, flavored as y, getActivationLog as z };
+//# sourceMappingURL=index-CtA2AWl3.esm.js.map