mutts 1.0.9 → 1.0.11

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

@@ -0,0 +1,2577 @@
+import { t as decorator, B as flavored, O as isReactive, $ as reactive, x as effect, a4 as touched, S as link, G as getState, aa as dependant, a5 as touched1, ab as keysOf, ac as markWithRoot, ad as objectsWithDeepWatchers, ae as effectToDeepWatchedObjects, a7 as untracked, af as deepWatchers, a0 as options, L as isNonReactive, a8 as unwrap, ag as registerDeepWatcher, V as named, ah as rootFunctionSymbol, _ as proxyToObject, ai as getRoot, u as deepCompare, aj as optionCall, a2 as root, ak as FoolProof, z as flavorOptions, al as effectHistory, p as captured, am as unreactiveProperties, g as addUnreactiveProps, an as __runInitializers, ao as __esDecorate, n as atomic, ap as batch, aq as contentRef, ar as notifyPropertyChange, as as metaProtos, at as wrapProtos, au as objectParents, av as watchers, aw as effectToReactiveObjects, W as objectToProxy } from './proxy-D2C49sXH.esm.js';
+
+// Integrated with `using` statement via Symbol.dispose
+const fr = new FinalizationRegistry((f) => f());
+/**
+ * Symbol for marking destructor methods
+ */
+const destructor = Symbol('destructor');
+/**
+ * Symbol for accessing allocated values in destroyable objects
+ */
+const allocatedValues = Symbol('allocated');
+/**
+ * Error thrown when attempting to access a destroyed object
+ */
+class DestructionError extends Error {
+    static throw(msg) {
+        return () => {
+            throw new DestructionError(msg);
+        };
+    }
+    constructor(msg) {
+        super(`Object is destroyed. ${msg}`);
+        this.name = 'DestroyedAccessError';
+    }
+}
+const destroyedHandler = {
+    [Symbol.toStringTag]: 'MutTs Destroyable',
+    get: DestructionError.throw('Cannot access destroyed object'),
+    set: DestructionError.throw('Cannot access destroyed object'),
+};
+function Destroyable(base, destructorObj) {
+    var _a;
+    if (base && typeof base !== 'function') {
+        destructorObj = base;
+        base = undefined;
+    }
+    if (!base) {
+        base = class {
+        };
+    }
+    return _a = class Destroyable extends base {
+            static destroy(obj) {
+                const destructor = _a.destructors.get(obj);
+                if (!destructor)
+                    return false;
+                fr.unregister(obj[allocatedValues]);
+                _a.destructors.delete(obj);
+                Object.setPrototypeOf(obj, new Proxy({}, destroyedHandler));
+                // Clear all own properties
+                for (const key of Object.getOwnPropertyNames(obj)) {
+                    delete obj[key];
+                }
+                destructor();
+                return true;
+            }
+            static isDestroyable(obj) {
+                return _a.destructors.has(obj);
+            }
+            constructor(...args) {
+                super(...args);
+                const allocated = {};
+                this[allocatedValues] = allocated;
+                // @ts-expect-error `this` is an AbstractDestroyable
+                const myDestructor = destructorObj?.destructor ?? this[destructor];
+                if (!myDestructor) {
+                    throw new DestructionError('Destructor is not defined');
+                }
+                function destruction() {
+                    myDestructor(allocated);
+                }
+                _a.destructors.set(this, destruction);
+                fr.register(this, destruction, allocated);
+            }
+        },
+        _a.destructors = new WeakMap(),
+        _a;
+}
+/**
+ * Decorator that marks properties to be stored in the allocated object and passed to the destructor
+ * Use with accessor properties or explicit get/set pairs
+ */
+const allocated = decorator({
+    setter(original, _target, propertyKey) {
+        return function (value) {
+            this[allocatedValues][propertyKey] = value;
+            return original.call(this, value);
+        };
+    },
+});
+/**
+ * Registers a callback to be called when an object is garbage collected
+ * @param cb - The callback function to execute on garbage collection
+ * @returns The object whose reference can be collected
+ */
+function callOnGC(cb) {
+    let called = false;
+    const forward = () => {
+        if (called)
+            return;
+        called = true;
+        cb();
+    };
+    fr.register(forward, cb, cb);
+    return forward;
+}
+
+/** Max edit distance before bailing out to a single "replace all" patch */
+const BAILOUT_D = 256;
+/**
+ * Myers' diff producing grouped patches: `{indexA, indexB, sliceA, sliceB}[]`.
+ * - O(N) for identical or prefix/suffix-only differences
+ * - O(ND) for small D, with a hard bailout at D=BAILOUT_D → single replacement patch
+ */
+function arrayDiff(A, B) {
+    let start = 0;
+    let endA = A.length;
+    let endB = B.length;
+    // Trim common prefix
+    while (start < endA && start < endB && A[start] === B[start])
+        start++;
+    // Trim common suffix
+    while (endA > start && endB > start && A[endA - 1] === B[endB - 1]) {
+        endA--;
+        endB--;
+    }
+    const lenA = endA - start;
+    const lenB = endB - start;
+    if (lenA === 0 && lenB === 0)
+        return [];
+    if (lenA === 0)
+        return [{ indexA: start, indexB: start, sliceA: [], sliceB: B.slice(start, endB) }];
+    if (lenB === 0)
+        return [{ indexA: start, indexB: start, sliceA: A.slice(start, endA), sliceB: [] }];
+    // Myers with bailout
+    const maxD = Math.min(lenA + lenB, BAILOUT_D);
+    const vSize = 2 * maxD + 1;
+    const vOffset = maxD;
+    const V = new Int32Array(vSize);
+    V[vOffset + 1] = 0;
+    const history = [];
+    for (let d = 0; d <= maxD; d++) {
+        for (let k = -d; k <= d; k += 2) {
+            let x;
+            if (k === -d || (k !== d && V[vOffset + k - 1] < V[vOffset + k + 1])) {
+                x = V[vOffset + k + 1];
+            }
+            else {
+                x = V[vOffset + k - 1] + 1;
+            }
+            let y = x - k;
+            while (x < lenA && y < lenB && A[start + x] === B[start + y]) {
+                x++;
+                y++;
+            }
+            V[vOffset + k] = x;
+            if (x >= lenA && y >= lenB)
+                return buildPatches(history, A, B, start, x, y, d, k, vOffset);
+        }
+        history.push(new Int32Array(V));
+    }
+    // Bailout: too many differences
+    return [
+        { indexA: start, indexB: start, sliceA: A.slice(start, endA), sliceB: B.slice(start, endB) },
+    ];
+}
+function buildPatches(history, A, B, offset, finalX, finalY, finalD, finalK, vOffset) {
+    // Backtrack from (finalX, finalY) at step finalD to step 0, collecting ops in reverse
+    const ops = []; // 0=eq, 1=ins, 2=del
+    let x = finalX;
+    let y = finalY;
+    let k = finalK;
+    for (let d = finalD; d > 0; d--) {
+        const prev = history[d - 1];
+        let prevK;
+        let down;
+        if (k === -d) {
+            prevK = k + 1;
+            down = true;
+        }
+        else if (k === d) {
+            prevK = k - 1;
+            down = false;
+        }
+        else if (prev[vOffset + k - 1] < prev[vOffset + k + 1]) {
+            prevK = k + 1;
+            down = true;
+        }
+        else {
+            prevK = k - 1;
+            down = false;
+        }
+        const prevXEnd = prev[vOffset + prevK];
+        const prevYEnd = prevXEnd - prevK;
+        const xStart = down ? prevXEnd : prevXEnd + 1;
+        const yStart = down ? prevYEnd + 1 : prevXEnd + 1 - k;
+        // Diagonal matches (pushed in reverse)
+        while (x > xStart && y > yStart) {
+            ops.push(0);
+            x--;
+            y--;
+        }
+        // The edit step
+        if (down) {
+            ops.push(1); // ins
+            y--;
+        }
+        else {
+            ops.push(2); // del
+            x--;
+        }
+        k = prevK;
+    }
+    // Walk ops forward (they were pushed in reverse), grouping contiguous edits
+    const patches = [];
+    let currA = offset;
+    let currB = offset;
+    let sliceA = [];
+    let sliceB = [];
+    let patchA = -1;
+    let patchB = -1;
+    const flush = () => {
+        if (patchA !== -1) {
+            patches.push({ indexA: patchA, indexB: patchB, sliceA, sliceB });
+            sliceA = [];
+            sliceB = [];
+            patchA = -1;
+        }
+    };
+    for (let i = ops.length - 1; i >= 0; i--) {
+        const op = ops[i];
+        if (op === 0) {
+            flush();
+            currA++;
+            currB++;
+        }
+        else if (op === 1) {
+            if (patchA === -1) {
+                patchA = currA;
+                patchB = currB;
+            }
+            sliceB.push(B[currB++]);
+        }
+        else {
+            if (patchA === -1) {
+                patchA = currA;
+                patchB = currB;
+            }
+            sliceA.push(A[currA++]);
+        }
+    }
+    flush();
+    return patches;
+}
+
+var _a, _b;
+const events = Symbol('events');
+const hooks = Symbol('hooks');
+const eventBehavior = {
+    on(eventOrEvents, cb) {
+        if (typeof eventOrEvents === 'object') {
+            for (const e of Object.keys(eventOrEvents)) {
+                this.on(e, eventOrEvents[e]);
+            }
+        }
+        else if (cb !== undefined) {
+            const callbacks = this[events].get(eventOrEvents) ?? new Set();
+            if (!callbacks.has(cb))
+                callbacks.add(cb);
+            this[events].set(eventOrEvents, callbacks);
+        }
+        return () => this.off(eventOrEvents, cb);
+    },
+    off(eventOrEvents, cb) {
+        if (typeof eventOrEvents === 'object') {
+            for (const e of Object.keys(eventOrEvents)) {
+                this.off(e, eventOrEvents[e]);
+            }
+        }
+        else if (cb !== null && cb !== undefined) {
+            const callbacks = this[events].get(eventOrEvents);
+            if (callbacks) {
+                callbacks.delete(cb);
+                if (!callbacks.size)
+                    this[events].delete(eventOrEvents);
+            }
+        }
+        else {
+            // Remove all listeners for this event
+            this[events].delete(eventOrEvents);
+        }
+    },
+    emit(event, ...args) {
+        const callbacks = this[events].get(event);
+        if (callbacks)
+            for (const cb of callbacks)
+                cb.apply(this, args);
+        for (const cb of this[hooks])
+            cb.call(this, event, ...args);
+    },
+};
+function perEvent(eventful, fct, use) {
+    const cache = new Map();
+    return new Proxy(fct, {
+        get(target, prop) {
+            if (typeof prop !== 'string')
+                return target[prop];
+            if (use && !eventful[events].has(prop) && !eventful[hooks].size)
+                return () => { };
+            // Return cached function or create and cache
+            let cached = cache.get(prop);
+            if (!cached) {
+                cached = (...args) => fct.apply(eventful, [prop, ...args]);
+                cache.set(prop, cached);
+            }
+            return cached;
+        },
+    });
+}
+/**
+ * A type-safe event system that provides a clean API for event handling
+ * @template Events - The event map defining event names and their handler signatures
+ */
+class Eventful {
+    constructor() {
+        this[_a] = new Map();
+        this[_b] = new Set();
+        this.on = perEvent(this, eventBehavior.on);
+        this.off = perEvent(this, eventBehavior.off);
+        this.emit = perEvent(this, eventBehavior.emit, 'use');
+    }
+    hook(cb) {
+        this[hooks].add(cb);
+        return () => {
+            this[hooks].delete(cb);
+        };
+    }
+}
+_a = events, _b = hooks;
+
+/**
+ * Symbol for defining custom getter logic for numeric index access
+ */
+const getAt = Symbol('getAt');
+/**
+ * Symbol for defining custom setter logic for numeric index access
+ */
+const setAt = Symbol('setAt');
+function Indexable(base, accessor) {
+    if (base && typeof base !== 'function') {
+        accessor = base;
+        base = undefined;
+    }
+    if (!base) {
+        //@ts-expect-error
+        base = class {
+        };
+    }
+    if (!accessor) {
+        accessor = {
+            get(index) {
+                if (typeof this[getAt] !== 'function') {
+                    throw new Error('Indexable class must have an [getAt] method');
+                }
+                return this[getAt](index);
+            },
+            set(index, value) {
+                if (typeof this[setAt] !== 'function') {
+                    throw new Error('Indexable class has read-only numeric index access');
+                }
+                this[setAt](index, value);
+            },
+        };
+    }
+    class Indexable extends base {
+    }
+    Object.setPrototypeOf(Indexable.prototype, new Proxy(base.prototype, {
+        //@ts-expect-error
+        [Symbol.toStringTag]: 'MutTs Indexable',
+        get(target, prop, receiver) {
+            if (prop in target) {
+                const getter = Object.getOwnPropertyDescriptor(target, prop)?.get;
+                return getter ? getter.call(receiver) : target[prop];
+            }
+            if (typeof prop === 'string') {
+                if (prop === 'length' && accessor.getLength)
+                    return accessor.getLength.call(receiver);
+                const numProp = Number(prop);
+                if (!Number.isNaN(numProp)) {
+                    return accessor.get.call(receiver, numProp);
+                }
+            }
+            return undefined;
+        },
+        set(target, prop, value, receiver) {
+            if (prop in target) {
+                const setter = Object.getOwnPropertyDescriptor(target, prop)?.set;
+                if (setter)
+                    setter.call(receiver, value);
+                else
+                    target[prop] = value;
+                return true;
+            }
+            if (typeof prop === 'string') {
+                if (prop === 'length' && accessor.setLength) {
+                    accessor.setLength.call(receiver, value);
+                    return true;
+                }
+                const numProp = Number(prop);
+                if (!Number.isNaN(numProp)) {
+                    if (!accessor.set)
+                        throw new Error('Indexable class has read-only numeric index access');
+                    accessor.set.call(receiver, numProp, value);
+                    return true;
+                }
+            }
+            Object.defineProperty(receiver, prop, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+            return true;
+        },
+        has(target, prop) {
+            if (prop in target)
+                return true;
+            if (typeof prop === 'string') {
+                if (prop === 'length' && accessor.getLength)
+                    return true;
+                const numProp = Number(prop);
+                if (!Number.isNaN(numProp))
+                    return true;
+            }
+            return false;
+        },
+        ownKeys(target) {
+            const keys = Reflect.ownKeys(target);
+            if (accessor.getLength) {
+                keys.push('length');
+                const len = accessor.getLength.call(this);
+                for (let i = 0; i < len; i++)
+                    keys.push(String(i));
+            }
+            return keys;
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            if (prop in target)
+                return Object.getOwnPropertyDescriptor(target, prop);
+            if (typeof prop === 'string') {
+                if (prop === 'length' && accessor.getLength) {
+                    return {
+                        enumerable: false,
+                        configurable: true,
+                        get: () => accessor.getLength.call(this),
+                    };
+                }
+                const numProp = Number(prop);
+                if (!Number.isNaN(numProp)) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        get: () => accessor.get.call(this, numProp),
+                        set: accessor.set
+                            ? (v) => accessor.set.call(this, numProp, v)
+                            : undefined,
+                    };
+                }
+            }
+            return undefined;
+        },
+    }));
+    return Indexable;
+}
+/**
+ * Symbol for accessing the forwarded array in ArrayReadForward
+ */
+const forwardArray = Symbol('forwardArray');
+/**
+ * A read-only array forwarder that implements all reading/iterating methods of Array
+ * but does not implement modification methods.
+ *
+ * The constructor takes a callback that returns an array, and all methods forward
+ * their behavior to the result of that callback.
+ */
+class ArrayReadForward {
+    get [forwardArray]() {
+        throw new Error('ArrayReadForward is not implemented');
+    }
+    /**
+     * Get the length of the array
+     */
+    get length() {
+        return this[forwardArray].length;
+    }
+    /**
+     * Iterator protocol support
+     */
+    [Symbol.iterator]() {
+        return this[forwardArray][Symbol.iterator]();
+    }
+    // Reading/Iterating methods
+    /**
+     * Creates a new array with the results of calling a provided function on every element
+     */
+    map(callbackfn, thisArg) {
+        return this[forwardArray].map(callbackfn, thisArg);
+    }
+    filter(predicate, thisArg) {
+        return this[forwardArray].filter(predicate, thisArg);
+    }
+    reduce(callbackfn, initialValue) {
+        return initialValue !== undefined
+            ? this[forwardArray].reduce(callbackfn, initialValue)
+            : this[forwardArray].reduce(callbackfn);
+    }
+    reduceRight(callbackfn, initialValue) {
+        return initialValue !== undefined
+            ? this[forwardArray].reduceRight(callbackfn, initialValue)
+            : this[forwardArray].reduceRight(callbackfn);
+    }
+    /**
+     * Executes a provided function once for each array element
+     */
+    forEach(callbackfn, thisArg) {
+        this[forwardArray].forEach(callbackfn, thisArg);
+    }
+    find(predicate, thisArg) {
+        return this[forwardArray].find(predicate, thisArg);
+    }
+    /**
+     * Returns the index of the first element in the array that satisfies the provided testing function
+     */
+    findIndex(predicate, thisArg) {
+        return this[forwardArray].findIndex(predicate, thisArg);
+    }
+    findLast(predicate, thisArg) {
+        return this[forwardArray].findLast(predicate, thisArg);
+    }
+    /**
+     * Returns the index of the last element in the array that satisfies the provided testing function
+     */
+    findLastIndex(predicate, thisArg) {
+        return this[forwardArray].findLastIndex(predicate, thisArg);
+    }
+    /**
+     * Determines whether an array includes a certain value among its entries
+     */
+    includes(searchElement, fromIndex) {
+        return this[forwardArray].includes(searchElement, fromIndex);
+    }
+    /**
+     * Returns the first index at which a given element can be found in the array
+     */
+    indexOf(searchElement, fromIndex) {
+        return this[forwardArray].indexOf(searchElement, fromIndex);
+    }
+    /**
+     * Returns the last index at which a given element can be found in the array
+     */
+    lastIndexOf(searchElement, fromIndex) {
+        return this[forwardArray].lastIndexOf(searchElement, fromIndex);
+    }
+    /**
+     * Returns a shallow copy of a portion of an array into a new array object
+     */
+    slice(start, end) {
+        return this[forwardArray].slice(start, end);
+    }
+    concat(...items) {
+        return this[forwardArray].concat(...items);
+    }
+    /**
+     * Tests whether all elements in the array pass the test implemented by the provided function
+     */
+    every(predicate, thisArg) {
+        return this[forwardArray].every(predicate, thisArg);
+    }
+    /**
+     * Tests whether at least one element in the array passes the test implemented by the provided function
+     */
+    some(predicate, thisArg) {
+        return this[forwardArray].some(predicate, thisArg);
+    }
+    /**
+     * Joins all elements of an array into a string
+     */
+    join(separator) {
+        return this[forwardArray].join(separator);
+    }
+    /**
+     * Returns a new array iterator that contains the keys for each index in the array
+     */
+    keys() {
+        return this[forwardArray].keys();
+    }
+    /**
+     * Returns a new array iterator that contains the values for each index in the array
+     */
+    values() {
+        return this[forwardArray].values();
+    }
+    /**
+     * Returns a new array iterator that contains the key/value pairs for each index in the array
+     */
+    entries() {
+        return this[forwardArray].entries();
+    }
+    /**
+     * Returns a string representation of the array
+     */
+    toString() {
+        return this[forwardArray].toString();
+    }
+    /**
+     * Returns a localized string representing the array
+     */
+    toLocaleString(locales, options) {
+        return this[forwardArray].toLocaleString(locales, options);
+    }
+    /**
+     * Returns the element at the specified index, or undefined if the index is out of bounds
+     */
+    at(index) {
+        return this[forwardArray].at(index);
+    }
+    /**
+     * Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth
+     */
+    flat(depth) {
+        return this[forwardArray].flat(depth);
+    }
+    /**
+     * Returns a new array formed by applying a given callback function to each element of the array,
+     * and then flattening the result by one level
+     */
+    flatMap(callback, thisArg) {
+        return this[forwardArray].flatMap(callback, thisArg);
+    }
+    /**
+     * Returns a new array with elements in reversed order (ES2023)
+     */
+    toReversed() {
+        return this[forwardArray].toReversed?.() ?? [...this[forwardArray]].reverse();
+    }
+    /**
+     * Returns a new array with elements sorted (ES2023)
+     */
+    toSorted(compareFn) {
+        return this[forwardArray].toSorted?.(compareFn) ?? [...this[forwardArray]].sort(compareFn);
+    }
+    /**
+     * Returns a new array with some elements removed and/or replaced at a given index (ES2023)
+     */
+    toSpliced(start, deleteCount, ...items) {
+        if (deleteCount === undefined)
+            return this[forwardArray].toSpliced(start);
+        return this[forwardArray].toSpliced(start, deleteCount, ...items);
+    }
+    /**
+     * Returns a new array with the element at the given index replaced with the given value (ES2023)
+     */
+    with(index, value) {
+        return this[forwardArray].with(index, value);
+    }
+    get [Symbol.unscopables]() {
+        return this[forwardArray][Symbol.unscopables];
+    }
+}
+
+const forward = (name, target) => (...args) => {
+    return target[name](...args);
+};
+const alreadyChained = new WeakMap();
+const originals = new WeakMap();
+function cache$1(target, rv) {
+    originals.set(rv, target);
+    alreadyChained.set(target, rv);
+}
+const promiseProxyHandler = {
+    //@ts-expect-error
+    [Symbol.toStringTag]: 'MutTs PromiseChain function',
+    get(target, prop) {
+        if (prop === Symbol.toStringTag)
+            return 'PromiseProxy';
+        if (typeof prop === 'string' && ['then', 'catch', 'finally'].includes(prop))
+            return target[prop];
+        return chainPromise(target.then((r) => r[prop]));
+    },
+};
+const promiseForward = (target) => ({
+    // biome-ignore lint/suspicious/noThenProperty: This one is the whole point
+    then: forward('then', target),
+    catch: forward('catch', target),
+    finally: forward('finally', target),
+});
+const objectProxyHandler = {
+    //@ts-expect-error
+    [Symbol.toStringTag]: 'MutTs PromiseChain object',
+    get(target, prop, receiver) {
+        const getter = Object.getOwnPropertyDescriptor(target, prop)?.get;
+        const rv = getter ? getter.call(receiver) : target[prop];
+        // Allows fct.call or fct.apply to bypass the chain system
+        if (typeof target === 'function')
+            return rv;
+        return chainPromise(rv);
+    },
+    apply(target, thisArg, args) {
+        return chainPromise(target.apply(thisArg, args));
+    },
+};
+function chainObject(given) {
+    const rv = new Proxy(given, objectProxyHandler);
+    cache$1(given, rv);
+    return rv;
+}
+function chainable(x) {
+    return x && ['function', 'object'].includes(typeof x);
+}
+/**
+ * Transforms a promise or value into a chainable object
+ * Allows calling methods directly on promise results without awaiting them first
+ * @param given - The promise or value to make chainable
+ * @returns A chainable version of the input
+ */
+function chainPromise(given) {
+    if (!chainable(given))
+        return given;
+    if (alreadyChained.has(given))
+        return alreadyChained.get(given);
+    if (!(given instanceof Promise))
+        return chainObject(given);
+    // @ts-expect-error It's ok as we check if it's an object above
+    given = given.then((r) => (chainable(r) ? chainObject(r) : r));
+    const target = Object.assign(function (...args) {
+        return chainPromise(given.then((r) => {
+            return this?.then
+                ? this.then((t) => r.apply(t, args))
+                : r.apply(this, args);
+        }));
+    }, promiseForward(given));
+    const chained = new Proxy(target, promiseProxyHandler);
+    cache$1(given, chained);
+    return chained;
+}
+
+function attend(source, callback) {
+    const enumerate = typeof source === 'function'
+        ? source
+        : Array.isArray(source)
+            ? () => Array.from({ length: source.length }, (_, i) => i)
+            : source instanceof Map
+                ? () => source.keys()
+                : source instanceof Set
+                    ? () => source.values()
+                    : () => Object.keys(source);
+    const keyEffects = new Map();
+    const outer = effect.named('attend')(({ ascend }) => {
+        const keys = new Set();
+        for (const key of enumerate())
+            keys.add(key);
+        for (const key of keys) {
+            if (keyEffects.has(key))
+                continue;
+            keyEffects.set(key, ascend(() => effect.named(`attend:${key}`)((access) => callback(key, 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();
+    };
+}
+function lift(cb) {
+    let result;
+    let rawResult;
+    const liftCleanup = effect.named(`lift:${cb.name}`)(markWithRoot((access) => {
+        const source = cb(access);
+        if (!source || typeof source !== 'object')
+            throw new Error('lift callback must return an array or object');
+        const sourceProto = Object.getPrototypeOf(source);
+        if (!result) {
+            rawResult = Array.isArray(source) ? [] : Object.create(sourceProto);
+            result = reactive(rawResult);
+        }
+        if (sourceProto !== Object.getPrototypeOf(result))
+            throw new Error('lift callback must return the same type as the previous result');
+        if (Array.isArray(source)) {
+            const res = result;
+            for (const { indexA, sliceA, sliceB } of arrayDiff(res, source).sort((a, b) => a.indexA - b.indexA))
+                res.splice(indexA, sliceA.length, ...sliceB);
+        }
+        else {
+            for (const key of Object.keys(source)) {
+                const had = key in rawResult;
+                const newDesc = Object.getOwnPropertyDescriptor(source, key);
+                if (had) {
+                    const oldDesc = Object.getOwnPropertyDescriptor(rawResult, key);
+                    const sameAccessor = oldDesc && newDesc.get && oldDesc.get === newDesc.get;
+                    Object.defineProperty(rawResult, key, newDesc);
+                    if (!sameAccessor &&
+                        rawResult[key] !==
+                            (oldDesc ? (oldDesc.get ? oldDesc.get() : oldDesc.value) : undefined))
+                        touched1(rawResult, { type: 'set', prop: key }, key);
+                }
+                else {
+                    Object.defineProperty(rawResult, key, newDesc);
+                    touched1(rawResult, { type: 'add', prop: key }, key);
+                }
+            }
+            for (const key of Object.keys(rawResult))
+                if (!(key in source)) {
+                    delete rawResult[key];
+                    touched1(rawResult, { type: 'del', prop: key }, key);
+                }
+        }
+    }, cb));
+    return link(result, liftCleanup);
+}
+/**
+ * Reactively maps an array source through `fn`, producing a lazy reactive output array.
+ *
+ * Each source item gets its own isolated effect (via `root()`) so that changes to one item
+ * only recompute that item's projection. Structural changes (push, splice, reorder) are detected
+ * via `arrayDiff` and surgically applied to the output cache.
+ *
+ * The source can be a reactive array or a function returning an array. When a function is provided,
+ * the function is re-evaluated inside an effect whenever its dependencies change.
+ *
+ * Output elements are computed lazily — accessing `result[i]` triggers computation if not yet cached.
+ *
+ * @param source - A reactive array or a function returning an array
+ * @param fn - Mapping function applied to each element
+ * @param options - Optional purity hints to skip per-item effects
+ * @returns A readonly reactive array with a `[cleanup]` method to dispose all effects
+ */
+function morphArray(source, fn, options) {
+    if (typeof source !== 'function' && !isReactive(source) && options?.pure === true) {
+        return source.map((i) => fn(i));
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = [];
+    let input = [];
+    function stopItem(key) {
+        const entry = itemEffects.get(key);
+        if (entry) {
+            entry.stop({ type: 'stopped' });
+            itemEffects.delete(key);
+        }
+    }
+    function computeItem(key, input) {
+        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(input));
+        if (isPure) {
+            track(() => {
+                cache[key] = fn(input);
+            });
+        }
+        else {
+            const indexRef = { value: key };
+            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache[indexRef.value] = fn(input, access);
+                return (reason) => {
+                    delete cache[indexRef.value];
+                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop?.({ type: 'invalidate', cause: reason });
+                };
+            }));
+            itemEffects.set(key, { stop, index: indexRef });
+        }
+    }
+    const proxy = reactive(cache, {
+        get(cache, prop) {
+            const n = typeof prop === 'string' ? Number(prop) : NaN;
+            if (Number.isNaN(n))
+                return cache[prop];
+            if (!(n in cache))
+                computeItem(n, input[n]);
+            return cache[n];
+        },
+        has(_cache, prop) {
+            return Reflect.has(input, prop);
+        },
+    });
+    const stopMain = effect.named(`morph:${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([keysOf]);
+            if (input.length !== newInput.length)
+                invalidates.add('length');
+            for (const diff of diffs) {
+                const max = Math.max(diff.sliceA.length, diff.sliceB.length);
+                for (let i = 0; i < max; i++)
+                    invalidates.add(String(diff.indexA + i));
+            }
+            touched(cache, { type: 'bunch', method: 'morph-input' }, invalidates);
+        }
+        input = newInput;
+    });
+    return link(proxy, (reason) => {
+        stopMain(reason);
+        for (const entry of itemEffects.values())
+            entry.stop(reason);
+        itemEffects.clear();
+    });
+}
+/**
+ * Reactively maps a `Map` source through `fn`, producing a reactive output Map.
+ *
+ * Each key gets its own isolated effect so that value changes for one key only recompute
+ * that key's projection. Key additions and removals are tracked via `keysOf` dependency.
+ *
+ * @param source - A reactive Map
+ * @param fn - Mapping function applied to each value
+ * @param options - Optional purity hints to skip per-key effects
+ * @returns A reactive Map with a `[cleanup]` method to dispose all effects
+ */
+function morphMap(source, fn, options) {
+    if (!isReactive(source) && options?.pure === true) {
+        const res = new Map();
+        for (const [k, v] of source)
+            res.set(k, fn(v, k));
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = new Map();
+    Object.defineProperty(cache, 'constructor', { value: Object, enumerable: false });
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
+        if (stop) {
+            stop({ type: 'stopped' });
+            itemEffects.delete(key);
+        }
+    }
+    function computeItem(key, val) {
+        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
+        if (isPure) {
+            cache.set(key, track(() => fn(val, key)));
+        }
+        else {
+            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache.set(key, fn(source.get(key), key, access));
+                return (reason) => {
+                    cache.delete(key);
+                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop?.({ type: 'invalidate', cause: reason });
+                };
+            }));
+            itemEffects.set(key, stop);
+        }
+    }
+    const proxy = reactive(cache, {
+        get(cache, prop) {
+            if (prop === 'get')
+                return (key) => {
+                    if (!cache.has(key) && source.has(key))
+                        computeItem(key, source.get(key));
+                    return cache.get(key);
+                };
+            if (prop === 'has')
+                return (key) => {
+                    return source.has(key);
+                };
+            if (prop === 'keys')
+                return () => {
+                    return source.keys();
+                };
+            if (prop === 'values')
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield proxy.get(key);
+                    }
+                };
+            if (prop === 'entries')
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy.get(key)];
+                    }
+                };
+            if (prop === Symbol.iterator)
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy.get(key)];
+                    }
+                };
+            return cache[prop];
+        },
+    });
+    let stateSnapshot = getState(source);
+    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
+        track = ascend;
+        dependant(source, keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                cache.delete(evolution.prop);
+                touched1(cache, evolution, evolution.prop);
+            }
+        }
+    });
+    return link(proxy, (reason) => {
+        stopMain(reason);
+        for (const stop of itemEffects.values())
+            stop(reason);
+        itemEffects.clear();
+    });
+}
+/**
+ * Reactively maps a record/object source through `fn`, producing a reactive output record.
+ *
+ * Each key gets its own isolated effect so that value changes for one key only recompute
+ * that key's projection. Key additions and removals are tracked automatically.
+ *
+ * @param source - A reactive record
+ * @param fn - Mapping function applied to each value
+ * @param options - Optional purity hints to skip per-key effects
+ * @returns A reactive record with a `[cleanup]` method to dispose all effects
+ */
+function morphRecord(source, fn, options) {
+    if (!isReactive(source) && options?.pure === true) {
+        const res = {};
+        for (const k of Object.keys(source))
+            res[k] = fn(source[k], k);
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = {};
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
+        if (stop) {
+            stop({ type: 'stopped' });
+            itemEffects.delete(key);
+        }
+    }
+    function computeItem(key, val) {
+        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
+        if (isPure) {
+            cache[key] = track(() => fn(val, key));
+        }
+        else {
+            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache[key] = fn(source[key], key, access);
+                return (reason) => {
+                    delete cache[key];
+                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop?.({ type: 'invalidate', cause: reason });
+                };
+            }));
+            itemEffects.set(key, stop);
+        }
+    }
+    function get(prop) {
+        if (!(prop in cache) && prop in source)
+            computeItem(prop, source[prop]);
+        return cache[prop];
+    }
+    const proxy = reactive(cache, {
+        get(_, prop) {
+            return get(prop);
+        },
+        has(_, prop) {
+            return prop in source;
+        },
+        ownKeys() {
+            return Reflect.ownKeys(source);
+        },
+        getOwnPropertyDescriptor(_cache, prop) {
+            if (prop in source)
+                return { configurable: true, enumerable: true, get: () => get(prop) };
+        },
+    });
+    let stateSnapshot = getState(source);
+    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
+        track = ascend;
+        // Track only structural changes on source
+        dependant(source, keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                delete cache[evolution.prop];
+                touched1(cache, evolution, evolution.prop);
+            }
+        }
+    });
+    return link(proxy, (reason) => {
+        stopMain(reason);
+        for (const stop of itemEffects.values())
+            stop(reason);
+        itemEffects.clear();
+    });
+}
+/**
+ * Reactively maps a collection (array, Map, or record) through a per-entry function.
+ *
+ * Each entry in the source gets its own reactive context — when only one entry's dependencies
+ * change, only that entry's projection recomputes. Structural changes (additions, removals,
+ * reorders) are detected via diffing and applied surgically.
+ *
+ * Use `morph.pure(source, fn)` when `fn` has no reactive reads (skips per-item effects).
+ *
+ * @example
+ * ```ts
+ * const users = reactive([{ name: 'John' }, { name: 'Jane' }])
+ * const names = morph(users, u => u.name.toUpperCase())
+ * // names[0] = 'JOHN', names[1] = 'JANE'
+ * // Changing users[0].name only recomputes names[0]
+ * ```
+ */
+const morph = flavored(function morph(source, fn, options) {
+    if (Array.isArray(source) || typeof source === 'function')
+        return morphArray(source, fn, options);
+    if (source instanceof Map)
+        return morphMap(source, fn, options);
+    return morphRecord(source, fn, options);
+}, {
+    get pure() {
+        return (source, fn, _opt) => this(source, fn, { pure: true });
+    },
+});
+
+/**
+ * Deep watch an object and all its nested properties
+ * @param target - The object to watch deeply
+ * @param callback - The callback to call when any nested property changes
+ * @param options - Options for the deep watch
+ * @returns A cleanup function to stop watching
+ */
+/**
+ * Sets up deep watching for an object, tracking all nested property changes
+ * @param target - The object to watch
+ * @param callback - The callback to call when changes occur
+ * @param options - Options for deep watching
+ * @returns A cleanup function to stop deep watching
+ */
+function deepWatch(target, callback, { immediate = false } = {}) {
+    if (target === null || target === undefined)
+        return undefined;
+    if (typeof target !== 'object')
+        throw new Error('Target of deep watching must be an object');
+    // Create a wrapper callback that matches EffectTrigger signature
+    const wrappedCallback = markWithRoot((() => callback(target)), callback);
+    registerDeepWatcher();
+    // Use the existing effect system to register dependencies
+    return effect.named('deepWatch')(() => {
+        // Mark the target object as having deep watchers
+        objectsWithDeepWatchers.add(target);
+        // Track which objects this effect is watching for cleanup
+        let effectObjects = effectToDeepWatchedObjects.get(wrappedCallback);
+        if (!effectObjects) {
+            effectObjects = new Set();
+            effectToDeepWatchedObjects.set(wrappedCallback, effectObjects);
+        }
+        effectObjects.add(target);
+        // Traverse the object graph and register dependencies
+        // This will re-run every time the effect runs, ensuring we catch all changes
+        const visited = new WeakSet();
+        function traverseAndTrack(obj, depth = 0) {
+            // Prevent infinite recursion and excessive depth
+            if (!obj || visited.has(obj) || typeof obj !== 'object' || depth > options.maxDeepWatchDepth)
+                return;
+            // Do not traverse into unreactive objects
+            if (isNonReactive(obj))
+                return;
+            visited.add(obj);
+            // Mark this object as having deep watchers
+            objectsWithDeepWatchers.add(obj);
+            effectObjects.add(obj);
+            // Traverse all properties to register dependencies
+            // unwrap to avoid kicking dependency
+            for (const key in unwrap(obj)) {
+                if (Object.hasOwn(obj, key)) {
+                    // Access the property to register dependency
+                    const value = obj[key];
+                    // Make the value reactive if it's an object
+                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+            }
+            // Also handle array indices and length
+            // 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 ? reactive(value) : value;
+                    traverseAndTrack(reactiveValue, depth + 1);
+                }
+                // Explicitly depend on length so array mutations changing count trigger re-evaluation
+                if ('length' in obj) {
+                    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 ? reactive(value) : value;
+                        traverseAndTrack(reactiveValue, depth + 1);
+                    }
+                }
+            }
+            // Note: WeakSet and WeakMap cannot be iterated, so we can't deep watch their contents
+            // They will only trigger when the collection itself is replaced
+        }
+        // Traverse the target object to register all dependencies
+        // This will register dependencies on all current properties and array elements
+        traverseAndTrack(target);
+        // Only call the callback if immediate is true or if it's not the first run
+        if (immediate) {
+            untracked(() => callback(target));
+        }
+        immediate = true;
+        // Return a cleanup function that properly removes deep watcher tracking
+        return () => {
+            // Get the objects this effect was watching
+            const effectObjects = effectToDeepWatchedObjects.get(wrappedCallback);
+            if (effectObjects) {
+                // Remove deep watcher tracking from all objects this effect was watching
+                for (const obj of effectObjects) {
+                    // Check if this object still has other deep watchers
+                    const watchers = deepWatchers.get(obj);
+                    if (watchers) {
+                        // Remove this effect's callback from the watchers
+                        watchers.delete(wrappedCallback);
+                        // If no more watchers, remove the object from deep watchers tracking
+                        if (watchers.size === 0) {
+                            deepWatchers.delete(obj);
+                            objectsWithDeepWatchers.delete(obj);
+                        }
+                    }
+                    else {
+                        // No watchers found, remove from deep watchers tracking
+                        objectsWithDeepWatchers.delete(obj);
+                    }
+                }
+                // Clean up the tracking data
+                effectToDeepWatchedObjects.delete(wrappedCallback);
+            }
+        };
+    });
+}
+
+const memoizedRegistry = new WeakMap();
+const wrapperRegistry = new WeakMap();
+function getBranch(tree, key) {
+    tree.branches ?? (tree.branches = new WeakMap());
+    let branch = tree.branches.get(key);
+    if (!branch) {
+        branch = {};
+        tree.branches.set(key, branch);
+    }
+    return branch;
+}
+function memoizeFunction(fn, opts) {
+    const fnRoot = getRoot(fn);
+    const existing = memoizedRegistry.get(fnRoot);
+    if (existing)
+        return existing;
+    const cacheRoot = {};
+    const memoized = markWithRoot(function memoized(...args) {
+        if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
+            if (opts?.lenient)
+                return fn.apply(this, args);
+            throw new Error('memoize expects non-null object arguments');
+        }
+        let node = cacheRoot;
+        // Note: decorators add `this` as first argument
+        for (const arg of args) {
+            node = getBranch(node, arg);
+        }
+        dependant(node, 'memoize');
+        if ('result' in node) {
+            if (options.onMemoizationDiscrepancy) {
+                const wasVerification = options.isVerificationRun;
+                options.isVerificationRun = true;
+                try {
+                    const fresh = untracked(() => fn.apply(this, args));
+                    if (!deepCompare(node.result, fresh)) {
+                        optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
+                    }
+                }
+                finally {
+                    options.isVerificationRun = wasVerification;
+                }
+            }
+            return node.result;
+        }
+        // Create memoize internal effect to track dependencies and invalidate cache
+        // Use untracked to prevent the effect creation from being affected by parent effects
+        node.cleanup = root(() => effect.named('memoize')(() => {
+            // Execute the function and track its dependencies
+            // The function execution will automatically track dependencies on reactive objects
+            node.result = fn.apply(this, args);
+            return (reason) => {
+                // When dependencies change, clear the cache and notify consumers
+                delete node.result;
+                touched1(node, { type: 'invalidate', prop: args }, 'memoize');
+                // Lazy memoization: stop the effect so it doesn't re-run immediately.
+                // It will be re-created on next access.
+                if (node.cleanup) {
+                    node.cleanup({ type: 'invalidate', cause: reason });
+                    node.cleanup = undefined;
+                }
+            };
+        }, { opaque: true }));
+        if (options.onMemoizationDiscrepancy) {
+            const wasVerification = options.isVerificationRun;
+            options.isVerificationRun = true;
+            try {
+                const fresh = untracked(() => fn.apply(this, args));
+                if (!deepCompare(node.result, fresh)) {
+                    optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
+                }
+            }
+            finally {
+                options.isVerificationRun = wasVerification;
+            }
+        }
+        return node.result;
+    }, fn);
+    memoizedRegistry.set(fnRoot, memoized);
+    memoizedRegistry.set(memoized, memoized);
+    return memoized;
+}
+function memoizeObject(target, opts) {
+    const existing = memoizedRegistry.get(target);
+    if (existing)
+        return existing;
+    const proxy = new Proxy(target, {
+        get(source, prop, receiver) {
+            // 1. Walk prototype chain to find descriptor
+            let current = source;
+            let desc;
+            while (current) {
+                desc = Object.getOwnPropertyDescriptor(current, prop);
+                if (desc)
+                    break;
+                current = Object.getPrototypeOf(current);
+            }
+            if (!desc)
+                return Reflect.get(source, prop, receiver);
+            // 2. If getter, memoize
+            if (desc.get) {
+                const originalGetter = desc.get;
+                let wrapper = wrapperRegistry.get(originalGetter);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
+                        return originalGetter.call(that);
+                    }), {
+                        propertyKey: prop,
+                    });
+                    const origRoot = originalGetter[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(originalGetter, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, opts);
+                return memoized(receiver);
+            }
+            // 3. Otherwise forward
+            return Reflect.get(source, prop, receiver);
+        },
+        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
+        set(source, prop, value, _receiver) {
+            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
+            // it recognizes itself and triggers change notifications.
+            return Reflect.set(source, prop, value, source);
+        },
+    });
+    proxyToObject.set(proxy, target);
+    memoizedRegistry.set(target, proxy);
+    return proxy;
+}
+/**
+ * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
+ *
+ * When used as a decorator on getters or methods, it caches the result and automatically
+ * invalidates the cache when reactive dependencies change.
+ *
+ * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @memoize
+ *   get fullName() {
+ *     return `${this.firstName} ${this.lastName}`
+ *   }
+ * }
+ *
+ * // Or as a function wrapper
+ * const expensive = memoize((obj: SomeObject) => {
+ *   return heavyComputation(obj)
+ * })
+ * ```
+ */
+function makeMemoizeDecorator(memoizeOpts) {
+    return decorator({
+        getter(original, target, propertyKey) {
+            return function () {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
+                        return original.call(that);
+                    }), {
+                        method: original,
+                        propertyKey,
+                    });
+                    const origRoot = original[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this);
+            };
+        },
+        method(original, target, name) {
+            return function (...args) {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
+                        return original.call(that, ...args);
+                    }), {
+                        method: original,
+                        propertyKey: name,
+                    });
+                    const origRoot = original[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this, ...args);
+            };
+        },
+        default: (target) => typeof target === 'object'
+            ? memoizeObject(target, memoizeOpts)
+            : memoizeFunction(target, memoizeOpts),
+    });
+}
+const memoize = flavored(makeMemoizeDecorator(), {
+    get lenient() {
+        return makeMemoizeDecorator({ lenient: true });
+    },
+});
+
+/**
+ * Organizes a source object's properties into a target object using a callback function.
+ * This creates a reactive mapping between source properties and a target object,
+ * automatically handling property additions, updates, and removals.
+ *
+ * @template Source - The type of the source object
+ * @template Target - The type of the target object (defaults to Record<PropertyKey, any>)
+ *
+ * @param {Source} source - The source object to organize
+ * @param {OrganizedCallback<Source, Target>} apply - Callback function that defines how each source property is mapped to the target
+ * @param {Target} [baseTarget={}] - Optional base target object to use (will be made reactive if not already)
+ *
+ * @returns {OrganizedResult<Target>} The target object with cleanup capability
+ *
+ * @example
+ * // Organize user permissions into role-based access
+ * const user = reactive({ isAdmin: true, canEdit: false });
+ * const permissions = organized(
+ *   user,
+ *   (access, target) => {
+ *     if (access.key === 'isAdmin') {
+ *       target.hasFullAccess = access.value;
+ *     }
+ *     target[`can${access.key.charAt(0).toUpperCase() + access.key.slice(1)}`] = access.value;
+ *   }
+ * );
+ *
+ * @example
+ * // Transform object structure with cleanup
+ * const source = reactive({ firstName: 'John', lastName: 'Doe' });
+ * const formatted = organized(
+ *   source,
+ *   (access, target) => {
+ *     if (access.key === 'firstName' || access.key === 'lastName') {
+ *       target.fullName = `${source.firstName} ${source.lastName}`.trim();
+ *     }
+ *   }
+ * );
+ *
+ * @example
+ * // Using with cleanup in a component
+ * effect(() => {
+ *   const data = fetchData();
+ *   const organizedData = organized(data, (access, target) => {
+ *     // Transform data
+ *   });
+ *
+ *   // The cleanup will be called automatically when the effect is disposed
+ *   return () => organizedData[cleanup]();
+ * });
+ */
+function organized(source, apply, baseTarget = {}) {
+    const observedSource = reactive(source);
+    const target = reactive(baseTarget);
+    const stop = attend(() => {
+        const keys = [];
+        for (const key in observedSource)
+            keys.push(key);
+        return keys;
+    }, (key) => {
+        const sourceKey = key;
+        const accessBase = {
+            key: sourceKey,
+            get: () => FoolProof.get(observedSource, sourceKey, observedSource),
+            set: (value) => FoolProof.set(observedSource, sourceKey, value, observedSource),
+        };
+        Object.defineProperty(accessBase, 'value', {
+            get: accessBase.get,
+            set: accessBase.set,
+            configurable: true,
+            enumerable: true,
+        });
+        return apply(accessBase, target);
+    });
+    return 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,
+    });
+    touched1(target, { type: 'set', prop: property }, property);
+    return () => delete target[property];
+}
+
+//#region watch
+const unsetYet = Symbol('unset-yet');
+const watch = flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
+changed, options = {}) {
+    return typeof value === 'function'
+        ? watchCallBack(value, changed, options)
+        : typeof value === 'object' && value !== null
+            ? watchObject(value, changed, options)
+            : (() => {
+                throw new Error('watch: value must be a function or an object');
+            })();
+}, {
+    get deep() {
+        return flavorOptions(this, { deep: true });
+    },
+    get immediate() {
+        return flavorOptions(this, { immediate: true });
+    },
+});
+function watchObject(value, changed, { immediate = false, deep = false } = {}) {
+    if (deep)
+        return deepWatch(value, changed, { immediate });
+    return effect.named('watch:object')(() => {
+        dependant(value);
+        if (immediate)
+            changed(value);
+        immediate = true;
+    });
+}
+function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
+    let oldValue = unsetYet;
+    let deepCleanup;
+    const cbCleanup = effect.named('watch:callback')(markWithRoot((access) => {
+        const newValue = value(access);
+        if (oldValue !== newValue) {
+            const old = oldValue;
+            if (old === unsetYet) {
+                if (immediate)
+                    untracked(() => changed(newValue));
+            }
+            else
+                untracked(() => changed(newValue, old));
+        }
+        oldValue = newValue;
+        if (deep) {
+            if (deepCleanup)
+                deepCleanup();
+            deepCleanup = deepWatch(newValue, (value) => changed(value, value));
+        }
+    }, value));
+    return (() => {
+        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 = effect.named('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 = unwrap(obj);
+    if (isNonReactive(obj))
+        return obj;
+    obj[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[unreactiveProperties];
+            // If parent is fully unreactive, child is too
+            if (parentMarker === true) {
+                original.prototype[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);
+                addUnreactiveProps(original.prototype, set);
+            }
+            return original; // Return the class
+        });
+}
+/**
+ * Decorator that marks classes or properties as non-reactive
+ * Prevents objects from being made reactive
+ */
+const unreactive = decorator({
+    class(original) {
+        original.prototype[unreactiveProperties] = true;
+    },
+    default: unreactiveApplication,
+});
+//#endregion
+//#region resource
+function lazyInit(resource, load) {
+    const creation = effectHistory.active;
+    let fresh = true;
+    return new Proxy(resource, {
+        [Symbol.toStringTag]: 'LazyInit',
+        get(target, prop) {
+            if (fresh) {
+                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 = reactive({
+        value: options.initialValue,
+        loading: true,
+        error: undefined,
+        latest: options.initialValue,
+        reload() {
+            reloadSignal.value++;
+        },
+    });
+    const reloadSignal = 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, () => {
+        link(resource, effect.named('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 reactive(result.value);
+        result = iterator.next();
+    }
+}
+/**
+ * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
+ */
+function* makeReactiveEntriesIterator(iterator) {
+    let result = iterator.next();
+    while (!result.done) {
+        const [key, value] = result.value;
+        yield [reactive(key), reactive(value)];
+        result = iterator.next();
+    }
+}
+
+function* index(i, { length = true } = {}) {
+    if (length)
+        yield 'length';
+    yield i;
+}
+class Indexer extends Array {
+    get(i) {
+        dependant(this, i);
+        return reactive(this[i]);
+    }
+    // Returns undefined intentionally: signals the proxy handler that notifications
+    // were already dispatched via touched(), preventing double notification
+    set(i, value) {
+        const added = i >= this.length;
+        this[i] = value;
+        touched(this, { type: 'set', prop: i }, index(i, { length: added }));
+    }
+}
+const indexLess = { get: FoolProof.get, set: FoolProof.set };
+// Fast numeric-string check: first char is a digit (0-9)
+function asIndex(prop) {
+    const c = prop.charCodeAt(0);
+    if (c < 48 || c > 57)
+        return -1; // not 0-9
+    const n = +prop; // coerce — faster than parseInt, handles "0", "12", etc.
+    return n === (n | 0) && n >= 0 ? n : -1;
+}
+Object.assign(FoolProof, {
+    get(obj, prop, receiver) {
+        if (Array.isArray(obj) && typeof prop === 'string') {
+            const i = asIndex(prop);
+            if (i >= 0)
+                return Indexer.prototype.get.call(obj, i);
+        }
+        return indexLess.get(obj, prop, receiver);
+    },
+    set(obj, prop, value, receiver) {
+        if (Array.isArray(obj) && typeof prop === 'string') {
+            const i = asIndex(prop);
+            if (i >= 0)
+                return Indexer.prototype.set.call(obj, i, value);
+        }
+        return indexLess.set(obj, prop, value, receiver);
+    },
+});
+class ReactiveArray extends Array {
+    toJSON() {
+        return this;
+    }
+}
+/**
+ * This is a wrapper class for Array that adds reactive behavior.
+ * It extends Array and overrides methods to add reactive behavior, while making sure that the internal representation is not reactive.
+ */
+let ReactiveArrayWrapper = (() => {
+    var _a;
+    let _classSuper = Array;
+    let _instanceExtraInitializers = [];
+    let _fill_decorators;
+    let _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 reactive(super.at(index));
+            }
+            concat(...items) {
+                return reactive(super.concat(...items.map(unwrap)));
+            }
+            entries() {
+                dependant(this, keysOf);
+                return makeReactiveEntriesIterator(super.entries());
+            }
+            every(predicate, thisArg) {
+                return super.every((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            fill(value, start, end) {
+                return super.fill(unwrap(value), start, end);
+            }
+            copyWithin(target, start, end) {
+                return super.copyWithin(target, start, end);
+            }
+            filter(predicate, thisArg) {
+                return reactive(super.filter((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg));
+            }
+            find(predicate, thisArg) {
+                return reactive(super.find((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg));
+            }
+            findIndex(predicate, thisArg) {
+                return super.findIndex((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            findLast(predicate, thisArg) {
+                return reactive(super.findLast((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg));
+            }
+            findLastIndex(predicate, thisArg) {
+                return super.findLastIndex((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            flat(depth) {
+                return reactive(super.flat(depth));
+            }
+            flatMap(callbackfn, thisArg) {
+                return reactive(super.flatMap((v, i, a) => unwrap(callbackfn.call(thisArg, reactive(v), i, a)), thisArg));
+            }
+            forEach(callbackfn, thisArg) {
+                super.forEach((v, i, a) => {
+                    callbackfn.call(thisArg, reactive(v), i, a);
+                }, thisArg);
+            }
+            includes(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.includes(unwrap(searchElement), fromIndex)
+                    : super.includes(unwrap(searchElement));
+            }
+            indexOf(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.indexOf(unwrap(searchElement), fromIndex)
+                    : super.indexOf(unwrap(searchElement));
+            }
+            join(separator) {
+                return super.join(separator);
+            }
+            keys() {
+                dependant(this, 'length');
+                return super.keys();
+            }
+            lastIndexOf(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.lastIndexOf(unwrap(searchElement), fromIndex)
+                    : super.lastIndexOf(unwrap(searchElement));
+            }
+            map(callbackfn, thisArg) {
+                return reactive(super.map((v, i, a) => unwrap(callbackfn.call(thisArg, reactive(v), i, a)), thisArg));
+            }
+            pop() {
+                return reactive(super.pop());
+            }
+            push(...items) {
+                return super.push(...items.map(unwrap));
+            }
+            reduce(callbackfn, initialValue) {
+                return reactive(arguments.length > 1
+                    ? super.reduce((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a)), initialValue)
+                    : super.reduce((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a))));
+            }
+            reduceRight(callbackfn, initialValue) {
+                return reactive(arguments.length > 1
+                    ? super.reduceRight((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a)), initialValue)
+                    : super.reduceRight((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a))));
+            }
+            reverse() {
+                return reactive(super.reverse());
+            }
+            shift() {
+                return reactive(super.shift());
+            }
+            slice(start, end) {
+                return reactive(super.slice(start, end));
+            }
+            some(predicate, thisArg) {
+                return super.some((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            sort(compareFn) {
+                const wrappedCompare = compareFn
+                    ? (a, b) => compareFn(reactive(a), reactive(b))
+                    : undefined;
+                return super.sort(wrappedCompare);
+            }
+            splice(start, deleteCount, ...items) {
+                if (arguments.length > 2)
+                    return reactive(super.splice(start, deleteCount, ...items.map(unwrap)));
+                if (arguments.length === 2)
+                    return reactive(super.splice(start, deleteCount));
+                if (arguments.length === 1)
+                    return reactive(super.splice(start));
+                return reactive([]);
+            }
+            unshift(...items) {
+                return super.unshift(...items.map(unwrap));
+            }
+            values() {
+                dependant(this, keysOf);
+                return makeReactiveIterator(super.values());
+            }
+            [(_fill_decorators = [atomic], _copyWithin_decorators = [atomic], _pop_decorators = [atomic], _push_decorators = [atomic], _reverse_decorators = [atomic], _shift_decorators = [atomic], _sort_decorators = [atomic], _splice_decorators = [atomic], _unshift_decorators = [atomic], Symbol.iterator)]() {
+                dependant(this, keysOf);
+                return makeReactiveIterator(super[Symbol.iterator]());
+            }
+            toReversed() {
+                return reactive(super.toReversed());
+            }
+            toSorted(compareFn) {
+                const wrappedCompare = compareFn
+                    ? (a, b) => compareFn(reactive(a), reactive(b))
+                    : undefined;
+                return reactive(super.toSorted(wrappedCompare));
+            }
+            toSpliced(start, deleteCount, ...items) {
+                if (arguments.length > 2)
+                    return reactive(super.toSpliced(start, deleteCount, ...items.map(unwrap)));
+                if (arguments.length === 2)
+                    return reactive(super.toSpliced(start, deleteCount));
+                if (arguments.length === 1)
+                    return reactive(super.toSpliced(start));
+                return reactive([...this]);
+            }
+            with(index, value) {
+                return reactive(super.with(index, unwrap(value)));
+            }
+            constructor() {
+                super(...arguments);
+                __runInitializers(this, _instanceExtraInitializers);
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(_a, null, _fill_decorators, { kind: "method", name: "fill", static: false, private: false, access: { has: obj => "fill" in obj, get: obj => obj.fill }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _copyWithin_decorators, { kind: "method", name: "copyWithin", static: false, private: false, access: { has: obj => "copyWithin" in obj, get: obj => obj.copyWithin }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _pop_decorators, { kind: "method", name: "pop", static: false, private: false, access: { has: obj => "pop" in obj, get: obj => obj.pop }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _push_decorators, { kind: "method", name: "push", static: false, private: false, access: { has: obj => "push" in obj, get: obj => obj.push }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _reverse_decorators, { kind: "method", name: "reverse", static: false, private: false, access: { has: obj => "reverse" in obj, get: obj => obj.reverse }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _shift_decorators, { kind: "method", name: "shift", static: false, private: false, access: { has: obj => "shift" in obj, get: obj => obj.shift }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _sort_decorators, { kind: "method", name: "sort", static: false, private: false, access: { has: obj => "sort" in obj, get: obj => obj.sort }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _splice_decorators, { kind: "method", name: "splice", static: false, private: false, access: { has: obj => "splice" in obj, get: obj => obj.splice }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _unshift_decorators, { kind: "method", name: "unshift", static: false, private: false, access: { has: obj => "unshift" in obj, get: obj => obj.unshift }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+
+/**
+ * Reactive wrapper around JavaScript's WeakMap class
+ * Only tracks individual key operations, no size tracking (WeakMap limitation)
+ */
+class ReactiveWeakMap extends WeakMap {
+    // Implement WeakMap interface methods with reactivity
+    delete(key) {
+        const hadKey = this.has(key);
+        const result = super.delete(key);
+        if (hadKey)
+            touched1(contentRef(this), { type: 'del', prop: key }, key);
+        return result;
+    }
+    get(key) {
+        dependant(contentRef(this), key);
+        return reactive(super.get(key));
+    }
+    has(key) {
+        dependant(contentRef(this), key);
+        return super.has(key);
+    }
+    set(key, value) {
+        const hadKey = this.has(key);
+        const oldValue = this.get(key);
+        const reactiveValue = reactive(value);
+        this.set(key, reactiveValue);
+        if (!hadKey || oldValue !== reactiveValue) {
+            notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey);
+        }
+        return this;
+    }
+}
+/**
+ * Reactive wrapper around JavaScript's Map class
+ * Tracks size changes, individual key operations, and collection-wide operations
+ */
+class ReactiveMap extends Map {
+    // Implement Map interface methods with reactivity
+    get size() {
+        dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
+        return 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
+            batch(() => {
+                touched1(this, evolution, 'size');
+                touched(contentRef(this), evolution);
+            });
+        }
+    }
+    entries() {
+        dependant(contentRef(this));
+        return makeReactiveEntriesIterator(this.entries());
+    }
+    forEach(callbackfn, thisArg) {
+        dependant(contentRef(this));
+        this.forEach(callbackfn, thisArg);
+    }
+    keys() {
+        dependant(contentRef(this), keysOf);
+        return this.keys();
+    }
+    values() {
+        dependant(contentRef(this));
+        return makeReactiveIterator(this.values());
+    }
+    [Symbol.iterator]() {
+        dependant(contentRef(this));
+        const it = Map.prototype[Symbol.iterator].call(this);
+        const nativeNext = it.next.bind(it);
+        it.next = () => {
+            const result = nativeNext();
+            if (result.done)
+                return result;
+            const [key, value] = result.value;
+            return { value: [reactive(key), reactive(value)], done: false };
+        };
+        return it;
+    }
+    // Implement Map methods with reactivity
+    delete(key) {
+        const hadKey = this.has(key);
+        const result = super.delete(key);
+        if (hadKey) {
+            const evolution = { type: 'del', prop: key };
+            batch(() => {
+                touched1(contentRef(this), evolution, key);
+                touched1(this, evolution, 'size');
+            });
+        }
+        return result;
+    }
+    get(key) {
+        dependant(contentRef(this), key);
+        return reactive(super.get(key));
+    }
+    has(key) {
+        dependant(contentRef(this), key);
+        return super.has(key);
+    }
+    set(key, value) {
+        const hadKey = this.has(key);
+        const oldValue = this.get(key);
+        const reactiveValue = reactive(value);
+        super.set(key, reactiveValue);
+        if (!hadKey || oldValue !== reactiveValue) {
+            batch(() => {
+                notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey);
+                // Also notify size change for Map (WeakMap doesn't track size)
+                const evolution = { type: hadKey ? 'set' : 'add', prop: key };
+                touched1(this, evolution, 'size');
+            });
+        }
+        return this;
+    }
+}
+
+/**
+ * Reactive wrapper around JavaScript's WeakSet class
+ * Only tracks individual value operations, no size tracking (WeakSet limitation)
+ */
+class ReactiveWeakSet extends WeakSet {
+    add(value) {
+        const had = this.has(value);
+        super.add(value);
+        if (!had) {
+            // touch the specific value and the collection view
+            touched1(contentRef(this), { type: 'add', prop: value }, value);
+            // no size/allProps for WeakSet
+        }
+        return this;
+    }
+    delete(value) {
+        const had = this.has(value);
+        const res = super.delete(value);
+        if (had)
+            touched1(contentRef(this), { type: 'del', prop: value }, value);
+        return res;
+    }
+    has(value) {
+        dependant(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
+        dependant(this, 'size');
+        return this.size;
+    }
+    add(value) {
+        const had = this.has(value);
+        const reactiveValue = reactive(value);
+        super.add(reactiveValue);
+        if (!had) {
+            const evolution = { type: 'add', prop: reactiveValue };
+            // touch for value-specific and aggregate dependencies
+            batch(() => {
+                touched1(contentRef(this), evolution, reactiveValue);
+                touched1(this, evolution, 'size');
+            });
+        }
+        return this;
+    }
+    clear() {
+        const hadEntries = this.size > 0;
+        super.clear();
+        if (hadEntries) {
+            const evolution = { type: 'bunch', method: 'clear' };
+            batch(() => {
+                touched1(this, evolution, 'size');
+                touched(contentRef(this), evolution);
+            });
+        }
+    }
+    delete(value) {
+        const had = this.has(value);
+        const res = super.delete(value);
+        if (had) {
+            const evolution = { type: 'del', prop: value };
+            batch(() => {
+                touched1(contentRef(this), evolution, value);
+                touched1(this, evolution, 'size');
+            });
+        }
+        return res;
+    }
+    has(value) {
+        dependant(contentRef(this), value);
+        return this.has(value);
+    }
+    entries() {
+        dependant(contentRef(this));
+        return makeReactiveEntriesIterator(this.entries());
+    }
+    forEach(callbackfn, thisArg) {
+        dependant(contentRef(this));
+        this.forEach(callbackfn, thisArg);
+    }
+    keys() {
+        dependant(contentRef(this));
+        return makeReactiveIterator(this.keys());
+    }
+    values() {
+        dependant(contentRef(this));
+        return makeReactiveIterator(this.values());
+    }
+    [Symbol.iterator]() {
+        dependant(contentRef(this));
+        const it = Set.prototype[Symbol.iterator].call(this);
+        const nativeNext = it.next.bind(it);
+        it.next = () => {
+            const result = nativeNext();
+            if (result.done)
+                return result;
+            return { value: reactive(result.value), done: false };
+        };
+        return it;
+    }
+}
+
+// Register native collection types to use specialized reactive wrappers
+metaProtos.set(Array, ReactiveArray.prototype);
+metaProtos.set(Set, ReactiveSet.prototype);
+metaProtos.set(WeakSet, ReactiveWeakSet.prototype);
+metaProtos.set(Map, ReactiveMap.prototype);
+metaProtos.set(WeakMap, ReactiveWeakMap.prototype);
+wrapProtos.set(Array, ReactiveArrayWrapper.prototype);
+/**
+ * Object containing internal reactive system state for debugging and profiling
+ */
+const profileInfo = {
+    objectToProxy,
+    proxyToObject,
+    effectToReactiveObjects,
+    watchers,
+    objectParents,
+    objectsWithDeepWatchers,
+    deepWatchers,
+    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 = decorator({
+    getter(original, _target, propertyKey) {
+        return function () {
+            const alreadyCalculating = syncCalculating.findIndex((c) => c.object === this && c.prop === propertyKey);
+            if (alreadyCalculating > -1)
+                throw new Error(`Circular dependency detected: ${syncCalculating
+                    .slice(alreadyCalculating)
+                    .map((c) => `${c.object.constructor.name}.${String(c.prop)}`)
+                    .join(' -> ')} -> again`);
+            syncCalculating.push({ object: this, prop: propertyKey });
+            try {
+                const rv = original.call(this);
+                cache(this, propertyKey, rv);
+                return rv;
+            }
+            finally {
+                syncCalculating.pop();
+            }
+        };
+    },
+});
+/**
+ * Checks if a property is cached (has a cached value)
+ * @param object - The object to check
+ * @param propertyKey - The property key to check
+ * @returns True if the property has a cached value
+ */
+function isCached(object, propertyKey) {
+    return !!Object.getOwnPropertyDescriptor(object, propertyKey);
+}
+/**
+ * Caches a value for a property on an object
+ * @param object - The object to cache the value on
+ * @param propertyKey - The property key to cache
+ * @param value - The value to cache
+ */
+function cache(object, propertyKey, value) {
+    Object.defineProperty(object, propertyKey, { value });
+}
+/**
+ * Creates a decorator that modifies property descriptors for specified properties
+ * @param descriptor - The descriptor properties to apply
+ * @returns A class decorator that applies the descriptor to specified properties
+ */
+const descriptor = flavored(function descriptor(descriptor) {
+    return (...properties) => (Base) => {
+        return class extends Base {
+            constructor(...args) {
+                super(...args);
+                for (const key of properties) {
+                    const existing = Object.getOwnPropertyDescriptor(this, key);
+                    Object.defineProperty(this, key, Object.assign(existing || {}, descriptor));
+                }
+            }
+        };
+    };
+}, {
+    /**
+     * enumerable: true
+     */
+    get enumerable() {
+        return descriptor({ enumerable: true });
+    },
+    /**
+     * enumerable: false
+     */
+    get hidden() {
+        return descriptor({ enumerable: false });
+    },
+    /**
+     * configurable: true
+     */
+    get configurable() {
+        return descriptor({ configurable: true });
+    },
+    /**
+     * configurable: false
+     */
+    get frozen() {
+        return descriptor({ configurable: false });
+    },
+    /**
+     * writable: true
+     */
+    get writable() {
+        return descriptor({ writable: true });
+    },
+    /**
+     * writable: false
+     */
+    get readonly() {
+        return descriptor({ writable: false });
+    },
+});
+/**
+ * Decorator that marks methods, properties, or classes as deprecated
+ * Provides warning messages when deprecated items are used
+ */
+const deprecated = Object.assign(decorator({
+    method(original, _target, propertyKey) {
+        return function (...args) {
+            deprecated.warn(this, propertyKey);
+            return original.apply(this, args);
+        };
+    },
+    getter(original, _target, propertyKey) {
+        return function () {
+            deprecated.warn(this, propertyKey);
+            return original.call(this);
+        };
+    },
+    setter(original, _target, propertyKey) {
+        return function (value) {
+            deprecated.warn(this, propertyKey);
+            return original.call(this, value);
+        };
+    },
+    class(original) {
+        return class extends original {
+            constructor(...args) {
+                super(...args);
+                deprecated.warn(this, 'constructor');
+            }
+        };
+    },
+    default(message) {
+        return decorator({
+            method(original, _target, propertyKey) {
+                return function (...args) {
+                    deprecated.warn(this, propertyKey, message);
+                    return original.apply(this, args);
+                };
+            },
+            getter(original, _target, propertyKey) {
+                return function () {
+                    deprecated.warn(this, propertyKey, message);
+                    return original.call(this);
+                };
+            },
+            setter(original, _target, propertyKey) {
+                return function (value) {
+                    deprecated.warn(this, propertyKey, message);
+                    return original.call(this, value);
+                };
+            },
+            class(original) {
+                return class extends original {
+                    constructor(...args) {
+                        super(...args);
+                        deprecated.warn(this, 'constructor', message);
+                    }
+                };
+            },
+        });
+    },
+}), {
+    warn: (target, propertyKey, message) => {
+        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 decorator({
+        method(original, _target, _propertyKey) {
+            let timeoutId = null;
+            return function (...args) {
+                // Clear existing timeout
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                // Set new timeout
+                timeoutId = setTimeout(() => {
+                    original.apply(this, args);
+                    timeoutId = null;
+                }, delay);
+            };
+        },
+    });
+}
+/**
+ * Creates a throttled method decorator that limits execution to once per delay period
+ * @param delay - The delay in milliseconds
+ * @returns A method decorator that throttles method calls
+ */
+function throttle(delay) {
+    return decorator({
+        method(original, _target, _propertyKey) {
+            let lastCallTime = 0;
+            let timeoutId = null;
+            return function (...args) {
+                const now = Date.now();
+                // If enough time has passed since last call, execute immediately
+                if (now - lastCallTime >= delay) {
+                    // Clear any pending timeout since we're executing now
+                    if (timeoutId) {
+                        clearTimeout(timeoutId);
+                        timeoutId = null;
+                    }
+                    lastCallTime = now;
+                    return original.apply(this, args);
+                }
+                // Otherwise, schedule execution for when the delay period ends
+                if (!timeoutId) {
+                    const remainingTime = delay - (now - lastCallTime);
+                    const scheduledArgs = [...args]; // Capture args at scheduling time
+                    timeoutId = setTimeout(() => {
+                        lastCallTime = Date.now();
+                        original.apply(this, scheduledArgs);
+                        timeoutId = null;
+                    }, remainingTime);
+                }
+            };
+        },
+    });
+}
+
+var version$1 = "1.0.11";
+var pkg = {
+	version: version$1};
+
+const { version } = pkg;
+const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
+const globalScope = (typeof globalThis !== 'undefined'
+    ? globalThis
+    : typeof window !== 'undefined'
+        ? window
+        : typeof global !== 'undefined'
+            ? global
+            : false);
+if (globalScope) {
+    let source = 'mutts/index';
+    try {
+        if (typeof __filename !== 'undefined')
+            source = __filename;
+        else if (typeof import.meta !== 'undefined' && import.meta.url) {
+            source = import.meta.url;
+        }
+    }
+    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;
+}
+
+export { ArrayReadForward as A, unreactive as B, watch as C, Destroyable as D, Eventful as E, when as F, Indexable as I, DestructionError as a, allocated as b, allocatedValues as c, arrayDiff as d, attend as e, cache as f, cached as g, callOnGC as h, chainPromise as i, debounce as j, deepWatch as k, deprecated as l, descriptor as m, destructor as n, forwardArray as o, getAt as p, isCached as q, lift as r, memoize as s, morph as t, organize as u, organized as v, profileInfo as w, resource as x, setAt as y, throttle as z };
+//# sourceMappingURL=index-Sf74wXTV.esm.js.map