mutts 1.0.11 → 1.0.13

package/dist/chunks/index-CAdnMJev.cjs

@@ -0,0 +1,2735 @@
+'use strict';
+
+var proxy = require('./proxy-DBHj3kGK.cjs');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// 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 = proxy.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');
+function getEventMap(target) {
+    return target[events];
+}
+function getHookSet(target) {
+    return target[hooks];
+}
+const eventBehavior = {
+    on(eventOrEvents, cb) {
+        const self = this;
+        const eventMap = getEventMap(self);
+        if (typeof eventOrEvents === 'object') {
+            for (const e of Object.keys(eventOrEvents)) {
+                this.on(e, eventOrEvents[e]);
+            }
+        }
+        else if (cb !== undefined) {
+            const callbacks = eventMap.get(eventOrEvents) ?? new Set();
+            if (!callbacks.has(cb))
+                callbacks.add(cb);
+            eventMap.set(eventOrEvents, callbacks);
+        }
+        return () => this.off(eventOrEvents, cb);
+    },
+    off(eventOrEvents, cb) {
+        const self = this;
+        const eventMap = getEventMap(self);
+        if (typeof eventOrEvents === 'object') {
+            for (const e of Object.keys(eventOrEvents)) {
+                this.off(e, eventOrEvents[e]);
+            }
+        }
+        else if (cb !== null && cb !== undefined) {
+            const callbacks = eventMap.get(eventOrEvents);
+            if (callbacks) {
+                callbacks.delete(cb);
+                if (!callbacks.size)
+                    eventMap.delete(eventOrEvents);
+            }
+        }
+        else {
+            // Remove all listeners for this event
+            eventMap.delete(eventOrEvents);
+        }
+    },
+    emit(event, ...args) {
+        const self = this;
+        const callbacks = getEventMap(self).get(event);
+        if (callbacks)
+            for (const cb of callbacks)
+                cb.apply(this, args);
+        for (const cb of getHookSet(self))
+            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 && !getEventMap(eventful).has(prop) && !getHookSet(eventful).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 attend = proxy.captioned(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 callbackLabel = callback.name ? callback.name : '';
+    const outer = proxy.effect `attend`(({ ascend }) => {
+        const keys = new Set();
+        for (const key of enumerate())
+            keys.add(key);
+        for (const key of keys) {
+            if (keyEffects.has(key))
+                continue;
+            const indexRef = { value: key };
+            keyEffects.set(key, ascend(() => proxy.effect `attend${callbackLabel ? `:${callbackLabel}` : ''}:${key}`((access) => callback(indexRef.value, access))));
+        }
+        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();
+    };
+}, {
+    name: 'attend',
+    callbackIndex: 1,
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+});
+/**
+ * Lifts a callback that returns an object into a reactive object that automatically
+ * synchronizes with the source object returned by the callback.
+ *
+ * The returned reactive object will update whenever the callback's dependencies change,
+ * efficiently syncing only the properties that differ from the previous result using
+ * Object.assign(). Properties that no longer exist in the source are automatically removed.
+ *
+ * @example
+ * ```typescript
+ * const user = reactive({ name: 'John', age: 30 })
+ * const profile = lift(() => ({
+ *   displayName: user.name.toUpperCase(),
+ *   isAdult: user.age >= 18,
+ *   description: `${user.name} is ${user.age} years old`
+ * }))
+ *
+ * console.log(profile.displayName) // JOHN
+ * console.log(profile.isAdult) // true
+ *
+ * user.name = 'Jane'
+ * console.log(profile.displayName) // JANE
+ * console.log(profile.description) // Jane is 30 years old
+ * ```
+ *
+ * @param cb Callback function that returns an object
+ * @returns A reactive object synchronized with the callback's result, with a [cleanup] property to stop tracking
+ */
+const lift = proxy.captioned(function lift(cb) {
+    let result;
+    let rawResult;
+    const resultName = `lift:${cb.name || 'anonymous'}`;
+    const liftCleanup = proxy.effect `lift:${cb.name}`(proxy.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 = proxy.tag(resultName, Array.isArray(source) ? [] : Object.create(sourceProto));
+            result = proxy.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;
+            for (const { indexA, sliceA, sliceB } of arrayDiff(res, source).sort((a, b) => a.indexA - b.indexA))
+                res.splice(indexA, sliceA.length, ...sliceB);
+        }
+        else {
+            const recordResult = rawResult;
+            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 &&
+                        recordResult[key] !==
+                            (oldDesc ? (oldDesc.get ? oldDesc.get() : oldDesc.value) : undefined))
+                        proxy.touched1(rawResult, { type: 'set', prop: key }, key);
+                }
+                else {
+                    Object.defineProperty(rawResult, key, newDesc);
+                    proxy.touched1(rawResult, { type: 'add', prop: key }, key);
+                }
+            }
+            for (const key of Object.keys(rawResult))
+                if (!(key in source)) {
+                    delete recordResult[key];
+                    proxy.touched1(rawResult, { type: 'del', prop: key }, key);
+                }
+        }
+    }, cb));
+    return proxy.link(result, liftCleanup);
+}, {
+    name: 'lift',
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+});
+/**
+ * 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' && !proxy.isReactive(source) && options?.pure === true) {
+        return source.map((i) => fn(i));
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = proxy.tag(`morph:${fn.name || 'anonymous'}`, []);
+    let input = [];
+    function stopItem(key) {
+        const entry = itemEffects.get(key);
+        if (entry) {
+            const activeEffect = proxy.getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = proxy.getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            entry.stop(proxy.chainExternalReason({ type: 'stopped', chain }));
+            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 };
+            const stop = track(() => proxy.effect.opaque `morph:${fn.name}:${key}`((access) => {
+                cache[indexRef.value] = fn(input, access);
+                return (reason) => {
+                    delete cache[indexRef.value];
+                    proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = proxy.getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: proxy.chainExternalReason(chain),
+                    });
+                };
+            }));
+            itemEffects.set(key, { stop, index: indexRef });
+        }
+    }
+    const proxy$1 = 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 = proxy.effect `morph:${fn.name}`(({ 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([proxy.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));
+            }
+            proxy.touched(cache, { type: 'bunch', method: 'morph-input' }, invalidates);
+        }
+        input = newInput;
+    });
+    return proxy.link(proxy$1, (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 (!proxy.isReactive(source) && options?.pure === true) {
+        const res = new Map();
+        for (const [k, v] of source)
+            res.set(k, fn(v, k));
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = proxy.tag(`morph:${fn.name || 'anonymous'}`, new Map());
+    Object.defineProperty(cache, 'constructor', { value: Object, enumerable: false });
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
+        if (stop) {
+            const activeEffect = proxy.getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = proxy.getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            stop({ type: 'stopped', chain });
+            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, key)));
+        }
+        else {
+            const stop = track(() => proxy.effect.opaque `morph:${fn.name}:${key}`((access) => {
+                const next = source.get(key);
+                if (next === undefined && !source.has(key))
+                    return;
+                cache.set(key, fn(next, key, access));
+                return (reason) => {
+                    cache.delete(key);
+                    proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = proxy.getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: proxy.chainExternalReason(chain),
+                    });
+                };
+            }));
+            itemEffects.set(key, stop);
+        }
+    }
+    const proxy$1 = 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$1.get(key);
+                    }
+                };
+            if (prop === 'entries')
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy$1.get(key)];
+                    }
+                };
+            if (prop === Symbol.iterator)
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy$1.get(key)];
+                    }
+                };
+            return cache[prop];
+        },
+    });
+    let stateSnapshot = proxy.getState(source);
+    const stopMain = proxy.effect `morph:${fn.name}`(({ ascend }) => {
+        track = ascend;
+        proxy.dependant(source, proxy.keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                proxy.touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                cache.delete(evolution.prop);
+                proxy.touched1(cache, evolution, evolution.prop);
+            }
+        }
+    });
+    return proxy.link(proxy$1, (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 (!proxy.isReactive(source) && options?.pure === true) {
+        const res = {};
+        for (const k of Object.keys(source))
+            res[k] = fn(source[k], k);
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = {};
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
+        if (stop) {
+            const activeEffect = proxy.getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = proxy.getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            stop({ type: 'stopped', chain });
+            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, key));
+        }
+        else {
+            const stop = track(() => proxy.effect.opaque `morph:${fn.name}:${key}`((access) => {
+                cache[key] = fn(source[key], key, access);
+                return (reason) => {
+                    delete cache[key];
+                    proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = proxy.getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: proxy.chainExternalReason(chain),
+                    });
+                };
+            }));
+            itemEffects.set(key, stop);
+        }
+    }
+    function get(prop) {
+        if (!(prop in cache) && prop in source)
+            computeItem(prop, source[prop]);
+        return cache[prop];
+    }
+    const proxy$1 = 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 = proxy.getState(source);
+    const stopMain = proxy.effect `morph:${fn.name}`(({ ascend }) => {
+        track = ascend;
+        // Track only structural changes on source
+        proxy.dependant(source, proxy.keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                proxy.touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                delete cache[evolution.prop];
+                proxy.touched1(cache, evolution, evolution.prop);
+            }
+        }
+    });
+    return proxy.link(proxy$1, (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 = proxy.captioned(proxy.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 });
+    },
+}), {
+    name: 'morph',
+    callbackIndex: 1,
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+});
+
+/**
+ * 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 = proxy.markWithRoot((() => callback(target)), callback);
+    proxy.registerDeepWatcher();
+    // Use the existing effect system to register dependencies
+    return proxy.effect `deepWatch`(() => {
+        // Mark the target object as having deep watchers
+        proxy.objectsWithDeepWatchers.add(target);
+        // Track which objects this effect is watching for cleanup
+        let effectObjects = proxy.effectToDeepWatchedObjects.get(wrappedCallback);
+        if (!effectObjects) {
+            effectObjects = new Set();
+            proxy.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 > proxy.options.maxDeepWatchDepth)
+                return;
+            // Do not traverse into unreactive objects
+            if (proxy.isNonReactive(obj))
+                return;
+            visited.add(obj);
+            // Mark this object as having deep watchers
+            proxy.objectsWithDeepWatchers.add(obj);
+            effectObjects.add(obj);
+            // Traverse all properties to register dependencies
+            // unwrap to avoid kicking dependency
+            for (const key in proxy.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 ? proxy.reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+            }
+            // Also handle array indices and length
+            // Handle arrays and collections using iterators to ensure proxy tracking is triggered
+            if (typeof obj[Symbol.iterator] === 'function') {
+                // Access the iterator to track additions/removals/collection changes
+                for (const value of obj) {
+                    // Make the value reactive if it's an object
+                    const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+                // Explicitly depend on length so array mutations changing count trigger re-evaluation
+                if ('length' in obj) {
+                    proxy.dependant(obj, 'length');
+                }
+                // For Maps, also ensure we track values explicitly if the iterator yields entries
+                if (obj instanceof Map) {
+                    for (const value of obj.values()) {
+                        const reactiveValue = typeof value === 'object' && value !== null ? proxy.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) {
+            proxy.untracked `deepWatch:callback`(() => callback(target));
+        }
+        immediate = true;
+        // Return a cleanup function that properly removes deep watcher tracking
+        return () => {
+            // Get the objects this effect was watching
+            const effectObjects = proxy.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 = proxy.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) {
+                            proxy.deepWatchers.delete(obj);
+                            proxy.objectsWithDeepWatchers.delete(obj);
+                        }
+                    }
+                    else {
+                        // No watchers found, remove from deep watchers tracking
+                        proxy.objectsWithDeepWatchers.delete(obj);
+                    }
+                }
+                // Clean up the tracking data
+                proxy.effectToDeepWatchedObjects.delete(wrappedCallback);
+            }
+        };
+    });
+}
+
+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 = proxy.getRoot(fn);
+    const existing = memoizedRegistry.get(fnRoot);
+    if (existing)
+        return existing;
+    const cacheRoot = {};
+    const memoized = proxy.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);
+        }
+        proxy.dependant(node, 'memoize');
+        if ('result' in node) {
+            if (proxy.options.onMemoizationDiscrepancy) {
+                const wasVerification = proxy.options.isVerificationRun;
+                proxy.options.isVerificationRun = true;
+                try {
+                    const fresh = proxy.untracked `memoize:verify-calculation`(() => fn.apply(this, args));
+                    if (!proxy.deepCompare(node.result, fresh)) {
+                        proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
+                    }
+                }
+                finally {
+                    proxy.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 = proxy.root `memoize:root`(() => proxy.effect `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;
+                proxy.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) {
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const effectNode = proxy.getEffectNode(activeEffect);
+                        chain = effectNode.currentReason;
+                    }
+                    node.cleanup({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: proxy.chainExternalReason(chain),
+                    });
+                    node.cleanup = undefined;
+                }
+            };
+        }, { opaque: true }));
+        if (proxy.options.onMemoizationDiscrepancy) {
+            const wasVerification = proxy.options.isVerificationRun;
+            proxy.options.isVerificationRun = true;
+            try {
+                const fresh = proxy.untracked `memoize:verify-comparison`(() => fn.apply(this, args));
+                if (!proxy.deepCompare(node.result, fresh)) {
+                    proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
+                }
+            }
+            finally {
+                proxy.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$1 = 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 = proxy.markWithRoot(proxy.named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
+                        return originalGetter.call(that);
+                    }), {
+                        propertyKey: prop,
+                    });
+                    const origRoot = originalGetter[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.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);
+        },
+    });
+    proxy.proxyToObject.set(proxy$1, target);
+    memoizedRegistry.set(target, proxy$1);
+    return proxy$1;
+}
+/**
+ * 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 proxy.decorator({
+        getter(original, target, propertyKey) {
+            return function () {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
+                        return original.call(that);
+                    }), {
+                        method: original,
+                        propertyKey,
+                    });
+                    const origRoot = original[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.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 = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
+                        return original.call(that, ...args);
+                    }), {
+                        method: original,
+                        propertyKey: name,
+                    });
+                    const origRoot = original[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.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 = proxy.flavored(makeMemoizeDecorator(), {
+    get lenient() {
+        return makeMemoizeDecorator({ lenient: true });
+    },
+});
+
+/**
+ * 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 = proxy.reactive(source);
+    const target = proxy.reactive(baseTarget);
+    const stop = attend `organized:entries`(function enumerateObservedSourceKeys() {
+        const keys = [];
+        for (const key in observedSource)
+            keys.push(key);
+        return keys;
+    }, function applyObservedSourceKey(key) {
+        const sourceKey = key;
+        const accessBase = {
+            key: sourceKey,
+            get: () => proxy.FoolProof.get(observedSource, sourceKey, observedSource),
+            set: (value) => proxy.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 proxy.link(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,
+    });
+    proxy.touched1(target, { type: 'set', prop: property }, property);
+    return () => delete target[property];
+}
+
+//#region watch
+const unsetYet = Symbol('unset-yet');
+const watch = proxy.captioned(proxy.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 proxy.flavorOptions(this, { deep: true });
+    },
+    get immediate() {
+        return proxy.flavorOptions(this, { immediate: true });
+    },
+}), {
+    name: 'watch',
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+});
+function watchObject(value, changed, { immediate = false, deep = false } = {}) {
+    if (deep)
+        return deepWatch(value, changed, { immediate });
+    return proxy.effect `watch:object`(() => {
+        proxy.dependant(value);
+        if (immediate)
+            changed(value);
+        immediate = true;
+    });
+}
+function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
+    let oldValue = unsetYet;
+    let deepCleanup;
+    const cbCleanup = proxy.effect `watch:callback`(proxy.markWithRoot((access) => {
+        const newValue = value(access);
+        if (oldValue !== newValue) {
+            const old = oldValue;
+            if (old === unsetYet) {
+                if (immediate)
+                    proxy.untracked `watch:changed`(() => changed(newValue));
+            }
+            else
+                proxy.untracked `watch:changed`(() => changed(newValue, old));
+        }
+        oldValue = newValue;
+        if (deep) {
+            if (deepCleanup)
+                deepCleanup();
+            deepCleanup = deepWatch(newValue, (value) => changed(value, value));
+        }
+    }, value));
+    return (() => {
+        cbCleanup();
+        if (deepCleanup)
+            deepCleanup();
+    });
+}
+//#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 = proxy.effect `watch:when`((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 = proxy.unwrap(obj);
+    if (proxy.isNonReactive(obj))
+        return obj;
+    obj[proxy.unreactiveProperties] = true;
+    return obj;
+}
+function unreactiveApplication(arg1, ...args) {
+    return typeof arg1 === 'object'
+        ? shallowNonReactive(arg1)
+        : ((original) => {
+            // Copy the parent's unreactive properties if they exist
+            const parentMarker = original.prototype[proxy.unreactiveProperties];
+            // If parent is fully unreactive, child is too
+            if (parentMarker === true) {
+                original.prototype[proxy.unreactiveProperties] = true;
+            }
+            else {
+                const set = new Set(parentMarker || []);
+                // Add all arguments (including the first one)
+                set.add(arg1);
+                for (const arg of args)
+                    set.add(arg);
+                proxy.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 = proxy.decorator({
+    class(original) {
+        original.prototype[proxy.unreactiveProperties] = true;
+    },
+    default: unreactiveApplication,
+});
+//#endregion
+//#region resource
+function lazyInit(resource, load) {
+    const creation = proxy.effectHistory.active;
+    let fresh = true;
+    return new Proxy(resource, {
+        [Symbol.toStringTag]: 'LazyInit',
+        get(target, prop) {
+            if (fresh) {
+                proxy.captured(creation, load)();
+                fresh = false;
+            }
+            return target[prop];
+        },
+    });
+}
+/**
+ * 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 resource = proxy.reactive({
+        value: options.initialValue,
+        loading: true,
+        error: undefined,
+        latest: options.initialValue,
+        reload() {
+            reloadSignal.value++;
+        },
+    });
+    const reloadSignal = proxy.reactive({ value: 0 });
+    // Solve race conditions: make sure a new fast request is not overloaded by a slow old one
+    let counter = 0;
+    return lazyInit(resource, () => {
+        proxy.link(resource, proxy.effect `watch:resource`((access) => {
+            // Track reload signal to enable manual reloading
+            void reloadSignal.value;
+            const id = ++counter;
+            resource.loading = true;
+            resource.error = undefined;
+            try {
+                const result = fetcher(access);
+                if (result instanceof Promise) {
+                    resource.promise = result
+                        .then((val) => {
+                        if (id === counter) {
+                            resource.value = val;
+                            resource.latest = val;
+                            resource.loading = false;
+                        }
+                    })
+                        .catch((err) => {
+                        if (id === counter) {
+                            resource.error = err;
+                            resource.loading = false;
+                        }
+                    });
+                }
+                else {
+                    resource.promise = Promise.resolve();
+                    resource.value = result;
+                    resource.latest = result;
+                    resource.loading = false;
+                }
+            }
+            catch (err) {
+                resource.promise = Promise.reject(err);
+                resource.error = err;
+                resource.loading = false;
+            }
+        }));
+    });
+}
+//#endregion
+
+/**
+ * Converts an iterator to a generator that yields reactive values
+ */
+function* makeReactiveIterator(iterator) {
+    let result = iterator.next();
+    while (!result.done) {
+        yield proxy.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 [proxy.reactive(key), proxy.reactive(value)];
+        result = iterator.next();
+    }
+}
+
+function* index(i, { length = true } = {}) {
+    if (length)
+        yield 'length';
+    yield i;
+}
+class Indexer extends Array {
+    get(i) {
+        proxy.dependant(this, i);
+        return proxy.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;
+        proxy.touched(this, { type: 'set', prop: i }, index(i, { length: added }));
+    }
+}
+const indexLess = { get: proxy.FoolProof.get, set: proxy.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(proxy.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 _copyWithin_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 proxy.reactive(super.at(index));
+            }
+            concat(...items) {
+                return proxy.reactive(super.concat(...items.map(proxy.unwrap)));
+            }
+            entries() {
+                proxy.dependant(this, proxy.keysOf);
+                return makeReactiveEntriesIterator(super.entries());
+            }
+            every(predicate, thisArg) {
+                return super.every((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+            }
+            fill(value, start, end) {
+                return super.fill(proxy.unwrap(value), start, end);
+            }
+            copyWithin(target, start, end) {
+                return super.copyWithin(target, start, end);
+            }
+            filter(predicate, thisArg) {
+                return proxy.reactive(super.filter((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
+            }
+            find(predicate, thisArg) {
+                return proxy.reactive(super.find((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
+            }
+            findIndex(predicate, thisArg) {
+                return super.findIndex((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+            }
+            findLast(predicate, thisArg) {
+                return proxy.reactive(super.findLast((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
+            }
+            findLastIndex(predicate, thisArg) {
+                return super.findLastIndex((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+            }
+            flat(depth) {
+                proxy.dependant(this, proxy.keysOf);
+                return proxy.reactive(super.flat(depth));
+            }
+            flatMap(callbackfn, thisArg) {
+                return proxy.reactive(super.flatMap((v, i, a) => proxy.unwrap(callbackfn.call(thisArg, proxy.reactive(v), i, a)), thisArg));
+            }
+            forEach(callbackfn, thisArg) {
+                super.forEach((v, i, a) => {
+                    callbackfn.call(thisArg, proxy.reactive(v), i, a);
+                }, thisArg);
+            }
+            includes(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.includes(proxy.unwrap(searchElement), fromIndex)
+                    : super.includes(proxy.unwrap(searchElement));
+            }
+            indexOf(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.indexOf(proxy.unwrap(searchElement), fromIndex)
+                    : super.indexOf(proxy.unwrap(searchElement));
+            }
+            join(separator) {
+                return super.join(separator);
+            }
+            keys() {
+                proxy.dependant(this, 'length');
+                return super.keys();
+            }
+            lastIndexOf(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.lastIndexOf(proxy.unwrap(searchElement), fromIndex)
+                    : super.lastIndexOf(proxy.unwrap(searchElement));
+            }
+            map(callbackfn, thisArg) {
+                return proxy.reactive(super.map((v, i, a) => proxy.unwrap(callbackfn.call(thisArg, proxy.reactive(v), i, a)), thisArg));
+            }
+            pop() {
+                return proxy.reactive(super.pop());
+            }
+            push(...items) {
+                return super.push(...items.map(proxy.unwrap));
+            }
+            reduce(callbackfn, initialValue) {
+                return proxy.reactive(arguments.length > 1
+                    ? super.reduce((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a)), initialValue)
+                    : super.reduce((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a))));
+            }
+            reduceRight(callbackfn, initialValue) {
+                return proxy.reactive(arguments.length > 1
+                    ? super.reduceRight((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a)), initialValue)
+                    : super.reduceRight((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a))));
+            }
+            reverse() {
+                return proxy.reactive(super.reverse());
+            }
+            shift() {
+                return proxy.reactive(super.shift());
+            }
+            slice(start, end) {
+                return proxy.reactive(super.slice(start, end));
+            }
+            some(predicate, thisArg) {
+                return super.some((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+            }
+            sort(compareFn) {
+                const wrappedCompare = compareFn
+                    ? (a, b) => compareFn(proxy.reactive(a), proxy.reactive(b))
+                    : undefined;
+                return super.sort(wrappedCompare);
+            }
+            splice(start, deleteCount, ...items) {
+                if (arguments.length > 2)
+                    return proxy.reactive(super.splice(start, deleteCount, ...items.map(proxy.unwrap)));
+                if (arguments.length === 2)
+                    return proxy.reactive(super.splice(start, deleteCount));
+                if (arguments.length === 1)
+                    return proxy.reactive(super.splice(start));
+                return proxy.reactive([]);
+            }
+            unshift(...items) {
+                return super.unshift(...items.map(proxy.unwrap));
+            }
+            values() {
+                proxy.dependant(this, proxy.keysOf);
+                return makeReactiveIterator(super.values());
+            }
+            [(_fill_decorators = [proxy.atomic], _copyWithin_decorators = [proxy.atomic], _pop_decorators = [proxy.atomic], _push_decorators = [proxy.atomic], _reverse_decorators = [proxy.atomic], _shift_decorators = [proxy.atomic], _sort_decorators = [proxy.atomic], _splice_decorators = [proxy.atomic], _unshift_decorators = [proxy.atomic], Symbol.iterator)]() {
+                proxy.dependant(this, proxy.keysOf);
+                return makeReactiveIterator(super[Symbol.iterator]());
+            }
+            toReversed() {
+                return proxy.reactive(super.toReversed());
+            }
+            toSorted(compareFn) {
+                const wrappedCompare = compareFn
+                    ? (a, b) => compareFn(proxy.reactive(a), proxy.reactive(b))
+                    : undefined;
+                return proxy.reactive(super.toSorted(wrappedCompare));
+            }
+            toSpliced(start, deleteCount, ...items) {
+                if (arguments.length > 2)
+                    return proxy.reactive(super.toSpliced(start, deleteCount, ...items.map(proxy.unwrap)));
+                if (arguments.length === 2)
+                    return proxy.reactive(super.toSpliced(start, deleteCount));
+                if (arguments.length === 1)
+                    return proxy.reactive(super.toSpliced(start));
+                return proxy.reactive([...this]);
+            }
+            with(index, value) {
+                return proxy.reactive(super.with(index, proxy.unwrap(value)));
+            }
+            constructor() {
+                super(...arguments);
+                proxy.__runInitializers(this, _instanceExtraInitializers);
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            proxy.__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);
+            proxy.__esDecorate(_a, null, _copyWithin_decorators, { kind: "method", name: "copyWithin", static: false, private: false, access: { has: obj => "copyWithin" in obj, get: obj => obj.copyWithin }, metadata: _metadata }, null, _instanceExtraInitializers);
+            proxy.__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);
+            proxy.__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);
+            proxy.__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);
+            proxy.__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);
+            proxy.__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);
+            proxy.__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);
+            proxy.__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 = super.delete(key);
+        if (hadKey)
+            proxy.touched1(proxy.contentRef(this), { type: 'del', prop: key }, key);
+        return result;
+    }
+    get(key) {
+        proxy.dependant(proxy.contentRef(this), key);
+        return proxy.reactive(super.get(key));
+    }
+    has(key) {
+        proxy.dependant(proxy.contentRef(this), key);
+        return super.has(key);
+    }
+    set(key, value) {
+        const hadKey = this.has(key);
+        const oldValue = this.get(key);
+        const reactiveValue = proxy.reactive(value);
+        this.set(key, reactiveValue);
+        if (!hadKey || oldValue !== reactiveValue) {
+            proxy.notifyPropertyChange(proxy.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() {
+        proxy.dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
+        return super.size;
+    }
+    clear() {
+        const hadEntries = this.size > 0;
+        super.clear();
+        if (hadEntries) {
+            const evolution = { type: 'bunch', method: 'clear' };
+            // Clear triggers all effects since all keys are affected
+            proxy.batch(() => {
+                proxy.touched1(this, evolution, 'size');
+                proxy.touched(proxy.contentRef(this), evolution);
+            });
+        }
+    }
+    entries() {
+        proxy.dependant(proxy.contentRef(this));
+        return makeReactiveEntriesIterator(this.entries());
+    }
+    forEach(callbackfn, thisArg) {
+        proxy.dependant(proxy.contentRef(this));
+        this.forEach(callbackfn, thisArg);
+    }
+    keys() {
+        proxy.dependant(proxy.contentRef(this), proxy.keysOf);
+        return this.keys();
+    }
+    values() {
+        proxy.dependant(proxy.contentRef(this));
+        return makeReactiveIterator(this.values());
+    }
+    [Symbol.iterator]() {
+        proxy.dependant(proxy.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: [proxy.reactive(key), proxy.reactive(value)], done: false };
+        };
+        return it;
+    }
+    // Implement Map methods with reactivity
+    delete(key) {
+        const hadKey = this.has(key);
+        const result = super.delete(key);
+        if (hadKey) {
+            const evolution = { type: 'del', prop: key };
+            proxy.batch(() => {
+                proxy.touched1(proxy.contentRef(this), evolution, key);
+                proxy.touched1(this, evolution, 'size');
+            });
+        }
+        return result;
+    }
+    get(key) {
+        proxy.dependant(proxy.contentRef(this), key);
+        return proxy.reactive(super.get(key));
+    }
+    has(key) {
+        proxy.dependant(proxy.contentRef(this), key);
+        return super.has(key);
+    }
+    set(key, value) {
+        const hadKey = this.has(key);
+        const oldValue = this.get(key);
+        const reactiveValue = proxy.reactive(value);
+        super.set(key, reactiveValue);
+        if (!hadKey || oldValue !== reactiveValue) {
+            proxy.batch(() => {
+                proxy.notifyPropertyChange(proxy.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 };
+                proxy.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);
+        super.add(value);
+        if (!had) {
+            // touch the specific value and the collection view
+            proxy.touched1(proxy.contentRef(this), { type: 'add', prop: value }, value);
+            // no size/allProps for WeakSet
+        }
+        return this;
+    }
+    delete(value) {
+        const had = this.has(value);
+        const res = super.delete(value);
+        if (had)
+            proxy.touched1(proxy.contentRef(this), { type: 'del', prop: value }, value);
+        return res;
+    }
+    has(value) {
+        proxy.dependant(proxy.contentRef(this), value);
+        return super.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
+        proxy.dependant(this, 'size');
+        return this.size;
+    }
+    add(value) {
+        const had = this.has(value);
+        const reactiveValue = proxy.reactive(value);
+        super.add(reactiveValue);
+        if (!had) {
+            const evolution = { type: 'add', prop: reactiveValue };
+            // touch for value-specific and aggregate dependencies
+            proxy.batch(() => {
+                proxy.touched1(proxy.contentRef(this), evolution, reactiveValue);
+                proxy.touched1(this, evolution, 'size');
+            });
+        }
+        return this;
+    }
+    clear() {
+        const hadEntries = this.size > 0;
+        super.clear();
+        if (hadEntries) {
+            const evolution = { type: 'bunch', method: 'clear' };
+            proxy.batch(() => {
+                proxy.touched1(this, evolution, 'size');
+                proxy.touched(proxy.contentRef(this), evolution);
+            });
+        }
+    }
+    delete(value) {
+        const had = this.has(value);
+        const res = super.delete(value);
+        if (had) {
+            const evolution = { type: 'del', prop: value };
+            proxy.batch(() => {
+                proxy.touched1(proxy.contentRef(this), evolution, value);
+                proxy.touched1(this, evolution, 'size');
+            });
+        }
+        return res;
+    }
+    has(value) {
+        proxy.dependant(proxy.contentRef(this), value);
+        return this.has(value);
+    }
+    entries() {
+        proxy.dependant(proxy.contentRef(this));
+        return makeReactiveEntriesIterator(this.entries());
+    }
+    forEach(callbackfn, thisArg) {
+        proxy.dependant(proxy.contentRef(this));
+        this.forEach(callbackfn, thisArg);
+    }
+    keys() {
+        proxy.dependant(proxy.contentRef(this));
+        return makeReactiveIterator(this.keys());
+    }
+    values() {
+        proxy.dependant(proxy.contentRef(this));
+        return makeReactiveIterator(this.values());
+    }
+    [Symbol.iterator]() {
+        proxy.dependant(proxy.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: proxy.reactive(result.value), done: false };
+        };
+        return it;
+    }
+}
+
+// Register native collection types to use specialized reactive wrappers
+proxy.metaProtos.set(Array, ReactiveArray.prototype);
+proxy.metaProtos.set(Set, ReactiveSet.prototype);
+proxy.metaProtos.set(WeakSet, ReactiveWeakSet.prototype);
+proxy.metaProtos.set(Map, ReactiveMap.prototype);
+proxy.metaProtos.set(WeakMap, ReactiveWeakMap.prototype);
+proxy.wrapProtos.set(Array, ReactiveArrayWrapper.prototype);
+/**
+ * Object containing internal reactive system state for debugging and profiling
+ */
+const profileInfo = {
+    objectToProxy: proxy.objectToProxy,
+    proxyToObject: proxy.proxyToObject,
+    effectToReactiveObjects: proxy.effectToReactiveObjects,
+    watchers: proxy.watchers,
+    objectParents: proxy.objectParents,
+    objectsWithDeepWatchers: proxy.objectsWithDeepWatchers,
+    deepWatchers: proxy.deepWatchers,
+    effectToDeepWatchedObjects: proxy.effectToDeepWatchedObjects,
+};
+
+// 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 = proxy.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 });
+}
+function descriptorBase(descriptor) {
+    return function descriptorDecorator(...properties) {
+        return (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));
+                    }
+                }
+            };
+        };
+    };
+}
+/**
+ * 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 = Object.assign(descriptorBase, {
+    /**
+     * enumerable: true
+     */
+    get enumerable() {
+        return descriptorBase({ enumerable: true });
+    },
+    /**
+     * enumerable: false
+     */
+    get hidden() {
+        return descriptorBase({ enumerable: false });
+    },
+    /**
+     * configurable: true
+     */
+    get configurable() {
+        return descriptorBase({ configurable: true });
+    },
+    /**
+     * configurable: false
+     */
+    get frozen() {
+        return descriptorBase({ configurable: false });
+    },
+    /**
+     * writable: true
+     */
+    get writable() {
+        return descriptorBase({ writable: true });
+    },
+    /**
+     * writable: false
+     */
+    get readonly() {
+        return descriptorBase({ writable: false });
+    },
+});
+/**
+ * Decorator that marks methods, properties, or classes as deprecated
+ * Provides warning messages when deprecated items are used
+ */
+const deprecated = Object.assign(proxy.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 proxy.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) => {
+        proxy.options.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 proxy.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 proxy.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.13";
+var pkg = {
+	version: version$1};
+
+const { version } = pkg;
+const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
+const runtimeGlobals = globalThis;
+const globalScope = (typeof globalThis !== 'undefined'
+    ? globalThis
+    : runtimeGlobals.window
+        ? runtimeGlobals.window
+        : runtimeGlobals.global
+            ? runtimeGlobals.global
+            : false);
+if (globalScope) {
+    let source = 'mutts/index';
+    try {
+        if (runtimeGlobals.__filename)
+            source = runtimeGlobals.__filename;
+        else if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-CAdnMJev.cjs', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-CAdnMJev.cjs', document.baseURI).href))) {
+            source = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-CAdnMJev.cjs', document.baseURI).href));
+        }
+    }
+    catch (_e) { }
+    const currentSourceInfo = { version, source, timestamp: Date.now() };
+    if (globalScope[GLOBAL_MUTTS_KEY]) {
+        const existing = globalScope[GLOBAL_MUTTS_KEY];
+        throw new Error(`[Mutts] Multiple instances detected!\n` +
+            `Existing instance: ${JSON.stringify(existing, null, 2)}\n` +
+            `New instance: ${JSON.stringify(currentSourceInfo, null, 2)}\n` +
+            `This usually happens when 'mutts' is both installed as a dependency and bundled, ` +
+            `or when different versions are loaded. ` +
+            `Please check your build configuration (aliases, externals) to ensure a single source of truth.`);
+    }
+    globalScope[GLOBAL_MUTTS_KEY] = currentSourceInfo;
+}
+
+exports.ArrayReadForward = ArrayReadForward;
+exports.Destroyable = Destroyable;
+exports.DestructionError = DestructionError;
+exports.Eventful = Eventful;
+exports.Indexable = Indexable;
+exports.allocated = allocated;
+exports.allocatedValues = allocatedValues;
+exports.arrayDiff = arrayDiff;
+exports.attend = attend;
+exports.cache = cache;
+exports.cached = cached;
+exports.callOnGC = callOnGC;
+exports.chainPromise = chainPromise;
+exports.debounce = debounce;
+exports.deepWatch = deepWatch;
+exports.deprecated = deprecated;
+exports.descriptor = descriptor;
+exports.destructor = destructor;
+exports.forwardArray = forwardArray;
+exports.getAt = getAt;
+exports.isCached = isCached;
+exports.lift = lift;
+exports.memoize = memoize;
+exports.morph = morph;
+exports.organize = organize;
+exports.organized = organized;
+exports.profileInfo = profileInfo;
+exports.resource = resource;
+exports.setAt = setAt;
+exports.throttle = throttle;
+exports.unreactive = unreactive;
+exports.watch = watch;
+exports.when = when;
+//# sourceMappingURL=index-CAdnMJev.cjs.map