mutts 1.0.7 → 1.0.9

package/dist/browser.cjs

@@ -0,0 +1,3111 @@
+'use strict';
+
+require('./chunks/async-browser-lvzLOCgk.cjs');
+var debug = require('./chunks/index-VTO-b2vR.cjs');
+var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
+require('./chunks/async-node-C3DeIb0y.cjs');
+require('node:async_hooks');
+
+// Integrated with `using` statement via Symbol.dispose
+const fr = new FinalizationRegistry((f) => f());
+/**
+ * Symbol for marking destructor methods
+ */
+const destructor = Symbol('destructor');
+/**
+ * Symbol for accessing allocated values in destroyable objects
+ */
+const allocatedValues = Symbol('allocated');
+/**
+ * Error thrown when attempting to access a destroyed object
+ */
+class DestructionError extends Error {
+    static throw(msg) {
+        return () => {
+            throw new DestructionError(msg);
+        };
+    }
+    constructor(msg) {
+        super(`Object is destroyed. ${msg}`);
+        this.name = 'DestroyedAccessError';
+    }
+}
+const destroyedHandler = {
+    [Symbol.toStringTag]: 'MutTs Destroyable',
+    get: DestructionError.throw('Cannot access destroyed object'),
+    set: DestructionError.throw('Cannot access destroyed object'),
+};
+function Destroyable(base, destructorObj) {
+    var _a;
+    if (base && typeof base !== 'function') {
+        destructorObj = base;
+        base = undefined;
+    }
+    if (!base) {
+        base = class {
+        };
+    }
+    return _a = class Destroyable extends base {
+            static destroy(obj) {
+                const destructor = _a.destructors.get(obj);
+                if (!destructor)
+                    return false;
+                fr.unregister(obj[allocatedValues]);
+                _a.destructors.delete(obj);
+                Object.setPrototypeOf(obj, new Proxy({}, destroyedHandler));
+                // Clear all own properties
+                for (const key of Object.getOwnPropertyNames(obj)) {
+                    delete obj[key];
+                }
+                destructor();
+                return true;
+            }
+            static isDestroyable(obj) {
+                return _a.destructors.has(obj);
+            }
+            constructor(...args) {
+                super(...args);
+                const allocated = {};
+                this[allocatedValues] = allocated;
+                // @ts-expect-error `this` is an AbstractDestroyable
+                const myDestructor = destructorObj?.destructor ?? this[destructor];
+                if (!myDestructor) {
+                    throw new DestructionError('Destructor is not defined');
+                }
+                function destruction() {
+                    myDestructor(allocated);
+                }
+                _a.destructors.set(this, destruction);
+                fr.register(this, destruction, allocated);
+            }
+        },
+        _a.destructors = new WeakMap(),
+        _a;
+}
+/**
+ * Decorator that marks properties to be stored in the allocated object and passed to the destructor
+ * Use with accessor properties or explicit get/set pairs
+ */
+const allocated = debug.decorator({
+    setter(original, _target, propertyKey) {
+        return function (value) {
+            this[allocatedValues][propertyKey] = value;
+            return original.call(this, value);
+        };
+    },
+});
+/**
+ * Registers a callback to be called when an object is garbage collected
+ * @param cb - The callback function to execute on garbage collection
+ * @returns The object whose reference can be collected
+ */
+function callOnGC(cb) {
+    let called = false;
+    const forward = () => {
+        if (called)
+            return;
+        called = true;
+        cb();
+    };
+    fr.register(forward, cb, cb);
+    return forward;
+}
+
+var _a, _b;
+const events = Symbol('events');
+const hooks = Symbol('hooks');
+const eventBehavior = {
+    on(eventOrEvents, cb) {
+        if (typeof eventOrEvents === 'object') {
+            for (const e of Object.keys(eventOrEvents)) {
+                this.on(e, eventOrEvents[e]);
+            }
+        }
+        else if (cb !== undefined) {
+            const callbacks = this[events].get(eventOrEvents) ?? new Set();
+            if (!callbacks.has(cb))
+                callbacks.add(cb);
+            this[events].set(eventOrEvents, callbacks);
+        }
+        return () => this.off(eventOrEvents, cb);
+    },
+    off(eventOrEvents, cb) {
+        if (typeof eventOrEvents === 'object') {
+            for (const e of Object.keys(eventOrEvents)) {
+                this.off(e, eventOrEvents[e]);
+            }
+        }
+        else if (cb !== null && cb !== undefined) {
+            const callbacks = this[events].get(eventOrEvents);
+            if (callbacks) {
+                callbacks.delete(cb);
+                if (!callbacks.size)
+                    this[events].delete(eventOrEvents);
+            }
+        }
+        else {
+            // Remove all listeners for this event
+            this[events].delete(eventOrEvents);
+        }
+    },
+    emit(event, ...args) {
+        const callbacks = this[events].get(event);
+        if (callbacks)
+            for (const cb of callbacks)
+                cb.apply(this, args);
+        for (const cb of this[hooks])
+            cb.call(this, event, ...args);
+    },
+};
+function perEvent(eventful, fct, use) {
+    const cache = new Map();
+    return new Proxy(fct, {
+        get(target, prop) {
+            if (typeof prop !== 'string')
+                return target[prop];
+            if (use && !eventful[events].has(prop) && !eventful[hooks].size)
+                return () => { };
+            // Return cached function or create and cache
+            let cached = cache.get(prop);
+            if (!cached) {
+                cached = (...args) => fct.apply(eventful, [prop, ...args]);
+                cache.set(prop, cached);
+            }
+            return cached;
+        },
+    });
+}
+/**
+ * A type-safe event system that provides a clean API for event handling
+ * @template Events - The event map defining event names and their handler signatures
+ */
+class Eventful {
+    constructor() {
+        this[_a] = new Map();
+        this[_b] = new Set();
+        this.on = perEvent(this, eventBehavior.on);
+        this.off = perEvent(this, eventBehavior.off);
+        this.emit = perEvent(this, eventBehavior.emit, 'use');
+    }
+    hook(cb) {
+        this[hooks].add(cb);
+        return () => {
+            this[hooks].delete(cb);
+        };
+    }
+}
+_a = events, _b = hooks;
+
+/**
+ * Symbol for defining custom getter logic for numeric index access
+ */
+const getAt = Symbol('getAt');
+/**
+ * Symbol for defining custom setter logic for numeric index access
+ */
+const setAt = Symbol('setAt');
+function Indexable(base, accessor) {
+    if (base && typeof base !== 'function') {
+        accessor = base;
+        base = undefined;
+    }
+    if (!base) {
+        //@ts-expect-error
+        base = class {
+        };
+    }
+    if (!accessor) {
+        accessor = {
+            get(index) {
+                if (typeof this[getAt] !== 'function') {
+                    throw new Error('Indexable class must have an [getAt] method');
+                }
+                return this[getAt](index);
+            },
+            set(index, value) {
+                if (typeof this[setAt] !== 'function') {
+                    throw new Error('Indexable class has read-only numeric index access');
+                }
+                this[setAt](index, value);
+            },
+        };
+    }
+    class Indexable extends base {
+    }
+    Object.setPrototypeOf(Indexable.prototype, new Proxy(base.prototype, {
+        //@ts-expect-error
+        [Symbol.toStringTag]: 'MutTs Indexable',
+        get(target, prop, receiver) {
+            if (prop in target) {
+                const getter = Object.getOwnPropertyDescriptor(target, prop)?.get;
+                return getter ? getter.call(receiver) : target[prop];
+            }
+            if (typeof prop === 'string') {
+                if (prop === 'length' && accessor.getLength)
+                    return accessor.getLength.call(receiver);
+                const numProp = Number(prop);
+                if (!Number.isNaN(numProp)) {
+                    return accessor.get.call(receiver, numProp);
+                }
+            }
+            return undefined;
+        },
+        set(target, prop, value, receiver) {
+            if (prop in target) {
+                const setter = Object.getOwnPropertyDescriptor(target, prop)?.set;
+                if (setter)
+                    setter.call(receiver, value);
+                else
+                    target[prop] = value;
+                return true;
+            }
+            if (typeof prop === 'string') {
+                if (prop === 'length' && accessor.setLength) {
+                    accessor.setLength.call(receiver, value);
+                    return true;
+                }
+                const numProp = Number(prop);
+                if (!Number.isNaN(numProp)) {
+                    if (!accessor.set)
+                        throw new Error('Indexable class has read-only numeric index access');
+                    accessor.set.call(receiver, numProp, value);
+                    return true;
+                }
+            }
+            Object.defineProperty(receiver, prop, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+            return true;
+        },
+        has(target, prop) {
+            if (prop in target)
+                return true;
+            if (typeof prop === 'string') {
+                if (prop === 'length' && accessor.getLength)
+                    return true;
+                const numProp = Number(prop);
+                if (!Number.isNaN(numProp))
+                    return true;
+            }
+            return false;
+        },
+        ownKeys(target) {
+            const keys = Reflect.ownKeys(target);
+            if (accessor.getLength) {
+                keys.push('length');
+                const len = accessor.getLength.call(this);
+                for (let i = 0; i < len; i++)
+                    keys.push(String(i));
+            }
+            return keys;
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            if (prop in target)
+                return Object.getOwnPropertyDescriptor(target, prop);
+            if (typeof prop === 'string') {
+                if (prop === 'length' && accessor.getLength) {
+                    return {
+                        enumerable: false,
+                        configurable: true,
+                        get: () => accessor.getLength.call(this),
+                    };
+                }
+                const numProp = Number(prop);
+                if (!Number.isNaN(numProp)) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        get: () => accessor.get.call(this, numProp),
+                        set: accessor.set
+                            ? (v) => accessor.set.call(this, numProp, v)
+                            : undefined,
+                    };
+                }
+            }
+            return undefined;
+        },
+    }));
+    return Indexable;
+}
+/**
+ * Symbol for accessing the forwarded array in ArrayReadForward
+ */
+const forwardArray = Symbol('forwardArray');
+/**
+ * A read-only array forwarder that implements all reading/iterating methods of Array
+ * but does not implement modification methods.
+ *
+ * The constructor takes a callback that returns an array, and all methods forward
+ * their behavior to the result of that callback.
+ */
+class ArrayReadForward {
+    get [forwardArray]() {
+        throw new Error('ArrayReadForward is not implemented');
+    }
+    /**
+     * Get the length of the array
+     */
+    get length() {
+        return this[forwardArray].length;
+    }
+    /**
+     * Iterator protocol support
+     */
+    [Symbol.iterator]() {
+        return this[forwardArray][Symbol.iterator]();
+    }
+    // Reading/Iterating methods
+    /**
+     * Creates a new array with the results of calling a provided function on every element
+     */
+    map(callbackfn, thisArg) {
+        return this[forwardArray].map(callbackfn, thisArg);
+    }
+    filter(predicate, thisArg) {
+        return this[forwardArray].filter(predicate, thisArg);
+    }
+    reduce(callbackfn, initialValue) {
+        return initialValue !== undefined
+            ? this[forwardArray].reduce(callbackfn, initialValue)
+            : this[forwardArray].reduce(callbackfn);
+    }
+    reduceRight(callbackfn, initialValue) {
+        return initialValue !== undefined
+            ? this[forwardArray].reduceRight(callbackfn, initialValue)
+            : this[forwardArray].reduceRight(callbackfn);
+    }
+    /**
+     * Executes a provided function once for each array element
+     */
+    forEach(callbackfn, thisArg) {
+        this[forwardArray].forEach(callbackfn, thisArg);
+    }
+    find(predicate, thisArg) {
+        return this[forwardArray].find(predicate, thisArg);
+    }
+    /**
+     * Returns the index of the first element in the array that satisfies the provided testing function
+     */
+    findIndex(predicate, thisArg) {
+        return this[forwardArray].findIndex(predicate, thisArg);
+    }
+    findLast(predicate, thisArg) {
+        return this[forwardArray].findLast(predicate, thisArg);
+    }
+    /**
+     * Returns the index of the last element in the array that satisfies the provided testing function
+     */
+    findLastIndex(predicate, thisArg) {
+        return this[forwardArray].findLastIndex(predicate, thisArg);
+    }
+    /**
+     * Determines whether an array includes a certain value among its entries
+     */
+    includes(searchElement, fromIndex) {
+        return this[forwardArray].includes(searchElement, fromIndex);
+    }
+    /**
+     * Returns the first index at which a given element can be found in the array
+     */
+    indexOf(searchElement, fromIndex) {
+        return this[forwardArray].indexOf(searchElement, fromIndex);
+    }
+    /**
+     * Returns the last index at which a given element can be found in the array
+     */
+    lastIndexOf(searchElement, fromIndex) {
+        return this[forwardArray].lastIndexOf(searchElement, fromIndex);
+    }
+    /**
+     * Returns a shallow copy of a portion of an array into a new array object
+     */
+    slice(start, end) {
+        return this[forwardArray].slice(start, end);
+    }
+    concat(...items) {
+        return this[forwardArray].concat(...items);
+    }
+    /**
+     * Tests whether all elements in the array pass the test implemented by the provided function
+     */
+    every(predicate, thisArg) {
+        return this[forwardArray].every(predicate, thisArg);
+    }
+    /**
+     * Tests whether at least one element in the array passes the test implemented by the provided function
+     */
+    some(predicate, thisArg) {
+        return this[forwardArray].some(predicate, thisArg);
+    }
+    /**
+     * Joins all elements of an array into a string
+     */
+    join(separator) {
+        return this[forwardArray].join(separator);
+    }
+    /**
+     * Returns a new array iterator that contains the keys for each index in the array
+     */
+    keys() {
+        return this[forwardArray].keys();
+    }
+    /**
+     * Returns a new array iterator that contains the values for each index in the array
+     */
+    values() {
+        return this[forwardArray].values();
+    }
+    /**
+     * Returns a new array iterator that contains the key/value pairs for each index in the array
+     */
+    entries() {
+        return this[forwardArray].entries();
+    }
+    /**
+     * Returns a string representation of the array
+     */
+    toString() {
+        return this[forwardArray].toString();
+    }
+    /**
+     * Returns a localized string representing the array
+     */
+    toLocaleString(locales, options) {
+        return this[forwardArray].toLocaleString(locales, options);
+    }
+    /**
+     * Returns the element at the specified index, or undefined if the index is out of bounds
+     */
+    at(index) {
+        return this[forwardArray].at(index);
+    }
+    /**
+     * Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth
+     */
+    flat(depth) {
+        return this[forwardArray].flat(depth);
+    }
+    /**
+     * Returns a new array formed by applying a given callback function to each element of the array,
+     * and then flattening the result by one level
+     */
+    flatMap(callback, thisArg) {
+        return this[forwardArray].flatMap(callback, thisArg);
+    }
+    /**
+     * Returns a new array with elements in reversed order (ES2023)
+     */
+    toReversed() {
+        return this[forwardArray].toReversed?.() ?? [...this[forwardArray]].reverse();
+    }
+    /**
+     * Returns a new array with elements sorted (ES2023)
+     */
+    toSorted(compareFn) {
+        return this[forwardArray].toSorted?.(compareFn) ?? [...this[forwardArray]].sort(compareFn);
+    }
+    /**
+     * Returns a new array with some elements removed and/or replaced at a given index (ES2023)
+     */
+    toSpliced(start, deleteCount, ...items) {
+        if (deleteCount === undefined)
+            return this[forwardArray].toSpliced(start);
+        return this[forwardArray].toSpliced(start, deleteCount, ...items);
+    }
+    /**
+     * Returns a new array with the element at the given index replaced with the given value (ES2023)
+     */
+    with(index, value) {
+        return this[forwardArray].with(index, value);
+    }
+    get [Symbol.unscopables]() {
+        return this[forwardArray][Symbol.unscopables];
+    }
+}
+
+const forward = (name, target) => (...args) => {
+    return target[name](...args);
+};
+const alreadyChained = new WeakMap();
+const originals = new WeakMap();
+function cache$1(target, rv) {
+    originals.set(rv, target);
+    alreadyChained.set(target, rv);
+}
+const promiseProxyHandler = {
+    //@ts-expect-error
+    [Symbol.toStringTag]: 'MutTs PromiseChain function',
+    get(target, prop) {
+        if (prop === Symbol.toStringTag)
+            return 'PromiseProxy';
+        if (typeof prop === 'string' && ['then', 'catch', 'finally'].includes(prop))
+            return target[prop];
+        return chainPromise(target.then((r) => r[prop]));
+    },
+};
+const promiseForward = (target) => ({
+    // biome-ignore lint/suspicious/noThenProperty: This one is the whole point
+    then: forward('then', target),
+    catch: forward('catch', target),
+    finally: forward('finally', target),
+});
+const objectProxyHandler = {
+    //@ts-expect-error
+    [Symbol.toStringTag]: 'MutTs PromiseChain object',
+    get(target, prop, receiver) {
+        const getter = Object.getOwnPropertyDescriptor(target, prop)?.get;
+        const rv = getter ? getter.call(receiver) : target[prop];
+        // Allows fct.call or fct.apply to bypass the chain system
+        if (typeof target === 'function')
+            return rv;
+        return chainPromise(rv);
+    },
+    apply(target, thisArg, args) {
+        return chainPromise(target.apply(thisArg, args));
+    },
+};
+function chainObject(given) {
+    const rv = new Proxy(given, objectProxyHandler);
+    cache$1(given, rv);
+    return rv;
+}
+function chainable(x) {
+    return x && ['function', 'object'].includes(typeof x);
+}
+/**
+ * Transforms a promise or value into a chainable object
+ * Allows calling methods directly on promise results without awaiting them first
+ * @param given - The promise or value to make chainable
+ * @returns A chainable version of the input
+ */
+function chainPromise(given) {
+    if (!chainable(given))
+        return given;
+    if (alreadyChained.has(given))
+        return alreadyChained.get(given);
+    if (!(given instanceof Promise))
+        return chainObject(given);
+    // @ts-expect-error It's ok as we check if it's an object above
+    given = given.then((r) => (chainable(r) ? chainObject(r) : r));
+    const target = Object.assign(function (...args) {
+        return chainPromise(given.then((r) => {
+            return this?.then
+                ? this.then((t) => r.apply(t, args))
+                : r.apply(this, args);
+        }));
+    }, promiseForward(given));
+    const chained = new Proxy(target, promiseProxyHandler);
+    cache$1(given, chained);
+    return chained;
+}
+
+const memoizedRegistry = new WeakMap();
+const wrapperRegistry = new WeakMap();
+function getBranch(tree, key) {
+    tree.branches ?? (tree.branches = new WeakMap());
+    let branch = tree.branches.get(key);
+    if (!branch) {
+        branch = {};
+        tree.branches.set(key, branch);
+    }
+    return branch;
+}
+function memoizeFunction(fn) {
+    const fnRoot = debug.getRoot(fn);
+    const existing = memoizedRegistry.get(fnRoot);
+    if (existing)
+        return existing;
+    const cacheRoot = {};
+    const memoized = debug.markWithRoot((...args) => {
+        const localArgs = args; //: Args = maxArgs !== undefined ? (args.slice(0, maxArgs) as Args) : args
+        if (localArgs.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg))))
+            throw new Error('memoize expects non-null object arguments');
+        let node = cacheRoot;
+        // Note: decorators add `this` as first argument
+        for (const arg of localArgs) {
+            node = getBranch(node, arg);
+        }
+        debug.dependant(node, 'memoize');
+        if ('result' in node) {
+            if (debug.options.onMemoizationDiscrepancy) {
+                const wasVerification = debug.options.isVerificationRun;
+                debug.options.isVerificationRun = true;
+                try {
+                    const fresh = debug.untracked(() => fn(...localArgs));
+                    if (!debug.deepCompare(node.result, fresh)) {
+                        debug.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, localArgs, 'calculation');
+                    }
+                }
+                finally {
+                    debug.options.isVerificationRun = wasVerification;
+                }
+            }
+            return node.result;
+        }
+        // Create memoize internal effect to track dependencies and invalidate cache
+        // Use untracked to prevent the effect creation from being affected by parent effects
+        node.cleanup = debug.root(() => debug.effect(() => {
+            // Execute the function and track its dependencies
+            // The function execution will automatically track dependencies on reactive objects
+            node.result = fn(...localArgs);
+            return () => {
+                // When dependencies change, clear the cache and notify consumers
+                delete node.result;
+                debug.touched1(node, { type: 'invalidate', prop: localArgs }, 'memoize');
+                // Lazy memoization: stop the effect so it doesn't re-run immediately.
+                // It will be re-created on next access.
+                if (node.cleanup) {
+                    node.cleanup();
+                    node.cleanup = undefined;
+                }
+            };
+        }, { opaque: true }));
+        if (debug.options.onMemoizationDiscrepancy) {
+            const wasVerification = debug.options.isVerificationRun;
+            debug.options.isVerificationRun = true;
+            try {
+                const fresh = debug.untracked(() => fn(...localArgs));
+                if (!debug.deepCompare(node.result, fresh)) {
+                    debug.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, localArgs, 'comparison');
+                }
+            }
+            finally {
+                debug.options.isVerificationRun = wasVerification;
+            }
+        }
+        return node.result;
+    }, fn);
+    memoizedRegistry.set(fnRoot, memoized);
+    memoizedRegistry.set(memoized, memoized);
+    return memoized;
+}
+/**
+ * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
+ *
+ * When used as a decorator on getters or methods, it caches the result and automatically
+ * invalidates the cache when reactive dependencies change.
+ *
+ * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @memoize
+ *   get fullName() {
+ *     return `${this.firstName} ${this.lastName}`
+ *   }
+ * }
+ *
+ * // Or as a function wrapper
+ * const expensive = memoize((obj: SomeObject) => {
+ *   return heavyComputation(obj)
+ * })
+ * ```
+ */
+const memoize = debug.decorator({
+    getter(original, target, propertyKey) {
+        return function () {
+            let wrapper = wrapperRegistry.get(original);
+            if (!wrapper) {
+                wrapper = debug.markWithRoot(debug.renamed((that) => {
+                    return original.call(that);
+                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`), {
+                    method: original,
+                    propertyKey,
+                    ...(original[debug.rootFunction]
+                        ? { [debug.rootFunction]: original[debug.rootFunction] }
+                        : {}),
+                });
+                wrapperRegistry.set(original, wrapper);
+            }
+            const memoized = memoizeFunction(wrapper);
+            return memoized(this);
+        };
+    },
+    method(original, target, name) {
+        return function (...args) {
+            let wrapper = wrapperRegistry.get(original);
+            if (!wrapper) {
+                wrapper = debug.markWithRoot(debug.renamed((that, ...args) => {
+                    return original.call(that, ...args);
+                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`), {
+                    method: original,
+                    propertyKey: name,
+                    ...(original[debug.rootFunction]
+                        ? { [debug.rootFunction]: original[debug.rootFunction] }
+                        : {}),
+                });
+                wrapperRegistry.set(original, wrapper);
+            }
+            const memoized = memoizeFunction(wrapper);
+            return memoized(this, ...args);
+        };
+    },
+    default: memoizeFunction,
+});
+
+function attend(source, callback) {
+    const enumerate = typeof source === 'function'
+        ? source
+        : Array.isArray(source)
+            ? () => Array.from({ length: source.length }, (_, i) => i)
+            : source instanceof Map
+                ? () => source.keys()
+                : source instanceof Set
+                    ? () => source.values()
+                    : () => Object.keys(source);
+    const keyEffects = new Map();
+    const outer = debug.effect(({ ascend }) => {
+        const keys = new Set();
+        for (const key of enumerate())
+            keys.add(key);
+        for (const key of keys) {
+            if (keyEffects.has(key))
+                continue;
+            keyEffects.set(key, ascend(() => debug.effect(() => callback(key))));
+        }
+        for (const key of Array.from(keyEffects.keys())) {
+            if (!keys.has(key)) {
+                keyEffects.get(key)();
+                keyEffects.delete(key);
+            }
+        }
+    });
+    return () => {
+        outer();
+        for (const stop of keyEffects.values())
+            stop();
+        keyEffects.clear();
+    };
+}
+/**
+ * Perform a reactive scan over an array of items.
+ *
+ * This implementation is highly optimized for performance and fine-grained reactivity:
+ * - **Incremental Updates**: Changes to an item only trigger re-computation from that
+ *   point onwards in the result chain.
+ * - **Move Optimization**: If items are moved within the array, their accumulated
+ *   values are reused as long as their predecessor remains the same.
+ * - **Duplicate Support**: Correctly handles multiple occurrences of the same object
+ *   instance using an internal occurrence tracking mechanism.
+ * - **Memory Efficient**: Uses `WeakMap` for caching intermediates, which are
+ *   automatically cleared when source items are garbage collected.
+ *
+ * @example
+ * ```typescript
+ * const source = reactive([{ val: 1 }, { val: 2 }, { val: 3 }])
+ * const sum = scan(source, (acc, item) => acc + item.val, 0)
+ *
+ * expect([...sum]).toEqual([1, 3, 6])
+ *
+ * // Modifying an item only re-computes subsequent sums
+ * source[1].val = 10
+ * expect([...sum]).toEqual([1, 11, 14])
+ * ```
+ *
+ * @param source The source array of objects (will be made reactive)
+ * @param callback The accumulator function called with (accumulator, currentItem)
+ * @param initialValue The starting value for the accumulation
+ * @returns A reactive array of accumulated values, with a [cleanup] property to stop the tracking
+ */
+function scan(source, callback, initialValue) {
+    const observedSource = debug.reactive(source);
+    const result = debug.reactive([]);
+    // Track effects for each index to dispose them when the array shrinks
+    const indexEffects = new Map();
+    // Mapping from index to its current intermediate object
+    const indexToIntermediate = debug.reactive([]);
+    const intermediaries = new WeakMap();
+    let Intermediate = (() => {
+        var _a;
+        let _instanceExtraInitializers = [];
+        let _get_acc_decorators;
+        return _a = class Intermediate {
+                constructor(val, prev) {
+                    this.val = (debug.__runInitializers(this, _instanceExtraInitializers), val);
+                    this.prev = prev;
+                }
+                get acc() {
+                    const prevAcc = this.prev ? this.prev.acc : initialValue;
+                    return callback(prevAcc, this.val);
+                }
+            },
+            (() => {
+                const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+                _get_acc_decorators = [memoize];
+                debug.__esDecorate(_a, null, _get_acc_decorators, { kind: "getter", name: "acc", static: false, private: false, access: { has: obj => "acc" in obj, get: obj => obj.acc }, metadata: _metadata }, null, _instanceExtraInitializers);
+                if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            })(),
+            _a;
+    })();
+    function disposeIndex(index) {
+        const stop = indexEffects.get(index);
+        if (stop) {
+            stop();
+            indexEffects.delete(index);
+            debug.untracked(() => {
+                Reflect.deleteProperty(indexToIntermediate, index);
+                Reflect.deleteProperty(result, index);
+            });
+        }
+    }
+    const mainEffect = debug.effect(function scanMainEffect({ ascend }) {
+        const length = observedSource.length;
+        const occurrenceCount = new Map();
+        let prev;
+        for (let i = 0; i < length; i++) {
+            const val = debug.FoolProof.get(observedSource, i, observedSource);
+            if (!(val && (typeof val === 'object' || typeof val === 'function' || typeof val === 'symbol'))) {
+                throw new Error('scan: items must be objects (WeakKey) for intermediate caching');
+            }
+            const count = occurrenceCount.get(val) ?? 0;
+            occurrenceCount.set(val, count + 1);
+            let list = intermediaries.get(val);
+            if (!list) {
+                list = [];
+                intermediaries.set(val, list);
+            }
+            let intermediate = list[count];
+            if (!intermediate) {
+                intermediate = debug.reactive(new Intermediate(val, prev));
+                list[count] = intermediate;
+            }
+            else {
+                // Update the link.
+                if (debug.untracked(() => intermediate.prev) !== prev) {
+                    intermediate.prev = prev;
+                }
+            }
+            // Update the reactive mapping for this index
+            if (indexToIntermediate[i] !== intermediate) {
+                indexToIntermediate[i] = intermediate;
+            }
+            // If we don't have an effect for this index yet, create one
+            if (!indexEffects.has(i)) {
+                ascend(() => {
+                    const index = i;
+                    const stop = debug.effect(function scanIndexSyncEffect() {
+                        const inter = indexToIntermediate[index];
+                        if (inter) {
+                            const accValue = inter.acc;
+                            debug.untracked(() => {
+                                result[index] = accValue;
+                            });
+                        }
+                    });
+                    indexEffects.set(index, stop);
+                });
+            }
+            prev = intermediate;
+        }
+        // Cleanup trailing indices
+        for (const index of Array.from(indexEffects.keys())) {
+            if (index >= length)
+                disposeIndex(index);
+        }
+        // Ensure result length matches source length
+        debug.untracked(() => {
+            if (result.length !== length) {
+                debug.FoolProof.set(result, 'length', length, result);
+            }
+        });
+    });
+    return debug.cleanedBy(result, (() => {
+        mainEffect();
+        for (const stop of indexEffects.values())
+            stop();
+        indexEffects.clear();
+    }));
+}
+function lift(cb) {
+    let result;
+    const liftCleanup = debug.effect((access) => {
+        const source = cb(access);
+        if (!source || typeof source !== 'object')
+            throw new Error('lift callback must return an array or object');
+        if (!result) {
+            if (Array.isArray(source)) {
+                result = debug.reactive([]);
+            }
+            else {
+                result = debug.reactive({});
+            }
+        }
+        if (Array.isArray(source) && Array.isArray(result)) {
+            if (result.length !== source.length)
+                result.length = source.length;
+            for (let i = 0; i < source.length; i++)
+                if (result[i] !== source[i])
+                    result[i] = source[i];
+        }
+        else if (!Array.isArray(source) && !Array.isArray(result)) {
+            Object.assign(result, source);
+            for (const key of Object.keys(result))
+                if (!(key in source))
+                    delete result[key];
+        }
+        else {
+            throw new Error('lift callback must return the same type as the previous result');
+        }
+    });
+    return debug.cleanedBy(result, liftCleanup);
+}
+
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Deep watch an object and all its nested properties
+ * @param target - The object to watch deeply
+ * @param callback - The callback to call when any nested property changes
+ * @param options - Options for the deep watch
+ * @returns A cleanup function to stop watching
+ */
+/**
+ * Sets up deep watching for an object, tracking all nested property changes
+ * @param target - The object to watch
+ * @param callback - The callback to call when changes occur
+ * @param options - Options for deep watching
+ * @returns A cleanup function to stop deep watching
+ */
+function deepWatch(target, callback, { immediate = false } = {}) {
+    if (target === null || target === undefined)
+        return undefined;
+    if (typeof target !== 'object')
+        throw new Error('Target of deep watching must be an object');
+    // Create a wrapper callback that matches EffectTrigger signature
+    const wrappedCallback = debug.markWithRoot((() => callback(target)), callback);
+    // Use the existing effect system to register dependencies
+    return debug.effect(() => {
+        // Mark the target object as having deep watchers
+        debug.objectsWithDeepWatchers.add(target);
+        // Track which objects this effect is watching for cleanup
+        let effectObjects = debug.effectToDeepWatchedObjects.get(wrappedCallback);
+        if (!effectObjects) {
+            effectObjects = new Set();
+            debug.effectToDeepWatchedObjects.set(wrappedCallback, effectObjects);
+        }
+        effectObjects.add(target);
+        // Traverse the object graph and register dependencies
+        // This will re-run every time the effect runs, ensuring we catch all changes
+        const visited = new WeakSet();
+        function traverseAndTrack(obj, depth = 0) {
+            // Prevent infinite recursion and excessive depth
+            if (!obj || visited.has(obj) || !isObject(obj) || depth > debug.options.maxDeepWatchDepth)
+                return;
+            // Do not traverse into unreactive objects
+            if (debug.isNonReactive(obj))
+                return;
+            visited.add(obj);
+            // Mark this object as having deep watchers
+            debug.objectsWithDeepWatchers.add(obj);
+            effectObjects.add(obj);
+            // Traverse all properties to register dependencies
+            // unwrap to avoid kicking dependency
+            for (const key in debug.unwrap(obj)) {
+                if (Object.hasOwn(obj, key)) {
+                    // Access the property to register dependency
+                    const value = obj[key];
+                    // Make the value reactive if it's an object
+                    const reactiveValue = typeof value === 'object' && value !== null ? debug.reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+            }
+            // Also handle array indices and length
+            // biome-ignore lint/suspicious/useIsArray: Check for both native arrays and reactive arrays
+            if (Array.isArray(obj) || obj instanceof Array) {
+                // Access array length to register dependency on length changes
+                const length = obj.length;
+                // Access all current array elements to register dependencies
+                for (let i = 0; i < length; i++) {
+                    // Access the array element to register dependency
+                    const value = obj[i];
+                    // Make the value reactive if it's an object
+                    const reactiveValue = typeof value === 'object' && value !== null ? debug.reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+            }
+            // Handle Set values (deep watch values only, not keys since Sets don't have separate keys)
+            else if (obj instanceof Set) {
+                // Access all Set values to register dependencies
+                for (const value of obj) {
+                    // Make the value reactive if it's an object
+                    const reactiveValue = typeof value === 'object' && value !== null ? debug.reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+            }
+            // Handle Map values (deep watch values only, not keys)
+            else if (obj instanceof Map) {
+                // Access all Map values to register dependencies
+                for (const [_key, value] of obj) {
+                    // Make the value reactive if it's an object
+                    const reactiveValue = typeof value === 'object' && value !== null ? debug.reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+            }
+            // Note: WeakSet and WeakMap cannot be iterated, so we can't deep watch their contents
+            // They will only trigger when the collection itself is replaced
+        }
+        // Traverse the target object to register all dependencies
+        // This will register dependencies on all current properties and array elements
+        traverseAndTrack(target);
+        // Only call the callback if immediate is true or if it's not the first run
+        if (immediate)
+            callback(target);
+        immediate = true;
+        // Return a cleanup function that properly removes deep watcher tracking
+        return () => {
+            // Get the objects this effect was watching
+            const effectObjects = debug.effectToDeepWatchedObjects.get(wrappedCallback);
+            if (effectObjects) {
+                // Remove deep watcher tracking from all objects this effect was watching
+                for (const obj of effectObjects) {
+                    // Check if this object still has other deep watchers
+                    const watchers = debug.deepWatchers.get(obj);
+                    if (watchers) {
+                        // Remove this effect's callback from the watchers
+                        watchers.delete(wrappedCallback);
+                        // If no more watchers, remove the object from deep watchers tracking
+                        if (watchers.size === 0) {
+                            debug.deepWatchers.delete(obj);
+                            debug.objectsWithDeepWatchers.delete(obj);
+                        }
+                    }
+                    else {
+                        // No watchers found, remove from deep watchers tracking
+                        debug.objectsWithDeepWatchers.delete(obj);
+                    }
+                }
+                // Clean up the tracking data
+                debug.effectToDeepWatchedObjects.delete(wrappedCallback);
+            }
+        };
+    });
+}
+
+/**
+ * Converts an iterator to a generator that yields reactive values
+ */
+function* makeReactiveIterator(iterator) {
+    let result = iterator.next();
+    while (!result.done) {
+        yield debug.reactive(result.value);
+        result = iterator.next();
+    }
+}
+/**
+ * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
+ */
+function* makeReactiveEntriesIterator(iterator) {
+    let result = iterator.next();
+    while (!result.done) {
+        const [key, value] = result.value;
+        yield [debug.reactive(key), debug.reactive(value)];
+        result = iterator.next();
+    }
+}
+
+//#region watch
+const unsetYet = Symbol('unset-yet');
+function watch(value, //object | ((dep: DependencyAccess) => object),
+changed, options = {}) {
+    return typeof value === 'function'
+        ? watchCallBack(value, changed, options)
+        : typeof value === 'object' && value !== null
+            ? watchObject(value, changed, options)
+            : (() => {
+                throw new Error('watch: value must be a function or an object');
+            })();
+}
+function watchObject(value, changed, { immediate = false, deep = false } = {}) {
+    if (deep)
+        return deepWatch(value, changed, { immediate });
+    return debug.effect(function watchObjectEffect() {
+        debug.dependant(value);
+        if (immediate)
+            changed(value);
+        immediate = true;
+    });
+}
+function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
+    let oldValue = unsetYet;
+    let deepCleanup;
+    const cbCleanup = debug.effect(debug.markWithRoot(function watchCallBackEffect(access) {
+        const newValue = value(access);
+        if (oldValue !== newValue)
+            if (oldValue === unsetYet) {
+                if (immediate)
+                    changed(newValue);
+            }
+            else
+                changed(newValue, oldValue);
+        oldValue = newValue;
+        if (deep) {
+            if (deepCleanup)
+                deepCleanup();
+            deepCleanup = deepWatch(newValue, (value) => changed(value, value));
+        }
+    }, value));
+    return Object.defineProperties(() => {
+        cbCleanup();
+        if (deepCleanup)
+            deepCleanup();
+    }, {
+        [debug.stopped]: { get: () => cbCleanup[debug.stopped] },
+    });
+}
+//#endregion
+//#region nonReactive
+/**
+ * Mark an object as non-reactive. This object and all its properties will never be made reactive.
+ * @param obj - The object to mark as non-reactive
+ */
+function shallowNonReactive(obj) {
+    obj = debug.unwrap(obj);
+    if (debug.isNonReactive(obj))
+        return obj;
+    try {
+        Object.defineProperty(obj, debug.nonReactiveMark, {
+            value: true,
+            writable: false,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    catch { }
+    if (!(debug.nonReactiveMark in obj))
+        debug.nonReactiveObjects.add(obj);
+    // Finally, not deep
+    //for (const key in obj) deepNonReactive(obj[key])
+    return obj;
+}
+function unreactiveApplication(arg1, ...args) {
+    return typeof arg1 === 'object'
+        ? shallowNonReactive(arg1)
+        : ((original) => {
+            // Copy the parent's unreactive properties if they exist
+            original.prototype[debug.unreactiveProperties] = new Set(original.prototype[debug.unreactiveProperties] || []);
+            // Add all arguments (including the first one)
+            original.prototype[debug.unreactiveProperties].add(arg1);
+            for (const arg of args)
+                original.prototype[debug.unreactiveProperties].add(arg);
+            return original; // Return the class
+        });
+}
+/**
+ * Decorator that marks classes or properties as non-reactive
+ * Prevents objects from being made reactive
+ */
+const unreactive = debug.decorator({
+    class(original) {
+        // Called without arguments, mark entire class as non-reactive
+        debug.nonReactiveClass(original);
+    },
+    default: unreactiveApplication,
+});
+//#endregion
+
+// Helper to work around TypeScript limitation: base class expressions cannot reference class type parameters
+function getRegisterBase() {
+    class RegisterBase extends Indexable(ArrayReadForward, {
+        get(index) {
+            return this[getAt](index);
+        },
+        set(index, value) {
+            this[setAt](index, value);
+        },
+        getLength() {
+            return this.length;
+        },
+        setLength(value) {
+            this.length = value;
+        },
+    }) {
+        toArray() {
+            return Array.from(this);
+        }
+    }
+    return RegisterBase;
+}
+let RegisterClass = (() => {
+    var _RegisterClass_instances, _RegisterClass_keyFn, _RegisterClass_keys, _RegisterClass_values, _RegisterClass_usage, _RegisterClass_valueInfo, _RegisterClass_keyEffects, _RegisterClass_ascend, _RegisterClass_events, _RegisterClass_rekeyValue;
+    let _classDecorators = [unreactive];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = getRegisterBase();
+    _classThis = class extends _classSuper {
+        get [(_RegisterClass_keyFn = new WeakMap(), _RegisterClass_keys = new WeakMap(), _RegisterClass_values = new WeakMap(), _RegisterClass_usage = new WeakMap(), _RegisterClass_valueInfo = new WeakMap(), _RegisterClass_keyEffects = new WeakMap(), _RegisterClass_ascend = new WeakMap(), _RegisterClass_events = new WeakMap(), _RegisterClass_instances = new WeakSet(), forwardArray)]() {
+            return this.toArray();
+        }
+        on(eventOrEvents, cb) {
+            // @ts-expect-error Delegate to Eventful
+            return debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").on(eventOrEvents, cb);
+        }
+        off(eventOrEvents, cb) {
+            // @ts-expect-error Delegate to Eventful
+            debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").off(eventOrEvents, cb);
+        }
+        /**
+         * Register a global hook that receives all events
+         */
+        hook(cb) {
+            return debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").hook(cb);
+        }
+        constructor(keyFn, initial) {
+            super();
+            _RegisterClass_instances.add(this);
+            _RegisterClass_keyFn.set(this, void 0);
+            _RegisterClass_keys.set(this, void 0);
+            _RegisterClass_values.set(this, void 0);
+            _RegisterClass_usage.set(this, new Map());
+            _RegisterClass_valueInfo.set(this, new Map());
+            _RegisterClass_keyEffects.set(this, new Set());
+            _RegisterClass_ascend.set(this, void 0);
+            _RegisterClass_events.set(this, new Eventful()
+            /**
+             * Register event listeners for CRUD operations
+             */
+            );
+            /* Moved below initialization */
+            let ascendGet;
+            debug.effect(({ ascend }) => {
+                ascendGet = ascend;
+            });
+            debug.__classPrivateFieldSet(this, _RegisterClass_ascend, ascendGet, "f");
+            if (typeof keyFn !== 'function')
+                throw new Error('Register requires a key function');
+            debug.__classPrivateFieldSet(this, _RegisterClass_keyFn, keyFn, "f");
+            debug.__classPrivateFieldSet(this, _RegisterClass_keys, debug.reactive([]), "f");
+            debug.__classPrivateFieldSet(this, _RegisterClass_values, debug.reactive(new Map()), "f");
+            if (initial)
+                this.push(...initial);
+        }
+        ensureKey(value) {
+            let info = debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (info)
+                return info.key;
+            info = { key: undefined };
+            debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").set(value, info);
+            debug.__classPrivateFieldGet(this, _RegisterClass_ascend, "f").call(this, () => {
+                const stop = debug.effect(({ reaction }) => {
+                    const nextKey = debug.__classPrivateFieldGet(this, _RegisterClass_keyFn, "f").call(this, value);
+                    this.assertValidKey(nextKey);
+                    const previousKey = info.key;
+                    if (reaction && previousKey !== undefined && !Object.is(nextKey, previousKey))
+                        debug.__classPrivateFieldGet(this, _RegisterClass_instances, "m", _RegisterClass_rekeyValue).call(this, value, previousKey, nextKey);
+                    info.key = nextKey;
+                });
+                info.stop = stop;
+                debug.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").add(stop);
+            });
+            if (info.key === undefined)
+                throw new Error('Register key function must return a property key');
+            return info.key;
+        }
+        assertValidKey(key) {
+            const type = typeof key;
+            if (type !== 'string' && type !== 'number' && type !== 'symbol')
+                throw new Error('Register key function must return a property key');
+        }
+        setKeyValue(key, value, index) {
+            const existing = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+            if (existing !== undefined && existing !== value) {
+                this.cleanupValue(existing);
+                debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+                if (index !== undefined) {
+                    debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', existing, value, key, index);
+                }
+            }
+            else {
+                debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+            }
+        }
+        cleanupValue(value) {
+            const info = debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (!info)
+                return;
+            const stop = info.stop;
+            if (stop) {
+                info.stop = undefined;
+                debug.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").delete(stop);
+                stop();
+            }
+            debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").delete(value);
+        }
+        disposeKeyEffects() {
+            for (const value of Array.from(debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").keys()))
+                this.cleanupValue(value);
+            debug.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").clear();
+        }
+        incrementUsage(key) {
+            const count = debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key) ?? 0;
+            debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count + 1);
+        }
+        decrementUsage(key, index) {
+            const count = debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key);
+            if (!count)
+                return;
+            if (count <= 1) {
+                const value = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(key);
+                debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").delete(key);
+                if (value !== undefined) {
+                    this.cleanupValue(value);
+                    const idx = index ?? debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
+                    debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('delete', value, key, idx);
+                }
+            }
+            else {
+                debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count - 1);
+            }
+        }
+        normalizeIndex(index, allowEnd = false) {
+            const length = this.length;
+            let resolved = index;
+            if (resolved < 0)
+                resolved = Math.max(length + resolved, 0);
+            if (resolved > length) {
+                if (allowEnd)
+                    resolved = length;
+                else
+                    throw new RangeError('Index out of bounds');
+            }
+            if (!allowEnd && resolved === length)
+                throw new RangeError('Index out of bounds');
+            return resolved;
+        }
+        assignAt(index, key, value) {
+            const oldKey = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
+            if (oldKey !== undefined && Object.is(oldKey, key)) {
+                const oldValue = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                this.setKeyValue(key, value);
+                if (oldValue !== undefined && oldValue !== value) {
+                    debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', oldValue, value, key, index);
+                }
+                return;
+            }
+            if (oldKey !== undefined)
+                this.decrementUsage(oldKey);
+            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index] = key;
+            this.incrementUsage(key);
+            this.setKeyValue(key, value);
+            debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
+        }
+        insertKeyValue(index, key, value) {
+            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 0, key);
+            this.incrementUsage(key);
+            this.setKeyValue(key, value);
+            debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
+        }
+        rebuildFrom(values) {
+            this.disposeKeyEffects();
+            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(0, debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length);
+            debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
+            debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
+            for (const value of values) {
+                const key = this.ensureKey(value);
+                debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").push(key);
+                this.incrementUsage(key);
+                debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+            }
+        }
+        get length() {
+            return debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length;
+        }
+        [(_RegisterClass_rekeyValue = function _RegisterClass_rekeyValue(value, oldKey, newKey) {
+            if (Object.is(oldKey, newKey))
+                return;
+            const existingValue = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(newKey);
+            if (existingValue !== undefined && existingValue !== value)
+                throw new Error(`Register key collision for key ${String(newKey)}`);
+            const count = debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(oldKey);
+            if (!count)
+                return;
+            const existingCount = debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(newKey) ?? 0;
+            this.setKeyValue(newKey, value);
+            let index = -1;
+            for (let i = 0; i < debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length; i++)
+                if (Object.is(debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i], oldKey)) {
+                    debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i] = newKey;
+                    if (index === -1)
+                        index = i;
+                }
+            debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(newKey, existingCount + count);
+            debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(oldKey);
+            debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").delete(oldKey);
+            const updatedInfo = debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (updatedInfo)
+                updatedInfo.key = newKey;
+            if (index !== -1) {
+                debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('rekey', value, oldKey, newKey, index);
+            }
+        }, getAt)](index) {
+            const key = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
+            return key === undefined ? undefined : debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+        }
+        [setAt](index, value) {
+            const key = this.ensureKey(value);
+            if (index === this.length) {
+                this.insertKeyValue(index, key, value);
+                return;
+            }
+            const normalized = this.normalizeIndex(index);
+            this.assignAt(normalized, key, value);
+        }
+        push(...items) {
+            for (const item of items) {
+                const key = this.ensureKey(item);
+                this.insertKeyValue(this.length, key, item);
+            }
+            return this.length;
+        }
+        pop() {
+            if (!this.length)
+                return undefined;
+            return this.removeAt(this.length - 1);
+        }
+        shift() {
+            if (!this.length)
+                return undefined;
+            return this.removeAt(0);
+        }
+        unshift(...items) {
+            let index = 0;
+            for (const item of items) {
+                const key = this.ensureKey(item);
+                this.insertKeyValue(index++, key, item);
+            }
+            return this.length;
+        }
+        splice(start, deleteCount, ...items) {
+            const normalizedStart = this.normalizeIndex(start, true);
+            const maxDeletions = this.length - normalizedStart;
+            const actualDelete = Math.min(deleteCount === undefined ? maxDeletions : Math.max(deleteCount, 0), maxDeletions);
+            const keysToInsert = [];
+            for (const item of items)
+                keysToInsert.push(this.ensureKey(item));
+            const removedKeys = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(normalizedStart, actualDelete, ...keysToInsert);
+            const removedValues = [];
+            for (let i = 0; i < removedKeys.length; i++) {
+                const key = removedKeys[i];
+                if (key === undefined)
+                    continue;
+                const value = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                this.decrementUsage(key, normalizedStart + i);
+                removedValues.push(value);
+            }
+            for (let i = 0; i < keysToInsert.length; i++) {
+                const key = keysToInsert[i];
+                const value = items[i];
+                this.incrementUsage(key);
+                this.setKeyValue(key, value);
+            }
+            return removedValues;
+        }
+        clear() {
+            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length = 0;
+            debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
+            debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
+            this.disposeKeyEffects();
+        }
+        get(key) {
+            return debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+        }
+        set(key, value) {
+            if (debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
+                this.setKeyValue(key, value);
+        }
+        remove(key) {
+            let index = this.indexOfKey(key);
+            while (index !== -1) {
+                this.removeAt(index);
+                index = this.indexOfKey(key);
+            }
+        }
+        removeAt(index) {
+            const [key] = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 1);
+            if (key === undefined)
+                return undefined;
+            const value = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+            this.decrementUsage(key, index);
+            return value;
+        }
+        /**
+         * Keep only the items for which the predicate returns true.
+         * Items for which the predicate returns false are removed.
+         *
+         * The predicate is evaluated once per distinct key; duplicate keys
+         * will follow the same keep/remove decision.
+         */
+        keep(predicate) {
+            const decisions = new Map();
+            for (const [index, key] of debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").entries()) {
+                if (decisions.has(key)) {
+                    if (!decisions.get(key))
+                        this.removeAt(index);
+                    continue;
+                }
+                const value = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                const shouldKeep = predicate(value);
+                decisions.set(key, shouldKeep);
+                if (!shouldKeep)
+                    this.removeAt(index);
+            }
+        }
+        hasKey(key) {
+            return debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").has(key);
+        }
+        indexOfKey(key) {
+            return debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
+        }
+        mapKeys() {
+            return debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").keys();
+        }
+        update(...values) {
+            for (const value of values) {
+                const key = this.ensureKey(value);
+                if (debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key)) {
+                    const index = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
+                    this.setKeyValue(key, value, index);
+                }
+            }
+        }
+        upsert(insert, ...values) {
+            for (const value of values) {
+                const key = this.ensureKey(value);
+                if (debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
+                    this.setKeyValue(key, value);
+                else
+                    insert(value);
+            }
+        }
+        entries() {
+            const self = this;
+            function* iterator() {
+                for (let i = 0; i < debug.__classPrivateFieldGet(self, _RegisterClass_keys, "f").length; i++) {
+                    const val = debug.__classPrivateFieldGet(self, _RegisterClass_values, "f").get(debug.__classPrivateFieldGet(self, _RegisterClass_keys, "f")[i]);
+                    if (val !== undefined)
+                        yield [i, val];
+                }
+            }
+            return iterator();
+        }
+        [Symbol.iterator]() {
+            const self = this;
+            function* iterator() {
+                for (const key of debug.__classPrivateFieldGet(self, _RegisterClass_keys, "f")) {
+                    const value = debug.__classPrivateFieldGet(self, _RegisterClass_values, "f").get(key);
+                    if (value !== undefined)
+                        yield value;
+                }
+            }
+            return iterator();
+        }
+        toString() {
+            return `[Register length=${this.length}]`;
+        }
+        at(index) {
+            const resolved = index < 0 ? this.length + index : index;
+            if (resolved < 0 || resolved >= this.length)
+                return undefined;
+            return this[getAt](resolved);
+        }
+        reverse() {
+            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").reverse();
+            return this;
+        }
+        sort(compareFn) {
+            const fwdCompareFn = compareFn
+                ? (a, b) => compareFn(debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(a), debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(b))
+                : undefined;
+            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").sort(fwdCompareFn);
+            return this;
+        }
+        fill(value, start = 0, end = this.length) {
+            const values = this.toArray();
+            values.fill(value, start, end);
+            this.rebuildFrom(values);
+            return this;
+        }
+        copyWithin(target, start, end) {
+            const values = this.toArray();
+            values.copyWithin(target, start, end);
+            this.rebuildFrom(values);
+            return this;
+        }
+    };
+    debug.__setFunctionName(_classThis, "RegisterClass");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        debug.__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        debug.__runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return _classThis;
+})();
+const Register = RegisterClass;
+/**
+ * Creates a reactive Register - an ordered, array-like collection with stable key-based identity.
+ *
+ * Register combines array semantics (indexable access, ordering, iteration) with Map-like
+ * key-based lookups. Items with the same key share the same value instance, making it ideal
+ * for UI lists keyed by IDs or when you need to preserve identity across reorders.
+ *
+ * @param keyFn - Function that extracts the key from each item
+ * @param initial - Optional initial items to populate the register
+ * @returns A reactive Register instance
+ *
+ * @example
+ * ```typescript
+ * const users = register(
+ *   (user: User) => user.id,
+ *   [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
+ * )
+ *
+ * users.push({ id: 3, name: 'Charlie' })
+ * const bob = users.get(2) // Get by key
+ * ```
+ */
+function register(keyFn, initial) {
+    return new RegisterClass(keyFn, initial);
+}
+
+/**
+ * Maps projection effects (item effects) to their projection context
+ */
+const effectProjectionMetadata = new WeakMap();
+/**
+ * Returns the projection context of the currently running effect, if any.
+ */
+function getActiveProjection() {
+    const active = debug.getActiveEffect();
+    return active ? effectProjectionMetadata.get(active) : undefined;
+}
+function setActiveProjection(projection) {
+    const active = debug.getActiveEffect();
+    if (active)
+        effectProjectionMetadata.set(active, projection);
+}
+function defineAccessValue(access) {
+    Object.defineProperty(access, 'value', {
+        get: access.get,
+        set: access.set,
+        configurable: true,
+        enumerable: true,
+    });
+}
+function makeCleanup(target, effectMap, onDispose, metadata) {
+    if (metadata) {
+        Object.defineProperty(target, debug.projectionInfo, {
+            value: metadata,
+            writable: false,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    return debug.cleanedBy(target, () => {
+        onDispose();
+        for (const stop of effectMap.values())
+            stop?.();
+        effectMap.clear();
+    });
+}
+function projectArray(source, apply) {
+    source = debug.reactive(source);
+    const target = debug.reactive([]);
+    const indexEffects = new Map();
+    function normalizeTargetLength(length) {
+        debug.FoolProof.set(target, 'length', length, target);
+    }
+    function disposeIndex(index) {
+        const stopEffect = indexEffects.get(index);
+        if (stopEffect) {
+            indexEffects.delete(index);
+            stopEffect();
+            Reflect.deleteProperty(target, index);
+        }
+    }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
+    const cleanupLength = debug.effect(debug.named(`project:${source[Symbol.toStringTag]}.length`, ({ ascend }) => {
+        const length = source.length;
+        normalizeTargetLength(length);
+        const existing = Array.from(indexEffects.keys());
+        for (let i = 0; i < length; i++) {
+            if (indexEffects.has(i))
+                continue;
+            ascend(function projectArrayIndexAscend() {
+                const index = i;
+                const stop = debug.effect(debug.named(`project:${source[Symbol.toStringTag]}[${index}]`, ({ reaction }) => {
+                    if (!reaction)
+                        setActiveProjection({ source, key: index, target, depth, parent });
+                    const previous = debug.untracked(() => target[index]);
+                    const accessBase = {
+                        key: index,
+                        source,
+                        get: () => debug.FoolProof.get(source, index, source),
+                        set: (value) => debug.FoolProof.set(source, index, value, source),
+                        old: previous,
+                    };
+                    defineAccessValue(accessBase);
+                    target[index] = apply(accessBase, target);
+                }));
+                debug.setEffectName(stop, `project[${depth}]:${index}`);
+                indexEffects.set(i, stop);
+            });
+        }
+        for (const index of existing)
+            if (index >= length)
+                disposeIndex(index);
+    }));
+    return makeCleanup(target, indexEffects, () => cleanupLength(), {
+        source,
+        target,
+        apply,
+        depth,
+        parent,
+    });
+}
+function projectRegister(source, apply) {
+    source = debug.reactive(source);
+    const rawTarget = new Map();
+    const target = debug.reactive(rawTarget);
+    const keyEffects = new Map();
+    function disposeKey(key) {
+        const stopEffect = keyEffects.get(key);
+        if (stopEffect) {
+            stopEffect();
+            keyEffects.delete(key);
+            target.delete(key);
+        }
+    }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
+    const cleanupKeys = debug.effect(function projectRegisterEffect({ ascend }) {
+        const keys = new Set();
+        for (const key of source.mapKeys())
+            keys.add(key);
+        for (const key of keys) {
+            if (keyEffects.has(key))
+                continue;
+            ascend(() => {
+                const stop = debug.effect(function projectRegisterKeyEffect({ reaction }) {
+                    if (!reaction)
+                        setActiveProjection({ source, key, target, depth, parent });
+                    const previous = debug.untracked(() => target.get(key));
+                    const accessBase = {
+                        key,
+                        source: source,
+                        get: () => source.get(key),
+                        set: (value) => {
+                            source.set(key, value);
+                            return true;
+                        },
+                        old: previous,
+                    };
+                    defineAccessValue(accessBase);
+                    const produced = apply(accessBase, target);
+                    target.set(key, produced);
+                });
+                debug.setEffectName(stop, `project[${depth}]:${String(key)}`);
+                keyEffects.set(key, stop);
+            });
+        }
+        for (const key of Array.from(keyEffects.keys()))
+            if (!keys.has(key))
+                disposeKey(key);
+    });
+    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+        source: source,
+        target,
+        apply,
+        depth,
+        parent,
+    });
+}
+function projectRecord(source, apply) {
+    source = debug.reactive(source);
+    const target = debug.reactive({});
+    const keyEffects = new Map();
+    function disposeKey(key) {
+        const stopEffect = keyEffects.get(key);
+        if (stopEffect) {
+            stopEffect();
+            keyEffects.delete(key);
+            Reflect.deleteProperty(target, key);
+        }
+    }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
+    const cleanupKeys = debug.effect(function projectRecordEffect({ ascend }) {
+        const keys = new Set();
+        for (const key in source)
+            keys.add(key);
+        const observed = Reflect.ownKeys(source);
+        for (const key of observed)
+            keys.add(key);
+        for (const key of keys) {
+            if (keyEffects.has(key))
+                continue;
+            ascend(() => {
+                const stop = debug.effect(function projectRecordKeyEffect({ reaction }) {
+                    if (!reaction)
+                        setActiveProjection({ source, key, target, depth, parent });
+                    const sourceKey = key;
+                    const previous = debug.untracked(() => target[key]);
+                    const accessBase = {
+                        key: sourceKey,
+                        source: source,
+                        get: () => debug.FoolProof.get(source, sourceKey, source),
+                        set: (value) => debug.FoolProof.set(source, sourceKey, value, source),
+                        old: previous,
+                    };
+                    defineAccessValue(accessBase);
+                    const produced = apply(accessBase, target);
+                    target[sourceKey] = produced;
+                });
+                debug.setEffectName(stop, `project[${depth}]:${String(key)}`);
+                keyEffects.set(key, stop);
+            });
+        }
+        for (const key of Array.from(keyEffects.keys()))
+            if (!keys.has(key))
+                disposeKey(key);
+    });
+    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+        source: source,
+        target,
+        apply,
+        depth,
+        parent,
+    });
+}
+function projectMap(source, apply) {
+    source = debug.reactive(source);
+    const rawTarget = new Map();
+    const target = debug.reactive(rawTarget);
+    const keyEffects = new Map();
+    function disposeKey(key) {
+        const stopEffect = keyEffects.get(key);
+        if (stopEffect) {
+            stopEffect();
+            keyEffects.delete(key);
+            target.delete(key);
+        }
+    }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
+    const cleanupKeys = debug.effect(function projectMapEffect({ ascend }) {
+        const keys = new Set();
+        for (const key of source.keys())
+            keys.add(key);
+        for (const key of keys) {
+            if (keyEffects.has(key))
+                continue;
+            ascend(() => {
+                const stop = debug.effect(function projectMapKeyEffect({ reaction }) {
+                    if (!reaction)
+                        setActiveProjection({ source, key, target, depth, parent });
+                    const previous = debug.untracked(() => target.get(key));
+                    const accessBase = {
+                        key,
+                        source: source,
+                        get: () => source.get(key),
+                        set: (value) => {
+                            source.set(key, value);
+                            return true;
+                        },
+                        old: previous,
+                    };
+                    defineAccessValue(accessBase);
+                    const produced = apply(accessBase, target);
+                    target.set(key, produced);
+                });
+                debug.setEffectName(stop, `project[${depth}]:${String(key)}`);
+                keyEffects.set(key, stop);
+            });
+        }
+        for (const key of Array.from(keyEffects.keys()))
+            if (!keys.has(key))
+                disposeKey(key);
+    });
+    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+        source: source,
+        target,
+        apply,
+        depth,
+        parent,
+    });
+}
+function projectCore(source, apply) {
+    if (Array.isArray(source))
+        return projectArray(source, apply);
+    if (source instanceof Map)
+        return projectMap(source, apply);
+    if (source instanceof Register)
+        return projectRegister(source, apply);
+    if (source && (source.constructor === Object || source.constructor === undefined))
+        return projectRecord(source, apply);
+    throw new Error('Unsupported source type');
+}
+const project = Object.assign(projectCore, {
+    array: projectArray,
+    register: projectRegister,
+    record: projectRecord,
+    map: projectMap,
+});
+
+/**
+ * Organizes a source object's properties into a target object using a callback function.
+ * This creates a reactive mapping between source properties and a target object,
+ * automatically handling property additions, updates, and removals.
+ *
+ * @template Source - The type of the source object
+ * @template Target - The type of the target object (defaults to Record<PropertyKey, any>)
+ *
+ * @param {Source} source - The source object to organize
+ * @param {OrganizedCallback<Source, Target>} apply - Callback function that defines how each source property is mapped to the target
+ * @param {Target} [baseTarget={}] - Optional base target object to use (will be made reactive if not already)
+ *
+ * @returns {OrganizedResult<Target>} The target object with cleanup capability
+ *
+ * @example
+ * // Organize user permissions into role-based access
+ * const user = reactive({ isAdmin: true, canEdit: false });
+ * const permissions = organized(
+ *   user,
+ *   (access, target) => {
+ *     if (access.key === 'isAdmin') {
+ *       target.hasFullAccess = access.value;
+ *     }
+ *     target[`can${access.key.charAt(0).toUpperCase() + access.key.slice(1)}`] = access.value;
+ *   }
+ * );
+ *
+ * @example
+ * // Transform object structure with cleanup
+ * const source = reactive({ firstName: 'John', lastName: 'Doe' });
+ * const formatted = organized(
+ *   source,
+ *   (access, target) => {
+ *     if (access.key === 'firstName' || access.key === 'lastName') {
+ *       target.fullName = `${source.firstName} ${source.lastName}`.trim();
+ *     }
+ *   }
+ * );
+ *
+ * @example
+ * // Using with cleanup in a component
+ * effect(() => {
+ *   const data = fetchData();
+ *   const organizedData = organized(data, (access, target) => {
+ *     // Transform data
+ *   });
+ *
+ *   // The cleanup will be called automatically when the effect is disposed
+ *   return () => organizedData[cleanup]();
+ * });
+ */
+function organized(source, apply, baseTarget = {}) {
+    const observedSource = debug.reactive(source);
+    const target = debug.reactive(baseTarget);
+    const stop = attend(() => {
+        const keys = [];
+        for (const key in observedSource)
+            keys.push(key);
+        return keys;
+    }, (key) => {
+        const sourceKey = key;
+        const accessBase = {
+            key: sourceKey,
+            get: () => debug.FoolProof.get(observedSource, sourceKey, observedSource),
+            set: (value) => debug.FoolProof.set(observedSource, sourceKey, value, observedSource),
+        };
+        Object.defineProperty(accessBase, 'value', {
+            get: accessBase.get,
+            set: accessBase.set,
+            configurable: true,
+            enumerable: true,
+        });
+        return apply(accessBase, target);
+    });
+    return debug.cleanedBy(target, stop);
+}
+/**
+ * Organizes a property on a target object
+ * Shortcut for defineProperty/delete with touched signal
+ * @param target - The target object
+ * @param property - The property to organize
+ * @param access - The access object
+ * @returns The property descriptor
+ */
+function organize(target, property, access) {
+    Object.defineProperty(target, property, {
+        get: access.get,
+        set: access.set,
+        configurable: true,
+        enumerable: true,
+    });
+    debug.touched1(target, { type: 'set', prop: property }, property);
+    return () => delete target[property];
+}
+
+/**
+ * Reactively defines properties on a target object based on a descriptors record.
+ *
+ * It tracks the keys of the descriptors record and defines/updates/removes
+ * properties on the target object as they change.
+ *
+ * @param descriptors - A reactive record of property descriptors.
+ * @param target - The object to define properties on (defaults to a new object).
+ * @returns The target object with reactive property definitions.
+ */
+function describe(descriptors, target = Object.create(null)) {
+    descriptors = debug.reactive(descriptors);
+    const stop = attend(() => Reflect.ownKeys(descriptors), (key) => {
+        const desc = descriptors[key];
+        if (desc) {
+            Object.defineProperty(target, key, {
+                enumerable: true,
+                ...desc,
+                configurable: true,
+            });
+            debug.touched1(target, { type: 'set', prop: key }, key);
+        }
+        return () => Reflect.deleteProperty(target, key);
+    });
+    return debug.cleanedBy(target, stop);
+}
+
+function* index(i, { length = true } = {}) {
+    if (length)
+        yield 'length';
+    yield i;
+}
+function* range(a, b, { length = false } = {}) {
+    const start = Math.min(a, b);
+    const end = Math.max(a, b);
+    if (length)
+        yield 'length';
+    for (let i = start; i <= end; i++)
+        yield i;
+}
+class Indexer extends Array {
+    get(i) {
+        debug.dependant(this, i);
+        return debug.reactive(this[i]);
+    }
+    // Returns undefined intentionally: signals the proxy handler that notifications
+    // were already dispatched via touched(), preventing double notification
+    set(i, value) {
+        const added = i >= this.length;
+        this[i] = value;
+        debug.touched(this, { type: 'set', prop: i }, index(i, { length: added }));
+    }
+}
+const indexLess = { get: debug.FoolProof.get, set: debug.FoolProof.set };
+Object.assign(debug.FoolProof, {
+    get(obj, prop, receiver) {
+        if (obj instanceof Array && typeof prop === 'string') {
+            const index = parseInt(prop);
+            if (!Number.isNaN(index))
+                return Indexer.prototype.get.call(obj, index);
+        }
+        return indexLess.get(obj, prop, receiver);
+    },
+    set(obj, prop, value, receiver) {
+        if (obj instanceof Array && typeof prop === 'string') {
+            const index = parseInt(prop);
+            if (!Number.isNaN(index))
+                return Indexer.prototype.set.call(obj, index, value);
+        }
+        return indexLess.set(obj, prop, value, receiver);
+    },
+});
+class ReactiveArray extends Array {
+    toJSON() {
+        return this;
+    }
+    get length() {
+        debug.dependant(this, 'length');
+        return this.length;
+    }
+    set length(value) {
+        const oldLength = this.length;
+        if (oldLength === value)
+            return;
+        try {
+            this.length = value;
+        }
+        finally {
+            debug.touched(this, { type: 'set', prop: 'length' }, range(oldLength, value, { length: true }));
+        }
+    }
+    // Safe array access with negative indices
+    at(index) {
+        const actualIndex = index < 0 ? this.length + index : index;
+        debug.dependant(this, actualIndex);
+        if (index < 0)
+            debug.dependant(this, 'length');
+        if (actualIndex < 0 || actualIndex >= this.length)
+            return undefined;
+        return debug.reactive(this[actualIndex]);
+    }
+    // Immutable versions of mutator methods
+    toReversed() {
+        debug.dependant(this);
+        return debug.reactive(this.toReversed());
+    }
+    toSorted(compareFn) {
+        debug.dependant(this);
+        return debug.reactive(this.toSorted(compareFn));
+    }
+    toSpliced(start, deleteCount, ...items) {
+        debug.dependant(this);
+        return deleteCount === undefined
+            ? this.toSpliced(start)
+            : this.toSpliced(start, deleteCount, ...items);
+    }
+    with(index, value) {
+        debug.dependant(this);
+        return debug.reactive(this.with(index, value));
+    }
+    // Iterator methods with reactivity tracking
+    entries() {
+        debug.dependant(this);
+        return makeReactiveEntriesIterator(this.entries());
+    }
+    keys() {
+        debug.dependant(this, 'length');
+        return this.keys();
+    }
+    values() {
+        debug.dependant(this);
+        return makeReactiveIterator(this.values());
+    }
+    [Symbol.iterator]() {
+        debug.dependant(this);
+        const nativeIterator = this[Symbol.iterator]();
+        return {
+            next() {
+                const result = nativeIterator.next();
+                if (result.done) {
+                    return result;
+                }
+                return { value: debug.reactive(result.value), done: false };
+            },
+            [Symbol.iterator]() {
+                return this;
+            },
+            [Symbol.dispose]() { },
+        };
+    }
+    indexOf(searchElement, fromIndex) {
+        const length = this.length;
+        let i = fromIndex === undefined ? 0 : fromIndex;
+        if (i < 0)
+            i = Math.max(length + i, 0);
+        const unwrappedSearch = debug.unwrap(searchElement);
+        for (; i < length; i++) {
+            debug.dependant(this, i);
+            const item = this[i];
+            if (item === searchElement || item === unwrappedSearch || debug.unwrap(item) === unwrappedSearch) {
+                return i;
+            }
+        }
+        debug.dependant(this, 'length');
+        return -1;
+    }
+    lastIndexOf(searchElement, fromIndex) {
+        const length = this.length;
+        let i = fromIndex === undefined ? length - 1 : fromIndex;
+        if (i >= length)
+            i = length - 1;
+        if (i < 0)
+            i = Math.max(length + i, -1); // -1 ensures loop condition i >= 0 works correctly
+        const unwrappedSearch = debug.unwrap(searchElement);
+        for (; i >= 0; i--) {
+            debug.dependant(this, i);
+            const item = this[i];
+            if (item === searchElement || item === unwrappedSearch || debug.unwrap(item) === unwrappedSearch) {
+                return i;
+            }
+        }
+        // If we scanned the whole relevant part and didn't find it, we depend on length
+        // (because adding elements might shift indices or add the element)
+        // Actually for lastIndexOf, if we start from end, length dependency is implicit in the start index calculation?
+        // But if we return -1, it means we didn't find it.
+        // If we push an element, should lastIndexOf update?
+        // Yes, if the new element is the one we are looking for.
+        debug.dependant(this, 'length');
+        return -1;
+    }
+    includes(searchElement, fromIndex) {
+        return this.indexOf(searchElement, fromIndex) !== -1;
+    }
+    find(predicateOrElement, thisArg) {
+        if (typeof predicateOrElement === 'function') {
+            const predicate = predicateOrElement;
+            const length = this.length;
+            for (let i = 0; i < length; i++) {
+                debug.dependant(this, i);
+                const val = debug.reactive(this[i]);
+                if (predicate.call(thisArg, val, i, this)) {
+                    return val;
+                }
+            }
+            debug.dependant(this, 'length');
+            return undefined;
+        }
+        const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
+        const index = this.indexOf(predicateOrElement, fromIndex);
+        if (index === -1)
+            return undefined;
+        return debug.reactive(this[index]);
+    }
+    findIndex(predicateOrElement, thisArg) {
+        if (typeof predicateOrElement === 'function') {
+            const predicate = predicateOrElement;
+            const length = this.length;
+            for (let i = 0; i < length; i++) {
+                debug.dependant(this, i);
+                const val = debug.reactive(this[i]);
+                if (predicate.call(thisArg, val, i, this)) {
+                    return i;
+                }
+            }
+            debug.dependant(this, 'length');
+            return -1;
+        }
+        const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
+        return this.indexOf(predicateOrElement, fromIndex);
+    }
+    flat(depth) {
+        debug.dependant(this);
+        return debug.reactive(depth === undefined ? this.flat() : this.flat(depth));
+    }
+    flatMap(callbackfn, thisArg) {
+        debug.dependant(this);
+        return debug.reactive(this.flatMap((item, index, array) => callbackfn.call(thisArg, debug.reactive(item), index, array), thisArg));
+    }
+    filter(callbackfn, thisArg) {
+        debug.dependant(this);
+        return debug.reactive(this.filter((item, index, array) => callbackfn(debug.reactive(item), index, array), thisArg));
+    }
+    map(callbackfn, thisArg) {
+        debug.dependant(this);
+        return debug.reactive(this.map((item, index, array) => callbackfn(debug.reactive(item), index, array), thisArg));
+    }
+    reduce(callbackfn, initialValue) {
+        debug.dependant(this);
+        const result = initialValue === undefined
+            ? this.reduce(callbackfn)
+            : this.reduce(callbackfn, initialValue);
+        return debug.reactive(result);
+    }
+    reduceRight(callbackfn, initialValue) {
+        debug.dependant(this);
+        const result = initialValue !== undefined
+            ? this.reduceRight(callbackfn, initialValue)
+            : this.reduceRight(callbackfn);
+        return debug.reactive(result);
+    }
+    slice(start, end) {
+        for (const i of range(start || 0, end || this.length - 1))
+            debug.dependant(this, i);
+        return start === undefined
+            ? this.slice()
+            : end === undefined
+                ? this.slice(start)
+                : this.slice(start, end);
+    }
+    concat(...items) {
+        debug.dependant(this);
+        return debug.reactive(this.concat(...items));
+    }
+    join(separator) {
+        debug.dependant(this);
+        return this.join(separator);
+    }
+    forEach(callbackfn, thisArg) {
+        debug.dependant(this);
+        this.forEach((value, index, array) => {
+            callbackfn.call(thisArg, debug.reactive(value), index, array);
+        });
+    }
+    every(callbackfn, thisArg) {
+        const length = this.length;
+        for (let i = 0; i < length; i++) {
+            debug.dependant(this, i);
+            if (!callbackfn.call(thisArg, debug.reactive(this[i]), i, this)) {
+                return false;
+            }
+        }
+        debug.dependant(this, 'length');
+        return true;
+    }
+    some(callbackfn, thisArg) {
+        const length = this.length;
+        for (let i = 0; i < length; i++) {
+            debug.dependant(this, i);
+            if (callbackfn.call(thisArg, debug.reactive(this[i]), i, this)) {
+                return true;
+            }
+        }
+        debug.dependant(this, 'length');
+        return false;
+    }
+    // Side-effectful
+    push(...items) {
+        const oldLength = this.length;
+        try {
+            return this.push(...items);
+        }
+        finally {
+            debug.touched(this, { type: 'bunch', method: 'push' }, range(oldLength, oldLength + items.length - 1, { length: true }));
+        }
+    }
+    pop() {
+        if (this.length === 0)
+            return undefined;
+        try {
+            return debug.reactive(this.pop());
+        }
+        finally {
+            debug.touched(this, { type: 'bunch', method: 'pop' }, index(this.length));
+        }
+    }
+    shift() {
+        if (this.length === 0)
+            return undefined;
+        try {
+            return debug.reactive(this.shift());
+        }
+        finally {
+            debug.touched(this, { type: 'bunch', method: 'shift' }, range(0, this.length + 1, { length: true }));
+        }
+    }
+    unshift(...items) {
+        try {
+            return this.unshift(...items);
+        }
+        finally {
+            debug.touched(this, { type: 'bunch', method: 'unshift' }, range(0, this.length - items.length, { length: true }));
+        }
+    }
+    splice(start, deleteCount, ...items) {
+        const oldLength = this.length;
+        // Normalize start index
+        let actualStart = start;
+        if (actualStart < 0)
+            actualStart = Math.max(oldLength + actualStart, 0);
+        else
+            actualStart = Math.min(actualStart, oldLength);
+        // Normalize deleteCount
+        let actualDeleteCount = deleteCount;
+        if (actualDeleteCount === undefined) {
+            actualDeleteCount = oldLength - actualStart;
+        }
+        else {
+            actualDeleteCount = Math.max(0, Math.min(actualDeleteCount, oldLength - actualStart));
+        }
+        try {
+            if (deleteCount === undefined)
+                return debug.reactive(this.splice(start));
+            return debug.reactive(this.splice(start, deleteCount, ...items));
+        }
+        finally {
+            debug.touched(this, { type: 'bunch', method: 'splice' }, actualDeleteCount === items.length
+                ? range(actualStart, actualStart + actualDeleteCount - 1)
+                : range(actualStart, oldLength + Math.max(items.length - actualDeleteCount, 0), {
+                    length: true,
+                }));
+        }
+    }
+    reverse() {
+        try {
+            return this.reverse();
+        }
+        finally {
+            debug.touched(this, { type: 'bunch', method: 'reverse' }, range(0, this.length - 1));
+        }
+    }
+    sort(compareFn) {
+        compareFn = compareFn || ((a, b) => a.toString().localeCompare(b.toString()));
+        try {
+            return this.sort((a, b) => compareFn(debug.reactive(a), debug.reactive(b)));
+        }
+        finally {
+            debug.touched(this, { type: 'bunch', method: 'sort' }, range(0, this.length - 1));
+        }
+    }
+    fill(value, start, end) {
+        const len = this.length;
+        let k = start === undefined ? 0 : start;
+        if (k < 0)
+            k = Math.max(len + k, 0);
+        else
+            k = Math.min(k, len);
+        let final = end === undefined ? len : end;
+        if (final < 0)
+            final = Math.max(len + final, 0);
+        else
+            final = Math.min(final, len);
+        try {
+            if (start === undefined)
+                return this.fill(value);
+            if (end === undefined)
+                return this.fill(value, start);
+            return this.fill(value, start, end);
+        }
+        finally {
+            if (final > k) {
+                debug.touched(this, { type: 'bunch', method: 'fill' }, range(k, final - 1));
+            }
+        }
+    }
+    copyWithin(target, start, end) {
+        try {
+            if (end === undefined)
+                return this.copyWithin(target, start);
+            return this.copyWithin(target, start, end);
+        }
+        finally {
+            const len = this.length;
+            let to = target;
+            if (to < 0)
+                to = Math.max(len + to, 0);
+            else if (to >= len)
+                to = len;
+            let from = start;
+            if (from < 0)
+                from = Math.max(len + from, 0);
+            else if (from >= len)
+                from = len;
+            let final = end === undefined ? len : end;
+            if (final < 0)
+                final = Math.max(len + final, 0);
+            else if (final >= len)
+                final = len;
+            const count = Math.min(final - from, len - to);
+            if (count > 0) {
+                debug.touched(this, { type: 'bunch', method: 'copyWithin' }, range(to, to + count - 1));
+            }
+        }
+    }
+}
+
+/**
+ * Reactive wrapper around JavaScript's WeakMap class
+ * Only tracks individual key operations, no size tracking (WeakMap limitation)
+ */
+class ReactiveWeakMap extends WeakMap {
+    // Implement WeakMap interface methods with reactivity
+    delete(key) {
+        const hadKey = this.has(key);
+        const result = this.delete(key);
+        if (hadKey)
+            debug.touched1(debug.contentRef(this), { type: 'del', prop: key }, key);
+        return result;
+    }
+    get(key) {
+        debug.dependant(debug.contentRef(this), key);
+        return debug.reactive(this.get(key));
+    }
+    has(key) {
+        debug.dependant(debug.contentRef(this), key);
+        return this.has(key);
+    }
+    set(key, value) {
+        const hadKey = this.has(key);
+        const oldValue = this.get(key);
+        const reactiveValue = debug.reactive(value);
+        this.set(key, reactiveValue);
+        if (!hadKey || oldValue !== reactiveValue) {
+            debug.notifyPropertyChange(debug.contentRef(this), key, oldValue, reactiveValue, hadKey);
+        }
+        return this;
+    }
+}
+/**
+ * Reactive wrapper around JavaScript's Map class
+ * Tracks size changes, individual key operations, and collection-wide operations
+ */
+class ReactiveMap extends Map {
+    // Implement Map interface methods with reactivity
+    get size() {
+        debug.dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
+        return this.size;
+    }
+    clear() {
+        const hadEntries = this.size > 0;
+        this.clear();
+        if (hadEntries) {
+            const evolution = { type: 'bunch', method: 'clear' };
+            // Clear triggers all effects since all keys are affected
+            debug.touched1(this, evolution, 'size');
+            debug.touched(debug.contentRef(this), evolution);
+        }
+    }
+    entries() {
+        debug.dependant(debug.contentRef(this));
+        return makeReactiveEntriesIterator(this.entries());
+    }
+    forEach(callbackfn, thisArg) {
+        debug.dependant(debug.contentRef(this));
+        this.forEach(callbackfn, thisArg);
+    }
+    keys() {
+        debug.dependant(debug.contentRef(this));
+        return this.keys();
+    }
+    values() {
+        debug.dependant(debug.contentRef(this));
+        return makeReactiveIterator(this.values());
+    }
+    [Symbol.iterator]() {
+        debug.dependant(debug.contentRef(this));
+        const it = Map.prototype[Symbol.iterator].call(this);
+        const nativeNext = it.next.bind(it);
+        it.next = () => {
+            const result = nativeNext();
+            if (result.done)
+                return result;
+            const [key, value] = result.value;
+            return { value: [debug.reactive(key), debug.reactive(value)], done: false };
+        };
+        return it;
+    }
+    // Implement Map methods with reactivity
+    delete(key) {
+        const hadKey = this.has(key);
+        const result = this.delete(key);
+        if (hadKey) {
+            const evolution = { type: 'del', prop: key };
+            debug.touched1(debug.contentRef(this), evolution, key);
+            debug.touched1(this, evolution, 'size');
+        }
+        return result;
+    }
+    get(key) {
+        debug.dependant(debug.contentRef(this), key);
+        return debug.reactive(this.get(key));
+    }
+    has(key) {
+        debug.dependant(debug.contentRef(this), key);
+        return this.has(key);
+    }
+    set(key, value) {
+        const hadKey = this.has(key);
+        const oldValue = this.get(key);
+        const reactiveValue = debug.reactive(value);
+        this.set(key, reactiveValue);
+        if (!hadKey || oldValue !== reactiveValue) {
+            debug.notifyPropertyChange(debug.contentRef(this), key, oldValue, reactiveValue, hadKey);
+            // Also notify size change for Map (WeakMap doesn't track size)
+            const evolution = { type: hadKey ? 'set' : 'add', prop: key };
+            debug.touched1(this, evolution, 'size');
+        }
+        return this;
+    }
+}
+
+/**
+ * Reactive wrapper around JavaScript's WeakSet class
+ * Only tracks individual value operations, no size tracking (WeakSet limitation)
+ */
+class ReactiveWeakSet extends WeakSet {
+    add(value) {
+        const had = this.has(value);
+        this.add(value);
+        if (!had) {
+            // touch the specific value and the collection view
+            debug.touched1(debug.contentRef(this), { type: 'add', prop: value }, value);
+            // no size/allProps for WeakSet
+        }
+        return this;
+    }
+    delete(value) {
+        const had = this.has(value);
+        const res = this.delete(value);
+        if (had)
+            debug.touched1(debug.contentRef(this), { type: 'del', prop: value }, value);
+        return res;
+    }
+    has(value) {
+        debug.dependant(debug.contentRef(this), value);
+        return this.has(value);
+    }
+}
+/**
+ * Reactive wrapper around JavaScript's Set class
+ * Tracks size changes, individual value operations, and collection-wide operations
+ */
+class ReactiveSet extends Set {
+    get size() {
+        // size depends on the wrapper instance, like Map counterpart
+        debug.dependant(this, 'size');
+        return this.size;
+    }
+    add(value) {
+        const had = this.has(value);
+        const reactiveValue = debug.reactive(value);
+        this.add(reactiveValue);
+        if (!had) {
+            const evolution = { type: 'add', prop: reactiveValue };
+            // touch for value-specific and aggregate dependencies
+            debug.touched1(debug.contentRef(this), evolution, reactiveValue);
+            debug.touched1(this, evolution, 'size');
+        }
+        return this;
+    }
+    clear() {
+        const hadEntries = this.size > 0;
+        this.clear();
+        if (hadEntries) {
+            const evolution = { type: 'bunch', method: 'clear' };
+            debug.touched1(this, evolution, 'size');
+            debug.touched(debug.contentRef(this), evolution);
+        }
+    }
+    delete(value) {
+        const had = this.has(value);
+        const res = this.delete(value);
+        if (had) {
+            const evolution = { type: 'del', prop: value };
+            debug.touched1(debug.contentRef(this), evolution, value);
+            debug.touched1(this, evolution, 'size');
+        }
+        return res;
+    }
+    has(value) {
+        debug.dependant(debug.contentRef(this), value);
+        return this.has(value);
+    }
+    entries() {
+        debug.dependant(debug.contentRef(this));
+        return makeReactiveEntriesIterator(this.entries());
+    }
+    forEach(callbackfn, thisArg) {
+        debug.dependant(debug.contentRef(this));
+        this.forEach(callbackfn, thisArg);
+    }
+    keys() {
+        debug.dependant(debug.contentRef(this));
+        return makeReactiveIterator(this.keys());
+    }
+    values() {
+        debug.dependant(debug.contentRef(this));
+        return makeReactiveIterator(this.values());
+    }
+    [Symbol.iterator]() {
+        debug.dependant(debug.contentRef(this));
+        const it = Set.prototype[Symbol.iterator].call(this);
+        const nativeNext = it.next.bind(it);
+        it.next = () => {
+            const result = nativeNext();
+            if (result.done)
+                return result;
+            return { value: debug.reactive(result.value), done: false };
+        };
+        return it;
+    }
+}
+
+// Register native collection types to use specialized reactive wrappers
+debug.metaProtos.set(Array, ReactiveArray.prototype);
+debug.metaProtos.set(Set, ReactiveSet.prototype);
+debug.metaProtos.set(WeakSet, ReactiveWeakSet.prototype);
+debug.metaProtos.set(Map, ReactiveMap.prototype);
+debug.metaProtos.set(WeakMap, ReactiveWeakMap.prototype);
+/**
+ * Object containing internal reactive system state for debugging and profiling
+ */
+const profileInfo = {
+    objectToProxy: debug.objectToProxy,
+    proxyToObject: debug.proxyToObject,
+    effectToReactiveObjects: debug.effectToReactiveObjects,
+    watchers: debug.watchers,
+    objectParents: debug.objectParents,
+    objectsWithDeepWatchers: debug.objectsWithDeepWatchers,
+    deepWatchers: debug.deepWatchers,
+    effectToDeepWatchedObjects: debug.effectToDeepWatchedObjects,
+    nonReactiveObjects: debug.nonReactiveObjects,
+};
+
+// In order to avoid async re-entrance, we could use zone.js or something like that.
+const syncCalculating = [];
+/**
+ * Decorator that caches the result of a getter method and only recomputes when dependencies change
+ * Prevents circular dependencies and provides automatic cache invalidation
+ */
+const cached = debug.decorator({
+    getter(original, _target, propertyKey) {
+        return function () {
+            const alreadyCalculating = syncCalculating.findIndex((c) => c.object === this && c.prop === propertyKey);
+            if (alreadyCalculating > -1)
+                throw new Error(`Circular dependency detected: ${syncCalculating
+                    .slice(alreadyCalculating)
+                    .map((c) => `${c.object.constructor.name}.${String(c.prop)}`)
+                    .join(' -> ')} -> again`);
+            syncCalculating.push({ object: this, prop: propertyKey });
+            try {
+                const rv = original.call(this);
+                cache(this, propertyKey, rv);
+                return rv;
+            }
+            finally {
+                syncCalculating.pop();
+            }
+        };
+    },
+});
+/**
+ * Checks if a property is cached (has a cached value)
+ * @param object - The object to check
+ * @param propertyKey - The property key to check
+ * @returns True if the property has a cached value
+ */
+function isCached(object, propertyKey) {
+    return !!Object.getOwnPropertyDescriptor(object, propertyKey);
+}
+/**
+ * Caches a value for a property on an object
+ * @param object - The object to cache the value on
+ * @param propertyKey - The property key to cache
+ * @param value - The value to cache
+ */
+function cache(object, propertyKey, value) {
+    Object.defineProperty(object, propertyKey, { value });
+}
+/**
+ * Creates a decorator that modifies property descriptors for specified properties
+ * @param descriptor - The descriptor properties to apply
+ * @returns A class decorator that applies the descriptor to specified properties
+ */
+const descriptor = debug.flavored(function descriptor(descriptor) {
+    return (...properties) => (Base) => {
+        return class extends Base {
+            constructor(...args) {
+                super(...args);
+                for (const key of properties) {
+                    const existing = Object.getOwnPropertyDescriptor(this, key);
+                    Object.defineProperty(this, key, Object.assign(existing || {}, descriptor));
+                }
+            }
+        };
+    };
+}, {
+    /**
+     * enumerable: true
+     */
+    get enumerable() {
+        return descriptor({ enumerable: true });
+    },
+    /**
+     * enumerable: false
+     */
+    get hidden() {
+        return descriptor({ enumerable: false });
+    },
+    /**
+     * configurable: true
+     */
+    get configurable() {
+        return descriptor({ configurable: true });
+    },
+    /**
+     * configurable: false
+     */
+    get frozen() {
+        return descriptor({ configurable: false });
+    },
+    /**
+     * writable: true
+     */
+    get writable() {
+        return descriptor({ writable: true });
+    },
+    /**
+     * writable: false
+     */
+    get readonly() {
+        return descriptor({ writable: false });
+    },
+});
+/**
+ * Decorator that marks methods, properties, or classes as deprecated
+ * Provides warning messages when deprecated items are used
+ */
+const deprecated = Object.assign(debug.decorator({
+    method(original, _target, propertyKey) {
+        return function (...args) {
+            deprecated.warn(this, propertyKey);
+            return original.apply(this, args);
+        };
+    },
+    getter(original, _target, propertyKey) {
+        return function () {
+            deprecated.warn(this, propertyKey);
+            return original.call(this);
+        };
+    },
+    setter(original, _target, propertyKey) {
+        return function (value) {
+            deprecated.warn(this, propertyKey);
+            return original.call(this, value);
+        };
+    },
+    class(original) {
+        return class extends original {
+            constructor(...args) {
+                super(...args);
+                deprecated.warn(this, 'constructor');
+            }
+        };
+    },
+    default(message) {
+        return debug.decorator({
+            method(original, _target, propertyKey) {
+                return function (...args) {
+                    deprecated.warn(this, propertyKey, message);
+                    return original.apply(this, args);
+                };
+            },
+            getter(original, _target, propertyKey) {
+                return function () {
+                    deprecated.warn(this, propertyKey, message);
+                    return original.call(this);
+                };
+            },
+            setter(original, _target, propertyKey) {
+                return function (value) {
+                    deprecated.warn(this, propertyKey, message);
+                    return original.call(this, value);
+                };
+            },
+            class(original) {
+                return class extends original {
+                    constructor(...args) {
+                        super(...args);
+                        deprecated.warn(this, 'constructor', message);
+                    }
+                };
+            },
+        });
+    },
+}), {
+    warn: (target, propertyKey, message) => {
+        // biome-ignore lint/suspicious/noConsole: To be overridden
+        console.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
+    },
+});
+/**
+ * Creates a debounced method decorator that delays execution until after the delay period has passed
+ * @param delay - The delay in milliseconds
+ * @returns A method decorator that debounces method calls
+ */
+function debounce(delay) {
+    return debug.decorator({
+        method(original, _target, _propertyKey) {
+            let timeoutId = null;
+            return function (...args) {
+                // Clear existing timeout
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                // Set new timeout
+                timeoutId = setTimeout(() => {
+                    original.apply(this, args);
+                    timeoutId = null;
+                }, delay);
+            };
+        },
+    });
+}
+/**
+ * Creates a throttled method decorator that limits execution to once per delay period
+ * @param delay - The delay in milliseconds
+ * @returns A method decorator that throttles method calls
+ */
+function throttle(delay) {
+    return debug.decorator({
+        method(original, _target, _propertyKey) {
+            let lastCallTime = 0;
+            let timeoutId = null;
+            return function (...args) {
+                const now = Date.now();
+                // If enough time has passed since last call, execute immediately
+                if (now - lastCallTime >= delay) {
+                    // Clear any pending timeout since we're executing now
+                    if (timeoutId) {
+                        clearTimeout(timeoutId);
+                        timeoutId = null;
+                    }
+                    lastCallTime = now;
+                    return original.apply(this, args);
+                }
+                // Otherwise, schedule execution for when the delay period ends
+                if (!timeoutId) {
+                    const remainingTime = delay - (now - lastCallTime);
+                    const scheduledArgs = [...args]; // Capture args at scheduling time
+                    timeoutId = setTimeout(() => {
+                        lastCallTime = Date.now();
+                        original.apply(this, scheduledArgs);
+                        timeoutId = null;
+                    }, remainingTime);
+                }
+            };
+        },
+    });
+}
+
+var version$1 = "1.0.9";
+var pkg = {
+	version: version$1};
+
+const { version } = pkg;
+// Singleton verification
+const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
+const globalScope = (typeof globalThis !== 'undefined'
+    ? globalThis
+    : typeof window !== 'undefined'
+        ? window
+        : typeof global !== 'undefined'
+            ? global
+            : false);
+if (globalScope) {
+    // Detect the source of this instance safely across different environments
+    let source = 'mutts/index';
+    const viteEval = eval;
+    try {
+        if (typeof __filename !== 'undefined')
+            source = __filename;
+        else {
+            // Using eval to avoid SyntaxError in CJS environments where import.meta is not allowed
+            const meta = viteEval('import.meta');
+            if (meta && meta.url)
+                source = meta.url;
+        }
+    }
+    catch (e) {
+        // Fallback for environments where neither is available or accessible
+    }
+    const currentSourceInfo = {
+        version,
+        source,
+        timestamp: Date.now(),
+    };
+    if (globalScope[GLOBAL_MUTTS_KEY]) {
+        const existing = globalScope[GLOBAL_MUTTS_KEY];
+        throw new Error(`[Mutts] Multiple instances detected!\n` +
+            `Existing instance: ${JSON.stringify(existing, null, 2)}\n` +
+            `New instance: ${JSON.stringify(currentSourceInfo, null, 2)}\n` +
+            `This usually happens when 'mutts' is both installed as a dependency and bundled, ` +
+            `or when different versions are loaded. ` +
+            `Please check your build configuration (aliases, externals) to ensure a single source of truth.`);
+    }
+    globalScope[GLOBAL_MUTTS_KEY] = currentSourceInfo;
+}
+
+exports.AZone = debug.AZone;
+exports.DecoratorError = debug.DecoratorError;
+exports.FoolProof = debug.FoolProof;
+exports.IterableWeakMap = debug.IterableWeakMap;
+exports.IterableWeakSet = debug.IterableWeakSet;
+exports.ReactiveBase = debug.ReactiveBase;
+exports.ReactiveError = debug.ReactiveError;
+Object.defineProperty(exports, "ReactiveErrorCode", {
+	enumerable: true,
+	get: function () { return debug.ReactiveErrorCode; }
+});
+exports.Zone = debug.Zone;
+exports.ZoneAggregator = debug.ZoneAggregator;
+exports.ZoneHistory = debug.ZoneHistory;
+exports.addBatchCleanup = debug.addBatchCleanup;
+exports.arrayEquals = debug.arrayEquals;
+exports.asyncZone = debug.asyncZone;
+exports.atomic = debug.atomic;
+exports.biDi = debug.biDi;
+exports.cleanedBy = debug.cleanedBy;
+exports.cleanup = debug.cleanup;
+exports.contentRef = debug.contentRef;
+exports.createFlavor = debug.createFlavor;
+exports.decorator = debug.decorator;
+exports.deepCompare = debug.deepCompare;
+exports.defer = debug.defer;
+exports.derived = debug.derived;
+exports.effect = debug.effect;
+exports.effectAggregator = debug.effectAggregator;
+exports.flavorOptions = debug.flavorOptions;
+exports.flavored = debug.flavored;
+exports.getActivationLog = debug.getActivationLog;
+exports.getActiveEffect = debug.getActiveEffect;
+exports.getState = debug.getState;
+exports.immutables = debug.immutables;
+exports.isConstructor = debug.isConstructor;
+exports.isNonReactive = debug.isNonReactive;
+exports.isOwnAccessor = debug.isOwnAccessor;
+exports.isReactive = debug.isReactive;
+exports.legacyDecorator = debug.legacyDecorator;
+exports.mixin = debug.mixin;
+exports.modernDecorator = debug.modernDecorator;
+exports.named = debug.named;
+exports.onEffectThrow = debug.onEffectThrow;
+exports.onEffectTrigger = debug.onEffectTrigger;
+exports.reactive = debug.reactive;
+exports.reactiveOptions = debug.options;
+exports.registerNativeReactivity = debug.registerNativeReactivity;
+exports.renamed = debug.renamed;
+exports.reset = debug.reset;
+exports.root = debug.root;
+exports.tag = debug.tag;
+exports.touched = debug.touched;
+exports.touched1 = debug.touched1;
+exports.untracked = debug.untracked;
+exports.unwrap = debug.unwrap;
+exports.zip = debug.zip;
+exports.asyncHook = asyncCore.asyncHook;
+exports.asyncHooks = asyncCore.asyncHooks;
+exports.hooks = asyncCore.hooks;
+exports.ArrayReadForward = ArrayReadForward;
+exports.Destroyable = Destroyable;
+exports.DestructionError = DestructionError;
+exports.Eventful = Eventful;
+exports.Indexable = Indexable;
+exports.Register = Register;
+exports.allocated = allocated;
+exports.allocatedValues = allocatedValues;
+exports.attend = attend;
+exports.cache = cache;
+exports.cached = cached;
+exports.callOnGC = callOnGC;
+exports.chainPromise = chainPromise;
+exports.debounce = debounce;
+exports.deepWatch = deepWatch;
+exports.deprecated = deprecated;
+exports.describe = describe;
+exports.descriptor = descriptor;
+exports.destructor = destructor;
+exports.forwardArray = forwardArray;
+exports.getActiveProjection = getActiveProjection;
+exports.getAt = getAt;
+exports.isCached = isCached;
+exports.lift = lift;
+exports.memoize = memoize;
+exports.organize = organize;
+exports.organized = organized;
+exports.profileInfo = profileInfo;
+exports.project = project;
+exports.register = register;
+exports.scan = scan;
+exports.setAt = setAt;
+exports.throttle = throttle;
+exports.unreactive = unreactive;
+exports.watch = watch;
+//# sourceMappingURL=browser.cjs.map