mutts 1.0.9 → 1.0.11

package/dist/browser.cjs

@@ -1,11 +1,12 @@
 'use strict';
 
-require('./chunks/async-browser-lvzLOCgk.cjs');
-var debug = require('./chunks/index-VTO-b2vR.cjs');
+require('./chunks/async-browser-Dgr5CreQ.cjs');
+var proxy = require('./chunks/proxy-Cc79Lrzj.cjs');
 var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
-require('./chunks/async-node-C3DeIb0y.cjs');
+require('./chunks/async-node-3PrbVAbB.cjs');
 require('node:async_hooks');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 // Integrated with `using` statement via Symbol.dispose
 const fr = new FinalizationRegistry((f) => f());
 /**
@@ -86,7 +87,7 @@ function Destroyable(base, destructorObj) {
  * Decorator that marks properties to be stored in the allocated object and passed to the destructor
  * Use with accessor properties or explicit get/set pairs
  */
-const allocated = debug.decorator({
+const allocated = proxy.decorator({
     setter(original, _target, propertyKey) {
         return function (value) {
             this[allocatedValues][propertyKey] = value;
@@ -111,6 +112,154 @@ function callOnGC(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');
@@ -602,151 +751,6 @@ function chainPromise(given) {
     return chained;
 }
 
-const memoizedRegistry = new WeakMap();
-const wrapperRegistry = new WeakMap();
-function getBranch(tree, key) {
-    tree.branches ?? (tree.branches = new WeakMap());
-    let branch = tree.branches.get(key);
-    if (!branch) {
-        branch = {};
-        tree.branches.set(key, branch);
-    }
-    return branch;
-}
-function memoizeFunction(fn) {
-    const fnRoot = debug.getRoot(fn);
-    const existing = memoizedRegistry.get(fnRoot);
-    if (existing)
-        return existing;
-    const cacheRoot = {};
-    const memoized = debug.markWithRoot((...args) => {
-        const localArgs = args; //: Args = maxArgs !== undefined ? (args.slice(0, maxArgs) as Args) : args
-        if (localArgs.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg))))
-            throw new Error('memoize expects non-null object arguments');
-        let node = cacheRoot;
-        // Note: decorators add `this` as first argument
-        for (const arg of localArgs) {
-            node = getBranch(node, arg);
-        }
-        debug.dependant(node, 'memoize');
-        if ('result' in node) {
-            if (debug.options.onMemoizationDiscrepancy) {
-                const wasVerification = debug.options.isVerificationRun;
-                debug.options.isVerificationRun = true;
-                try {
-                    const fresh = debug.untracked(() => fn(...localArgs));
-                    if (!debug.deepCompare(node.result, fresh)) {
-                        debug.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, localArgs, 'calculation');
-                    }
-                }
-                finally {
-                    debug.options.isVerificationRun = wasVerification;
-                }
-            }
-            return node.result;
-        }
-        // Create memoize internal effect to track dependencies and invalidate cache
-        // Use untracked to prevent the effect creation from being affected by parent effects
-        node.cleanup = debug.root(() => debug.effect(() => {
-            // Execute the function and track its dependencies
-            // The function execution will automatically track dependencies on reactive objects
-            node.result = fn(...localArgs);
-            return () => {
-                // When dependencies change, clear the cache and notify consumers
-                delete node.result;
-                debug.touched1(node, { type: 'invalidate', prop: localArgs }, 'memoize');
-                // Lazy memoization: stop the effect so it doesn't re-run immediately.
-                // It will be re-created on next access.
-                if (node.cleanup) {
-                    node.cleanup();
-                    node.cleanup = undefined;
-                }
-            };
-        }, { opaque: true }));
-        if (debug.options.onMemoizationDiscrepancy) {
-            const wasVerification = debug.options.isVerificationRun;
-            debug.options.isVerificationRun = true;
-            try {
-                const fresh = debug.untracked(() => fn(...localArgs));
-                if (!debug.deepCompare(node.result, fresh)) {
-                    debug.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, localArgs, 'comparison');
-                }
-            }
-            finally {
-                debug.options.isVerificationRun = wasVerification;
-            }
-        }
-        return node.result;
-    }, fn);
-    memoizedRegistry.set(fnRoot, memoized);
-    memoizedRegistry.set(memoized, memoized);
-    return memoized;
-}
-/**
- * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
- *
- * When used as a decorator on getters or methods, it caches the result and automatically
- * invalidates the cache when reactive dependencies change.
- *
- * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
- *
- * @example
- * ```typescript
- * class User {
- *   @memoize
- *   get fullName() {
- *     return `${this.firstName} ${this.lastName}`
- *   }
- * }
- *
- * // Or as a function wrapper
- * const expensive = memoize((obj: SomeObject) => {
- *   return heavyComputation(obj)
- * })
- * ```
- */
-const memoize = debug.decorator({
-    getter(original, target, propertyKey) {
-        return function () {
-            let wrapper = wrapperRegistry.get(original);
-            if (!wrapper) {
-                wrapper = debug.markWithRoot(debug.renamed((that) => {
-                    return original.call(that);
-                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`), {
-                    method: original,
-                    propertyKey,
-                    ...(original[debug.rootFunction]
-                        ? { [debug.rootFunction]: original[debug.rootFunction] }
-                        : {}),
-                });
-                wrapperRegistry.set(original, wrapper);
-            }
-            const memoized = memoizeFunction(wrapper);
-            return memoized(this);
-        };
-    },
-    method(original, target, name) {
-        return function (...args) {
-            let wrapper = wrapperRegistry.get(original);
-            if (!wrapper) {
-                wrapper = debug.markWithRoot(debug.renamed((that, ...args) => {
-                    return original.call(that, ...args);
-                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`), {
-                    method: original,
-                    propertyKey: name,
-                    ...(original[debug.rootFunction]
-                        ? { [debug.rootFunction]: original[debug.rootFunction] }
-                        : {}),
-                });
-                wrapperRegistry.set(original, wrapper);
-            }
-            const memoized = memoizeFunction(wrapper);
-            return memoized(this, ...args);
-        };
-    },
-    default: memoizeFunction,
-});
-
 function attend(source, callback) {
     const enumerate = typeof source === 'function'
         ? source
@@ -758,14 +762,14 @@ function attend(source, callback) {
                     ? () => source.values()
                     : () => Object.keys(source);
     const keyEffects = new Map();
-    const outer = debug.effect(({ ascend }) => {
+    const outer = proxy.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(() => debug.effect(() => callback(key))));
+            keyEffects.set(key, ascend(() => proxy.effect.named(`attend:${key}`)((access) => callback(key, access))));
         }
         for (const key of Array.from(keyEffects.keys())) {
             if (!keys.has(key)) {
@@ -774,189 +778,404 @@ function attend(source, callback) {
             }
         }
     });
-    return () => {
-        outer();
+    return (reason) => {
+        outer(reason);
         for (const stop of keyEffects.values())
-            stop();
+            stop(reason);
         keyEffects.clear();
     };
 }
+function lift(cb) {
+    let result;
+    let rawResult;
+    const liftCleanup = proxy.effect.named(`lift:${cb.name}`)(proxy.markWithRoot((access) => {
+        const source = cb(access);
+        if (!source || typeof source !== 'object')
+            throw new Error('lift callback must return an array or object');
+        const sourceProto = Object.getPrototypeOf(source);
+        if (!result) {
+            rawResult = Array.isArray(source) ? [] : Object.create(sourceProto);
+            result = proxy.reactive(rawResult);
+        }
+        if (sourceProto !== Object.getPrototypeOf(result))
+            throw new Error('lift callback must return the same type as the previous result');
+        if (Array.isArray(source)) {
+            const res = result;
+            for (const { indexA, sliceA, sliceB } of arrayDiff(res, source).sort((a, b) => a.indexA - b.indexA))
+                res.splice(indexA, sliceA.length, ...sliceB);
+        }
+        else {
+            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))
+                        proxy.touched1(rawResult, { type: 'set', prop: key }, key);
+                }
+                else {
+                    Object.defineProperty(rawResult, key, newDesc);
+                    proxy.touched1(rawResult, { type: 'add', prop: key }, key);
+                }
+            }
+            for (const key of Object.keys(rawResult))
+                if (!(key in source)) {
+                    delete rawResult[key];
+                    proxy.touched1(rawResult, { type: 'del', prop: key }, key);
+                }
+        }
+    }, cb));
+    return proxy.link(result, liftCleanup);
+}
 /**
- * Perform a reactive scan over an array of items.
- *
- * This implementation is highly optimized for performance and fine-grained reactivity:
- * - **Incremental Updates**: Changes to an item only trigger re-computation from that
- *   point onwards in the result chain.
- * - **Move Optimization**: If items are moved within the array, their accumulated
- *   values are reused as long as their predecessor remains the same.
- * - **Duplicate Support**: Correctly handles multiple occurrences of the same object
- *   instance using an internal occurrence tracking mechanism.
- * - **Memory Efficient**: Uses `WeakMap` for caching intermediates, which are
- *   automatically cleared when source items are garbage collected.
+ * Reactively maps an array source through `fn`, producing a lazy reactive output array.
  *
- * @example
- * ```typescript
- * const source = reactive([{ val: 1 }, { val: 2 }, { val: 3 }])
- * const sum = scan(source, (acc, item) => acc + item.val, 0)
+ * 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.
  *
- * expect([...sum]).toEqual([1, 3, 6])
+ * 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.
  *
- * // Modifying an item only re-computes subsequent sums
- * source[1].val = 10
- * expect([...sum]).toEqual([1, 11, 14])
- * ```
+ * Output elements are computed lazily — accessing `result[i]` triggers computation if not yet cached.
  *
- * @param source The source array of objects (will be made reactive)
- * @param callback The accumulator function called with (accumulator, currentItem)
- * @param initialValue The starting value for the accumulation
- * @returns A reactive array of accumulated values, with a [cleanup] property to stop the tracking
+ * @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 scan(source, callback, initialValue) {
-    const observedSource = debug.reactive(source);
-    const result = debug.reactive([]);
-    // Track effects for each index to dispose them when the array shrinks
-    const indexEffects = new Map();
-    // Mapping from index to its current intermediate object
-    const indexToIntermediate = debug.reactive([]);
-    const intermediaries = new WeakMap();
-    let Intermediate = (() => {
-        var _a;
-        let _instanceExtraInitializers = [];
-        let _get_acc_decorators;
-        return _a = class Intermediate {
-                constructor(val, prev) {
-                    this.val = (debug.__runInitializers(this, _instanceExtraInitializers), val);
-                    this.prev = prev;
-                }
-                get acc() {
-                    const prevAcc = this.prev ? this.prev.acc : initialValue;
-                    return callback(prevAcc, this.val);
+function morphArray(source, fn, options) {
+    if (typeof source !== 'function' && !proxy.isReactive(source) && options?.pure === true) {
+        return source.map((i) => fn(i));
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = [];
+    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(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache[indexRef.value] = fn(input, access);
+                return (reason) => {
+                    delete cache[indexRef.value];
+                    proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop?.({ type: 'invalidate', cause: reason });
+                };
+            }));
+            itemEffects.set(key, { stop, index: indexRef });
+        }
+    }
+    const proxy$1 = proxy.reactive(cache, {
+        get(cache, prop) {
+            const n = typeof prop === 'string' ? Number(prop) : NaN;
+            if (Number.isNaN(n))
+                return cache[prop];
+            if (!(n in cache))
+                computeItem(n, input[n]);
+            return cache[n];
+        },
+        has(_cache, prop) {
+            return Reflect.has(input, prop);
+        },
+    });
+    const stopMain = proxy.effect.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);
+                        }
+                    }
                 }
-            },
-            (() => {
-                const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-                _get_acc_decorators = [memoize];
-                debug.__esDecorate(_a, null, _get_acc_decorators, { kind: "getter", name: "acc", static: false, private: false, access: { has: obj => "acc" in obj, get: obj => obj.acc }, metadata: _metadata }, null, _instanceExtraInitializers);
-                if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            })(),
-            _a;
-    })();
-    function disposeIndex(index) {
-        const stop = indexEffects.get(index);
+                // Splice the cache
+                cache.splice(diff.indexA, diff.sliceA.length, ...new Array(diff.sliceB.length).fill(undefined));
+                // Make holes for lazy computation
+                for (let i = diff.indexA; i < diff.indexA + diff.sliceB.length; i++)
+                    delete cache[i];
+            }
+            const invalidates = new Set([proxy.keysOf]);
+            if (input.length !== newInput.length)
+                invalidates.add('length');
+            for (const diff of diffs) {
+                const max = Math.max(diff.sliceA.length, diff.sliceB.length);
+                for (let i = 0; i < max; i++)
+                    invalidates.add(String(diff.indexA + i));
+            }
+            proxy.touched(cache, { type: 'bunch', method: 'morph-input' }, invalidates);
+        }
+        input = newInput;
+    });
+    return proxy.link(proxy$1, (reason) => {
+        stopMain(reason);
+        for (const entry of itemEffects.values())
+            entry.stop(reason);
+        itemEffects.clear();
+    });
+}
+/**
+ * Reactively maps a `Map` source through `fn`, producing a reactive output Map.
+ *
+ * Each key gets its own isolated effect so that value changes for one key only recompute
+ * that key's projection. Key additions and removals are tracked via `keysOf` dependency.
+ *
+ * @param source - A reactive Map
+ * @param fn - Mapping function applied to each value
+ * @param options - Optional purity hints to skip per-key effects
+ * @returns A reactive Map with a `[cleanup]` method to dispose all effects
+ */
+function morphMap(source, fn, options) {
+    if (!proxy.isReactive(source) && options?.pure === true) {
+        const res = new Map();
+        for (const [k, v] of source)
+            res.set(k, fn(v, k));
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = new Map();
+    Object.defineProperty(cache, 'constructor', { value: Object, enumerable: false });
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
         if (stop) {
-            stop();
-            indexEffects.delete(index);
-            debug.untracked(() => {
-                Reflect.deleteProperty(indexToIntermediate, index);
-                Reflect.deleteProperty(result, index);
-            });
+            stop({ type: 'stopped' });
+            itemEffects.delete(key);
         }
     }
-    const mainEffect = debug.effect(function scanMainEffect({ ascend }) {
-        const length = observedSource.length;
-        const occurrenceCount = new Map();
-        let prev;
-        for (let i = 0; i < length; i++) {
-            const val = debug.FoolProof.get(observedSource, i, observedSource);
-            if (!(val && (typeof val === 'object' || typeof val === 'function' || typeof val === 'symbol'))) {
-                throw new Error('scan: items must be objects (WeakKey) for intermediate caching');
-            }
-            const count = occurrenceCount.get(val) ?? 0;
-            occurrenceCount.set(val, count + 1);
-            let list = intermediaries.get(val);
-            if (!list) {
-                list = [];
-                intermediaries.set(val, list);
-            }
-            let intermediate = list[count];
-            if (!intermediate) {
-                intermediate = debug.reactive(new Intermediate(val, prev));
-                list[count] = intermediate;
-            }
-            else {
-                // Update the link.
-                if (debug.untracked(() => intermediate.prev) !== prev) {
-                    intermediate.prev = prev;
-                }
-            }
-            // Update the reactive mapping for this index
-            if (indexToIntermediate[i] !== intermediate) {
-                indexToIntermediate[i] = intermediate;
-            }
-            // If we don't have an effect for this index yet, create one
-            if (!indexEffects.has(i)) {
-                ascend(() => {
-                    const index = i;
-                    const stop = debug.effect(function scanIndexSyncEffect() {
-                        const inter = indexToIntermediate[index];
-                        if (inter) {
-                            const accValue = inter.acc;
-                            debug.untracked(() => {
-                                result[index] = accValue;
-                            });
-                        }
-                    });
-                    indexEffects.set(index, stop);
-                });
-            }
-            prev = intermediate;
+    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)));
         }
