mutts 1.0.8 → 1.0.10

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

@@ -0,0 +1,3174 @@
+import { r as decorator, x as flavored, a3 as markWithRoot, O as named, a4 as rootFunctionSymbol, S as proxyToObject, a5 as getRoot, a6 as dependant, U as options, a0 as untracked, s as deepCompare, a7 as optionCall, W as root, u as effect, $ as touched1, K as isReactive, T as reactive, _ as touched, o as cleanedBy, C as getState, a8 as keysOf, a9 as __runInitializers, aa as __esDecorate, ab as FoolProof, ac as objectsWithDeepWatchers, ad as effectToDeepWatchedObjects, ae as deepWatchers, H as isNonReactive, a1 as unwrap, af as registerDeepWatcher, w as flavorOptions, X as stopped, ag as nonReactiveClass, ah as unreactiveProps, ai as addUnreactiveProps, aj as nonReactiveObjects, ak as __setFunctionName, al as __classPrivateFieldGet, am as __classPrivateFieldSet, l as atomic, an as contentRef, ao as notifyPropertyChange, ap as metaProtos, aq as wrapProtos, ar as objectParents, as as watchers, at as effectToReactiveObjects, P as objectToProxy } from './proxy-r7lARftl.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;
+}
+
+/** Max edit distance before bailing out to a single "replace all" patch */
+const BAILOUT_D = 256;
+/**
+ * Myers' diff producing grouped patches: `{indexA, indexB, sliceA, sliceB}[]`.
+ * - O(N) for identical or prefix/suffix-only differences
+ * - O(ND) for small D, with a hard bailout at D=BAILOUT_D → single replacement patch
+ */
+function arrayDiff(A, B) {
+    let start = 0;
+    let endA = A.length;
+    let endB = B.length;
+    // Trim common prefix
+    while (start < endA && start < endB && A[start] === B[start])
+        start++;
+    // Trim common suffix
+    while (endA > start && endB > start && A[endA - 1] === B[endB - 1]) {
+        endA--;
+        endB--;
+    }
+    const lenA = endA - start;
+    const lenB = endB - start;
+    if (lenA === 0 && lenB === 0)
+        return [];
+    if (lenA === 0)
+        return [{ indexA: start, indexB: start, sliceA: [], sliceB: B.slice(start, endB) }];
+    if (lenB === 0)
+        return [{ indexA: start, indexB: start, sliceA: A.slice(start, endA), sliceB: [] }];
+    // Myers with bailout
+    const maxD = Math.min(lenA + lenB, BAILOUT_D);
+    const vSize = 2 * maxD + 1;
+    const vOffset = maxD;
+    const V = new Int32Array(vSize);
+    V[vOffset + 1] = 0;
+    const history = [];
+    for (let d = 0; d <= maxD; d++) {
+        for (let k = -d; k <= d; k += 2) {
+            let x;
+            if (k === -d || (k !== d && V[vOffset + k - 1] < V[vOffset + k + 1])) {
+                x = V[vOffset + k + 1];
+            }
+            else {
+                x = V[vOffset + k - 1] + 1;
+            }
+            let y = x - k;
+            while (x < lenA && y < lenB && A[start + x] === B[start + y]) {
+                x++;
+                y++;
+            }
+            V[vOffset + k] = x;
+            if (x >= lenA && y >= lenB)
+                return buildPatches(history, A, B, start, x, y, d, k, vOffset);
+        }
+        history.push(new Int32Array(V));
+    }
+    // Bailout: too many differences
+    return [
+        { indexA: start, indexB: start, sliceA: A.slice(start, endA), sliceB: B.slice(start, endB) },
+    ];
+}
+function buildPatches(history, A, B, offset, finalX, finalY, finalD, finalK, vOffset) {
+    // Backtrack from (finalX, finalY) at step finalD to step 0, collecting ops in reverse
+    const ops = []; // 0=eq, 1=ins, 2=del
+    let x = finalX;
+    let y = finalY;
+    let k = finalK;
+    for (let d = finalD; d > 0; d--) {
+        const prev = history[d - 1];
+        let prevK;
+        let down;
+        if (k === -d) {
+            prevK = k + 1;
+            down = true;
+        }
+        else if (k === d) {
+            prevK = k - 1;
+            down = false;
+        }
+        else if (prev[vOffset + k - 1] < prev[vOffset + k + 1]) {
+            prevK = k + 1;
+            down = true;
+        }
+        else {
+            prevK = k - 1;
+            down = false;
+        }
+        const prevXEnd = prev[vOffset + prevK];
+        const prevYEnd = prevXEnd - prevK;
+        const xStart = down ? prevXEnd : prevXEnd + 1;
+        const yStart = down ? prevYEnd + 1 : prevXEnd + 1 - k;
+        // Diagonal matches (pushed in reverse)
+        while (x > xStart && y > yStart) {
+            ops.push(0);
+            x--;
+            y--;
+        }
+        // The edit step
+        if (down) {
+            ops.push(1); // ins
+            y--;
+        }
+        else {
+            ops.push(2); // del
+            x--;
+        }
+        k = prevK;
+    }
+    // Walk ops forward (they were pushed in reverse), grouping contiguous edits
+    const patches = [];
+    let currA = offset;
+    let currB = offset;
+    let sliceA = [];
+    let sliceB = [];
+    let patchA = -1;
+    let patchB = -1;
+    const flush = () => {
+        if (patchA !== -1) {
+            patches.push({ indexA: patchA, indexB: patchB, sliceA, sliceB });
+            sliceA = [];
+            sliceB = [];
+            patchA = -1;
+        }
+    };
+    for (let i = ops.length - 1; i >= 0; i--) {
+        const op = ops[i];
+        if (op === 0) {
+            flush();
+            currA++;
+            currB++;
+        }
+        else if (op === 1) {
+            if (patchA === -1) {
+                patchA = currA;
+                patchB = currB;
+            }
+            sliceB.push(B[currB++]);
+        }
+        else {
+            if (patchA === -1) {
+                patchA = currA;
+                patchB = currB;
+            }
+            sliceA.push(A[currA++]);
+        }
+    }
+    flush();
+    return patches;
+}
+
+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, opts) {
+    const fnRoot = getRoot(fn);
+    const existing = memoizedRegistry.get(fnRoot);
+    if (existing)
+        return existing;
+    const cacheRoot = {};
+    const memoized = markWithRoot(function memoized(...args) {
+        if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
+            if (opts?.lenient)
+                return fn.apply(this, args);
+            throw new Error('memoize expects non-null object arguments');
+        }
+        let node = cacheRoot;
+        // Note: decorators add `this` as first argument
+        for (const arg of args) {
+            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.apply(this, args));
+                    if (!deepCompare(node.result, fresh)) {
+                        optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, '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.named('memoize')(() => {
+            // Execute the function and track its dependencies
+            // The function execution will automatically track dependencies on reactive objects
+            node.result = fn.apply(this, args);
+            return (reason) => {
+                // When dependencies change, clear the cache and notify consumers
+                delete node.result;
+                touched1(node, { type: 'invalidate', prop: args }, '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({ type: 'invalidate', cause: reason });
+                    node.cleanup = undefined;
+                }
+            };
+        }, { opaque: true }));
+        if (options.onMemoizationDiscrepancy) {
+            const wasVerification = options.isVerificationRun;
+            options.isVerificationRun = true;
+            try {
+                const fresh = untracked(() => fn.apply(this, args));
+                if (!deepCompare(node.result, fresh)) {
+                    optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
+                }
+            }
+            finally {
+                options.isVerificationRun = wasVerification;
+            }
+        }
+        return node.result;
+    }, fn);
+    memoizedRegistry.set(fnRoot, memoized);
+    memoizedRegistry.set(memoized, memoized);
+    return memoized;
+}
+function memoizeObject(target, opts) {
+    const existing = memoizedRegistry.get(target);
+    if (existing)
+        return existing;
+    const proxy = new Proxy(target, {
+        get(source, prop, receiver) {
+            // 1. Walk prototype chain to find descriptor
+            let current = source;
+            let desc;
+            while (current) {
+                desc = Object.getOwnPropertyDescriptor(current, prop);
+                if (desc)
+                    break;
+                current = Object.getPrototypeOf(current);
+            }
+            if (!desc)
+                return Reflect.get(source, prop, receiver);
+            // 2. If getter, memoize
+            if (desc.get) {
+                const originalGetter = desc.get;
+                let wrapper = wrapperRegistry.get(originalGetter);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
+                        return originalGetter.call(that);
+                    }), {
+                        propertyKey: prop,
+                    });
+                    const origRoot = originalGetter[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(originalGetter, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, opts);
+                return memoized(receiver);
+            }
+            // 3. Otherwise forward
+            return Reflect.get(source, prop, receiver);
+        },
+        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
+        set(source, prop, value, _receiver) {
+            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
+            // it recognizes itself and triggers change notifications.
+            return Reflect.set(source, prop, value, source);
+        },
+    });
+    proxyToObject.set(proxy, target);
+    memoizedRegistry.set(target, proxy);
+    return proxy;
+}
+/**
+ * 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)
+ * })
+ * ```
+ */
+function makeMemoizeDecorator(memoizeOpts) {
+    return decorator({
+        getter(original, target, propertyKey) {
+            return function () {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
+                        return original.call(that);
+                    }), {
+                        method: original,
+                        propertyKey,
+                    });
+                    const origRoot = original[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this);
+            };
+        },
+        method(original, target, name) {
+            return function (...args) {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
+                        return original.call(that, ...args);
+                    }), {
+                        method: original,
+                        propertyKey: name,
+                    });
+                    const origRoot = original[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this, ...args);
+            };
+        },
+        default: (target) => typeof target === 'object'
+            ? memoizeObject(target, memoizeOpts)
+            : memoizeFunction(target, memoizeOpts),
+    });
+}
+const memoize = flavored(makeMemoizeDecorator(), {
+    get lenient() {
+        return makeMemoizeDecorator({ lenient: true });
+    },
+});
+
+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 (reason) => {
+        outer(reason);
+        for (const stop of keyEffects.values())
+            stop(reason);
+        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 rawResult = [];
+    const result = reactive(rawResult);
+    // 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);
+            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++)
+            if (i in observedSource) {
+                const val = observedSource[i];
+                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;
+                                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
+        if (rawResult.length !== length) {
+            FoolProof.set(result, 'length', length, result);
+        }
+    });
+    return cleanedBy(result, ((reason) => {
+        mainEffect(reason);
+        for (const stop of indexEffects.values())
+            stop(reason);
+        indexEffects.clear();
+    }));
+}
+function lift(cb) {
+    let result;
+    let rawResult;
+    const liftCleanup = effect.named('lift')(markWithRoot((access) => {
+        const source = cb(access);
+        if (!source || typeof source !== 'object')
+            throw new Error('lift callback must return an array or object');
+        const sourceProto = Object.getPrototypeOf(source);
+        if (!result) {
+            rawResult = Array.isArray(source) ? [] : Object.create(sourceProto);
+            result = reactive(rawResult);
+        }
+        if (sourceProto !== Object.getPrototypeOf(result))
+            throw new Error('lift callback must return the same type as the previous result');
+        if (Array.isArray(source)) {
+            const res = result;
+            const patches = arrayDiff(res, source);
+            for (let i = patches.length - 1; i >= 0; i--) {
+                const { indexA, sliceA, sliceB } = patches[i];
+                res.splice(indexA, sliceA.length, ...sliceB);
+            }
+        }
+        else {
+            for (const key of Object.keys(source)) {
+                const had = key in rawResult;
+                const newDesc = Object.getOwnPropertyDescriptor(source, key);
+                if (had) {
+                    const oldDesc = Object.getOwnPropertyDescriptor(rawResult, key);
+                    const sameAccessor = oldDesc && newDesc.get && oldDesc.get === newDesc.get;
+                    Object.defineProperty(rawResult, key, newDesc);
+                    if (!sameAccessor &&
+                        rawResult[key] !==
+                            (oldDesc ? (oldDesc.get ? oldDesc.get() : oldDesc.value) : undefined))
+                        touched1(rawResult, { type: 'set', prop: key }, key);
+                }
+                else {
+                    Object.defineProperty(rawResult, key, newDesc);
+                    touched1(rawResult, { type: 'add', prop: key }, key);
+                }
+            }
+            for (const key of Object.keys(rawResult))
+                if (!(key in source)) {
+                    delete rawResult[key];
+                    touched1(rawResult, { type: 'del', prop: key }, key);
+                }
+        }
+    }, cb));
+    return cleanedBy(result, liftCleanup);
+}
+/**
+ * Reactively maps an array source through `fn`, producing a lazy reactive output array.
+ *
+ * Each source item gets its own isolated effect (via `root()`) so that changes to one item
+ * only recompute that item's projection. Structural changes (push, splice, reorder) are detected
+ * via `arrayDiff` and surgically applied to the output cache.
+ *
+ * The source can be a reactive array or a function returning an array. When a function is provided,
+ * the function is re-evaluated inside an effect whenever its dependencies change.
+ *
+ * Output elements are computed lazily — accessing `result[i]` triggers computation if not yet cached.
+ *
+ * @param source - A reactive array or a function returning an array
+ * @param fn - Mapping function applied to each element
+ * @param options - Optional purity hints to skip per-item effects
+ * @returns A readonly reactive array with a `[cleanup]` method to dispose all effects
+ */
+function morphArray(source, fn, options) {
+    if (typeof source !== 'function' && !isReactive(source) && options?.pure === true) {
+        return source.map(fn);
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = [];
+    let input = [];
+    function stopItem(key) {
+        const entry = itemEffects.get(key);
+        if (entry) {
+            entry.stop({ type: 'stopped' });
+            itemEffects.delete(key);
+        }
+    }
+    function computeItem(key, input) {
+        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(input));
+        if (isPure) {
+            track(() => {
+                cache[key] = fn(input);
+            });
+        }
+        else {
+            const indexRef = { value: key };
+            let stop;
+            track(() => {
+                stop = effect.opaque(() => {
+                    cache[indexRef.value] = fn(input);
+                    return (reason) => {
+                        delete cache[indexRef.value];
+                        touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                        stop({ type: 'invalidate', cause: reason });
+                    };
+                });
+            });
+            itemEffects.set(key, { stop, index: indexRef });
+        }
+    }
+    const proxy = reactive(cache, {
+        get(cache, prop) {
+            const n = typeof prop === 'string' ? Number(prop) : NaN;
+            if (Number.isNaN(n))
+                return cache[prop];
+            if (!(n in cache))
+                computeItem(n, input[n]);
+            return cache[n];
+        },
+        has(_cache, prop) {
+            return Reflect.has(input, prop);
+        },
+    });
+    const stopMain = effect.named('morph:array')(({ ascend }) => {
+        track = ascend;
+        const newInput = [...(typeof source === 'function' ? source() : source)];
+        const diffs = arrayDiff(input, newInput).toSorted((a, b) => b.indexA - a.indexA);
+        if (diffs.length > 0) {
+            for (const diff of diffs) {
+                // Stop items in removed range
+                for (let i = diff.indexA; i < diff.indexA + diff.sliceA.length; i++)
+                    stopItem(i);
+                // Shift existing itemEffects in the Map to match the new indices
+                const shift = diff.sliceB.length - diff.sliceA.length;
+                if (shift !== 0) {
+                    // We need to move entries in the Map.
+                    const entries = Array.from(itemEffects.entries()).sort((a, b) => a[0] - b[0]);
+                    // Remove entries that will be shifted
+                    for (const [idx, entry] of entries) {
+                        if (idx >= diff.indexA + diff.sliceA.length) {
+                            itemEffects.delete(idx);
+                        }
+                    }
+                    // Re-add them with shifted indices
+                    for (const [idx, entry] of entries) {
+                        if (idx >= diff.indexA + diff.sliceA.length) {
+                            const newIdx = idx + shift;
+                            entry.index.value = newIdx;
+                            itemEffects.set(newIdx, entry);
+                        }
+                    }
+                }
+                // Splice the cache
+                cache.splice(diff.indexA, diff.sliceA.length, ...new Array(diff.sliceB.length).fill(undefined));
+                // Make holes for lazy computation
+                for (let i = diff.indexA; i < diff.indexA + diff.sliceB.length; i++)
+                    delete cache[i];
+            }
+            const invalidates = new Set([keysOf]);
+            if (input.length !== newInput.length)
+                invalidates.add('length');
+            for (const diff of diffs) {
+                const max = Math.max(diff.sliceA.length, diff.sliceB.length);
+                for (let i = 0; i < max; i++)
+                    invalidates.add(String(diff.indexA + i));
+            }
+            touched(cache, { type: 'bunch', method: 'morph-input' }, invalidates);
+        }
+        input = newInput;
+    });
+    return cleanedBy(proxy, (reason) => {
+        stopMain(reason);
+        for (const entry of itemEffects.values())
+            entry.stop(reason);
+        itemEffects.clear();
+    });
+}
+/**
+ * Reactively maps a `Map` source through `fn`, producing a reactive output Map.
+ *
+ * Each key gets its own isolated effect so that value changes for one key only recompute
+ * that key's projection. Key additions and removals are tracked via `keysOf` dependency.
+ *
+ * @param source - A reactive Map
+ * @param fn - Mapping function applied to each value
+ * @param options - Optional purity hints to skip per-key effects
+ * @returns A reactive Map with a `[cleanup]` method to dispose all effects
+ */
+function morphMap(source, fn, options) {
+    if (!isReactive(source) && options?.pure === true) {
+        const res = new Map();
+        for (const [k, v] of source)
+            res.set(k, fn(v));
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = new Map();
+    Object.defineProperty(cache, 'constructor', { value: Object, enumerable: false });
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
+        if (stop) {
+            stop({ type: 'stopped' });
+            itemEffects.delete(key);
+        }
+    }
+    function computeItem(key, val) {
+        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
+        if (isPure) {
+            cache.set(key, track(() => fn(val)));
+        }
+        else {
+            const stop = track(() => effect.opaque(() => {
+                cache.set(key, fn(source.get(key)));
+                return (reason) => {
+                    cache.delete(key);
+                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop({ type: 'invalidate', cause: reason });
+                };
+            }));
+            itemEffects.set(key, stop);
+        }
+    }
+    const proxy = reactive(cache, {
+        get(cache, prop) {
+            if (prop === 'get')
+                return (key) => {
+                    if (!cache.has(key) && source.has(key))
+                        computeItem(key, source.get(key));
+                    return cache.get(key);
+                };
+            if (prop === 'has')
+                return (key) => {
+                    return source.has(key);
+                };
+            if (prop === 'keys')
+                return () => {
+                    return source.keys();
+                };
+            if (prop === 'values')
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield proxy.get(key);
+                    }
+                };
+            if (prop === 'entries')
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy.get(key)];
+                    }
+                };
+            if (prop === Symbol.iterator)
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy.get(key)];
+                    }
+                };
+            return cache[prop];
+        },
+    });
+    let stateSnapshot = getState(source);
+    const stopMain = effect.named('morph:map')(({ ascend }) => {
+        track = ascend;
+        dependant(source, keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                cache.delete(evolution.prop);
+                touched1(cache, evolution, evolution.prop);
+            }
+        }
+    });
+    return cleanedBy(proxy, (reason) => {
+        stopMain(reason);
+        for (const stop of itemEffects.values())
+            stop(reason);
+        itemEffects.clear();
+    });
+}
+/**
+ * Reactively maps a record/object source through `fn`, producing a reactive output record.
+ *
+ * Each key gets its own isolated effect so that value changes for one key only recompute
+ * that key's projection. Key additions and removals are tracked automatically.
+ *
+ * @param source - A reactive record
+ * @param fn - Mapping function applied to each value
+ * @param options - Optional purity hints to skip per-key effects
+ * @returns A reactive record with a `[cleanup]` method to dispose all effects
+ */
+function morphRecord(source, fn, options) {
+    if (!isReactive(source) && options?.pure === true) {
+        const res = {};
+        for (const k of Object.keys(source))
+            res[k] = fn(source[k]);
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = {};
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
+        if (stop) {
+            stop({ type: 'stopped' });
+            itemEffects.delete(key);
+        }
+    }
+    function computeItem(key, val) {
+        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
+        if (isPure) {
+            cache[key] = track(() => fn(val));
+        }
+        else {
+            const stop = track(() => effect.opaque(() => {
+                cache[key] = fn(source[key]);
+                return (reason) => {
+                    delete cache[key];
+                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop({ type: 'invalidate', cause: reason });
+                };
+            }));
+            itemEffects.set(key, stop);
+        }
+    }
+    function get(prop) {
+        if (!(prop in cache) && prop in source)
+            computeItem(prop, source[prop]);
+        return cache[prop];
+    }
+    const proxy = reactive(cache, {
+        get(_, prop) {
+            return get(prop);
+        },
+        has(_, prop) {
+            return prop in source;
+        },
+        ownKeys() {
+            return Reflect.ownKeys(source);
+        },
+        getOwnPropertyDescriptor(_cache, prop) {
+            if (prop in source)
+                return { configurable: true, enumerable: true, get: () => get(prop) };
+        },
+    });
+    let stateSnapshot = getState(source);
+    const stopMain = effect.named('morph:record')(({ ascend }) => {
+        track = ascend;
+        // Track only structural changes on source
+        dependant(source, keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                delete cache[evolution.prop];
+                touched1(cache, evolution, evolution.prop);
+            }
+        }
+    });
+    return cleanedBy(proxy, (reason) => {
+        stopMain(reason);
+        for (const stop of itemEffects.values())
+            stop(reason);
+        itemEffects.clear();
+    });
+}
+/**
+ * Reactively maps a collection (array, Map, or record) through a per-entry function.
+ *
+ * Each entry in the source gets its own reactive context — when only one entry's dependencies
+ * change, only that entry's projection recomputes. Structural changes (additions, removals,
+ * reorders) are detected via diffing and applied surgically.
+ *
+ * Use `morph.pure(source, fn)` when `fn` has no reactive reads (skips per-item effects).
+ *
+ * @example
+ * ```ts
+ * const users = reactive([{ name: 'John' }, { name: 'Jane' }])
+ * const names = morph(users, u => u.name.toUpperCase())
+ * // names[0] = 'JOHN', names[1] = 'JANE'
+ * // Changing users[0].name only recomputes names[0]
+ * ```
+ */
+const morph = flavored(function morph(source, fn, options) {
+    if (Array.isArray(source) || typeof source === 'function')
+        return morphArray(source, fn, options);
+    if (source instanceof Map)
+        return morphMap(source, fn, options);
+    return morphRecord(source, fn, options);
+}, {
+    get pure() {
+        return (source, fn, _opt) => this(source, fn, { pure: true });
+    },
+});
+
+/**
+ * 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);
+    registerDeepWatcher();
+    // 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) || typeof obj !== 'object' || 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) {
+            untracked(() => 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);
+            }
+        };
+    });
+}
+
+/**
+ * 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, (reason) => stop(reason));
+}
+/**
+ * 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];
+}
+
+//#region watch
+const unsetYet = Symbol('unset-yet');
+const watch = flavored(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');
+            })();
+}, {
+    get deep() {
+        return flavorOptions(this, { deep: true });
+    },
+    get immediate() {
+        return flavorOptions(this, { immediate: true });
+    },
+});
+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) {
+            const old = oldValue;
+            if (old === unsetYet) {
+                if (immediate)
+                    untracked(() => changed(newValue));
+            }
+            else
+                untracked(() => changed(newValue, old));
+        }
+        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 when
+/**
+ * Returns a promise that resolves when the predicate returns a truthy value.
+ * The predicate is evaluated reactively — it re-runs whenever its dependencies change.
+ * @param predicate - Reactive function that returns a value; resolves when truthy
+ * @param timeout - Optional timeout in milliseconds — rejects if condition is not met within this duration
+ * @returns Promise that resolves with the first truthy return value
+ */
+function when(predicate, timeout) {
+    return new Promise((resolve, reject) => {
+        let timer;
+        const stop = effect(function whenEffect(access) {
+            try {
+                const value = predicate(access);
+                if (value) {
+                    if (timer !== undefined)
+                        clearTimeout(timer);
+                    timer = undefined;
+                    queueMicrotask(() => stop());
+                    resolve(value);
+                }
+            }
+            catch (error) {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                timer = undefined;
+                reject(error);
+            }
+        });
+        if (timeout !== undefined) {
+            timer = setTimeout(() => {
+                stop();
+                timer = undefined;
+                reject(new Error(`when: timed out after ${timeout}ms`));
+            }, timeout);
+        }
+    });
+}
+//#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;
+    nonReactiveObjects.add(obj);
+    return obj;
+}
+function unreactiveApplication(arg1, ...args) {
+    return typeof arg1 === 'object'
+        ? shallowNonReactive(arg1)
+        : ((original) => {
+            // Copy the parent's unreactive properties if they exist
+            const parentSet = unreactiveProps.get(original.prototype);
+            const set = new Set(parentSet || []);
+            // Add all arguments (including the first one)
+            set.add(arg1);
+            for (const arg of args)
+                set.add(arg);
+            addUnreactiveProps(original.prototype, set);
+            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,
+});
+/**
+ * Creates a reactive resource that automatically tracks async state.
+ * @param fetcher - Async function that returns the value. Reactive dependencies are tracked.
+ * @param options - Resource options (initialValue)
+ * @returns Reactive Resource object with value, loading, error, latest properties
+ */
+function resource(fetcher, options = {}) {
+    const state = reactive({
+        value: options.initialValue,
+        loading: true,
+        error: undefined,
+        latest: options.initialValue,
+        reload: () => {
+            reloadSignal.value++;
+        },
+    });
+    const reloadSignal = reactive({ value: 0 });
+    let counter = 0;
+    const stop = effect(function resourceEffect(access) {
+        // Track reload signal to enable manual reloading
+        if (reloadSignal.value) ;
+        const id = ++counter;
+        state.loading = true;
+        state.error = undefined;
+        try {
+            const result = fetcher(access);
+            if (result instanceof Promise) {
+                result.then((val) => {
+                    if (id === counter) {
+                        state.value = val;
+                        state.latest = val;
+                        state.loading = false;
+                    }
+                }, (err) => {
+                    if (id === counter) {
+                        state.error = err;
+                        state.loading = false;
+                    }
+                });
+            }
+            else {
+                state.value = result;
+                state.latest = result;
+                state.loading = false;
+            }
+        }
+        catch (err) {
+            state.error = err;
+            state.loading = false;
+        }
+    });
+    state.stop = stop;
+    return state;
+}
+//#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);
+}
+
+/**
+ * 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();
+    }
+}
+
+function* index(i, { length = true } = {}) {
+    if (length)
+        yield 'length';
+    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 };
+// Fast numeric-string check: first char is a digit (0-9)
+function asIndex(prop) {
+    const c = prop.charCodeAt(0);
+    if (c < 48 || c > 57)
+        return -1; // not 0-9
+    const n = +prop; // coerce — faster than parseInt, handles "0", "12", etc.
+    return n === (n | 0) && n >= 0 ? n : -1;
+}
+Object.assign(FoolProof, {
+    get(obj, prop, receiver) {
+        if (Array.isArray(obj) && typeof prop === 'string') {
+            const i = asIndex(prop);
+            if (i >= 0)
+                return Indexer.prototype.get.call(obj, i);
+        }
+        return indexLess.get(obj, prop, receiver);
+    },
+    set(obj, prop, value, receiver) {
+        if (Array.isArray(obj) && typeof prop === 'string') {
+            const i = asIndex(prop);
+            if (i >= 0)
+                return Indexer.prototype.set.call(obj, i, value);
+        }
+        return indexLess.set(obj, prop, value, receiver);
+    },
+});
+class ReactiveArray extends Array {
+    toJSON() {
+        return this;
+    }
+}
+/**
+ * This is a wrapper class for Array that adds reactive behavior.
+ * It extends Array and overrides methods to add reactive behavior, while making sure that the internal representation is not reactive.
+ */
+let ReactiveArrayWrapper = (() => {
+    var _a;
+    let _classSuper = Array;
+    let _instanceExtraInitializers = [];
+    let _fill_decorators;
+    let _pop_decorators;
+    let _push_decorators;
+    let _reverse_decorators;
+    let _shift_decorators;
+    let _sort_decorators;
+    let _splice_decorators;
+    let _unshift_decorators;
+    return _a = class ReactiveArrayWrapper extends _classSuper {
+            at(index) {
+                return reactive(super.at(index));
+            }
+            concat(...items) {
+                return reactive(super.concat(...items.map(unwrap)));
+            }
+            entries() {
+                dependant(this, keysOf);
+                return makeReactiveEntriesIterator(super.entries());
+            }
+            every(predicate, thisArg) {
+                return super.every((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            fill(value, start, end) {
+                return super.fill(unwrap(value), start, end);
+            }
+            filter(predicate, thisArg) {
+                return reactive(super.filter((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg));
+            }
+            find(predicate, thisArg) {
+                return reactive(super.find((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg));
+            }
+            findIndex(predicate, thisArg) {
+                return super.findIndex((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            findLast(predicate, thisArg) {
+                return reactive(super.findLast((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg));
+            }
+            findLastIndex(predicate, thisArg) {
+                return super.findLastIndex((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            flat(depth) {
+                return reactive(super.flat(depth));
+            }
+            flatMap(callbackfn, thisArg) {
+                return reactive(super.flatMap((v, i, a) => unwrap(callbackfn.call(thisArg, reactive(v), i, a)), thisArg));
+            }
+            forEach(callbackfn, thisArg) {
+                super.forEach((v, i, a) => {
+                    callbackfn.call(thisArg, reactive(v), i, a);
+                }, thisArg);
+            }
+            includes(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.includes(unwrap(searchElement), fromIndex)
+                    : super.includes(unwrap(searchElement));
+            }
+            indexOf(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.indexOf(unwrap(searchElement), fromIndex)
+                    : super.indexOf(unwrap(searchElement));
+            }
+            join(separator) {
+                return super.join(separator);
+            }
+            keys() {
+                dependant(this, 'length');
+                return super.keys();
+            }
+            lastIndexOf(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.lastIndexOf(unwrap(searchElement), fromIndex)
+                    : super.lastIndexOf(unwrap(searchElement));
+            }
+            map(callbackfn, thisArg) {
+                return reactive(super.map((v, i, a) => unwrap(callbackfn.call(thisArg, reactive(v), i, a)), thisArg));
+            }
+            pop() {
+                return reactive(super.pop());
+            }
+            push(...items) {
+                return super.push(...items.map(unwrap));
+            }
+            reduce(callbackfn, initialValue) {
+                return reactive(arguments.length > 1
+                    ? super.reduce((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a)), initialValue)
+                    : super.reduce((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a))));
+            }
+            reduceRight(callbackfn, initialValue) {
+                return reactive(arguments.length > 1
+                    ? super.reduceRight((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a)), initialValue)
+                    : super.reduceRight((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a))));
+            }
+            reverse() {
+                return reactive(super.reverse());
+            }
+            shift() {
+                return reactive(super.shift());
+            }
+            slice(start, end) {
+                return reactive(super.slice(start, end));
+            }
+            some(predicate, thisArg) {
+                return super.some((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            sort(compareFn) {
+                const wrappedCompare = compareFn
+                    ? (a, b) => compareFn(reactive(a), reactive(b))
+                    : undefined;
+                return super.sort(wrappedCompare);
+            }
+            splice(start, deleteCount, ...items) {
+                if (arguments.length > 2)
+                    return reactive(super.splice(start, deleteCount, ...items.map(unwrap)));
+                if (arguments.length === 2)
+                    return reactive(super.splice(start, deleteCount));
+                if (arguments.length === 1)
+                    return reactive(super.splice(start));
+                return reactive([]);
+            }
+            unshift(...items) {
+                return super.unshift(...items.map(unwrap));
+            }
+            values() {
+                dependant(this, keysOf);
+                return makeReactiveIterator(super.values());
+            }
+            [(_fill_decorators = [atomic], _pop_decorators = [atomic], _push_decorators = [atomic], _reverse_decorators = [atomic], _shift_decorators = [atomic], _sort_decorators = [atomic], _splice_decorators = [atomic], _unshift_decorators = [atomic], Symbol.iterator)]() {
+                dependant(this, keysOf);
+                return makeReactiveIterator(super[Symbol.iterator]());
+            }
+            toReversed() {
+                return reactive(super.toReversed());
+            }
+            toSorted(compareFn) {
+                const wrappedCompare = compareFn
+                    ? (a, b) => compareFn(reactive(a), reactive(b))
+                    : undefined;
+                return reactive(super.toSorted(wrappedCompare));
+            }
+            // biome-ignore lint/complexity/noArguments: Needed to distinguish fn() from fn(undefined)
+            toSpliced(start, deleteCount, ...items) {
+                if (arguments.length > 2)
+                    return reactive(super.toSpliced(start, deleteCount, ...items.map(unwrap)));
+                if (arguments.length === 2)
+                    return reactive(super.toSpliced(start, deleteCount));
+                if (arguments.length === 1)
+                    return reactive(super.toSpliced(start));
+                return reactive([...this]);
+            }
+            with(index, value) {
+                return reactive(super.with(index, unwrap(value)));
+            }
+            constructor() {
+                super(...arguments);
+                __runInitializers(this, _instanceExtraInitializers);
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(_a, null, _fill_decorators, { kind: "method", name: "fill", static: false, private: false, access: { has: obj => "fill" in obj, get: obj => obj.fill }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _pop_decorators, { kind: "method", name: "pop", static: false, private: false, access: { has: obj => "pop" in obj, get: obj => obj.pop }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _push_decorators, { kind: "method", name: "push", static: false, private: false, access: { has: obj => "push" in obj, get: obj => obj.push }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _reverse_decorators, { kind: "method", name: "reverse", static: false, private: false, access: { has: obj => "reverse" in obj, get: obj => obj.reverse }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _shift_decorators, { kind: "method", name: "shift", static: false, private: false, access: { has: obj => "shift" in obj, get: obj => obj.shift }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _sort_decorators, { kind: "method", name: "sort", static: false, private: false, access: { has: obj => "sort" in obj, get: obj => obj.sort }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _splice_decorators, { kind: "method", name: "splice", static: false, private: false, access: { has: obj => "splice" in obj, get: obj => obj.splice }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _unshift_decorators, { kind: "method", name: "unshift", static: false, private: false, access: { has: obj => "unshift" in obj, get: obj => obj.unshift }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+
+/**
+ * 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), keysOf);
+        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
+console.time('mutts-reactive-init');
+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);
+wrapProtos.set(Array, ReactiveArrayWrapper.prototype);
+console.timeEnd('mutts-reactive-init');
+/**
+ * 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.10";
+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';
+    // biome-ignore lint/security/noGlobalEval: Intentional eval for cross-env import.meta detection
+    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, when as H, Indexable as I, Register as R, DestructionError as a, allocated as b, allocatedValues as c, arrayDiff as d, attend as e, cache as f, cached as g, callOnGC as h, chainPromise as i, debounce as j, deepWatch as k, deprecated as l, descriptor as m, destructor as n, forwardArray as o, getAt as p, isCached as q, lift as r, memoize as s, morph as t, organize as u, organized as v, profileInfo as w, register as x, resource as y, scan as z };
+//# sourceMappingURL=index-CaaQQlPJ.esm.js.map