mutts 1.0.7 → 1.0.9

package/dist/chunks/index-2vea86wD.esm.js

@@ -0,0 +1,3011 @@
+import { r as decorator, a3 as markWithRoot, a4 as rootFunction, V as renamed, a5 as getRoot, a6 as dependant, T as options, a0 as untracked, s as deepCompare, a7 as optionCall, X as root, v as effect, $ as touched1, S as reactive, n as cleanedBy, a8 as __runInitializers, a9 as __esDecorate, F as FoolProof, aa as objectsWithDeepWatchers, ab as effectToDeepWatchedObjects, ac as deepWatchers, H as isNonReactive, a1 as unwrap, ad as stopped, ae as nonReactiveClass, af as unreactiveProperties, ag as nonReactiveMark, ah as nonReactiveObjects, ai as __setFunctionName, aj as __classPrivateFieldGet, ak as __classPrivateFieldSet, al as setEffectName, O as named, B as getActiveEffect, am as projectionInfo, _ as touched, p as contentRef, an as notifyPropertyChange, ao as metaProtos, ap as objectParents, aq as watchers, ar as effectToReactiveObjects, as as proxyToObject, at as objectToProxy, y as flavored } from './index-CtA2AWl3.esm.js';
+
+// 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 = 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 = getRoot(fn);
+    const existing = memoizedRegistry.get(fnRoot);
+    if (existing)
+        return existing;
+    const cacheRoot = {};
+    const memoized = 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);
+        }
+        dependant(node, 'memoize');
+        if ('result' in node) {
+            if (options.onMemoizationDiscrepancy) {
+                const wasVerification = options.isVerificationRun;
+                options.isVerificationRun = true;
+                try {
+                    const fresh = untracked(() => fn(...localArgs));
+                    if (!deepCompare(node.result, fresh)) {
+                        optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, localArgs, 'calculation');
+                    }
+                }
+                finally {
+                    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 = root(() => 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;
+                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 (options.onMemoizationDiscrepancy) {
+            const wasVerification = options.isVerificationRun;
+            options.isVerificationRun = true;
+            try {
+                const fresh = untracked(() => fn(...localArgs));
+                if (!deepCompare(node.result, fresh)) {
+                    optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, localArgs, 'comparison');
+                }
+            }
+            finally {
+                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 = decorator({
+    getter(original, target, propertyKey) {
+        return function () {
+            let wrapper = wrapperRegistry.get(original);
+            if (!wrapper) {
+                wrapper = markWithRoot(renamed((that) => {
+                    return original.call(that);
+                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`), {
+                    method: original,
+                    propertyKey,
+                    ...(original[rootFunction]
+                        ? { [rootFunction]: original[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 = markWithRoot(renamed((that, ...args) => {
+                    return original.call(that, ...args);
+                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`), {
+                    method: original,
+                    propertyKey: name,
+                    ...(original[rootFunction]
+                        ? { [rootFunction]: original[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 = 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(() => 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 = reactive(source);
+    const result = 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 = reactive([]);
+    const intermediaries = new WeakMap();
+    let Intermediate = (() => {
+        var _a;
+        let _instanceExtraInitializers = [];
+        let _get_acc_decorators;
+        return _a = class Intermediate {
+                constructor(val, prev) {
+                    this.val = (__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];
+                __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);
+            untracked(() => {
+                Reflect.deleteProperty(indexToIntermediate, index);
+                Reflect.deleteProperty(result, index);
+            });
+        }
+    }
+    const mainEffect = effect(function scanMainEffect({ ascend }) {
+        const length = observedSource.length;
+        const occurrenceCount = new Map();
+        let prev;
+        for (let i = 0; i < length; i++) {
+            const val = 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 = reactive(new Intermediate(val, prev));
+                list[count] = intermediate;
+            }
+            else {
+                // Update the link.
+                if (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 = effect(function scanIndexSyncEffect() {
+                        const inter = indexToIntermediate[index];
+                        if (inter) {
+                            const accValue = inter.acc;
+                            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
+        untracked(() => {
+            if (result.length !== length) {
+                FoolProof.set(result, 'length', length, result);
+            }
+        });
+    });
+    return cleanedBy(result, (() => {
+        mainEffect();
+        for (const stop of indexEffects.values())
+            stop();
+        indexEffects.clear();
+    }));
+}
+function lift(cb) {
+    let result;
+    const liftCleanup = 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 = reactive([]);
+            }
+            else {
+                result = 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 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 = markWithRoot((() => callback(target)), callback);
+    // Use the existing effect system to register dependencies
+    return effect(() => {
+        // Mark the target object as having deep watchers
+        objectsWithDeepWatchers.add(target);
+        // Track which objects this effect is watching for cleanup
+        let effectObjects = effectToDeepWatchedObjects.get(wrappedCallback);
+        if (!effectObjects) {
+            effectObjects = new Set();
+            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 > options.maxDeepWatchDepth)
+                return;
+            // Do not traverse into unreactive objects
+            if (isNonReactive(obj))
+                return;
+            visited.add(obj);
+            // Mark this object as having deep watchers
+            objectsWithDeepWatchers.add(obj);
+            effectObjects.add(obj);
+            // Traverse all properties to register dependencies
+            // unwrap to avoid kicking dependency
+            for (const key in 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 ? 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 ? 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 ? 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 ? 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 = 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 = 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) {
+                            deepWatchers.delete(obj);
+                            objectsWithDeepWatchers.delete(obj);
+                        }
+                    }
+                    else {
+                        // No watchers found, remove from deep watchers tracking
+                        objectsWithDeepWatchers.delete(obj);
+                    }
+                }
+                // Clean up the tracking data
+                effectToDeepWatchedObjects.delete(wrappedCallback);
+            }
+        };
+    });
+}
+
+/**
+ * Converts an iterator to a generator that yields reactive values
+ */
+function* makeReactiveIterator(iterator) {
+    let result = iterator.next();
+    while (!result.done) {
+        yield 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 [reactive(key), 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 effect(function watchObjectEffect() {
+        dependant(value);
+        if (immediate)
+            changed(value);
+        immediate = true;
+    });
+}
+function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
+    let oldValue = unsetYet;
+    let deepCleanup;
+    const cbCleanup = effect(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();
+    }, {
+        [stopped]: { get: () => cbCleanup[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 = unwrap(obj);
+    if (isNonReactive(obj))
+        return obj;
+    try {
+        Object.defineProperty(obj, nonReactiveMark, {
+            value: true,
+            writable: false,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    catch { }
+    if (!(nonReactiveMark in obj))
+        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[unreactiveProperties] = new Set(original.prototype[unreactiveProperties] || []);
+            // Add all arguments (including the first one)
+            original.prototype[unreactiveProperties].add(arg1);
+            for (const arg of args)
+                original.prototype[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 = decorator({
+    class(original) {
+        // Called without arguments, mark entire class as non-reactive
+        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 __classPrivateFieldGet(this, _RegisterClass_events, "f").on(eventOrEvents, cb);
+        }
+        off(eventOrEvents, cb) {
+            // @ts-expect-error Delegate to Eventful
+            __classPrivateFieldGet(this, _RegisterClass_events, "f").off(eventOrEvents, cb);
+        }
+        /**
+         * Register a global hook that receives all events
+         */
+        hook(cb) {
+            return __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;
+            effect(({ ascend }) => {
+                ascendGet = ascend;
+            });
+            __classPrivateFieldSet(this, _RegisterClass_ascend, ascendGet, "f");
+            if (typeof keyFn !== 'function')
+                throw new Error('Register requires a key function');
+            __classPrivateFieldSet(this, _RegisterClass_keyFn, keyFn, "f");
+            __classPrivateFieldSet(this, _RegisterClass_keys, reactive([]), "f");
+            __classPrivateFieldSet(this, _RegisterClass_values, reactive(new Map()), "f");
+            if (initial)
+                this.push(...initial);
+        }
+        ensureKey(value) {
+            let info = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (info)
+                return info.key;
+            info = { key: undefined };
+            __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").set(value, info);
+            __classPrivateFieldGet(this, _RegisterClass_ascend, "f").call(this, () => {
+                const stop = effect(({ reaction }) => {
+                    const nextKey = __classPrivateFieldGet(this, _RegisterClass_keyFn, "f").call(this, value);
+                    this.assertValidKey(nextKey);
+                    const previousKey = info.key;
+                    if (reaction && previousKey !== undefined && !Object.is(nextKey, previousKey))
+                        __classPrivateFieldGet(this, _RegisterClass_instances, "m", _RegisterClass_rekeyValue).call(this, value, previousKey, nextKey);
+                    info.key = nextKey;
+                });
+                info.stop = stop;
+                __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 = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+            if (existing !== undefined && existing !== value) {
+                this.cleanupValue(existing);
+                __classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+                if (index !== undefined) {
+                    __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', existing, value, key, index);
+                }
+            }
+            else {
+                __classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+            }
+        }
+        cleanupValue(value) {
+            const info = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (!info)
+                return;
+            const stop = info.stop;
+            if (stop) {
+                info.stop = undefined;
+                __classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").delete(stop);
+                stop();
+            }
+            __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").delete(value);
+        }
+        disposeKeyEffects() {
+            for (const value of Array.from(__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").keys()))
+                this.cleanupValue(value);
+            __classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").clear();
+        }
+        incrementUsage(key) {
+            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key) ?? 0;
+            __classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count + 1);
+        }
+        decrementUsage(key, index) {
+            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key);
+            if (!count)
+                return;
+            if (count <= 1) {
+                const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                __classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(key);
+                __classPrivateFieldGet(this, _RegisterClass_values, "f").delete(key);
+                if (value !== undefined) {
+                    this.cleanupValue(value);
+                    const idx = index ?? __classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
+                    __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('delete', value, key, idx);
+                }
+            }
+            else {
+                __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 = __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
+            if (oldKey !== undefined && Object.is(oldKey, key)) {
+                const oldValue = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                this.setKeyValue(key, value);
+                if (oldValue !== undefined && oldValue !== value) {
+                    __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', oldValue, value, key, index);
+                }
+                return;
+            }
+            if (oldKey !== undefined)
+                this.decrementUsage(oldKey);
+            __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index] = key;
+            this.incrementUsage(key);
+            this.setKeyValue(key, value);
+            __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
+        }
+        insertKeyValue(index, key, value) {
+            __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 0, key);
+            this.incrementUsage(key);
+            this.setKeyValue(key, value);
+            __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
+        }
+        rebuildFrom(values) {
+            this.disposeKeyEffects();
+            __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(0, __classPrivateFieldGet(this, _RegisterClass_keys, "f").length);
+            __classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
+            __classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
+            for (const value of values) {
+                const key = this.ensureKey(value);
+                __classPrivateFieldGet(this, _RegisterClass_keys, "f").push(key);
+                this.incrementUsage(key);
+                __classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+            }
+        }
+        get length() {
+            return __classPrivateFieldGet(this, _RegisterClass_keys, "f").length;
+        }
+        [(_RegisterClass_rekeyValue = function _RegisterClass_rekeyValue(value, oldKey, newKey) {
+            if (Object.is(oldKey, newKey))
+                return;
+            const existingValue = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(newKey);
+            if (existingValue !== undefined && existingValue !== value)
+                throw new Error(`Register key collision for key ${String(newKey)}`);
+            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(oldKey);
+            if (!count)
+                return;
+            const existingCount = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(newKey) ?? 0;
+            this.setKeyValue(newKey, value);
+            let index = -1;
+            for (let i = 0; i < __classPrivateFieldGet(this, _RegisterClass_keys, "f").length; i++)
+                if (Object.is(__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i], oldKey)) {
+                    __classPrivateFieldGet(this, _RegisterClass_keys, "f")[i] = newKey;
+                    if (index === -1)
+                        index = i;
+                }
+            __classPrivateFieldGet(this, _RegisterClass_usage, "f").set(newKey, existingCount + count);
+            __classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(oldKey);
+            __classPrivateFieldGet(this, _RegisterClass_values, "f").delete(oldKey);
+            const updatedInfo = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            if (updatedInfo)
+                updatedInfo.key = newKey;
+            if (index !== -1) {
+                __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('rekey', value, oldKey, newKey, index);
+            }
+        }, getAt)](index) {
+            const key = __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
+            return key === undefined ? undefined : __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 = __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 = __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() {
+            __classPrivateFieldGet(this, _RegisterClass_keys, "f").length = 0;
+            __classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
+            __classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
+            this.disposeKeyEffects();
+        }
+        get(key) {
+            return __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+        }
+        set(key, value) {
+            if (__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] = __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 1);
+            if (key === undefined)
+                return undefined;
+            const value = __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 __classPrivateFieldGet(this, _RegisterClass_keys, "f").entries()) {
+                if (decisions.has(key)) {
+                    if (!decisions.get(key))
+                        this.removeAt(index);
+                    continue;
+                }
+                const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                const shouldKeep = predicate(value);
+                decisions.set(key, shouldKeep);
+                if (!shouldKeep)
+                    this.removeAt(index);
+            }
+        }
+        hasKey(key) {
+            return __classPrivateFieldGet(this, _RegisterClass_usage, "f").has(key);
+        }
+        indexOfKey(key) {
+            return __classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
+        }
+        mapKeys() {
+            return __classPrivateFieldGet(this, _RegisterClass_values, "f").keys();
+        }
+        update(...values) {
+            for (const value of values) {
+                const key = this.ensureKey(value);
+                if (__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key)) {
+                    const index = __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 (__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 < __classPrivateFieldGet(self, _RegisterClass_keys, "f").length; i++) {
+                    const val = __classPrivateFieldGet(self, _RegisterClass_values, "f").get(__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 __classPrivateFieldGet(self, _RegisterClass_keys, "f")) {
+                    const value = __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() {
+            __classPrivateFieldGet(this, _RegisterClass_keys, "f").reverse();
+            return this;
+        }
+        sort(compareFn) {
+            const fwdCompareFn = compareFn
+                ? (a, b) => compareFn(__classPrivateFieldGet(this, _RegisterClass_values, "f").get(a), __classPrivateFieldGet(this, _RegisterClass_values, "f").get(b))
+                : undefined;
+            __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;
+        }
+    };
+    __setFunctionName(_classThis, "RegisterClass");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+        __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 });
+        __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 = getActiveEffect();
+    return active ? effectProjectionMetadata.get(active) : undefined;
+}
+function setActiveProjection(projection) {
+    const active = 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, projectionInfo, {
+            value: metadata,
+            writable: false,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    return cleanedBy(target, () => {
+        onDispose();
+        for (const stop of effectMap.values())
+            stop?.();
+        effectMap.clear();
+    });
+}
+function projectArray(source, apply) {
+    source = reactive(source);
+    const target = reactive([]);
+    const indexEffects = new Map();
+    function normalizeTargetLength(length) {
+        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 = effect(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 = effect(named(`project:${source[Symbol.toStringTag]}[${index}]`, ({ reaction }) => {
+                    if (!reaction)
+                        setActiveProjection({ source, key: index, target, depth, parent });
+                    const previous = untracked(() => target[index]);
+                    const accessBase = {
+                        key: index,
+                        source,
+                        get: () => FoolProof.get(source, index, source),
+                        set: (value) => FoolProof.set(source, index, value, source),
+                        old: previous,
+                    };
+                    defineAccessValue(accessBase);
+                    target[index] = apply(accessBase, target);
+                }));
+                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 = reactive(source);
+    const rawTarget = new Map();
+    const target = 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 = 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 = effect(function projectRegisterKeyEffect({ reaction }) {
+                    if (!reaction)
+                        setActiveProjection({ source, key, target, depth, parent });
+                    const previous = 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);
+                });
+                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 = reactive(source);
+    const target = 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 = 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 = effect(function projectRecordKeyEffect({ reaction }) {
+                    if (!reaction)
+                        setActiveProjection({ source, key, target, depth, parent });
+                    const sourceKey = key;
+                    const previous = untracked(() => target[key]);
+                    const accessBase = {
+                        key: sourceKey,
+                        source: source,
+                        get: () => FoolProof.get(source, sourceKey, source),
+                        set: (value) => FoolProof.set(source, sourceKey, value, source),
+                        old: previous,
+                    };
+                    defineAccessValue(accessBase);
+                    const produced = apply(accessBase, target);
+                    target[sourceKey] = produced;
+                });
+                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 = reactive(source);
+    const rawTarget = new Map();
+    const target = 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 = 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 = effect(function projectMapKeyEffect({ reaction }) {
+                    if (!reaction)
+                        setActiveProjection({ source, key, target, depth, parent });
+                    const previous = 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);
+                });
+                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 = reactive(source);
+    const target = 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: () => FoolProof.get(observedSource, sourceKey, observedSource),
+            set: (value) => 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 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,
+    });
+    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 = reactive(descriptors);
+    const stop = attend(() => Reflect.ownKeys(descriptors), (key) => {
+        const desc = descriptors[key];
+        if (desc) {
+            Object.defineProperty(target, key, {
+                enumerable: true,
+                ...desc,
+                configurable: true,
+            });
+            touched1(target, { type: 'set', prop: key }, key);
+        }
+        return () => Reflect.deleteProperty(target, key);
+    });
+    return 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) {
+        dependant(this, i);
+        return 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;
+        touched(this, { type: 'set', prop: i }, index(i, { length: added }));
+    }
+}
+const indexLess = { get: FoolProof.get, set: FoolProof.set };
+Object.assign(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() {
+        dependant(this, 'length');
+        return this.length;
+    }
+    set length(value) {
+        const oldLength = this.length;
+        if (oldLength === value)
+            return;
+        try {
+            this.length = value;
+        }
+        finally {
+            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;
+        dependant(this, actualIndex);
+        if (index < 0)
+            dependant(this, 'length');
+        if (actualIndex < 0 || actualIndex >= this.length)
+            return undefined;
+        return reactive(this[actualIndex]);
+    }
+    // Immutable versions of mutator methods
+    toReversed() {
+        dependant(this);
+        return reactive(this.toReversed());
+    }
+    toSorted(compareFn) {
+        dependant(this);
+        return reactive(this.toSorted(compareFn));
+    }
+    toSpliced(start, deleteCount, ...items) {
+        dependant(this);
+        return deleteCount === undefined
+            ? this.toSpliced(start)
+            : this.toSpliced(start, deleteCount, ...items);
+    }
+    with(index, value) {
+        dependant(this);
+        return reactive(this.with(index, value));
+    }
+    // Iterator methods with reactivity tracking
+    entries() {
+        dependant(this);
+        return makeReactiveEntriesIterator(this.entries());
+    }
+    keys() {
+        dependant(this, 'length');
+        return this.keys();
+    }
+    values() {
+        dependant(this);
+        return makeReactiveIterator(this.values());
+    }
+    [Symbol.iterator]() {
+        dependant(this);
+        const nativeIterator = this[Symbol.iterator]();
+        return {
+            next() {
+                const result = nativeIterator.next();
+                if (result.done) {
+                    return result;
+                }
+                return { value: 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 = unwrap(searchElement);
+        for (; i < length; i++) {
+            dependant(this, i);
+            const item = this[i];
+            if (item === searchElement || item === unwrappedSearch || unwrap(item) === unwrappedSearch) {
+                return i;
+            }
+        }
+        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 = unwrap(searchElement);
+        for (; i >= 0; i--) {
+            dependant(this, i);
+            const item = this[i];
+            if (item === searchElement || item === unwrappedSearch || 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.
+        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++) {
+                dependant(this, i);
+                const val = reactive(this[i]);
+                if (predicate.call(thisArg, val, i, this)) {
+                    return val;
+                }
+            }
+            dependant(this, 'length');
+            return undefined;
+        }
+        const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
+        const index = this.indexOf(predicateOrElement, fromIndex);
+        if (index === -1)
+            return undefined;
+        return reactive(this[index]);
+    }
+    findIndex(predicateOrElement, thisArg) {
+        if (typeof predicateOrElement === 'function') {
+            const predicate = predicateOrElement;
+            const length = this.length;
+            for (let i = 0; i < length; i++) {
+                dependant(this, i);
+                const val = reactive(this[i]);
+                if (predicate.call(thisArg, val, i, this)) {
+                    return i;
+                }
+            }
+            dependant(this, 'length');
+            return -1;
+        }
+        const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
+        return this.indexOf(predicateOrElement, fromIndex);
+    }
+    flat(depth) {
+        dependant(this);
+        return reactive(depth === undefined ? this.flat() : this.flat(depth));
+    }
+    flatMap(callbackfn, thisArg) {
+        dependant(this);
+        return reactive(this.flatMap((item, index, array) => callbackfn.call(thisArg, reactive(item), index, array), thisArg));
+    }
+    filter(callbackfn, thisArg) {
+        dependant(this);
+        return reactive(this.filter((item, index, array) => callbackfn(reactive(item), index, array), thisArg));
+    }
+    map(callbackfn, thisArg) {
+        dependant(this);
+        return reactive(this.map((item, index, array) => callbackfn(reactive(item), index, array), thisArg));
+    }
+    reduce(callbackfn, initialValue) {
+        dependant(this);
+        const result = initialValue === undefined
+            ? this.reduce(callbackfn)
+            : this.reduce(callbackfn, initialValue);
+        return reactive(result);
+    }
+    reduceRight(callbackfn, initialValue) {
+        dependant(this);
+        const result = initialValue !== undefined
+            ? this.reduceRight(callbackfn, initialValue)
+            : this.reduceRight(callbackfn);
+        return reactive(result);
+    }
+    slice(start, end) {
+        for (const i of range(start || 0, end || this.length - 1))
+            dependant(this, i);
+        return start === undefined
+            ? this.slice()
+            : end === undefined
+                ? this.slice(start)
+                : this.slice(start, end);
+    }
+    concat(...items) {
+        dependant(this);
+        return reactive(this.concat(...items));
+    }
+    join(separator) {
+        dependant(this);
+        return this.join(separator);
+    }
+    forEach(callbackfn, thisArg) {
+        dependant(this);
+        this.forEach((value, index, array) => {
+            callbackfn.call(thisArg, reactive(value), index, array);
+        });
+    }
+    every(callbackfn, thisArg) {
+        const length = this.length;
+        for (let i = 0; i < length; i++) {
+            dependant(this, i);
+            if (!callbackfn.call(thisArg, reactive(this[i]), i, this)) {
+                return false;
+            }
+        }
+        dependant(this, 'length');
+        return true;
+    }
+    some(callbackfn, thisArg) {
+        const length = this.length;
+        for (let i = 0; i < length; i++) {
+            dependant(this, i);
+            if (callbackfn.call(thisArg, reactive(this[i]), i, this)) {
+                return true;
+            }
+        }
+        dependant(this, 'length');
+        return false;
+    }
+    // Side-effectful
+    push(...items) {
+        const oldLength = this.length;
+        try {
+            return this.push(...items);
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'push' }, range(oldLength, oldLength + items.length - 1, { length: true }));
+        }
+    }
+    pop() {
+        if (this.length === 0)
+            return undefined;
+        try {
+            return reactive(this.pop());
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'pop' }, index(this.length));
+        }
+    }
+    shift() {
+        if (this.length === 0)
+            return undefined;
+        try {
+            return reactive(this.shift());
+        }
+        finally {
+            touched(this, { type: 'bunch', method: 'shift' }, range(0, this.length + 1, { length: true }));
+        }
+    }
+    unshift(...items) {
+        try {
+            return this.unshift(...items);
+        }
+        finally {
+            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 reactive(this.splice(start));
+            return reactive(this.splice(start, deleteCount, ...items));
+        }
+        finally {
+            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 {
+            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(reactive(a), reactive(b)));
+        }
+        finally {
+            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) {
+                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) {
+                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)
+            touched1(contentRef(this), { type: 'del', prop: key }, key);
+        return result;
+    }
+    get(key) {
+        dependant(contentRef(this), key);
+        return reactive(this.get(key));
+    }
+    has(key) {
+        dependant(contentRef(this), key);
+        return this.has(key);
+    }
+    set(key, value) {
+        const hadKey = this.has(key);
+        const oldValue = this.get(key);
+        const reactiveValue = reactive(value);
+        this.set(key, reactiveValue);
+        if (!hadKey || oldValue !== reactiveValue) {
+            notifyPropertyChange(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() {
+        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
+            touched1(this, evolution, 'size');
+            touched(contentRef(this), evolution);
+        }
+    }
+    entries() {
+        dependant(contentRef(this));
+        return makeReactiveEntriesIterator(this.entries());
+    }
+    forEach(callbackfn, thisArg) {
+        dependant(contentRef(this));
+        this.forEach(callbackfn, thisArg);
+    }
+    keys() {
+        dependant(contentRef(this));
+        return this.keys();
+    }
+    values() {
+        dependant(contentRef(this));
+        return makeReactiveIterator(this.values());
+    }
+    [Symbol.iterator]() {
+        dependant(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: [reactive(key), 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 };
+            touched1(contentRef(this), evolution, key);
+            touched1(this, evolution, 'size');
+        }
+        return result;
+    }
+    get(key) {
+        dependant(contentRef(this), key);
+        return reactive(this.get(key));
+    }
+    has(key) {
+        dependant(contentRef(this), key);
+        return this.has(key);
+    }
+    set(key, value) {
+        const hadKey = this.has(key);
+        const oldValue = this.get(key);
+        const reactiveValue = reactive(value);
+        this.set(key, reactiveValue);
+        if (!hadKey || oldValue !== reactiveValue) {
+            notifyPropertyChange(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 };
+            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
+            touched1(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)
+            touched1(contentRef(this), { type: 'del', prop: value }, value);
+        return res;
+    }
+    has(value) {
+        dependant(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
+        dependant(this, 'size');
+        return this.size;
+    }
+    add(value) {
+        const had = this.has(value);
+        const reactiveValue = reactive(value);
+        this.add(reactiveValue);
+        if (!had) {
+            const evolution = { type: 'add', prop: reactiveValue };
+            // touch for value-specific and aggregate dependencies
+            touched1(contentRef(this), evolution, reactiveValue);
+            touched1(this, evolution, 'size');
+        }
+        return this;
+    }
+    clear() {
+        const hadEntries = this.size > 0;
+        this.clear();
+        if (hadEntries) {
+            const evolution = { type: 'bunch', method: 'clear' };
+            touched1(this, evolution, 'size');
+            touched(contentRef(this), evolution);
+        }
+    }
+    delete(value) {
+        const had = this.has(value);
+        const res = this.delete(value);
+        if (had) {
+            const evolution = { type: 'del', prop: value };
+            touched1(contentRef(this), evolution, value);
+            touched1(this, evolution, 'size');
+        }
+        return res;
+    }
+    has(value) {
+        dependant(contentRef(this), value);
+        return this.has(value);
+    }
+    entries() {
+        dependant(contentRef(this));
+        return makeReactiveEntriesIterator(this.entries());
+    }
+    forEach(callbackfn, thisArg) {
+        dependant(contentRef(this));
+        this.forEach(callbackfn, thisArg);
+    }
+    keys() {
+        dependant(contentRef(this));
+        return makeReactiveIterator(this.keys());
+    }
+    values() {
+        dependant(contentRef(this));
+        return makeReactiveIterator(this.values());
+    }
+    [Symbol.iterator]() {
+        dependant(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: reactive(result.value), done: false };
+        };
+        return it;
+    }
+}
+
+// Register native collection types to use specialized reactive wrappers
+metaProtos.set(Array, ReactiveArray.prototype);
+metaProtos.set(Set, ReactiveSet.prototype);
+metaProtos.set(WeakSet, ReactiveWeakSet.prototype);
+metaProtos.set(Map, ReactiveMap.prototype);
+metaProtos.set(WeakMap, ReactiveWeakMap.prototype);
+/**
+ * Object containing internal reactive system state for debugging and profiling
+ */
+const profileInfo = {
+    objectToProxy,
+    proxyToObject,
+    effectToReactiveObjects,
+    watchers,
+    objectParents,
+    objectsWithDeepWatchers,
+    deepWatchers,
+    effectToDeepWatchedObjects,
+    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 = 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 = 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(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 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 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 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;
+}
+
+export { ArrayReadForward as A, setAt as B, throttle as C, Destroyable as D, Eventful as E, unreactive as F, watch as G, Indexable as I, Register as R, DestructionError as a, allocated as b, allocatedValues as c, attend as d, cache as e, cached as f, callOnGC as g, chainPromise as h, debounce as i, deepWatch as j, deprecated as k, describe as l, descriptor as m, destructor as n, forwardArray as o, getActiveProjection as p, getAt as q, isCached as r, lift as s, memoize as t, organize as u, organized as v, profileInfo as w, project as x, register as y, scan as z };
+//# sourceMappingURL=index-2vea86wD.esm.js.map