-        // Cleanup trailing indices
-        for (const index of Array.from(indexEffects.keys())) {
-            if (index >= length)
-                disposeIndex(index);
+        else {
+            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache.set(key, fn(source.get(key), key, access));
+                return (reason) => {
+                    cache.delete(key);
+                    proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop?.({ type: 'invalidate', cause: reason });
+                };
+            }));
+            itemEffects.set(key, stop);
         }
-        // Ensure result length matches source length
-        debug.untracked(() => {
-            if (result.length !== length) {
-                debug.FoolProof.set(result, 'length', length, result);
-            }
-        });
+    }
+    const proxy$1 = proxy.reactive(cache, {
+        get(cache, prop) {
+            if (prop === 'get')
+                return (key) => {
+                    if (!cache.has(key) && source.has(key))
+                        computeItem(key, source.get(key));
+                    return cache.get(key);
+                };
+            if (prop === 'has')
+                return (key) => {
+                    return source.has(key);
+                };
+            if (prop === 'keys')
+                return () => {
+                    return source.keys();
+                };
+            if (prop === 'values')
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield proxy$1.get(key);
+                    }
+                };
+            if (prop === 'entries')
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy$1.get(key)];
+                    }
+                };
+            if (prop === Symbol.iterator)
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy$1.get(key)];
+                    }
+                };
+            return cache[prop];
+        },
     });
-    return debug.cleanedBy(result, (() => {
-        mainEffect();
-        for (const stop of indexEffects.values())
-            stop();
-        indexEffects.clear();
-    }));
-}
-function lift(cb) {
-    let result;
-    const liftCleanup = debug.effect((access) => {
-        const source = cb(access);
-        if (!source || typeof source !== 'object')
-            throw new Error('lift callback must return an array or object');
-        if (!result) {
-            if (Array.isArray(source)) {
-                result = debug.reactive([]);
-            }
-            else {
-                result = debug.reactive({});
+    let stateSnapshot = proxy.getState(source);
+    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
+        track = ascend;
+        proxy.dependant(source, proxy.keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                proxy.touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                cache.delete(evolution.prop);
+                proxy.touched1(cache, evolution, evolution.prop);
             }
         }
-        if (Array.isArray(source) && Array.isArray(result)) {
-            if (result.length !== source.length)
-                result.length = source.length;
-            for (let i = 0; i < source.length; i++)
-                if (result[i] !== source[i])
-                    result[i] = source[i];
+    });
+    return proxy.link(proxy$1, (reason) => {
+        stopMain(reason);
+        for (const stop of itemEffects.values())
+            stop(reason);
+        itemEffects.clear();
+    });
+}
+/**
+ * Reactively maps a record/object source through `fn`, producing a reactive output record.
+ *
+ * Each key gets its own isolated effect so that value changes for one key only recompute
+ * that key's projection. Key additions and removals are tracked automatically.
+ *
+ * @param source - A reactive record
+ * @param fn - Mapping function applied to each value
+ * @param options - Optional purity hints to skip per-key effects
+ * @returns A reactive record with a `[cleanup]` method to dispose all effects
+ */
+function morphRecord(source, fn, options) {
+    if (!proxy.isReactive(source) && options?.pure === true) {
+        const res = {};
+        for (const k of Object.keys(source))
+            res[k] = fn(source[k], k);
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = {};
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
+        if (stop) {
+            stop({ type: 'stopped' });
+            itemEffects.delete(key);
         }
-        else if (!Array.isArray(source) && !Array.isArray(result)) {
-            Object.assign(result, source);
-            for (const key of Object.keys(result))
-                if (!(key in source))
-                    delete result[key];
+    }
+    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 {
-            throw new Error('lift callback must return the same type as the previous result');
+            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache[key] = fn(source[key], key, access);
+                return (reason) => {
+                    delete cache[key];
+                    proxy.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$1 = proxy.reactive(cache, {
+        get(_, prop) {
+            return get(prop);
+        },
+        has(_, prop) {
+            return prop in source;
+        },
+        ownKeys() {
+            return Reflect.ownKeys(source);
+        },
+        getOwnPropertyDescriptor(_cache, prop) {
+            if (prop in source)
+                return { configurable: true, enumerable: true, get: () => get(prop) };
+        },
+    });
+    let stateSnapshot = proxy.getState(source);
+    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
+        track = ascend;
+        // Track only structural changes on source
+        proxy.dependant(source, proxy.keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                proxy.touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                delete cache[evolution.prop];
+                proxy.touched1(cache, evolution, evolution.prop);
+            }
         }
     });
-    return debug.cleanedBy(result, liftCleanup);
+    return proxy.link(proxy$1, (reason) => {
+        stopMain(reason);
+        for (const stop of itemEffects.values())
+            stop(reason);
+        itemEffects.clear();
+    });
 }
+/**
+ * Reactively maps a collection (array, Map, or record) through a per-entry function.
+ *
+ * Each entry in the source gets its own reactive context — when only one entry's dependencies
+ * change, only that entry's projection recomputes. Structural changes (additions, removals,
+ * reorders) are detected via diffing and applied surgically.
+ *
+ * Use `morph.pure(source, fn)` when `fn` has no reactive reads (skips per-item effects).
+ *
+ * @example
+ * ```ts
+ * const users = reactive([{ name: 'John' }, { name: 'Jane' }])
+ * const names = morph(users, u => u.name.toUpperCase())
+ * // names[0] = 'JOHN', names[1] = 'JANE'
+ * // Changing users[0].name only recomputes names[0]
+ * ```
+ */
+const morph = proxy.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 });
+    },
+});
 
-function isObject(value) {
-    return typeof value === 'object' && value !== null;
-}
 /**
  * Deep watch an object and all its nested properties
  * @param target - The object to watch deeply
@@ -977,16 +1196,17 @@ function deepWatch(target, callback, { immediate = false } = {}) {
     if (typeof target !== 'object')
         throw new Error('Target of deep watching must be an object');
     // Create a wrapper callback that matches EffectTrigger signature
-    const wrappedCallback = debug.markWithRoot((() => callback(target)), callback);
+    const wrappedCallback = proxy.markWithRoot((() => callback(target)), callback);
+    proxy.registerDeepWatcher();
     // Use the existing effect system to register dependencies
-    return debug.effect(() => {
+    return proxy.effect.named('deepWatch')(() => {
         // Mark the target object as having deep watchers
-        debug.objectsWithDeepWatchers.add(target);
+        proxy.objectsWithDeepWatchers.add(target);
         // Track which objects this effect is watching for cleanup
-        let effectObjects = debug.effectToDeepWatchedObjects.get(wrappedCallback);
+        let effectObjects = proxy.effectToDeepWatchedObjects.get(wrappedCallback);
         if (!effectObjects) {
             effectObjects = new Set();
-            debug.effectToDeepWatchedObjects.set(wrappedCallback, effectObjects);
+            proxy.effectToDeepWatchedObjects.set(wrappedCallback, effectObjects);
         }
         effectObjects.add(target);
         // Traverse the object graph and register dependencies
@@ -994,56 +1214,45 @@ function deepWatch(target, callback, { immediate = false } = {}) {
         const visited = new WeakSet();
         function traverseAndTrack(obj, depth = 0) {
             // Prevent infinite recursion and excessive depth
-            if (!obj || visited.has(obj) || !isObject(obj) || depth > debug.options.maxDeepWatchDepth)
+            if (!obj || visited.has(obj) || typeof obj !== 'object' || depth > proxy.options.maxDeepWatchDepth)
                 return;
             // Do not traverse into unreactive objects
-            if (debug.isNonReactive(obj))
+            if (proxy.isNonReactive(obj))
                 return;
             visited.add(obj);
             // Mark this object as having deep watchers
-            debug.objectsWithDeepWatchers.add(obj);
+            proxy.objectsWithDeepWatchers.add(obj);
             effectObjects.add(obj);
             // Traverse all properties to register dependencies
             // unwrap to avoid kicking dependency
-            for (const key in debug.unwrap(obj)) {
+            for (const key in proxy.unwrap(obj)) {
                 if (Object.hasOwn(obj, key)) {
                     // Access the property to register dependency
                     const value = obj[key];
                     // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? debug.reactive(value) : value;
+                    const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
                     traverseAndTrack(reactiveValue, depth + 1);
                 }
             }
             // Also handle array indices and length
-            // biome-ignore lint/suspicious/useIsArray: Check for both native arrays and reactive arrays
-            if (Array.isArray(obj) || obj instanceof Array) {
-                // Access array length to register dependency on length changes
-                const length = obj.length;
-                // Access all current array elements to register dependencies
-                for (let i = 0; i < length; i++) {
-                    // Access the array element to register dependency
-                    const value = obj[i];
-                    // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? debug.reactive(value) : value;
-                    traverseAndTrack(reactiveValue, depth + 1);
-                }
-            }
-            // Handle Set values (deep watch values only, not keys since Sets don't have separate keys)
-            else if (obj instanceof Set) {
-                // Access all Set values to register dependencies
+            // 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 ? debug.reactive(value) : value;
+                    const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
                     traverseAndTrack(reactiveValue, depth + 1);
                 }
-            }
-            // Handle Map values (deep watch values only, not keys)
-            else if (obj instanceof Map) {
-                // Access all Map values to register dependencies
-                for (const [_key, value] of obj) {
-                    // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? debug.reactive(value) : value;
-                    traverseAndTrack(reactiveValue, depth + 1);
+                // Explicitly depend on length so array mutations changing count trigger re-evaluation
+                if ('length' in obj) {
+                    proxy.dependant(obj, 'length');
+                }
+                // For Maps, also ensure we track values explicitly if the iterator yields entries
+                if (obj instanceof Map) {
+                    for (const value of obj.values()) {
+                        const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
+                        traverseAndTrack(reactiveValue, depth + 1);
+                    }
                 }
             }
             // Note: WeakSet and WeakMap cannot be iterated, so we can't deep watch their contents
@@ -1053,911 +1262,243 @@ function deepWatch(target, callback, { immediate = false } = {}) {
         // This will register dependencies on all current properties and array elements
         traverseAndTrack(target);
         // Only call the callback if immediate is true or if it's not the first run
-        if (immediate)
-            callback(target);
+        if (immediate) {
+            proxy.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 = debug.effectToDeepWatchedObjects.get(wrappedCallback);
+            const effectObjects = proxy.effectToDeepWatchedObjects.get(wrappedCallback);
             if (effectObjects) {
                 // Remove deep watcher tracking from all objects this effect was watching
                 for (const obj of effectObjects) {
                     // Check if this object still has other deep watchers
-                    const watchers = debug.deepWatchers.get(obj);
+                    const watchers = proxy.deepWatchers.get(obj);
                     if (watchers) {
                         // Remove this effect's callback from the watchers
                         watchers.delete(wrappedCallback);
                         // If no more watchers, remove the object from deep watchers tracking
                         if (watchers.size === 0) {
-                            debug.deepWatchers.delete(obj);
-                            debug.objectsWithDeepWatchers.delete(obj);
+                            proxy.deepWatchers.delete(obj);
+                            proxy.objectsWithDeepWatchers.delete(obj);
                         }
                     }
                     else {
                         // No watchers found, remove from deep watchers tracking
-                        debug.objectsWithDeepWatchers.delete(obj);
+                        proxy.objectsWithDeepWatchers.delete(obj);
                     }
                 }
                 // Clean up the tracking data
-                debug.effectToDeepWatchedObjects.delete(wrappedCallback);
+                proxy.effectToDeepWatchedObjects.delete(wrappedCallback);
             }
         };
     });
 }
 
-/**
- * Converts an iterator to a generator that yields reactive values
- */
-function* makeReactiveIterator(iterator) {
-    let result = iterator.next();
-    while (!result.done) {
-        yield debug.reactive(result.value);
-        result = iterator.next();
+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;
 }
-/**
- * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
- */
-function* makeReactiveEntriesIterator(iterator) {
-    let result = iterator.next();
-    while (!result.done) {
-        const [key, value] = result.value;
-        yield [debug.reactive(key), debug.reactive(value)];
-        result = iterator.next();
-    }
-}
-
-//#region watch
-const unsetYet = Symbol('unset-yet');
-function watch(value, //object | ((dep: DependencyAccess) => object),
-changed, options = {}) {
-    return typeof value === 'function'
-        ? watchCallBack(value, changed, options)
-        : typeof value === 'object' && value !== null
-            ? watchObject(value, changed, options)
-            : (() => {
-                throw new Error('watch: value must be a function or an object');
-            })();
-}
-function watchObject(value, changed, { immediate = false, deep = false } = {}) {
-    if (deep)
-        return deepWatch(value, changed, { immediate });
-    return debug.effect(function watchObjectEffect() {
-        debug.dependant(value);
-        if (immediate)
-            changed(value);
-        immediate = true;
-    });
-}
-function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
-    let oldValue = unsetYet;
-    let deepCleanup;
-    const cbCleanup = debug.effect(debug.markWithRoot(function watchCallBackEffect(access) {
-        const newValue = value(access);
-        if (oldValue !== newValue)
-            if (oldValue === unsetYet) {
-                if (immediate)
-                    changed(newValue);
-            }
-            else
-                changed(newValue, oldValue);
-        oldValue = newValue;
-        if (deep) {
-            if (deepCleanup)
-                deepCleanup();
-            deepCleanup = deepWatch(newValue, (value) => changed(value, value));
-        }
-    }, value));
-    return Object.defineProperties(() => {
-        cbCleanup();
-        if (deepCleanup)
-            deepCleanup();
-    }, {
-        [debug.stopped]: { get: () => cbCleanup[debug.stopped] },
-    });
-}
-//#endregion
-//#region nonReactive
-/**
- * Mark an object as non-reactive. This object and all its properties will never be made reactive.
- * @param obj - The object to mark as non-reactive
- */
-function shallowNonReactive(obj) {
-    obj = debug.unwrap(obj);
-    if (debug.isNonReactive(obj))
-        return obj;
-    try {
-        Object.defineProperty(obj, debug.nonReactiveMark, {
-            value: true,
-            writable: false,
-            enumerable: false,
-            configurable: true,
-        });
-    }
-    catch { }
-    if (!(debug.nonReactiveMark in obj))
-        debug.nonReactiveObjects.add(obj);
-    // Finally, not deep
-    //for (const key in obj) deepNonReactive(obj[key])
-    return obj;
-}
-function unreactiveApplication(arg1, ...args) {
-    return typeof arg1 === 'object'
-        ? shallowNonReactive(arg1)
-        : ((original) => {
-            // Copy the parent's unreactive properties if they exist
-            original.prototype[debug.unreactiveProperties] = new Set(original.prototype[debug.unreactiveProperties] || []);
-            // Add all arguments (including the first one)
-            original.prototype[debug.unreactiveProperties].add(arg1);
-            for (const arg of args)
-                original.prototype[debug.unreactiveProperties].add(arg);
-            return original; // Return the class
-        });
-}
-/**
- * Decorator that marks classes or properties as non-reactive
- * Prevents objects from being made reactive
- */
-const unreactive = debug.decorator({
-    class(original) {
-        // Called without arguments, mark entire class as non-reactive
-        debug.nonReactiveClass(original);
-    },
-    default: unreactiveApplication,
-});
-//#endregion
-
-// Helper to work around TypeScript limitation: base class expressions cannot reference class type parameters
-function getRegisterBase() {
-    class RegisterBase extends Indexable(ArrayReadForward, {
-        get(index) {
-            return this[getAt](index);
-        },
-        set(index, value) {
-            this[setAt](index, value);
-        },
-        getLength() {
-            return this.length;
-        },
-        setLength(value) {
-            this.length = value;
-        },
-    }) {
-        toArray() {
-            return Array.from(this);
-        }
-    }
-    return RegisterBase;
-}
-let RegisterClass = (() => {
-    var _RegisterClass_instances, _RegisterClass_keyFn, _RegisterClass_keys, _RegisterClass_values, _RegisterClass_usage, _RegisterClass_valueInfo, _RegisterClass_keyEffects, _RegisterClass_ascend, _RegisterClass_events, _RegisterClass_rekeyValue;
-    let _classDecorators = [unreactive];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    let _classSuper = getRegisterBase();
-    _classThis = class extends _classSuper {
-        get [(_RegisterClass_keyFn = new WeakMap(), _RegisterClass_keys = new WeakMap(), _RegisterClass_values = new WeakMap(), _RegisterClass_usage = new WeakMap(), _RegisterClass_valueInfo = new WeakMap(), _RegisterClass_keyEffects = new WeakMap(), _RegisterClass_ascend = new WeakMap(), _RegisterClass_events = new WeakMap(), _RegisterClass_instances = new WeakSet(), forwardArray)]() {
-            return this.toArray();
-        }
-        on(eventOrEvents, cb) {
-            // @ts-expect-error Delegate to Eventful
-            return debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").on(eventOrEvents, cb);
-        }
-        off(eventOrEvents, cb) {
-            // @ts-expect-error Delegate to Eventful
-            debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").off(eventOrEvents, cb);
-        }
-        /**
-         * Register a global hook that receives all events
-         */
-        hook(cb) {
-            return debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").hook(cb);
-        }
-        constructor(keyFn, initial) {
-            super();
-            _RegisterClass_instances.add(this);
-            _RegisterClass_keyFn.set(this, void 0);
-            _RegisterClass_keys.set(this, void 0);
-            _RegisterClass_values.set(this, void 0);
-            _RegisterClass_usage.set(this, new Map());
-            _RegisterClass_valueInfo.set(this, new Map());
-            _RegisterClass_keyEffects.set(this, new Set());
-            _RegisterClass_ascend.set(this, void 0);
-            _RegisterClass_events.set(this, new Eventful()
-            /**
-             * Register event listeners for CRUD operations
-             */
-            );
-            /* Moved below initialization */
-            let ascendGet;
-            debug.effect(({ ascend }) => {
-                ascendGet = ascend;
-            });
-            debug.__classPrivateFieldSet(this, _RegisterClass_ascend, ascendGet, "f");
-            if (typeof keyFn !== 'function')
-                throw new Error('Register requires a key function');
-            debug.__classPrivateFieldSet(this, _RegisterClass_keyFn, keyFn, "f");
-            debug.__classPrivateFieldSet(this, _RegisterClass_keys, debug.reactive([]), "f");
-            debug.__classPrivateFieldSet(this, _RegisterClass_values, debug.reactive(new Map()), "f");
-            if (initial)
-                this.push(...initial);
-        }
-        ensureKey(value) {
-            let info = debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-            if (info)
-                return info.key;
-            info = { key: undefined };
-            debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").set(value, info);
-            debug.__classPrivateFieldGet(this, _RegisterClass_ascend, "f").call(this, () => {
-                const stop = debug.effect(({ reaction }) => {
-                    const nextKey = debug.__classPrivateFieldGet(this, _RegisterClass_keyFn, "f").call(this, value);
-                    this.assertValidKey(nextKey);
-                    const previousKey = info.key;
-                    if (reaction && previousKey !== undefined && !Object.is(nextKey, previousKey))
-                        debug.__classPrivateFieldGet(this, _RegisterClass_instances, "m", _RegisterClass_rekeyValue).call(this, value, previousKey, nextKey);
-                    info.key = nextKey;
-                });
-                info.stop = stop;
-                debug.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").add(stop);
-            });
-            if (info.key === undefined)
-                throw new Error('Register key function must return a property key');
-            return info.key;
-        }
-        assertValidKey(key) {
-            const type = typeof key;
-            if (type !== 'string' && type !== 'number' && type !== 'symbol')
-                throw new Error('Register key function must return a property key');
-        }
-        setKeyValue(key, value, index) {
-            const existing = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-            if (existing !== undefined && existing !== value) {
-                this.cleanupValue(existing);
-                debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-                if (index !== undefined) {
-                    debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', existing, value, key, index);
-                }
-            }
-            else {
-                debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-            }
-        }
-        cleanupValue(value) {
-            const info = debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-            if (!info)
-                return;
-            const stop = info.stop;
-            if (stop) {
-                info.stop = undefined;
-                debug.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").delete(stop);
-                stop();
-            }
-            debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").delete(value);
-        }
-        disposeKeyEffects() {
-            for (const value of Array.from(debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").keys()))
-                this.cleanupValue(value);
-            debug.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").clear();
-        }
-        incrementUsage(key) {
-            const count = debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key) ?? 0;
-            debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count + 1);
-        }
-        decrementUsage(key, index) {
-            const count = debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key);
-            if (!count)
-                return;
-            if (count <= 1) {
-                const value = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-                debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(key);
-                debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").delete(key);
-                if (value !== undefined) {
-                    this.cleanupValue(value);
-                    const idx = index ?? debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-                    debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('delete', value, key, idx);
-                }
-            }
-            else {
-                debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count - 1);
-            }
+function memoizeFunction(fn, opts) {
+    const fnRoot = proxy.getRoot(fn);
+    const existing = memoizedRegistry.get(fnRoot);
+    if (existing)
+        return existing;
+    const cacheRoot = {};
+    const memoized = proxy.markWithRoot(function memoized(...args) {
+        if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
+            if (opts?.lenient)
+                return fn.apply(this, args);
+            throw new Error('memoize expects non-null object arguments');
         }
-        normalizeIndex(index, allowEnd = false) {
-            const length = this.length;
-            let resolved = index;
-            if (resolved < 0)
-                resolved = Math.max(length + resolved, 0);
-            if (resolved > length) {
-                if (allowEnd)
-                    resolved = length;
-                else
-                    throw new RangeError('Index out of bounds');
-            }
-            if (!allowEnd && resolved === length)
-                throw new RangeError('Index out of bounds');
-            return resolved;
+        let node = cacheRoot;
+        // Note: decorators add `this` as first argument
+        for (const arg of args) {
+            node = getBranch(node, arg);
         }
-        assignAt(index, key, value) {
-            const oldKey = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
-            if (oldKey !== undefined && Object.is(oldKey, key)) {
-                const oldValue = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-                this.setKeyValue(key, value);
-                if (oldValue !== undefined && oldValue !== value) {
-                    debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', oldValue, value, key, index);
+        proxy.dependant(node, 'memoize');
+        if ('result' in node) {
+            if (proxy.options.onMemoizationDiscrepancy) {
+                const wasVerification = proxy.options.isVerificationRun;
+                proxy.options.isVerificationRun = true;
+                try {
+                    const fresh = proxy.untracked(() => fn.apply(this, args));
+                    if (!proxy.deepCompare(node.result, fresh)) {
+                        proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
+                    }
                 }
-                return;
-            }
-            if (oldKey !== undefined)
-                this.decrementUsage(oldKey);
-            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index] = key;
-            this.incrementUsage(key);
-            this.setKeyValue(key, value);
-            debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
-        }
-        insertKeyValue(index, key, value) {
-            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 0, key);
-            this.incrementUsage(key);
-            this.setKeyValue(key, value);
-            debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
-        }
-        rebuildFrom(values) {
-            this.disposeKeyEffects();
-            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(0, debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length);
-            debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
-            debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
-            for (const value of values) {
-                const key = this.ensureKey(value);
-                debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").push(key);
-                this.incrementUsage(key);
-                debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-            }
-        }
-        get length() {
-            return debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length;
-        }
-        [(_RegisterClass_rekeyValue = function _RegisterClass_rekeyValue(value, oldKey, newKey) {
-            if (Object.is(oldKey, newKey))
-                return;
-            const existingValue = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(newKey);
-            if (existingValue !== undefined && existingValue !== value)
-                throw new Error(`Register key collision for key ${String(newKey)}`);
-            const count = debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(oldKey);
-            if (!count)
-                return;
-            const existingCount = debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(newKey) ?? 0;
-            this.setKeyValue(newKey, value);
-            let index = -1;
-            for (let i = 0; i < debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length; i++)
-                if (Object.is(debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i], oldKey)) {
-                    debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i] = newKey;
-                    if (index === -1)
-                        index = i;
+                finally {
+                    proxy.options.isVerificationRun = wasVerification;
                 }
-            debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(newKey, existingCount + count);
-            debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(oldKey);
-            debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").delete(oldKey);
-            const updatedInfo = debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-            if (updatedInfo)
-                updatedInfo.key = newKey;
-            if (index !== -1) {
-                debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('rekey', value, oldKey, newKey, index);
-            }
-        }, getAt)](index) {
-            const key = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
-            return key === undefined ? undefined : debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-        }
-        [setAt](index, value) {
-            const key = this.ensureKey(value);
-            if (index === this.length) {
-                this.insertKeyValue(index, key, value);
-                return;
-            }
-            const normalized = this.normalizeIndex(index);
-            this.assignAt(normalized, key, value);
-        }
-        push(...items) {
-            for (const item of items) {
-                const key = this.ensureKey(item);
-                this.insertKeyValue(this.length, key, item);
-            }
-            return this.length;
-        }
-        pop() {
-            if (!this.length)
-                return undefined;
-            return this.removeAt(this.length - 1);
-        }
-        shift() {
-            if (!this.length)
-                return undefined;
-            return this.removeAt(0);
-        }
-        unshift(...items) {
-            let index = 0;
-            for (const item of items) {
-                const key = this.ensureKey(item);
-                this.insertKeyValue(index++, key, item);
-            }
-            return this.length;
-        }
-        splice(start, deleteCount, ...items) {
-            const normalizedStart = this.normalizeIndex(start, true);
-            const maxDeletions = this.length - normalizedStart;
-            const actualDelete = Math.min(deleteCount === undefined ? maxDeletions : Math.max(deleteCount, 0), maxDeletions);
-            const keysToInsert = [];
-            for (const item of items)
-                keysToInsert.push(this.ensureKey(item));
-            const removedKeys = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(normalizedStart, actualDelete, ...keysToInsert);
-            const removedValues = [];
-            for (let i = 0; i < removedKeys.length; i++) {
-                const key = removedKeys[i];
-                if (key === undefined)
-                    continue;
-                const value = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-                this.decrementUsage(key, normalizedStart + i);
-                removedValues.push(value);
-            }
-            for (let i = 0; i < keysToInsert.length; i++) {
-                const key = keysToInsert[i];
-                const value = items[i];
-                this.incrementUsage(key);
-                this.setKeyValue(key, value);
-            }
-            return removedValues;
-        }
-        clear() {
-            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length = 0;
-            debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
-            debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
-            this.disposeKeyEffects();
-        }
-        get(key) {
-            return debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-        }
-        set(key, value) {
-            if (debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
-                this.setKeyValue(key, value);
-        }
-        remove(key) {
-            let index = this.indexOfKey(key);
-            while (index !== -1) {
-                this.removeAt(index);
-                index = this.indexOfKey(key);
             }
+            return node.result;
         }
-        removeAt(index) {
-            const [key] = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 1);
-            if (key === undefined)
-                return undefined;
-            const value = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-            this.decrementUsage(key, index);
-            return value;
-        }
-        /**
-         * Keep only the items for which the predicate returns true.
-         * Items for which the predicate returns false are removed.
-         *
-         * The predicate is evaluated once per distinct key; duplicate keys
-         * will follow the same keep/remove decision.
-         */
-        keep(predicate) {
-            const decisions = new Map();
-            for (const [index, key] of debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").entries()) {
-                if (decisions.has(key)) {
-                    if (!decisions.get(key))
-                        this.removeAt(index);
-                    continue;
+        // Create memoize internal effect to track dependencies and invalidate cache
+        // Use untracked to prevent the effect creation from being affected by parent effects
+        node.cleanup = proxy.root(() => proxy.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;
+                proxy.touched1(node, { type: 'invalidate', prop: args }, 'memoize');
+                // Lazy memoization: stop the effect so it doesn't re-run immediately.
+                // It will be re-created on next access.
+                if (node.cleanup) {
+                    node.cleanup({ type: 'invalidate', cause: reason });
+                    node.cleanup = undefined;
                 }
-                const value = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-                const shouldKeep = predicate(value);
-                decisions.set(key, shouldKeep);
-                if (!shouldKeep)
-                    this.removeAt(index);
-            }
-        }
-        hasKey(key) {
-            return debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").has(key);
-        }
-        indexOfKey(key) {
-            return debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-        }
-        mapKeys() {
-            return debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").keys();
-        }
-        update(...values) {
-            for (const value of values) {
-                const key = this.ensureKey(value);
-                if (debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key)) {
-                    const index = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-                    this.setKeyValue(key, value, index);
+            };
+        }, { opaque: true }));
+        if (proxy.options.onMemoizationDiscrepancy) {
+            const wasVerification = proxy.options.isVerificationRun;
+            proxy.options.isVerificationRun = true;
+            try {
+                const fresh = proxy.untracked(() => fn.apply(this, args));
+                if (!proxy.deepCompare(node.result, fresh)) {
+                    proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
                 }
             }
-        }
-        upsert(insert, ...values) {
-            for (const value of values) {
-                const key = this.ensureKey(value);
-                if (debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
-                    this.setKeyValue(key, value);
-                else
-                    insert(value);
-            }
-        }
-        entries() {
-            const self = this;
-            function* iterator() {
-                for (let i = 0; i < debug.__classPrivateFieldGet(self, _RegisterClass_keys, "f").length; i++) {
-                    const val = debug.__classPrivateFieldGet(self, _RegisterClass_values, "f").get(debug.__classPrivateFieldGet(self, _RegisterClass_keys, "f")[i]);
-                    if (val !== undefined)
-                        yield [i, val];
-                }
+            finally {
+                proxy.options.isVerificationRun = wasVerification;
             }
-            return iterator();
         }
-        [Symbol.iterator]() {
-            const self = this;
-            function* iterator() {
-                for (const key of debug.__classPrivateFieldGet(self, _RegisterClass_keys, "f")) {
-                    const value = debug.__classPrivateFieldGet(self, _RegisterClass_values, "f").get(key);
-                    if (value !== undefined)
-                        yield value;
+        return node.result;
+    }, fn);
+    memoizedRegistry.set(fnRoot, memoized);
+    memoizedRegistry.set(memoized, memoized);
+    return memoized;
+}
+function memoizeObject(target, opts) {
+    const existing = memoizedRegistry.get(target);
+    if (existing)
+        return existing;
+    const proxy$1 = new Proxy(target, {
+        get(source, prop, receiver) {
+            // 1. Walk prototype chain to find descriptor
+            let current = source;
+            let desc;
+            while (current) {
+                desc = Object.getOwnPropertyDescriptor(current, prop);
+                if (desc)
+                    break;
+                current = Object.getPrototypeOf(current);
+            }
+            if (!desc)
+                return Reflect.get(source, prop, receiver);
+            // 2. If getter, memoize
+            if (desc.get) {
+                const originalGetter = desc.get;
+                let wrapper = wrapperRegistry.get(originalGetter);
+                if (!wrapper) {
+                    wrapper = proxy.markWithRoot(proxy.named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
+                        return originalGetter.call(that);
+                    }), {
+                        propertyKey: prop,
+                    });
+                    const origRoot = originalGetter[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(originalGetter, wrapper);
                 }
+                const memoized = memoizeFunction(wrapper, opts);
+                return memoized(receiver);
             }
-            return iterator();
-        }
-        toString() {
-            return `[Register length=${this.length}]`;
-        }
-        at(index) {
-            const resolved = index < 0 ? this.length + index : index;
-            if (resolved < 0 || resolved >= this.length)
-                return undefined;
-            return this[getAt](resolved);
-        }
-        reverse() {
-            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").reverse();
-            return this;
-        }
-        sort(compareFn) {
-            const fwdCompareFn = compareFn
-                ? (a, b) => compareFn(debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(a), debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(b))
-                : undefined;
-            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").sort(fwdCompareFn);
-            return this;
-        }
-        fill(value, start = 0, end = this.length) {
-            const values = this.toArray();
-            values.fill(value, start, end);
-            this.rebuildFrom(values);
-            return this;
-        }
-        copyWithin(target, start, end) {
-            const values = this.toArray();
-            values.copyWithin(target, start, end);
-            this.rebuildFrom(values);
-            return this;
-        }
-    };
-    debug.__setFunctionName(_classThis, "RegisterClass");
-    (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-        debug.__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-        _classThis = _classDescriptor.value;
-        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        debug.__runInitializers(_classThis, _classExtraInitializers);
-    })();
-    return _classThis;
-})();
-const Register = RegisterClass;
+            // 3. Otherwise forward
+            return Reflect.get(source, prop, receiver);
+        },
+        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
+        set(source, prop, value, _receiver) {
+            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
+            // it recognizes itself and triggers change notifications.
+            return Reflect.set(source, prop, value, source);
+        },
+    });
+    proxy.proxyToObject.set(proxy$1, target);
+    memoizedRegistry.set(target, proxy$1);
+    return proxy$1;
+}
 /**
- * Creates a reactive Register - an ordered, array-like collection with stable key-based identity.
+ * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
  *
- * Register combines array semantics (indexable access, ordering, iteration) with Map-like
- * key-based lookups. Items with the same key share the same value instance, making it ideal
- * for UI lists keyed by IDs or when you need to preserve identity across reorders.
+ * When used as a decorator on getters or methods, it caches the result and automatically
+ * invalidates the cache when reactive dependencies change.
  *
- * @param keyFn - Function that extracts the key from each item
- * @param initial - Optional initial items to populate the register
- * @returns A reactive Register instance
+ * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
  *
  * @example
  * ```typescript
- * const users = register(
- *   (user: User) => user.id,
- *   [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
- * )
+ * class User {
+ *   @memoize
+ *   get fullName() {
+ *     return `${this.firstName} ${this.lastName}`
+ *   }
+ * }
  *
- * users.push({ id: 3, name: 'Charlie' })
- * const bob = users.get(2) // Get by key
+ * // Or as a function wrapper
+ * const expensive = memoize((obj: SomeObject) => {
+ *   return heavyComputation(obj)
+ * })
  * ```
  */
-function register(keyFn, initial) {
-    return new RegisterClass(keyFn, initial);
-}
-
-/**
- * Maps projection effects (item effects) to their projection context
- */
-const effectProjectionMetadata = new WeakMap();
-/**
- * Returns the projection context of the currently running effect, if any.
- */
-function getActiveProjection() {
-    const active = debug.getActiveEffect();
-    return active ? effectProjectionMetadata.get(active) : undefined;
-}
-function setActiveProjection(projection) {
-    const active = debug.getActiveEffect();
-    if (active)
-        effectProjectionMetadata.set(active, projection);
-}
-function defineAccessValue(access) {
-    Object.defineProperty(access, 'value', {
-        get: access.get,
-        set: access.set,
-        configurable: true,
-        enumerable: true,
-    });
-}
-function makeCleanup(target, effectMap, onDispose, metadata) {
-    if (metadata) {
-        Object.defineProperty(target, debug.projectionInfo, {
-            value: metadata,
-            writable: false,
-            enumerable: false,
-            configurable: true,
-        });
-    }
-    return debug.cleanedBy(target, () => {
-        onDispose();
-        for (const stop of effectMap.values())
-            stop?.();
-        effectMap.clear();
-    });
-}
-function projectArray(source, apply) {
-    source = debug.reactive(source);
-    const target = debug.reactive([]);
-    const indexEffects = new Map();
-    function normalizeTargetLength(length) {
-        debug.FoolProof.set(target, 'length', length, target);
-    }
-    function disposeIndex(index) {
-        const stopEffect = indexEffects.get(index);
-        if (stopEffect) {
-            indexEffects.delete(index);
-            stopEffect();
-            Reflect.deleteProperty(target, index);
-        }
-    }
-    const parent = getActiveProjection();
-    const depth = parent ? parent.depth + 1 : 0;
-    const cleanupLength = debug.effect(debug.named(`project:${source[Symbol.toStringTag]}.length`, ({ ascend }) => {
-        const length = source.length;
-        normalizeTargetLength(length);
-        const existing = Array.from(indexEffects.keys());
-        for (let i = 0; i < length; i++) {
-            if (indexEffects.has(i))
-                continue;
-            ascend(function projectArrayIndexAscend() {
-                const index = i;
-                const stop = debug.effect(debug.named(`project:${source[Symbol.toStringTag]}[${index}]`, ({ reaction }) => {
-                    if (!reaction)
-                        setActiveProjection({ source, key: index, target, depth, parent });
-                    const previous = debug.untracked(() => target[index]);
-                    const accessBase = {
-                        key: index,
-                        source,
-                        get: () => debug.FoolProof.get(source, index, source),
-                        set: (value) => debug.FoolProof.set(source, index, value, source),
-                        old: previous,
-                    };
-                    defineAccessValue(accessBase);
-                    target[index] = apply(accessBase, target);
-                }));
-                debug.setEffectName(stop, `project[${depth}]:${index}`);
-                indexEffects.set(i, stop);
-            });
-        }
-        for (const index of existing)
-            if (index >= length)
-                disposeIndex(index);
-    }));
-    return makeCleanup(target, indexEffects, () => cleanupLength(), {
-        source,
-        target,
-        apply,
-        depth,
-        parent,
-    });
-}
-function projectRegister(source, apply) {
-    source = debug.reactive(source);
-    const rawTarget = new Map();
-    const target = debug.reactive(rawTarget);
-    const keyEffects = new Map();
-    function disposeKey(key) {
-        const stopEffect = keyEffects.get(key);
-        if (stopEffect) {
-            stopEffect();
-            keyEffects.delete(key);
-            target.delete(key);
-        }
-    }
-    const parent = getActiveProjection();
-    const depth = parent ? parent.depth + 1 : 0;
-    const cleanupKeys = debug.effect(function projectRegisterEffect({ ascend }) {
-        const keys = new Set();
-        for (const key of source.mapKeys())
-            keys.add(key);
-        for (const key of keys) {
-            if (keyEffects.has(key))
-                continue;
-            ascend(() => {
-                const stop = debug.effect(function projectRegisterKeyEffect({ reaction }) {
-                    if (!reaction)
-                        setActiveProjection({ source, key, target, depth, parent });
-                    const previous = debug.untracked(() => target.get(key));
-                    const accessBase = {
-                        key,
-                        source: source,
-                        get: () => source.get(key),
-                        set: (value) => {
-                            source.set(key, value);
-                            return true;
-                        },
-                        old: previous,
-                    };
-                    defineAccessValue(accessBase);
-                    const produced = apply(accessBase, target);
-                    target.set(key, produced);
-                });
-                debug.setEffectName(stop, `project[${depth}]:${String(key)}`);
-                keyEffects.set(key, stop);
-            });
-        }
-        for (const key of Array.from(keyEffects.keys()))
-            if (!keys.has(key))
-                disposeKey(key);
-    });
-    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
-        source: source,
-        target,
-        apply,
-        depth,
-        parent,
-    });
-}
-function projectRecord(source, apply) {
-    source = debug.reactive(source);
-    const target = debug.reactive({});
-    const keyEffects = new Map();
-    function disposeKey(key) {
-        const stopEffect = keyEffects.get(key);
-        if (stopEffect) {
-            stopEffect();
-            keyEffects.delete(key);
-            Reflect.deleteProperty(target, key);
-        }
-    }
-    const parent = getActiveProjection();
-    const depth = parent ? parent.depth + 1 : 0;
-    const cleanupKeys = debug.effect(function projectRecordEffect({ ascend }) {
-        const keys = new Set();
-        for (const key in source)
-            keys.add(key);
-        const observed = Reflect.ownKeys(source);
-        for (const key of observed)
-            keys.add(key);
-        for (const key of keys) {
-            if (keyEffects.has(key))
-                continue;
-            ascend(() => {
-                const stop = debug.effect(function projectRecordKeyEffect({ reaction }) {
-                    if (!reaction)
-                        setActiveProjection({ source, key, target, depth, parent });
-                    const sourceKey = key;
-                    const previous = debug.untracked(() => target[key]);
-                    const accessBase = {
-                        key: sourceKey,
-                        source: source,
-                        get: () => debug.FoolProof.get(source, sourceKey, source),
-                        set: (value) => debug.FoolProof.set(source, sourceKey, value, source),
-                        old: previous,
-                    };
-                    defineAccessValue(accessBase);
-                    const produced = apply(accessBase, target);
-                    target[sourceKey] = produced;
-                });
-                debug.setEffectName(stop, `project[${depth}]:${String(key)}`);
-                keyEffects.set(key, stop);
-            });
-        }
-        for (const key of Array.from(keyEffects.keys()))
-            if (!keys.has(key))
-                disposeKey(key);
-    });
-    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
-        source: source,
-        target,
-        apply,
-        depth,
-        parent,
-    });
-}
-function projectMap(source, apply) {
-    source = debug.reactive(source);
-    const rawTarget = new Map();
-    const target = debug.reactive(rawTarget);
-    const keyEffects = new Map();
-    function disposeKey(key) {
-        const stopEffect = keyEffects.get(key);
-        if (stopEffect) {
-            stopEffect();
-            keyEffects.delete(key);
-            target.delete(key);
-        }
-    }
-    const parent = getActiveProjection();
-    const depth = parent ? parent.depth + 1 : 0;
-    const cleanupKeys = debug.effect(function projectMapEffect({ ascend }) {
-        const keys = new Set();
-        for (const key of source.keys())
-            keys.add(key);
-        for (const key of keys) {
-            if (keyEffects.has(key))
-                continue;
-            ascend(() => {
-                const stop = debug.effect(function projectMapKeyEffect({ reaction }) {
-                    if (!reaction)
-                        setActiveProjection({ source, key, target, depth, parent });
-                    const previous = debug.untracked(() => target.get(key));
-                    const accessBase = {
-                        key,
-                        source: source,
-                        get: () => source.get(key),
-                        set: (value) => {
-                            source.set(key, value);
-                            return true;
-                        },
-                        old: previous,
-                    };
-                    defineAccessValue(accessBase);
-                    const produced = apply(accessBase, target);
-                    target.set(key, produced);
-                });
-                debug.setEffectName(stop, `project[${depth}]:${String(key)}`);
-                keyEffects.set(key, stop);
-            });
-        }
-        for (const key of Array.from(keyEffects.keys()))
-            if (!keys.has(key))
-                disposeKey(key);
-    });
-    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
-        source: source,
-        target,
-        apply,
-        depth,
-        parent,
+function makeMemoizeDecorator(memoizeOpts) {
+    return proxy.decorator({
+        getter(original, target, propertyKey) {
+            return function () {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
+                        return original.call(that);
+                    }), {
+                        method: original,
+                        propertyKey,
+                    });
+                    const origRoot = original[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this);
+            };
+        },
+        method(original, target, name) {
+            return function (...args) {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
+                        return original.call(that, ...args);
+                    }), {
+                        method: original,
+                        propertyKey: name,
+                    });
+                    const origRoot = original[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this, ...args);
+            };
+        },
+        default: (target) => typeof target === 'object'
+            ? memoizeObject(target, memoizeOpts)
+            : memoizeFunction(target, memoizeOpts),
     });
 }
-function projectCore(source, apply) {
-    if (Array.isArray(source))
-        return projectArray(source, apply);
-    if (source instanceof Map)
-        return projectMap(source, apply);
-    if (source instanceof Register)
-        return projectRegister(source, apply);
-    if (source && (source.constructor === Object || source.constructor === undefined))
-        return projectRecord(source, apply);
-    throw new Error('Unsupported source type');
-}
-const project = Object.assign(projectCore, {
-    array: projectArray,
-    register: projectRegister,
-    record: projectRecord,
-    map: projectMap,
+const memoize = proxy.flavored(makeMemoizeDecorator(), {
+    get lenient() {
+        return makeMemoizeDecorator({ lenient: true });
+    },
 });
 
 /**
@@ -2012,8 +1553,8 @@ const project = Object.assign(projectCore, {
  * });
  */
 function organized(source, apply, baseTarget = {}) {
-    const observedSource = debug.reactive(source);
-    const target = debug.reactive(baseTarget);
+    const observedSource = proxy.reactive(source);
+    const target = proxy.reactive(baseTarget);
     const stop = attend(() => {
         const keys = [];
         for (const key in observedSource)
@@ -2023,8 +1564,8 @@ function organized(source, apply, baseTarget = {}) {
         const sourceKey = key;
         const accessBase = {
             key: sourceKey,
-            get: () => debug.FoolProof.get(observedSource, sourceKey, observedSource),
-            set: (value) => debug.FoolProof.set(observedSource, sourceKey, value, observedSource),
+            get: () => proxy.FoolProof.get(observedSource, sourceKey, observedSource),
+            set: (value) => proxy.FoolProof.set(observedSource, sourceKey, value, observedSource),
         };
         Object.defineProperty(accessBase, 'value', {
             get: accessBase.get,
@@ -2034,7 +1575,7 @@ function organized(source, apply, baseTarget = {}) {
         });
         return apply(accessBase, target);
     });
-    return debug.cleanedBy(target, stop);
+    return proxy.link(target, (reason) => stop(reason));
 }
 /**
  * Organizes a property on a target object
@@ -2051,35 +1592,246 @@ function organize(target, property, access) {
         configurable: true,
         enumerable: true,
     });
-    debug.touched1(target, { type: 'set', prop: property }, property);
+    proxy.touched1(target, { type: 'set', prop: property }, property);
     return () => delete target[property];
 }
 
+//#region watch
+const unsetYet = Symbol('unset-yet');
+const watch = proxy.flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
+changed, options = {}) {
+    return typeof value === 'function'
+        ? watchCallBack(value, changed, options)
+        : typeof value === 'object' && value !== null
+            ? watchObject(value, changed, options)
+            : (() => {
+                throw new Error('watch: value must be a function or an object');
+            })();
+}, {
+    get deep() {
+        return proxy.flavorOptions(this, { deep: true });
+    },
+    get immediate() {
+        return proxy.flavorOptions(this, { immediate: true });
+    },
+});
+function watchObject(value, changed, { immediate = false, deep = false } = {}) {
+    if (deep)
+        return deepWatch(value, changed, { immediate });
+    return proxy.effect.named('watch:object')(() => {
+        proxy.dependant(value);
+        if (immediate)
+            changed(value);
+        immediate = true;
+    });
+}
+function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
+    let oldValue = unsetYet;
+    let deepCleanup;
+    const cbCleanup = proxy.effect.named('watch:callback')(proxy.markWithRoot((access) => {
+        const newValue = value(access);
+        if (oldValue !== newValue) {
+            const old = oldValue;
+            if (old === unsetYet) {
+                if (immediate)
+                    proxy.untracked(() => changed(newValue));
+            }
+            else
+                proxy.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
 /**
- * Reactively defines properties on a target object based on a descriptors record.
- *
- * It tracks the keys of the descriptors record and defines/updates/removes
- * properties on the target object as they change.
- *
- * @param descriptors - A reactive record of property descriptors.
- * @param target - The object to define properties on (defaults to a new object).
- * @returns The target object with reactive property definitions.
+ * 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 describe(descriptors, target = Object.create(null)) {
-    descriptors = debug.reactive(descriptors);
-    const stop = attend(() => Reflect.ownKeys(descriptors), (key) => {
-        const desc = descriptors[key];
-        if (desc) {
-            Object.defineProperty(target, key, {
-                enumerable: true,
-                ...desc,
-                configurable: true,
-            });
-            debug.touched1(target, { type: 'set', prop: key }, key);
+function when(predicate, timeout) {
+    return new Promise((resolve, reject) => {
+        let timer;
+        const stop = proxy.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);
         }
-        return () => Reflect.deleteProperty(target, key);
     });
-    return debug.cleanedBy(target, stop);
+}
+//#endregion
+//#region nonReactive
+/**
+ * Mark an object as non-reactive. This object and all its properties will never be made reactive.
+ * @param obj - The object to mark as non-reactive
+ */
+function shallowNonReactive(obj) {
+    obj = proxy.unwrap(obj);
+    if (proxy.isNonReactive(obj))
+        return obj;
+    obj[proxy.unreactiveProperties] = true;
+    return obj;
+}
+function unreactiveApplication(arg1, ...args) {
+    return typeof arg1 === 'object'
+        ? shallowNonReactive(arg1)
+        : ((original) => {
+            // Copy the parent's unreactive properties if they exist
+            const parentMarker = original.prototype[proxy.unreactiveProperties];
+            // If parent is fully unreactive, child is too
+            if (parentMarker === true) {
+                original.prototype[proxy.unreactiveProperties] = true;
+            }
+            else {
+                const set = new Set(parentMarker || []);
+                // Add all arguments (including the first one)
+                set.add(arg1);
+                for (const arg of args)
+                    set.add(arg);
+                proxy.addUnreactiveProps(original.prototype, set);
+            }
+            return original; // Return the class
+        });
+}
+/**
+ * Decorator that marks classes or properties as non-reactive
+ * Prevents objects from being made reactive
+ */
+const unreactive = proxy.decorator({
+    class(original) {
+        original.prototype[proxy.unreactiveProperties] = true;
+    },
+    default: unreactiveApplication,
+});
+//#endregion
+//#region resource
+function lazyInit(resource, load) {
+    const creation = proxy.effectHistory.active;
+    let fresh = true;
+    return new Proxy(resource, {
+        [Symbol.toStringTag]: 'LazyInit',
+        get(target, prop) {
+            if (fresh) {
+                proxy.captured(creation, load)();
+                fresh = false;
+            }
+            return target[prop];
+        },
+    });
+}
+/**
+ * Creates a reactive resource that automatically tracks async state.
+ * @param fetcher - Async function that returns the value. Reactive dependencies are tracked.
+ * @param options - Resource options (initialValue)
+ * @returns Reactive Resource object with value, loading, error, latest properties
+ */
+function resource(fetcher, options = {}) {
+    const resource = proxy.reactive({
+        value: options.initialValue,
+        loading: true,
+        error: undefined,
+        latest: options.initialValue,
+        reload() {
+            reloadSignal.value++;
+        },
+    });
+    const reloadSignal = proxy.reactive({ value: 0 });
+    // Solve race conditions: make sure a new fast request is not overloaded by a slow old one
+    let counter = 0;
+    return lazyInit(resource, () => {
+        proxy.link(resource, proxy.effect.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 proxy.reactive(result.value);
+        result = iterator.next();
+    }
+}
+/**
+ * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
+ */
+function* makeReactiveEntriesIterator(iterator) {
+    let result = iterator.next();
+    while (!result.done) {
+        const [key, value] = result.value;
+        yield [proxy.reactive(key), proxy.reactive(value)];
+        result = iterator.next();
+    }
 }
 
 function* index(i, { length = true } = {}) {
@@ -2087,42 +1839,42 @@ function* index(i, { length = true } = {}) {
         yield 'length';
     yield i;
 }
-function* range(a, b, { length = false } = {}) {
-    const start = Math.min(a, b);
-    const end = Math.max(a, b);
-    if (length)
-        yield 'length';
-    for (let i = start; i <= end; i++)
-        yield i;
-}
 class Indexer extends Array {
     get(i) {
-        debug.dependant(this, i);
-        return debug.reactive(this[i]);
+        proxy.dependant(this, i);
+        return proxy.reactive(this[i]);
     }
     // Returns undefined intentionally: signals the proxy handler that notifications
     // were already dispatched via touched(), preventing double notification
     set(i, value) {
         const added = i >= this.length;
         this[i] = value;
-        debug.touched(this, { type: 'set', prop: i }, index(i, { length: added }));
+        proxy.touched(this, { type: 'set', prop: i }, index(i, { length: added }));
     }
 }
-const indexLess = { get: debug.FoolProof.get, set: debug.FoolProof.set };
-Object.assign(debug.FoolProof, {
+const indexLess = { get: proxy.FoolProof.get, set: proxy.FoolProof.set };
+// Fast numeric-string check: first char is a digit (0-9)
+function asIndex(prop) {
+    const c = prop.charCodeAt(0);
+    if (c < 48 || c > 57)
+        return -1; // not 0-9
+    const n = +prop; // coerce — faster than parseInt, handles "0", "12", etc.
+    return n === (n | 0) && n >= 0 ? n : -1;
+}
+Object.assign(proxy.FoolProof, {
     get(obj, prop, receiver) {
-        if (obj instanceof Array && typeof prop === 'string') {
-            const index = parseInt(prop);
-            if (!Number.isNaN(index))
-                return Indexer.prototype.get.call(obj, index);
+        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 (obj instanceof Array && typeof prop === 'string') {
-            const index = parseInt(prop);
-            if (!Number.isNaN(index))
-                return Indexer.prototype.set.call(obj, index, value);
+        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);
     },
@@ -2131,374 +1883,190 @@ class ReactiveArray extends Array {
     toJSON() {
         return this;
     }
-    get length() {
-        debug.dependant(this, 'length');
-        return this.length;
-    }
-    set length(value) {
-        const oldLength = this.length;
-        if (oldLength === value)
-            return;
-        try {
-            this.length = value;
-        }
-        finally {
-            debug.touched(this, { type: 'set', prop: 'length' }, range(oldLength, value, { length: true }));
-        }
-    }
-    // Safe array access with negative indices
-    at(index) {
-        const actualIndex = index < 0 ? this.length + index : index;
-        debug.dependant(this, actualIndex);
-        if (index < 0)
-            debug.dependant(this, 'length');
-        if (actualIndex < 0 || actualIndex >= this.length)
-            return undefined;
-        return debug.reactive(this[actualIndex]);
-    }
-    // Immutable versions of mutator methods
-    toReversed() {
-        debug.dependant(this);
-        return debug.reactive(this.toReversed());
-    }
-    toSorted(compareFn) {
-        debug.dependant(this);
-        return debug.reactive(this.toSorted(compareFn));
-    }
-    toSpliced(start, deleteCount, ...items) {
-        debug.dependant(this);
-        return deleteCount === undefined
-            ? this.toSpliced(start)
-            : this.toSpliced(start, deleteCount, ...items);
-    }
-    with(index, value) {
-        debug.dependant(this);
-        return debug.reactive(this.with(index, value));
-    }
-    // Iterator methods with reactivity tracking
-    entries() {
-        debug.dependant(this);
-        return makeReactiveEntriesIterator(this.entries());
-    }
-    keys() {
-        debug.dependant(this, 'length');
-        return this.keys();
-    }
-    values() {
-        debug.dependant(this);
-        return makeReactiveIterator(this.values());
-    }
-    [Symbol.iterator]() {
-        debug.dependant(this);
-        const nativeIterator = this[Symbol.iterator]();
-        return {
-            next() {
-                const result = nativeIterator.next();
-                if (result.done) {
-                    return result;
-                }
-                return { value: debug.reactive(result.value), done: false };
-            },
-            [Symbol.iterator]() {
-                return this;
-            },
-            [Symbol.dispose]() { },
-        };
-    }
-    indexOf(searchElement, fromIndex) {
-        const length = this.length;
-        let i = fromIndex === undefined ? 0 : fromIndex;
-        if (i < 0)
-            i = Math.max(length + i, 0);
-        const unwrappedSearch = debug.unwrap(searchElement);
-        for (; i < length; i++) {
-            debug.dependant(this, i);
-            const item = this[i];
-            if (item === searchElement || item === unwrappedSearch || debug.unwrap(item) === unwrappedSearch) {
-                return i;
+}
+/**
+ * This is a wrapper class for Array that adds reactive behavior.
+ * It extends Array and overrides methods to add reactive behavior, while making sure that the internal representation is not reactive.
+ */
+let ReactiveArrayWrapper = (() => {
+    var _a;
+    let _classSuper = Array;
+    let _instanceExtraInitializers = [];
+    let _fill_decorators;
+    let _copyWithin_decorators;
+    let _pop_decorators;
+    let _push_decorators;
+    let _reverse_decorators;
+    let _shift_decorators;
+    let _sort_decorators;
+    let _splice_decorators;
+    let _unshift_decorators;
+    return _a = class ReactiveArrayWrapper extends _classSuper {
+            at(index) {
+                return proxy.reactive(super.at(index));
             }
-        }
-        debug.dependant(this, 'length');
-        return -1;
-    }
-    lastIndexOf(searchElement, fromIndex) {
-        const length = this.length;
-        let i = fromIndex === undefined ? length - 1 : fromIndex;
-        if (i >= length)
-            i = length - 1;
-        if (i < 0)
-            i = Math.max(length + i, -1); // -1 ensures loop condition i >= 0 works correctly
-        const unwrappedSearch = debug.unwrap(searchElement);
-        for (; i >= 0; i--) {
-            debug.dependant(this, i);
-            const item = this[i];
-            if (item === searchElement || item === unwrappedSearch || debug.unwrap(item) === unwrappedSearch) {
-                return i;
+            concat(...items) {
+                return proxy.reactive(super.concat(...items.map(proxy.unwrap)));
             }
-        }
-        // If we scanned the whole relevant part and didn't find it, we depend on length
-        // (because adding elements might shift indices or add the element)
-        // Actually for lastIndexOf, if we start from end, length dependency is implicit in the start index calculation?
-        // But if we return -1, it means we didn't find it.
-        // If we push an element, should lastIndexOf update?
-        // Yes, if the new element is the one we are looking for.
-        debug.dependant(this, 'length');
-        return -1;
-    }
-    includes(searchElement, fromIndex) {
-        return this.indexOf(searchElement, fromIndex) !== -1;
-    }
-    find(predicateOrElement, thisArg) {
-        if (typeof predicateOrElement === 'function') {
-            const predicate = predicateOrElement;
-            const length = this.length;
-            for (let i = 0; i < length; i++) {
-                debug.dependant(this, i);
-                const val = debug.reactive(this[i]);
-                if (predicate.call(thisArg, val, i, this)) {
-                    return val;
-                }
+            entries() {
+                proxy.dependant(this, proxy.keysOf);
+                return makeReactiveEntriesIterator(super.entries());
+            }
+            every(predicate, thisArg) {
+                return super.every((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+            }
+            fill(value, start, end) {
+                return super.fill(proxy.unwrap(value), start, end);
+            }
+            copyWithin(target, start, end) {
+                return super.copyWithin(target, start, end);
+            }
+            filter(predicate, thisArg) {
+                return proxy.reactive(super.filter((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
+            }
+            find(predicate, thisArg) {
+                return proxy.reactive(super.find((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
+            }
+            findIndex(predicate, thisArg) {
+                return super.findIndex((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+            }
+            findLast(predicate, thisArg) {
+                return proxy.reactive(super.findLast((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
+            }
+            findLastIndex(predicate, thisArg) {
+                return super.findLastIndex((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+            }
+            flat(depth) {
+                return proxy.reactive(super.flat(depth));
+            }
+            flatMap(callbackfn, thisArg) {
+                return proxy.reactive(super.flatMap((v, i, a) => proxy.unwrap(callbackfn.call(thisArg, proxy.reactive(v), i, a)), thisArg));
+            }
+            forEach(callbackfn, thisArg) {
+                super.forEach((v, i, a) => {
+                    callbackfn.call(thisArg, proxy.reactive(v), i, a);
+                }, thisArg);
+            }
+            includes(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.includes(proxy.unwrap(searchElement), fromIndex)
+                    : super.includes(proxy.unwrap(searchElement));
+            }
+            indexOf(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.indexOf(proxy.unwrap(searchElement), fromIndex)
+                    : super.indexOf(proxy.unwrap(searchElement));
+            }
+            join(separator) {
+                return super.join(separator);
+            }
+            keys() {
+                proxy.dependant(this, 'length');
+                return super.keys();
+            }
+            lastIndexOf(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.lastIndexOf(proxy.unwrap(searchElement), fromIndex)
+                    : super.lastIndexOf(proxy.unwrap(searchElement));
+            }
+            map(callbackfn, thisArg) {
+                return proxy.reactive(super.map((v, i, a) => proxy.unwrap(callbackfn.call(thisArg, proxy.reactive(v), i, a)), thisArg));
+            }
+            pop() {
+                return proxy.reactive(super.pop());
+            }
+            push(...items) {
+                return super.push(...items.map(proxy.unwrap));
+            }
+            reduce(callbackfn, initialValue) {
+                return proxy.reactive(arguments.length > 1
+                    ? super.reduce((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a)), initialValue)
+                    : super.reduce((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a))));
+            }
+            reduceRight(callbackfn, initialValue) {
+                return proxy.reactive(arguments.length > 1
+                    ? super.reduceRight((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a)), initialValue)
+                    : super.reduceRight((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a))));
+            }
+            reverse() {
+                return proxy.reactive(super.reverse());
+            }
+            shift() {
+                return proxy.reactive(super.shift());
+            }
+            slice(start, end) {
+                return proxy.reactive(super.slice(start, end));
             }
-            debug.dependant(this, 'length');
-            return undefined;
-        }
-        const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
-        const index = this.indexOf(predicateOrElement, fromIndex);
-        if (index === -1)
-            return undefined;
-        return debug.reactive(this[index]);
-    }
-    findIndex(predicateOrElement, thisArg) {
-        if (typeof predicateOrElement === 'function') {
-            const predicate = predicateOrElement;
-            const length = this.length;
-            for (let i = 0; i < length; i++) {
-                debug.dependant(this, i);
-                const val = debug.reactive(this[i]);
-                if (predicate.call(thisArg, val, i, this)) {
-                    return i;
-                }
+            some(predicate, thisArg) {
+                return super.some((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
             }
-            debug.dependant(this, 'length');
-            return -1;
-        }
-        const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
-        return this.indexOf(predicateOrElement, fromIndex);
-    }
-    flat(depth) {
-        debug.dependant(this);
-        return debug.reactive(depth === undefined ? this.flat() : this.flat(depth));
-    }
-    flatMap(callbackfn, thisArg) {
-        debug.dependant(this);
-        return debug.reactive(this.flatMap((item, index, array) => callbackfn.call(thisArg, debug.reactive(item), index, array), thisArg));
-    }
-    filter(callbackfn, thisArg) {
-        debug.dependant(this);
-        return debug.reactive(this.filter((item, index, array) => callbackfn(debug.reactive(item), index, array), thisArg));
-    }
-    map(callbackfn, thisArg) {
-        debug.dependant(this);
-        return debug.reactive(this.map((item, index, array) => callbackfn(debug.reactive(item), index, array), thisArg));
-    }
-    reduce(callbackfn, initialValue) {
-        debug.dependant(this);
-        const result = initialValue === undefined
-            ? this.reduce(callbackfn)
-            : this.reduce(callbackfn, initialValue);
-        return debug.reactive(result);
-    }
-    reduceRight(callbackfn, initialValue) {
-        debug.dependant(this);
-        const result = initialValue !== undefined
-            ? this.reduceRight(callbackfn, initialValue)
-            : this.reduceRight(callbackfn);
-        return debug.reactive(result);
-    }
-    slice(start, end) {
-        for (const i of range(start || 0, end || this.length - 1))
-            debug.dependant(this, i);
-        return start === undefined
-            ? this.slice()
-            : end === undefined
-                ? this.slice(start)
-                : this.slice(start, end);
-    }
-    concat(...items) {
-        debug.dependant(this);
-        return debug.reactive(this.concat(...items));
-    }
-    join(separator) {
-        debug.dependant(this);
-        return this.join(separator);
-    }
-    forEach(callbackfn, thisArg) {
-        debug.dependant(this);
-        this.forEach((value, index, array) => {
-            callbackfn.call(thisArg, debug.reactive(value), index, array);
-        });
-    }
-    every(callbackfn, thisArg) {
-        const length = this.length;
-        for (let i = 0; i < length; i++) {
-            debug.dependant(this, i);
-            if (!callbackfn.call(thisArg, debug.reactive(this[i]), i, this)) {
-                return false;
+            sort(compareFn) {
+                const wrappedCompare = compareFn
+                    ? (a, b) => compareFn(proxy.reactive(a), proxy.reactive(b))
+                    : undefined;
+                return super.sort(wrappedCompare);
             }
-        }
-        debug.dependant(this, 'length');
-        return true;
-    }
-    some(callbackfn, thisArg) {
-        const length = this.length;
-        for (let i = 0; i < length; i++) {
-            debug.dependant(this, i);
-            if (callbackfn.call(thisArg, debug.reactive(this[i]), i, this)) {
-                return true;
+            splice(start, deleteCount, ...items) {
+                if (arguments.length > 2)
+                    return proxy.reactive(super.splice(start, deleteCount, ...items.map(proxy.unwrap)));
+                if (arguments.length === 2)
+                    return proxy.reactive(super.splice(start, deleteCount));
+                if (arguments.length === 1)
+                    return proxy.reactive(super.splice(start));
+                return proxy.reactive([]);
             }
-        }
-        debug.dependant(this, 'length');
-        return false;
-    }
-    // Side-effectful
-    push(...items) {
-        const oldLength = this.length;
-        try {
-            return this.push(...items);
-        }
-        finally {
-            debug.touched(this, { type: 'bunch', method: 'push' }, range(oldLength, oldLength + items.length - 1, { length: true }));
-        }
-    }
-    pop() {
-        if (this.length === 0)
-            return undefined;
-        try {
-            return debug.reactive(this.pop());
-        }
-        finally {
-            debug.touched(this, { type: 'bunch', method: 'pop' }, index(this.length));
-        }
-    }
-    shift() {
-        if (this.length === 0)
-            return undefined;
-        try {
-            return debug.reactive(this.shift());
-        }
-        finally {
-            debug.touched(this, { type: 'bunch', method: 'shift' }, range(0, this.length + 1, { length: true }));
-        }
-    }
-    unshift(...items) {
-        try {
-            return this.unshift(...items);
-        }
-        finally {
-            debug.touched(this, { type: 'bunch', method: 'unshift' }, range(0, this.length - items.length, { length: true }));
-        }
-    }
-    splice(start, deleteCount, ...items) {
-        const oldLength = this.length;
-        // Normalize start index
-        let actualStart = start;
-        if (actualStart < 0)
-            actualStart = Math.max(oldLength + actualStart, 0);
-        else
-            actualStart = Math.min(actualStart, oldLength);
-        // Normalize deleteCount
-        let actualDeleteCount = deleteCount;
-        if (actualDeleteCount === undefined) {
-            actualDeleteCount = oldLength - actualStart;
-        }
-        else {
-            actualDeleteCount = Math.max(0, Math.min(actualDeleteCount, oldLength - actualStart));
-        }
-        try {
-            if (deleteCount === undefined)
-                return debug.reactive(this.splice(start));
-            return debug.reactive(this.splice(start, deleteCount, ...items));
-        }
-        finally {
-            debug.touched(this, { type: 'bunch', method: 'splice' }, actualDeleteCount === items.length
-                ? range(actualStart, actualStart + actualDeleteCount - 1)
-                : range(actualStart, oldLength + Math.max(items.length - actualDeleteCount, 0), {
-                    length: true,
-                }));
-        }
-    }
-    reverse() {
-        try {
-            return this.reverse();
-        }
-        finally {
-            debug.touched(this, { type: 'bunch', method: 'reverse' }, range(0, this.length - 1));
-        }
-    }
-    sort(compareFn) {
-        compareFn = compareFn || ((a, b) => a.toString().localeCompare(b.toString()));
-        try {
-            return this.sort((a, b) => compareFn(debug.reactive(a), debug.reactive(b)));
-        }
-        finally {
-            debug.touched(this, { type: 'bunch', method: 'sort' }, range(0, this.length - 1));
-        }
-    }
-    fill(value, start, end) {
-        const len = this.length;
-        let k = start === undefined ? 0 : start;
-        if (k < 0)
-            k = Math.max(len + k, 0);
-        else
-            k = Math.min(k, len);
-        let final = end === undefined ? len : end;
-        if (final < 0)
-            final = Math.max(len + final, 0);
-        else
-            final = Math.min(final, len);
-        try {
-            if (start === undefined)
-                return this.fill(value);
-            if (end === undefined)
-                return this.fill(value, start);
-            return this.fill(value, start, end);
-        }
-        finally {
-            if (final > k) {
-                debug.touched(this, { type: 'bunch', method: 'fill' }, range(k, final - 1));
+            unshift(...items) {
+                return super.unshift(...items.map(proxy.unwrap));
             }
-        }
-    }
-    copyWithin(target, start, end) {
-        try {
-            if (end === undefined)
-                return this.copyWithin(target, start);
-            return this.copyWithin(target, start, end);
-        }
-        finally {
-            const len = this.length;
-            let to = target;
-            if (to < 0)
-                to = Math.max(len + to, 0);
-            else if (to >= len)
-                to = len;
-            let from = start;
-            if (from < 0)
-                from = Math.max(len + from, 0);
-            else if (from >= len)
-                from = len;
-            let final = end === undefined ? len : end;
-            if (final < 0)
-                final = Math.max(len + final, 0);
-            else if (final >= len)
-                final = len;
-            const count = Math.min(final - from, len - to);
-            if (count > 0) {
-                debug.touched(this, { type: 'bunch', method: 'copyWithin' }, range(to, to + count - 1));
+            values() {
+                proxy.dependant(this, proxy.keysOf);
+                return makeReactiveIterator(super.values());
             }
-        }
-    }
-}
+            [(_fill_decorators = [proxy.atomic], _copyWithin_decorators = [proxy.atomic], _pop_decorators = [proxy.atomic], _push_decorators = [proxy.atomic], _reverse_decorators = [proxy.atomic], _shift_decorators = [proxy.atomic], _sort_decorators = [proxy.atomic], _splice_decorators = [proxy.atomic], _unshift_decorators = [proxy.atomic], Symbol.iterator)]() {
+                proxy.dependant(this, proxy.keysOf);
+                return makeReactiveIterator(super[Symbol.iterator]());
+            }
+            toReversed() {
+                return proxy.reactive(super.toReversed());
+            }
+            toSorted(compareFn) {
+                const wrappedCompare = compareFn
+                    ? (a, b) => compareFn(proxy.reactive(a), proxy.reactive(b))
+                    : undefined;
+                return proxy.reactive(super.toSorted(wrappedCompare));
+            }
+            toSpliced(start, deleteCount, ...items) {
+                if (arguments.length > 2)
+                    return proxy.reactive(super.toSpliced(start, deleteCount, ...items.map(proxy.unwrap)));
+                if (arguments.length === 2)
+                    return proxy.reactive(super.toSpliced(start, deleteCount));
+                if (arguments.length === 1)
+                    return proxy.reactive(super.toSpliced(start));
+                return proxy.reactive([...this]);
+            }
+            with(index, value) {
+                return proxy.reactive(super.with(index, proxy.unwrap(value)));
+            }
+            constructor() {
+                super(...arguments);
+                proxy.__runInitializers(this, _instanceExtraInitializers);
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            proxy.__esDecorate(_a, null, _fill_decorators, { kind: "method", name: "fill", static: false, private: false, access: { has: obj => "fill" in obj, get: obj => obj.fill }, metadata: _metadata }, null, _instanceExtraInitializers);
+            proxy.__esDecorate(_a, null, _copyWithin_decorators, { kind: "method", name: "copyWithin", static: false, private: false, access: { has: obj => "copyWithin" in obj, get: obj => obj.copyWithin }, metadata: _metadata }, null, _instanceExtraInitializers);
+            proxy.__esDecorate(_a, null, _pop_decorators, { kind: "method", name: "pop", static: false, private: false, access: { has: obj => "pop" in obj, get: obj => obj.pop }, metadata: _metadata }, null, _instanceExtraInitializers);
+            proxy.__esDecorate(_a, null, _push_decorators, { kind: "method", name: "push", static: false, private: false, access: { has: obj => "push" in obj, get: obj => obj.push }, metadata: _metadata }, null, _instanceExtraInitializers);
+            proxy.__esDecorate(_a, null, _reverse_decorators, { kind: "method", name: "reverse", static: false, private: false, access: { has: obj => "reverse" in obj, get: obj => obj.reverse }, metadata: _metadata }, null, _instanceExtraInitializers);
+            proxy.__esDecorate(_a, null, _shift_decorators, { kind: "method", name: "shift", static: false, private: false, access: { has: obj => "shift" in obj, get: obj => obj.shift }, metadata: _metadata }, null, _instanceExtraInitializers);
+            proxy.__esDecorate(_a, null, _sort_decorators, { kind: "method", name: "sort", static: false, private: false, access: { has: obj => "sort" in obj, get: obj => obj.sort }, metadata: _metadata }, null, _instanceExtraInitializers);
+            proxy.__esDecorate(_a, null, _splice_decorators, { kind: "method", name: "splice", static: false, private: false, access: { has: obj => "splice" in obj, get: obj => obj.splice }, metadata: _metadata }, null, _instanceExtraInitializers);
+            proxy.__esDecorate(_a, null, _unshift_decorators, { kind: "method", name: "unshift", static: false, private: false, access: { has: obj => "unshift" in obj, get: obj => obj.unshift }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
 
 /**
  * Reactive wrapper around JavaScript's WeakMap class
@@ -2508,26 +2076,26 @@ class ReactiveWeakMap extends WeakMap {
     // Implement WeakMap interface methods with reactivity
     delete(key) {
         const hadKey = this.has(key);
-        const result = this.delete(key);
+        const result = super.delete(key);
         if (hadKey)
-            debug.touched1(debug.contentRef(this), { type: 'del', prop: key }, key);
+            proxy.touched1(proxy.contentRef(this), { type: 'del', prop: key }, key);
         return result;
     }
     get(key) {
-        debug.dependant(debug.contentRef(this), key);
-        return debug.reactive(this.get(key));
+        proxy.dependant(proxy.contentRef(this), key);
+        return proxy.reactive(super.get(key));
     }
     has(key) {
-        debug.dependant(debug.contentRef(this), key);
-        return this.has(key);
+        proxy.dependant(proxy.contentRef(this), key);
+        return super.has(key);
     }
     set(key, value) {
         const hadKey = this.has(key);
         const oldValue = this.get(key);
-        const reactiveValue = debug.reactive(value);
+        const reactiveValue = proxy.reactive(value);
         this.set(key, reactiveValue);
         if (!hadKey || oldValue !== reactiveValue) {
-            debug.notifyPropertyChange(debug.contentRef(this), key, oldValue, reactiveValue, hadKey);
+            proxy.notifyPropertyChange(proxy.contentRef(this), key, oldValue, reactiveValue, hadKey);
         }
         return this;
     }
@@ -2539,37 +2107,39 @@ class ReactiveWeakMap extends WeakMap {
 class ReactiveMap extends Map {
     // Implement Map interface methods with reactivity
     get size() {
-        debug.dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
-        return this.size;
+        proxy.dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
+        return super.size;
     }
     clear() {
         const hadEntries = this.size > 0;
-        this.clear();
+        super.clear();
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
             // Clear triggers all effects since all keys are affected
-            debug.touched1(this, evolution, 'size');
-            debug.touched(debug.contentRef(this), evolution);
+            proxy.batch(() => {
+                proxy.touched1(this, evolution, 'size');
+                proxy.touched(proxy.contentRef(this), evolution);
+            });
         }
     }
     entries() {
-        debug.dependant(debug.contentRef(this));
+        proxy.dependant(proxy.contentRef(this));
         return makeReactiveEntriesIterator(this.entries());
     }
     forEach(callbackfn, thisArg) {
-        debug.dependant(debug.contentRef(this));
+        proxy.dependant(proxy.contentRef(this));
         this.forEach(callbackfn, thisArg);
     }
     keys() {
-        debug.dependant(debug.contentRef(this));
+        proxy.dependant(proxy.contentRef(this), proxy.keysOf);
         return this.keys();
     }
     values() {
-        debug.dependant(debug.contentRef(this));
+        proxy.dependant(proxy.contentRef(this));
         return makeReactiveIterator(this.values());
     }
     [Symbol.iterator]() {
-        debug.dependant(debug.contentRef(this));
+        proxy.dependant(proxy.contentRef(this));
         const it = Map.prototype[Symbol.iterator].call(this);
         const nativeNext = it.next.bind(it);
         it.next = () => {
@@ -2577,39 +2147,43 @@ class ReactiveMap extends Map {
             if (result.done)
                 return result;
             const [key, value] = result.value;
-            return { value: [debug.reactive(key), debug.reactive(value)], done: false };
+            return { value: [proxy.reactive(key), proxy.reactive(value)], done: false };
         };
         return it;
     }
     // Implement Map methods with reactivity
     delete(key) {
         const hadKey = this.has(key);
-        const result = this.delete(key);
+        const result = super.delete(key);
         if (hadKey) {
             const evolution = { type: 'del', prop: key };
-            debug.touched1(debug.contentRef(this), evolution, key);
-            debug.touched1(this, evolution, 'size');
+            proxy.batch(() => {
+                proxy.touched1(proxy.contentRef(this), evolution, key);
+                proxy.touched1(this, evolution, 'size');
+            });
         }
         return result;
     }
     get(key) {
-        debug.dependant(debug.contentRef(this), key);
-        return debug.reactive(this.get(key));
+        proxy.dependant(proxy.contentRef(this), key);
+        return proxy.reactive(super.get(key));
     }
     has(key) {
-        debug.dependant(debug.contentRef(this), key);
-        return this.has(key);
+        proxy.dependant(proxy.contentRef(this), key);
+        return super.has(key);
     }
     set(key, value) {
         const hadKey = this.has(key);
         const oldValue = this.get(key);
-        const reactiveValue = debug.reactive(value);
-        this.set(key, reactiveValue);
+        const reactiveValue = proxy.reactive(value);
+        super.set(key, reactiveValue);
         if (!hadKey || oldValue !== reactiveValue) {
-            debug.notifyPropertyChange(debug.contentRef(this), key, oldValue, reactiveValue, hadKey);
-            // Also notify size change for Map (WeakMap doesn't track size)
-            const evolution = { type: hadKey ? 'set' : 'add', prop: key };
-            debug.touched1(this, evolution, 'size');
+            proxy.batch(() => {
+                proxy.notifyPropertyChange(proxy.contentRef(this), key, oldValue, reactiveValue, hadKey);
+                // Also notify size change for Map (WeakMap doesn't track size)
+                const evolution = { type: hadKey ? 'set' : 'add', prop: key };
+                proxy.touched1(this, evolution, 'size');
+            });
         }
         return this;
     }
@@ -2622,24 +2196,24 @@ class ReactiveMap extends Map {
 class ReactiveWeakSet extends WeakSet {
     add(value) {
         const had = this.has(value);
-        this.add(value);
+        super.add(value);
         if (!had) {
             // touch the specific value and the collection view
-            debug.touched1(debug.contentRef(this), { type: 'add', prop: value }, value);
+            proxy.touched1(proxy.contentRef(this), { type: 'add', prop: value }, value);
             // no size/allProps for WeakSet
         }
         return this;
     }
     delete(value) {
         const had = this.has(value);
-        const res = this.delete(value);
+        const res = super.delete(value);
         if (had)
-            debug.touched1(debug.contentRef(this), { type: 'del', prop: value }, value);
+            proxy.touched1(proxy.contentRef(this), { type: 'del', prop: value }, value);
         return res;
     }
     has(value) {
-        debug.dependant(debug.contentRef(this), value);
-        return this.has(value);
+        proxy.dependant(proxy.contentRef(this), value);
+        return super.has(value);
     }
 }
 /**
@@ -2649,93 +2223,99 @@ class ReactiveWeakSet extends WeakSet {
 class ReactiveSet extends Set {
     get size() {
         // size depends on the wrapper instance, like Map counterpart
-        debug.dependant(this, 'size');
+        proxy.dependant(this, 'size');
         return this.size;
     }
     add(value) {
         const had = this.has(value);
-        const reactiveValue = debug.reactive(value);
-        this.add(reactiveValue);
+        const reactiveValue = proxy.reactive(value);
+        super.add(reactiveValue);
         if (!had) {
             const evolution = { type: 'add', prop: reactiveValue };
             // touch for value-specific and aggregate dependencies
-            debug.touched1(debug.contentRef(this), evolution, reactiveValue);
-            debug.touched1(this, evolution, 'size');
+            proxy.batch(() => {
+                proxy.touched1(proxy.contentRef(this), evolution, reactiveValue);
+                proxy.touched1(this, evolution, 'size');
+            });
         }
         return this;
     }
     clear() {
         const hadEntries = this.size > 0;
-        this.clear();
+        super.clear();
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
-            debug.touched1(this, evolution, 'size');
-            debug.touched(debug.contentRef(this), evolution);
+            proxy.batch(() => {
+                proxy.touched1(this, evolution, 'size');
+                proxy.touched(proxy.contentRef(this), evolution);
+            });
         }
     }
     delete(value) {
         const had = this.has(value);
-        const res = this.delete(value);
+        const res = super.delete(value);
         if (had) {
             const evolution = { type: 'del', prop: value };
-            debug.touched1(debug.contentRef(this), evolution, value);
-            debug.touched1(this, evolution, 'size');
+            proxy.batch(() => {
+                proxy.touched1(proxy.contentRef(this), evolution, value);
+                proxy.touched1(this, evolution, 'size');
+            });
         }
         return res;
     }
     has(value) {
-        debug.dependant(debug.contentRef(this), value);
+        proxy.dependant(proxy.contentRef(this), value);
         return this.has(value);
     }
     entries() {
-        debug.dependant(debug.contentRef(this));
+        proxy.dependant(proxy.contentRef(this));
         return makeReactiveEntriesIterator(this.entries());
     }
     forEach(callbackfn, thisArg) {
-        debug.dependant(debug.contentRef(this));
+        proxy.dependant(proxy.contentRef(this));
         this.forEach(callbackfn, thisArg);
     }
     keys() {
-        debug.dependant(debug.contentRef(this));
+        proxy.dependant(proxy.contentRef(this));
         return makeReactiveIterator(this.keys());
     }
     values() {
-        debug.dependant(debug.contentRef(this));
+        proxy.dependant(proxy.contentRef(this));
         return makeReactiveIterator(this.values());
     }
     [Symbol.iterator]() {
-        debug.dependant(debug.contentRef(this));
+        proxy.dependant(proxy.contentRef(this));
         const it = Set.prototype[Symbol.iterator].call(this);
         const nativeNext = it.next.bind(it);
         it.next = () => {
             const result = nativeNext();
             if (result.done)
                 return result;
-            return { value: debug.reactive(result.value), done: false };
+            return { value: proxy.reactive(result.value), done: false };
         };
         return it;
     }
 }
 
 // Register native collection types to use specialized reactive wrappers
-debug.metaProtos.set(Array, ReactiveArray.prototype);
-debug.metaProtos.set(Set, ReactiveSet.prototype);
-debug.metaProtos.set(WeakSet, ReactiveWeakSet.prototype);
-debug.metaProtos.set(Map, ReactiveMap.prototype);
-debug.metaProtos.set(WeakMap, ReactiveWeakMap.prototype);
+proxy.metaProtos.set(Array, ReactiveArray.prototype);
+proxy.metaProtos.set(Set, ReactiveSet.prototype);
+proxy.metaProtos.set(WeakSet, ReactiveWeakSet.prototype);
+proxy.metaProtos.set(Map, ReactiveMap.prototype);
+proxy.metaProtos.set(WeakMap, ReactiveWeakMap.prototype);
+proxy.wrapProtos.set(Array, ReactiveArrayWrapper.prototype);
 /**
  * Object containing internal reactive system state for debugging and profiling
  */
 const profileInfo = {
-    objectToProxy: debug.objectToProxy,
-    proxyToObject: debug.proxyToObject,
-    effectToReactiveObjects: debug.effectToReactiveObjects,
-    watchers: debug.watchers,
-    objectParents: debug.objectParents,
-    objectsWithDeepWatchers: debug.objectsWithDeepWatchers,
-    deepWatchers: debug.deepWatchers,
-    effectToDeepWatchedObjects: debug.effectToDeepWatchedObjects,
-    nonReactiveObjects: debug.nonReactiveObjects,
+    objectToProxy: proxy.objectToProxy,
+    proxyToObject: proxy.proxyToObject,
+    effectToReactiveObjects: proxy.effectToReactiveObjects,
+    watchers: proxy.watchers,
+    objectParents: proxy.objectParents,
+    objectsWithDeepWatchers: proxy.objectsWithDeepWatchers,
+    deepWatchers: proxy.deepWatchers,
+    effectToDeepWatchedObjects: proxy.effectToDeepWatchedObjects,
 };
 
 // In order to avoid async re-entrance, we could use zone.js or something like that.
@@ -2744,7 +2324,7 @@ const syncCalculating = [];
  * Decorator that caches the result of a getter method and only recomputes when dependencies change
  * Prevents circular dependencies and provides automatic cache invalidation
  */
-const cached = debug.decorator({
+const cached = proxy.decorator({
     getter(original, _target, propertyKey) {
         return function () {
             const alreadyCalculating = syncCalculating.findIndex((c) => c.object === this && c.prop === propertyKey);
@@ -2788,7 +2368,7 @@ function cache(object, propertyKey, value) {
  * @param descriptor - The descriptor properties to apply
  * @returns A class decorator that applies the descriptor to specified properties
  */
-const descriptor = debug.flavored(function descriptor(descriptor) {
+const descriptor = proxy.flavored(function descriptor(descriptor) {
     return (...properties) => (Base) => {
         return class extends Base {
             constructor(...args) {
@@ -2842,7 +2422,7 @@ const descriptor = debug.flavored(function descriptor(descriptor) {
  * Decorator that marks methods, properties, or classes as deprecated
  * Provides warning messages when deprecated items are used
  */
-const deprecated = Object.assign(debug.decorator({
+const deprecated = Object.assign(proxy.decorator({
     method(original, _target, propertyKey) {
         return function (...args) {
             deprecated.warn(this, propertyKey);
@@ -2870,7 +2450,7 @@ const deprecated = Object.assign(debug.decorator({
         };
     },
     default(message) {
-        return debug.decorator({
+        return proxy.decorator({
             method(original, _target, propertyKey) {
                 return function (...args) {
                     deprecated.warn(this, propertyKey, message);
@@ -2901,8 +2481,7 @@ const deprecated = Object.assign(debug.decorator({
     },
 }), {
     warn: (target, propertyKey, message) => {
-        // biome-ignore lint/suspicious/noConsole: To be overridden
-        console.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
+        proxy.options.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
     },
 });
 /**
@@ -2911,7 +2490,7 @@ const deprecated = Object.assign(debug.decorator({
  * @returns A method decorator that debounces method calls
  */
 function debounce(delay) {
-    return debug.decorator({
+    return proxy.decorator({
         method(original, _target, _propertyKey) {
             let timeoutId = null;
             return function (...args) {
@@ -2934,7 +2513,7 @@ function debounce(delay) {
  * @returns A method decorator that throttles method calls
  */
 function throttle(delay) {
-    return debug.decorator({
+    return proxy.decorator({
         method(original, _target, _propertyKey) {
             let lastCallTime = 0;
             let timeoutId = null;
@@ -2965,12 +2544,11 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.9";
+var version$1 = "1.0.11";
 var pkg = {
 	version: version$1};
 
 const { version } = pkg;
-// Singleton verification
 const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
 const globalScope = (typeof globalThis !== 'undefined'
     ? globalThis
@@ -2980,27 +2558,16 @@ const globalScope = (typeof globalThis !== 'undefined'
             ? global
             : false);
 if (globalScope) {
-    // Detect the source of this instance safely across different environments
     let source = 'mutts/index';
-    const viteEval = eval;
     try {
         if (typeof __filename !== 'undefined')
             source = __filename;
-        else {
-            // Using eval to avoid SyntaxError in CJS environments where import.meta is not allowed
-            const meta = viteEval('import.meta');
-            if (meta && meta.url)
-                source = meta.url;
+        else if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('browser.cjs', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('browser.cjs', document.baseURI).href))) {
+            source = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('browser.cjs', document.baseURI).href));
         }
     }
-    catch (e) {
-        // Fallback for environments where neither is available or accessible
-    }
-    const currentSourceInfo = {
-        version,
-        source,
-        timestamp: Date.now(),
-    };
+    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` +
@@ -3013,63 +2580,70 @@ if (globalScope) {
     globalScope[GLOBAL_MUTTS_KEY] = currentSourceInfo;
 }
 
-exports.AZone = debug.AZone;
-exports.DecoratorError = debug.DecoratorError;
-exports.FoolProof = debug.FoolProof;
-exports.IterableWeakMap = debug.IterableWeakMap;
-exports.IterableWeakSet = debug.IterableWeakSet;
-exports.ReactiveBase = debug.ReactiveBase;
-exports.ReactiveError = debug.ReactiveError;
+exports.AZone = proxy.AZone;
+exports.DecoratorError = proxy.DecoratorError;
+exports.IterableWeakMap = proxy.IterableWeakMap;
+exports.IterableWeakSet = proxy.IterableWeakSet;
+exports.ReactiveBase = proxy.ReactiveBase;
+exports.ReactiveError = proxy.ReactiveError;
 Object.defineProperty(exports, "ReactiveErrorCode", {
 	enumerable: true,
-	get: function () { return debug.ReactiveErrorCode; }
+	get: function () { return proxy.ReactiveErrorCode; }
 });
-exports.Zone = debug.Zone;
-exports.ZoneAggregator = debug.ZoneAggregator;
-exports.ZoneHistory = debug.ZoneHistory;
-exports.addBatchCleanup = debug.addBatchCleanup;
-exports.arrayEquals = debug.arrayEquals;
-exports.asyncZone = debug.asyncZone;
-exports.atomic = debug.atomic;
-exports.biDi = debug.biDi;
-exports.cleanedBy = debug.cleanedBy;
-exports.cleanup = debug.cleanup;
-exports.contentRef = debug.contentRef;
-exports.createFlavor = debug.createFlavor;
-exports.decorator = debug.decorator;
-exports.deepCompare = debug.deepCompare;
-exports.defer = debug.defer;
-exports.derived = debug.derived;
-exports.effect = debug.effect;
-exports.effectAggregator = debug.effectAggregator;
-exports.flavorOptions = debug.flavorOptions;
-exports.flavored = debug.flavored;
-exports.getActivationLog = debug.getActivationLog;
-exports.getActiveEffect = debug.getActiveEffect;
-exports.getState = debug.getState;
-exports.immutables = debug.immutables;
-exports.isConstructor = debug.isConstructor;
-exports.isNonReactive = debug.isNonReactive;
-exports.isOwnAccessor = debug.isOwnAccessor;
-exports.isReactive = debug.isReactive;
-exports.legacyDecorator = debug.legacyDecorator;
-exports.mixin = debug.mixin;
-exports.modernDecorator = debug.modernDecorator;
-exports.named = debug.named;
-exports.onEffectThrow = debug.onEffectThrow;
-exports.onEffectTrigger = debug.onEffectTrigger;
-exports.reactive = debug.reactive;
-exports.reactiveOptions = debug.options;
-exports.registerNativeReactivity = debug.registerNativeReactivity;
-exports.renamed = debug.renamed;
-exports.reset = debug.reset;
-exports.root = debug.root;
-exports.tag = debug.tag;
-exports.touched = debug.touched;
-exports.touched1 = debug.touched1;
-exports.untracked = debug.untracked;
-exports.unwrap = debug.unwrap;
-exports.zip = debug.zip;
+exports.Zone = proxy.Zone;
+exports.ZoneAggregator = proxy.ZoneAggregator;
+exports.ZoneHistory = proxy.ZoneHistory;
+exports.addBatchCleanup = proxy.addBatchCleanup;
+exports.addUnreactiveProps = proxy.addUnreactiveProps;
+exports.arrayEquals = proxy.arrayEquals;
+exports.assertUntracked = proxy.assertUntracked;
+exports.asyncZone = proxy.asyncZone;
+exports.atom = proxy.atom;
+exports.atomic = proxy.atomic;
+exports.biDi = proxy.biDi;
+exports.captured = proxy.captured;
+exports.caught = proxy.caught;
+exports.createFlavor = proxy.createFlavor;
+exports.debugPreset = proxy.debugPreset;
+exports.decorator = proxy.decorator;
+exports.deepCompare = proxy.deepCompare;
+exports.defer = proxy.defer;
+exports.devPreset = proxy.devPreset;
+exports.effect = proxy.effect;
+exports.effectAggregator = proxy.effectAggregator;
+exports.flavorOptions = proxy.flavorOptions;
+exports.flavored = proxy.flavored;
+exports.formatCleanupReason = proxy.formatCleanupReason;
+exports.getActivationLog = proxy.getActivationLog;
+exports.getActiveEffect = proxy.getActiveEffect;
+exports.getState = proxy.getState;
+exports.isConstructor = proxy.isConstructor;
+exports.isDev = proxy.isDev;
+exports.isNonReactive = proxy.isNonReactive;
+exports.isObject = proxy.isObject;
+exports.isProd = proxy.isProd;
+exports.isReactive = proxy.isReactive;
+exports.isTest = proxy.isTest;
+exports.legacyDecorator = proxy.legacyDecorator;
+exports.link = proxy.link;
+exports.mixin = proxy.mixin;
+exports.modernDecorator = proxy.modernDecorator;
+exports.named = proxy.named;
+exports.objectToProxy = proxy.objectToProxy;
+exports.onEffectThrow = proxy.onEffectThrow;
+exports.prodPreset = proxy.prodPreset;
+exports.proxyToObject = proxy.proxyToObject;
+exports.reactive = proxy.reactive;
+exports.reactiveOptions = proxy.options;
+exports.reset = proxy.reset;
+exports.root = proxy.root;
+exports.tag = proxy.tag;
+exports.touched = proxy.touched;
+exports.touched1 = proxy.touched1;
+exports.unlink = proxy.unlink;
+exports.untracked = proxy.untracked;
+exports.unwrap = proxy.unwrap;
+exports.zip = proxy.zip;
 exports.asyncHook = asyncCore.asyncHook;
 exports.asyncHooks = asyncCore.asyncHooks;
 exports.hooks = asyncCore.hooks;
@@ -3078,9 +2652,9 @@ exports.Destroyable = Destroyable;
 exports.DestructionError = DestructionError;
 exports.Eventful = Eventful;
 exports.Indexable = Indexable;
-exports.Register = Register;
 exports.allocated = allocated;
 exports.allocatedValues = allocatedValues;
+exports.arrayDiff = arrayDiff;
 exports.attend = attend;
 exports.cache = cache;
 exports.cached = cached;
@@ -3089,23 +2663,22 @@ exports.chainPromise = chainPromise;
 exports.debounce = debounce;
 exports.deepWatch = deepWatch;
 exports.deprecated = deprecated;
-exports.describe = describe;
 exports.descriptor = descriptor;
 exports.destructor = destructor;
 exports.forwardArray = forwardArray;
-exports.getActiveProjection = getActiveProjection;
 exports.getAt = getAt;
 exports.isCached = isCached;
 exports.lift = lift;
 exports.memoize = memoize;
+exports.morph = morph;
 exports.organize = organize;
 exports.organized = organized;
 exports.profileInfo = profileInfo;
-exports.project = project;
-exports.register = register;
-exports.scan = scan;
+exports.project = morph;
+exports.resource = resource;
 exports.setAt = setAt;
 exports.throttle = throttle;
 exports.unreactive = unreactive;
 exports.watch = watch;
+exports.when = when;
 //# sourceMappingURL=browser.cjs.map