mutts 1.0.9 → 1.0.10

package/dist/browser.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
-require('./chunks/async-browser-lvzLOCgk.cjs');
-var debug = require('./chunks/index-VTO-b2vR.cjs');
+require('./chunks/async-browser-BU_IfxYD.cjs');
+var proxy = require('./chunks/proxy-Dtg-bJ3T.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');
 
 // Integrated with `using` statement via Symbol.dispose
@@ -86,7 +86,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 +111,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');
@@ -613,67 +761,69 @@ function getBranch(tree, key) {
     }
     return branch;
 }
-function memoizeFunction(fn) {
-    const fnRoot = debug.getRoot(fn);
+function memoizeFunction(fn, opts) {
+    const fnRoot = proxy.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))))
+    const memoized = proxy.markWithRoot(function memoized(...args) {
+        if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
+            if (opts?.lenient)
+                return fn.apply(this, args);
             throw new Error('memoize expects non-null object arguments');
+        }
         let node = cacheRoot;
         // Note: decorators add `this` as first argument
-        for (const arg of localArgs) {
+        for (const arg of args) {
             node = getBranch(node, arg);
         }
-        debug.dependant(node, 'memoize');
+        proxy.dependant(node, 'memoize');
         if ('result' in node) {
-            if (debug.options.onMemoizationDiscrepancy) {
-                const wasVerification = debug.options.isVerificationRun;
-                debug.options.isVerificationRun = true;
+            if (proxy.options.onMemoizationDiscrepancy) {
+                const wasVerification = proxy.options.isVerificationRun;
+                proxy.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');
+                    const fresh = proxy.untracked(() => fn.apply(this, args));
+                    if (!proxy.deepCompare(node.result, fresh)) {
+                        proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
                     }
                 }
                 finally {
-                    debug.options.isVerificationRun = wasVerification;
+                    proxy.options.isVerificationRun = wasVerification;
                 }
             }
             return node.result;
         }
         // Create memoize internal effect to track dependencies and invalidate cache
         // Use untracked to prevent the effect creation from being affected by parent effects
-        node.cleanup = debug.root(() => debug.effect(() => {
+        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(...localArgs);
-            return () => {
+            node.result = fn.apply(this, args);
+            return (reason) => {
                 // When dependencies change, clear the cache and notify consumers
                 delete node.result;
-                debug.touched1(node, { type: 'invalidate', prop: localArgs }, 'memoize');
+                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();
+                    node.cleanup({ type: 'invalidate', cause: reason });
                     node.cleanup = undefined;
                 }
             };
         }, { opaque: true }));
-        if (debug.options.onMemoizationDiscrepancy) {
-            const wasVerification = debug.options.isVerificationRun;
-            debug.options.isVerificationRun = true;
+        if (proxy.options.onMemoizationDiscrepancy) {
+            const wasVerification = proxy.options.isVerificationRun;
+            proxy.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');
+                const fresh = proxy.untracked(() => fn.apply(this, args));
+                if (!proxy.deepCompare(node.result, fresh)) {
+                    proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
                 }
             }
             finally {
-                debug.options.isVerificationRun = wasVerification;
+                proxy.options.isVerificationRun = wasVerification;
             }
         }
         return node.result;
@@ -682,6 +832,55 @@ function memoizeFunction(fn) {
     memoizedRegistry.set(memoized, memoized);
     return memoized;
 }
+function memoizeObject(target, opts) {
+    const existing = memoizedRegistry.get(target);
+    if (existing)
+        return existing;
+    const proxy$1 = new Proxy(target, {
+        get(source, prop, receiver) {
+            // 1. Walk prototype chain to find descriptor
+            let current = source;
+            let desc;
+            while (current) {
+                desc = Object.getOwnPropertyDescriptor(current, prop);
+                if (desc)
+                    break;
+                current = Object.getPrototypeOf(current);
+            }
+            if (!desc)
+                return Reflect.get(source, prop, receiver);
+            // 2. If getter, memoize
+            if (desc.get) {
+                const originalGetter = desc.get;
+                let wrapper = wrapperRegistry.get(originalGetter);
+                if (!wrapper) {
+                    wrapper = proxy.markWithRoot(proxy.named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
+                        return originalGetter.call(that);
+                    }), {
+                        propertyKey: prop,
+                    });
+                    const origRoot = originalGetter[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(originalGetter, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, opts);
+                return memoized(receiver);
+            }
+            // 3. Otherwise forward
+            return Reflect.get(source, prop, receiver);
+        },
+        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
+        set(source, prop, value, _receiver) {
+            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
+            // it recognizes itself and triggers change notifications.
+            return Reflect.set(source, prop, value, source);
+        },
+    });
+    proxy.proxyToObject.set(proxy$1, target);
+    memoizedRegistry.set(target, proxy$1);
+    return proxy$1;
+}
 /**
  * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
  *
@@ -705,46 +904,55 @@ function memoizeFunction(fn) {
  * })
  * ```
  */
-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);
-        };
+function makeMemoizeDecorator(memoizeOpts) {
+    return proxy.decorator({
+        getter(original, target, propertyKey) {
+            return function () {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
+                        return original.call(that);
+                    }), {
+                        method: original,
+                        propertyKey,
+                    });
+                    const origRoot = original[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this);
+            };
+        },
+        method(original, target, name) {
+            return function (...args) {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
+                        return original.call(that, ...args);
+                    }), {
+                        method: original,
+                        propertyKey: name,
+                    });
+                    const origRoot = original[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this, ...args);
+            };
+        },
+        default: (target) => typeof target === 'object'
+            ? memoizeObject(target, memoizeOpts)
+            : memoizeFunction(target, memoizeOpts),
+    });
+}
+const memoize = proxy.flavored(makeMemoizeDecorator(), {
+    get lenient() {
+        return makeMemoizeDecorator({ lenient: true });
     },
-    default: memoizeFunction,
 });
 
 function attend(source, callback) {
@@ -758,14 +966,14 @@ function attend(source, callback) {
                     ? () => source.values()
                     : () => Object.keys(source);
     const keyEffects = new Map();
-    const outer = debug.effect(({ ascend }) => {
+    const outer = proxy.effect(({ ascend }) => {
         const keys = new Set();
         for (const key of enumerate())
             keys.add(key);
         for (const key of keys) {
             if (keyEffects.has(key))
                 continue;
-            keyEffects.set(key, ascend(() => debug.effect(() => callback(key))));
+            keyEffects.set(key, ascend(() => proxy.effect(() => callback(key))));
         }
         for (const key of Array.from(keyEffects.keys())) {
             if (!keys.has(key)) {
@@ -774,10 +982,10 @@ function attend(source, callback) {
             }
         }
     });
-    return () => {
-        outer();
+    return (reason) => {
+        outer(reason);
         for (const stop of keyEffects.values())
-            stop();
+            stop(reason);
         keyEffects.clear();
     };
 }
@@ -812,12 +1020,13 @@ function attend(source, callback) {
  * @returns A reactive array of accumulated values, with a [cleanup] property to stop the tracking
  */
 function scan(source, callback, initialValue) {
-    const observedSource = debug.reactive(source);
-    const result = debug.reactive([]);
+    const observedSource = proxy.reactive(source);
+    const rawResult = [];
+    const result = proxy.reactive(rawResult);
     // Track effects for each index to dispose them when the array shrinks
     const indexEffects = new Map();
     // Mapping from index to its current intermediate object
-    const indexToIntermediate = debug.reactive([]);
+    const indexToIntermediate = proxy.reactive([]);
     const intermediaries = new WeakMap();
     let Intermediate = (() => {
         var _a;
@@ -825,7 +1034,7 @@ function scan(source, callback, initialValue) {
         let _get_acc_decorators;
         return _a = class Intermediate {
                 constructor(val, prev) {
-                    this.val = (debug.__runInitializers(this, _instanceExtraInitializers), val);
+                    this.val = (proxy.__runInitializers(this, _instanceExtraInitializers), val);
                     this.prev = prev;
                 }
                 get acc() {
@@ -836,7 +1045,7 @@ function scan(source, callback, initialValue) {
             (() => {
                 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);
+                proxy.__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;
@@ -846,117 +1055,473 @@ function scan(source, callback, initialValue) {
         if (stop) {
             stop();
             indexEffects.delete(index);
-            debug.untracked(() => {
-                Reflect.deleteProperty(indexToIntermediate, index);
-                Reflect.deleteProperty(result, index);
-            });
+            Reflect.deleteProperty(indexToIntermediate, index);
+            Reflect.deleteProperty(result, index);
         }
     }
-    const mainEffect = debug.effect(function scanMainEffect({ ascend }) {
+    const mainEffect = proxy.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;
+        for (let i = 0; i < length; i++)
+            if (i in observedSource) {
+                const val = observedSource[i];
+                if (!(val &&
+                    (typeof val === 'object' || typeof val === 'function' || typeof val === 'symbol'))) {
+                    throw new Error('scan: items must be objects (WeakKey) for intermediate caching');
                 }
-            }
-            // 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(() => {
+                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 = proxy.reactive(new Intermediate(val, prev));
+                    list[count] = intermediate;
+                }
+                else {
+                    // Update the link.
+                    if (proxy.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 = proxy.effect(function scanIndexSyncEffect() {
+                            const inter = indexToIntermediate[index];
+                            if (inter) {
+                                const accValue = inter.acc;
                                 result[index] = accValue;
-                            });
-                        }
+                            }
+                        });
+                        indexEffects.set(index, stop);
                     });
-                    indexEffects.set(index, stop);
-                });
+                }
+                prev = intermediate;
             }
-            prev = intermediate;
-        }
         // Cleanup trailing indices
         for (const index of Array.from(indexEffects.keys())) {
             if (index >= length)
                 disposeIndex(index);
         }
         // Ensure result length matches source length
-        debug.untracked(() => {
-            if (result.length !== length) {
-                debug.FoolProof.set(result, 'length', length, result);
-            }
-        });
+        if (rawResult.length !== length) {
+            proxy.FoolProof.set(result, 'length', length, result);
+        }
     });
-    return debug.cleanedBy(result, (() => {
-        mainEffect();
+    return proxy.cleanedBy(result, ((reason) => {
+        mainEffect(reason);
         for (const stop of indexEffects.values())
-            stop();
+            stop(reason);
         indexEffects.clear();
     }));
 }
 function lift(cb) {
     let result;
-    const liftCleanup = debug.effect((access) => {
+    let rawResult;
+    const liftCleanup = proxy.effect.named('lift')(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) {
-            if (Array.isArray(source)) {
-                result = debug.reactive([]);
+            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;
+            const patches = arrayDiff(res, source);
+            for (let i = patches.length - 1; i >= 0; i--) {
+                const { indexA, sliceA, sliceB } = patches[i];
+                res.splice(indexA, sliceA.length, ...sliceB);
             }
-            else {
-                result = debug.reactive({});
+        }
+        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);
+                }
         }
-        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];
+    }, cb));
+    return proxy.cleanedBy(result, liftCleanup);
+}
+/**
+ * Reactively maps an array source through `fn`, producing a lazy reactive output array.
+ *
+ * Each source item gets its own isolated effect (via `root()`) so that changes to one item
+ * only recompute that item's projection. Structural changes (push, splice, reorder) are detected
+ * via `arrayDiff` and surgically applied to the output cache.
+ *
+ * The source can be a reactive array or a function returning an array. When a function is provided,
+ * the function is re-evaluated inside an effect whenever its dependencies change.
+ *
+ * Output elements are computed lazily — accessing `result[i]` triggers computation if not yet cached.
+ *
+ * @param source - A reactive array or a function returning an array
+ * @param fn - Mapping function applied to each element
+ * @param options - Optional purity hints to skip per-item effects
+ * @returns A readonly reactive array with a `[cleanup]` method to dispose all effects
+ */
+function morphArray(source, fn, options) {
+    if (typeof source !== 'function' && !proxy.isReactive(source) && options?.pure === true) {
+        return source.map(fn);
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = [];
+    let input = [];
+    function stopItem(key) {
+        const entry = itemEffects.get(key);
+        if (entry) {
+            entry.stop({ type: 'stopped' });
+            itemEffects.delete(key);
+        }
+    }
+    function computeItem(key, input) {
+        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(input));
+        if (isPure) {
+            track(() => {
+                cache[key] = fn(input);
+            });
+        }
+        else {
+            const indexRef = { value: key };
+            let stop;
+            track(() => {
+                stop = proxy.effect.opaque(() => {
+                    cache[indexRef.value] = fn(input);
+                    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:array')(({ ascend }) => {
+        track = ascend;
+        const newInput = [...(typeof source === 'function' ? source() : source)];
+        const diffs = arrayDiff(input, newInput).toSorted((a, b) => b.indexA - a.indexA);
+        if (diffs.length > 0) {
+            for (const diff of diffs) {
+                // Stop items in removed range
+                for (let i = diff.indexA; i < diff.indexA + diff.sliceA.length; i++)
+                    stopItem(i);
+                // Shift existing itemEffects in the Map to match the new indices
+                const shift = diff.sliceB.length - diff.sliceA.length;
+                if (shift !== 0) {
+                    // We need to move entries in the Map.
+                    const entries = Array.from(itemEffects.entries()).sort((a, b) => a[0] - b[0]);
+                    // Remove entries that will be shifted
+                    for (const [idx, entry] of entries) {
+                        if (idx >= diff.indexA + diff.sliceA.length) {
+                            itemEffects.delete(idx);
+                        }
+                    }
+                    // Re-add them with shifted indices
+                    for (const [idx, entry] of entries) {
+                        if (idx >= diff.indexA + diff.sliceA.length) {
+                            const newIdx = idx + shift;
+                            entry.index.value = newIdx;
+                            itemEffects.set(newIdx, entry);
+                        }
+                    }
+                }
+                // Splice the cache
+                cache.splice(diff.indexA, diff.sliceA.length, ...new Array(diff.sliceB.length).fill(undefined));
+                // Make holes for lazy computation
+                for (let i = diff.indexA; i < diff.indexA + diff.sliceB.length; i++)
+                    delete cache[i];
+            }
+            const invalidates = new Set([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.cleanedBy(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));
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = new Map();
+    Object.defineProperty(cache, 'constructor', { value: Object, enumerable: false });
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
+        if (stop) {
+            stop({ type: 'stopped' });
+            itemEffects.delete(key);
         }
-        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.set(key, track(() => fn(val)));
         }
         else {
-            throw new Error('lift callback must return the same type as the previous result');
+            const stop = track(() => proxy.effect.opaque(() => {
+                cache.set(key, fn(source.get(key)));
+                return (reason) => {
+                    cache.delete(key);
+                    proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop({ type: 'invalidate', cause: reason });
+                };
+            }));
+            itemEffects.set(key, stop);
+        }
+    }
+    const proxy$1 = proxy.reactive(cache, {
+        get(cache, prop) {
+            if (prop === 'get')
+                return (key) => {
+                    if (!cache.has(key) && source.has(key))
+                        computeItem(key, source.get(key));
+                    return cache.get(key);
+                };
+            if (prop === 'has')
+                return (key) => {
+                    return source.has(key);
+                };
+            if (prop === 'keys')
+                return () => {
+                    return source.keys();
+                };
+            if (prop === 'values')
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield proxy$1.get(key);
+                    }
+                };
+            if (prop === 'entries')
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy$1.get(key)];
+                    }
+                };
+            if (prop === Symbol.iterator)
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy$1.get(key)];
+                    }
+                };
+            return cache[prop];
+        },
+    });
+    let stateSnapshot = proxy.getState(source);
+    const stopMain = proxy.effect.named('morph:map')(({ ascend }) => {
+        track = ascend;
+        proxy.dependant(source, proxy.keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                proxy.touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                cache.delete(evolution.prop);
+                proxy.touched1(cache, evolution, evolution.prop);
+            }
         }
     });
-    return debug.cleanedBy(result, liftCleanup);
+    return proxy.cleanedBy(proxy$1, (reason) => {
+        stopMain(reason);
+        for (const stop of itemEffects.values())
+            stop(reason);
+        itemEffects.clear();
+    });
 }
-
-function isObject(value) {
-    return typeof value === 'object' && value !== null;
+/**
+ * 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]);
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = {};
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
+        if (stop) {
+            stop({ type: 'stopped' });
+            itemEffects.delete(key);
+        }
+    }
+    function computeItem(key, val) {
+        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
+        if (isPure) {
+            cache[key] = track(() => fn(val));
+        }
+        else {
+            const stop = track(() => proxy.effect.opaque(() => {
+                cache[key] = fn(source[key]);
+                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:record')(({ ascend }) => {
+        track = ascend;
+        // Track only structural changes on source
+        proxy.dependant(source, proxy.keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                proxy.touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                delete cache[evolution.prop];
+                proxy.touched1(cache, evolution, evolution.prop);
+            }
+        }
+    });
+    return proxy.cleanedBy(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 });
+    },
+});
+
 /**
  * Deep watch an object and all its nested properties
  * @param target - The object to watch deeply
@@ -977,16 +1542,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(() => {
         // 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,23 +1560,23 @@ 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);
                 }
             }
@@ -1024,7 +1590,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
                     // 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;
+                    const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
                     traverseAndTrack(reactiveValue, depth + 1);
                 }
             }
@@ -1033,7 +1599,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
                 // Access all Set values to register dependencies
                 for (const value of obj) {
                     // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? debug.reactive(value) : value;
+                    const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
                     traverseAndTrack(reactiveValue, depth + 1);
                 }
             }
@@ -1042,7 +1608,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
                 // 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;
+                    const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
                     traverseAndTrack(reactiveValue, depth + 1);
                 }
             }
@@ -1053,64 +1619,138 @@ 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
+ * Organizes a source object's properties into a target object using a callback function.
+ * This creates a reactive mapping between source properties and a target object,
+ * automatically handling property additions, updates, and removals.
+ *
+ * @template Source - The type of the source object
+ * @template Target - The type of the target object (defaults to Record<PropertyKey, any>)
+ *
+ * @param {Source} source - The source object to organize
+ * @param {OrganizedCallback<Source, Target>} apply - Callback function that defines how each source property is mapped to the target
+ * @param {Target} [baseTarget={}] - Optional base target object to use (will be made reactive if not already)
+ *
+ * @returns {OrganizedResult<Target>} The target object with cleanup capability
+ *
+ * @example
+ * // Organize user permissions into role-based access
+ * const user = reactive({ isAdmin: true, canEdit: false });
+ * const permissions = organized(
+ *   user,
+ *   (access, target) => {
+ *     if (access.key === 'isAdmin') {
+ *       target.hasFullAccess = access.value;
+ *     }
+ *     target[`can${access.key.charAt(0).toUpperCase() + access.key.slice(1)}`] = access.value;
+ *   }
+ * );
+ *
+ * @example
+ * // Transform object structure with cleanup
+ * const source = reactive({ firstName: 'John', lastName: 'Doe' });
+ * const formatted = organized(
+ *   source,
+ *   (access, target) => {
+ *     if (access.key === 'firstName' || access.key === 'lastName') {
+ *       target.fullName = `${source.firstName} ${source.lastName}`.trim();
+ *     }
+ *   }
+ * );
+ *
+ * @example
+ * // Using with cleanup in a component
+ * effect(() => {
+ *   const data = fetchData();
+ *   const organizedData = organized(data, (access, target) => {
+ *     // Transform data
+ *   });
+ *
+ *   // The cleanup will be called automatically when the effect is disposed
+ *   return () => organizedData[cleanup]();
+ * });
  */
-function* makeReactiveIterator(iterator) {
-    let result = iterator.next();
-    while (!result.done) {
-        yield debug.reactive(result.value);
-        result = iterator.next();
-    }
+function organized(source, apply, baseTarget = {}) {
+    const observedSource = proxy.reactive(source);
+    const target = proxy.reactive(baseTarget);
+    const stop = attend(() => {
+        const keys = [];
+        for (const key in observedSource)
+            keys.push(key);
+        return keys;
+    }, (key) => {
+        const sourceKey = key;
+        const accessBase = {
+            key: sourceKey,
+            get: () => proxy.FoolProof.get(observedSource, sourceKey, observedSource),
+            set: (value) => proxy.FoolProof.set(observedSource, sourceKey, value, observedSource),
+        };
+        Object.defineProperty(accessBase, 'value', {
+            get: accessBase.get,
+            set: accessBase.set,
+            configurable: true,
+            enumerable: true,
+        });
+        return apply(accessBase, target);
+    });
+    return proxy.cleanedBy(target, (reason) => stop(reason));
 }
 /**
- * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
+ * Organizes a property on a target object
+ * Shortcut for defineProperty/delete with touched signal
+ * @param target - The target object
+ * @param property - The property to organize
+ * @param access - The access object
+ * @returns The property descriptor
  */
-function* makeReactiveEntriesIterator(iterator) {
-    let result = iterator.next();
-    while (!result.done) {
-        const [key, value] = result.value;
-        yield [debug.reactive(key), debug.reactive(value)];
-        result = iterator.next();
-    }
+function organize(target, property, access) {
+    Object.defineProperty(target, property, {
+        get: access.get,
+        set: access.set,
+        configurable: true,
+        enumerable: true,
+    });
+    proxy.touched1(target, { type: 'set', prop: property }, property);
+    return () => delete target[property];
 }
 
 //#region watch
 const unsetYet = Symbol('unset-yet');
-function watch(value, //object | ((dep: DependencyAccess) => object),
+const watch = proxy.flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
 changed, options = {}) {
     return typeof value === 'function'
         ? watchCallBack(value, changed, options)
@@ -1119,12 +1759,19 @@ 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 debug.effect(function watchObjectEffect() {
-        debug.dependant(value);
+    return proxy.effect(function watchObjectEffect() {
+        proxy.dependant(value);
         if (immediate)
             changed(value);
         immediate = true;
@@ -1133,15 +1780,17 @@ function watchObject(value, changed, { immediate = false, deep = false } = {}) {
 function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
     let oldValue = unsetYet;
     let deepCleanup;
-    const cbCleanup = debug.effect(debug.markWithRoot(function watchCallBackEffect(access) {
+    const cbCleanup = proxy.effect(proxy.markWithRoot(function watchCallBackEffect(access) {
         const newValue = value(access);
-        if (oldValue !== newValue)
-            if (oldValue === unsetYet) {
+        if (oldValue !== newValue) {
+            const old = oldValue;
+            if (old === unsetYet) {
                 if (immediate)
-                    changed(newValue);
+                    proxy.untracked(() => changed(newValue));
             }
             else
-                changed(newValue, oldValue);
+                proxy.untracked(() => changed(newValue, old));
+        }
         oldValue = newValue;
         if (deep) {
             if (deepCleanup)
@@ -1154,7 +1803,46 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
         if (deepCleanup)
             deepCleanup();
     }, {
-        [debug.stopped]: { get: () => cbCleanup[debug.stopped] },
+        [proxy.stopped]: { get: () => cbCleanup[proxy.stopped] },
+    });
+}
+//#endregion
+//#region when
+/**
+ * Returns a promise that resolves when the predicate returns a truthy value.
+ * The predicate is evaluated reactively — it re-runs whenever its dependencies change.
+ * @param predicate - Reactive function that returns a value; resolves when truthy
+ * @param timeout - Optional timeout in milliseconds — rejects if condition is not met within this duration
+ * @returns Promise that resolves with the first truthy return value
+ */
+function when(predicate, timeout) {
+    return new Promise((resolve, reject) => {
+        let timer;
+        const stop = proxy.effect(function whenEffect(access) {
+            try {
+                const value = predicate(access);
+                if (value) {
+                    if (timer !== undefined)
+                        clearTimeout(timer);
+                    timer = undefined;
+                    queueMicrotask(() => stop());
+                    resolve(value);
+                }
+            }
+            catch (error) {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                timer = undefined;
+                reject(error);
+            }
+        });
+        if (timeout !== undefined) {
+            timer = setTimeout(() => {
+                stop();
+                timer = undefined;
+                reject(new Error(`when: timed out after ${timeout}ms`));
+            }, timeout);
+        }
     });
 }
 //#endregion
@@ -1164,22 +1852,10 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
  * @param obj - The object to mark as non-reactive
  */
 function shallowNonReactive(obj) {
-    obj = debug.unwrap(obj);
-    if (debug.isNonReactive(obj))
+    obj = proxy.unwrap(obj);
+    if (proxy.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])
+    proxy.nonReactiveObjects.add(obj);
     return obj;
 }
 function unreactiveApplication(arg1, ...args) {
@@ -1187,11 +1863,13 @@ function unreactiveApplication(arg1, ...args) {
         ? shallowNonReactive(arg1)
         : ((original) => {
             // Copy the parent's unreactive properties if they exist
-            original.prototype[debug.unreactiveProperties] = new Set(original.prototype[debug.unreactiveProperties] || []);
+            const parentSet = proxy.unreactiveProps.get(original.prototype);
+            const set = new Set(parentSet || []);
             // Add all arguments (including the first one)
-            original.prototype[debug.unreactiveProperties].add(arg1);
+            set.add(arg1);
             for (const arg of args)
-                original.prototype[debug.unreactiveProperties].add(arg);
+                set.add(arg);
+            proxy.addUnreactiveProps(original.prototype, set);
             return original; // Return the class
         });
 }
@@ -1199,13 +1877,67 @@ function unreactiveApplication(arg1, ...args) {
  * Decorator that marks classes or properties as non-reactive
  * Prevents objects from being made reactive
  */
-const unreactive = debug.decorator({
+const unreactive = proxy.decorator({
     class(original) {
         // Called without arguments, mark entire class as non-reactive
-        debug.nonReactiveClass(original);
+        proxy.nonReactiveClass(original);
     },
     default: unreactiveApplication,
 });
+/**
+ * Creates a reactive resource that automatically tracks async state.
+ * @param fetcher - Async function that returns the value. Reactive dependencies are tracked.
+ * @param options - Resource options (initialValue)
+ * @returns Reactive Resource object with value, loading, error, latest properties
+ */
+function resource(fetcher, options = {}) {
+    const state = proxy.reactive({
+        value: options.initialValue,
+        loading: true,
+        error: undefined,
+        latest: options.initialValue,
+        reload: () => {
+            reloadSignal.value++;
+        },
+    });
+    const reloadSignal = proxy.reactive({ value: 0 });
+    let counter = 0;
+    const stop = proxy.effect(function resourceEffect(access) {
+        // Track reload signal to enable manual reloading
+        if (reloadSignal.value) ;
+        const id = ++counter;
+        state.loading = true;
+        state.error = undefined;
+        try {
+            const result = fetcher(access);
+            if (result instanceof Promise) {
+                result.then((val) => {
+                    if (id === counter) {
+                        state.value = val;
+                        state.latest = val;
+                        state.loading = false;
+                    }
+                }, (err) => {
+                    if (id === counter) {
+                        state.error = err;
+                        state.loading = false;
+                    }
+                });
+            }
+            else {
+                state.value = result;
+                state.latest = result;
+                state.loading = false;
+            }
+        }
+        catch (err) {
+            state.error = err;
+            state.loading = false;
+        }
+    });
+    state.stop = stop;
+    return state;
+}
 //#endregion
 
 // Helper to work around TypeScript limitation: base class expressions cannot reference class type parameters
@@ -1243,17 +1975,17 @@ let RegisterClass = (() => {
         }
         on(eventOrEvents, cb) {
             // @ts-expect-error Delegate to Eventful
-            return debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").on(eventOrEvents, cb);
+            return proxy.__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);
+            proxy.__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);
+            return proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").hook(cb);
         }
         constructor(keyFn, initial) {
             super();
@@ -1272,35 +2004,35 @@ let RegisterClass = (() => {
             );
             /* Moved below initialization */
             let ascendGet;
-            debug.effect(({ ascend }) => {
+            proxy.effect(({ ascend }) => {
                 ascendGet = ascend;
             });
-            debug.__classPrivateFieldSet(this, _RegisterClass_ascend, ascendGet, "f");
+            proxy.__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");
+            proxy.__classPrivateFieldSet(this, _RegisterClass_keyFn, keyFn, "f");
+            proxy.__classPrivateFieldSet(this, _RegisterClass_keys, proxy.reactive([]), "f");
+            proxy.__classPrivateFieldSet(this, _RegisterClass_values, proxy.reactive(new Map()), "f");
             if (initial)
                 this.push(...initial);
         }
         ensureKey(value) {
-            let info = debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            let info = proxy.__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);
+            proxy.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").set(value, info);
+            proxy.__classPrivateFieldGet(this, _RegisterClass_ascend, "f").call(this, () => {
+                const stop = proxy.effect(({ reaction }) => {
+                    const nextKey = proxy.__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);
+                        proxy.__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);
+                proxy.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").add(stop);
             });
             if (info.key === undefined)
                 throw new Error('Register key function must return a property key');
@@ -1312,55 +2044,55 @@ let RegisterClass = (() => {
                 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);
+            const existing = proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
             if (existing !== undefined && existing !== value) {
                 this.cleanupValue(existing);
-                debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+                proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
                 if (index !== undefined) {
-                    debug.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', existing, value, key, index);
+                    proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', existing, value, key, index);
                 }
             }
             else {
-                debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+                proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
             }
         }
         cleanupValue(value) {
-            const info = debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
+            const info = proxy.__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);
+                proxy.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").delete(stop);
                 stop();
             }
-            debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").delete(value);
+            proxy.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").delete(value);
         }
         disposeKeyEffects() {
-            for (const value of Array.from(debug.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").keys()))
+            for (const value of Array.from(proxy.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").keys()))
                 this.cleanupValue(value);
-            debug.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").clear();
+            proxy.__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);
+            const count = proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key) ?? 0;
+            proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count + 1);
         }
         decrementUsage(key, index) {
-            const count = debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key);
+            const count = proxy.__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);
+                const value = proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(key);
+                proxy.__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);
+                    const idx = index ?? proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
+                    proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('delete', value, key, idx);
                 }
             }
             else {
-                debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count - 1);
+                proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count - 1);
             }
         }
         normalizeIndex(index, allowEnd = false) {
@@ -1379,73 +2111,73 @@ let RegisterClass = (() => {
             return resolved;
         }
         assignAt(index, key, value) {
-            const oldKey = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
+            const oldKey = proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
             if (oldKey !== undefined && Object.is(oldKey, key)) {
-                const oldValue = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                const oldValue = proxy.__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.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', oldValue, value, key, index);
                 }
                 return;
             }
             if (oldKey !== undefined)
                 this.decrementUsage(oldKey);
-            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index] = key;
+            proxy.__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);
+            proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
         }
         insertKeyValue(index, key, value) {
-            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 0, key);
+            proxy.__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);
+            proxy.__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();
+            proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(0, proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length);
+            proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
+            proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
             for (const value of values) {
                 const key = this.ensureKey(value);
-                debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").push(key);
+                proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").push(key);
                 this.incrementUsage(key);
-                debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
+                proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
             }
         }
         get length() {
-            return debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length;
+            return proxy.__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);
+            const existingValue = proxy.__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);
+            const count = proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(oldKey);
             if (!count)
                 return;
-            const existingCount = debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(newKey) ?? 0;
+            const existingCount = proxy.__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;
+            for (let i = 0; i < proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length; i++)
+                if (Object.is(proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i], oldKey)) {
+                    proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i] = newKey;
                     if (index === -1)
                         index = i;
                 }
-            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);
+            proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(newKey, existingCount + count);
+            proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(oldKey);
+            proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").delete(oldKey);
+            const updatedInfo = proxy.__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);
+                proxy.__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);
+            const key = proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
+            return key === undefined ? undefined : proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
         }
         [setAt](index, value) {
             const key = this.ensureKey(value);
@@ -1488,13 +2220,13 @@ let RegisterClass = (() => {
             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 removedKeys = proxy.__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);
+                const value = proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
                 this.decrementUsage(key, normalizedStart + i);
                 removedValues.push(value);
             }
@@ -1507,16 +2239,16 @@ let RegisterClass = (() => {
             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();
+            proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length = 0;
+            proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
+            proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
             this.disposeKeyEffects();
         }
         get(key) {
-            return debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+            return proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
         }
         set(key, value) {
-            if (debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
+            if (proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
                 this.setKeyValue(key, value);
         }
         remove(key) {
@@ -1527,10 +2259,10 @@ let RegisterClass = (() => {
             }
         }
         removeAt(index) {
-            const [key] = debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 1);
+            const [key] = proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 1);
             if (key === undefined)
                 return undefined;
-            const value = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+            const value = proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
             this.decrementUsage(key, index);
             return value;
         }
@@ -1543,13 +2275,13 @@ let RegisterClass = (() => {
          */
         keep(predicate) {
             const decisions = new Map();
-            for (const [index, key] of debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").entries()) {
+            for (const [index, key] of proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").entries()) {
                 if (decisions.has(key)) {
                     if (!decisions.get(key))
                         this.removeAt(index);
                     continue;
                 }
-                const value = debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
+                const value = proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
                 const shouldKeep = predicate(value);
                 decisions.set(key, shouldKeep);
                 if (!shouldKeep)
@@ -1557,19 +2289,19 @@ let RegisterClass = (() => {
             }
         }
         hasKey(key) {
-            return debug.__classPrivateFieldGet(this, _RegisterClass_usage, "f").has(key);
+            return proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").has(key);
         }
         indexOfKey(key) {
-            return debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
+            return proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
         }
         mapKeys() {
-            return debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").keys();
+            return proxy.__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);
+                if (proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key)) {
+                    const index = proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
                     this.setKeyValue(key, value, index);
                 }
             }
@@ -1577,7 +2309,7 @@ let RegisterClass = (() => {
         upsert(insert, ...values) {
             for (const value of values) {
                 const key = this.ensureKey(value);
-                if (debug.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
+                if (proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
                     this.setKeyValue(key, value);
                 else
                     insert(value);
@@ -1586,8 +2318,8 @@ let RegisterClass = (() => {
         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]);
+                for (let i = 0; i < proxy.__classPrivateFieldGet(self, _RegisterClass_keys, "f").length; i++) {
+                    const val = proxy.__classPrivateFieldGet(self, _RegisterClass_values, "f").get(proxy.__classPrivateFieldGet(self, _RegisterClass_keys, "f")[i]);
                     if (val !== undefined)
                         yield [i, val];
                 }
@@ -1597,8 +2329,8 @@ let RegisterClass = (() => {
         [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);
+                for (const key of proxy.__classPrivateFieldGet(self, _RegisterClass_keys, "f")) {
+                    const value = proxy.__classPrivateFieldGet(self, _RegisterClass_values, "f").get(key);
                     if (value !== undefined)
                         yield value;
                 }
@@ -1615,14 +2347,14 @@ let RegisterClass = (() => {
             return this[getAt](resolved);
         }
         reverse() {
-            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").reverse();
+            proxy.__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))
+                ? (a, b) => compareFn(proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(a), proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(b))
                 : undefined;
-            debug.__classPrivateFieldGet(this, _RegisterClass_keys, "f").sort(fwdCompareFn);
+            proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").sort(fwdCompareFn);
             return this;
         }
         fill(value, start = 0, end = this.length) {
@@ -1638,13 +2370,13 @@ let RegisterClass = (() => {
             return this;
         }
     };
-    debug.__setFunctionName(_classThis, "RegisterClass");
+    proxy.__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);
+        proxy.__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);
+        proxy.__runInitializers(_classThis, _classExtraInitializers);
     })();
     return _classThis;
 })();
@@ -1676,410 +2408,25 @@ function register(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.
+ * Converts an iterator to a generator that yields reactive values
  */
-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);
-        }
+function* makeReactiveIterator(iterator) {
+    let result = iterator.next();
+    while (!result.done) {
+        yield proxy.reactive(result.value);
+        result = iterator.next();
     }
-    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 projectCore(source, apply) {
-    if (Array.isArray(source))
-        return projectArray(source, apply);
-    if (source instanceof Map)
-        return projectMap(source, apply);
-    if (source instanceof Register)
-        return projectRegister(source, apply);
-    if (source && (source.constructor === Object || source.constructor === undefined))
-        return projectRecord(source, apply);
-    throw new Error('Unsupported source type');
-}
-const project = Object.assign(projectCore, {
-    array: projectArray,
-    register: projectRegister,
-    record: projectRecord,
-    map: projectMap,
-});
-
-/**
- * Organizes a source object's properties into a target object using a callback function.
- * This creates a reactive mapping between source properties and a target object,
- * automatically handling property additions, updates, and removals.
- *
- * @template Source - The type of the source object
- * @template Target - The type of the target object (defaults to Record<PropertyKey, any>)
- *
- * @param {Source} source - The source object to organize
- * @param {OrganizedCallback<Source, Target>} apply - Callback function that defines how each source property is mapped to the target
- * @param {Target} [baseTarget={}] - Optional base target object to use (will be made reactive if not already)
- *
- * @returns {OrganizedResult<Target>} The target object with cleanup capability
- *
- * @example
- * // Organize user permissions into role-based access
- * const user = reactive({ isAdmin: true, canEdit: false });
- * const permissions = organized(
- *   user,
- *   (access, target) => {
- *     if (access.key === 'isAdmin') {
- *       target.hasFullAccess = access.value;
- *     }
- *     target[`can${access.key.charAt(0).toUpperCase() + access.key.slice(1)}`] = access.value;
- *   }
- * );
- *
- * @example
- * // Transform object structure with cleanup
- * const source = reactive({ firstName: 'John', lastName: 'Doe' });
- * const formatted = organized(
- *   source,
- *   (access, target) => {
- *     if (access.key === 'firstName' || access.key === 'lastName') {
- *       target.fullName = `${source.firstName} ${source.lastName}`.trim();
- *     }
- *   }
- * );
- *
- * @example
- * // Using with cleanup in a component
- * effect(() => {
- *   const data = fetchData();
- *   const organizedData = organized(data, (access, target) => {
- *     // Transform data
- *   });
- *
- *   // The cleanup will be called automatically when the effect is disposed
- *   return () => organizedData[cleanup]();
- * });
- */
-function organized(source, apply, baseTarget = {}) {
-    const observedSource = debug.reactive(source);
-    const target = debug.reactive(baseTarget);
-    const stop = attend(() => {
-        const keys = [];
-        for (const key in observedSource)
-            keys.push(key);
-        return keys;
-    }, (key) => {
-        const sourceKey = key;
-        const accessBase = {
-            key: sourceKey,
-            get: () => debug.FoolProof.get(observedSource, sourceKey, observedSource),
-            set: (value) => debug.FoolProof.set(observedSource, sourceKey, value, observedSource),
-        };
-        Object.defineProperty(accessBase, 'value', {
-            get: accessBase.get,
-            set: accessBase.set,
-            configurable: true,
-            enumerable: true,
-        });
-        return apply(accessBase, target);
-    });
-    return debug.cleanedBy(target, stop);
 }
 /**
- * Organizes a property on a target object
- * Shortcut for defineProperty/delete with touched signal
- * @param target - The target object
- * @param property - The property to organize
- * @param access - The access object
- * @returns The property descriptor
- */
-function organize(target, property, access) {
-    Object.defineProperty(target, property, {
-        get: access.get,
-        set: access.set,
-        configurable: true,
-        enumerable: true,
-    });
-    debug.touched1(target, { type: 'set', prop: property }, property);
-    return () => delete target[property];
-}
-
-/**
- * Reactively defines properties on a target object based on a descriptors record.
- *
- * It tracks the keys of the descriptors record and defines/updates/removes
- * properties on the target object as they change.
- *
- * @param descriptors - A reactive record of property descriptors.
- * @param target - The object to define properties on (defaults to a new object).
- * @returns The target object with reactive property definitions.
+ * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
  */
-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);
-        }
-        return () => Reflect.deleteProperty(target, key);
-    });
-    return debug.cleanedBy(target, stop);
+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 +2434,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 +2478,186 @@ 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 _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;
-            }
-        }
-        // 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;
-                }
+            concat(...items) {
+                return proxy.reactive(super.concat(...items.map(proxy.unwrap)));
+            }
+            entries() {
+                proxy.dependant(this, proxy.keysOf);
+                return makeReactiveEntriesIterator(super.entries());
+            }
+            every(predicate, thisArg) {
+                return super.every((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+            }
+            fill(value, start, end) {
+                return super.fill(proxy.unwrap(value), start, end);
+            }
+            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));
+            }
+            some(predicate, thisArg) {
+                return super.some((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+            }
+            sort(compareFn) {
+                const wrappedCompare = compareFn
+                    ? (a, b) => compareFn(proxy.reactive(a), proxy.reactive(b))
+                    : undefined;
+                return super.sort(wrappedCompare);
             }
-            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;
-                }
+            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 -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;
+            unshift(...items) {
+                return super.unshift(...items.map(proxy.unwrap));
             }
-        }
-        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;
+            values() {
+                proxy.dependant(this, proxy.keysOf);
+                return makeReactiveIterator(super.values());
             }
-        }
-        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));
+            [(_fill_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]());
             }
-        }
-    }
-    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));
+            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));
+            }
+            // biome-ignore lint/complexity/noArguments: Needed to distinguish fn() from fn(undefined)
+            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, _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
@@ -2510,24 +2669,24 @@ class ReactiveWeakMap extends WeakMap {
         const hadKey = this.has(key);
         const result = this.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(this.get(key));
     }
     has(key) {
-        debug.dependant(debug.contentRef(this), key);
+        proxy.dependant(proxy.contentRef(this), key);
         return this.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,7 +2698,7 @@ 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
+        proxy.dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
         return this.size;
     }
     clear() {
@@ -2548,28 +2707,28 @@ class ReactiveMap extends Map {
         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.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,7 +2736,7 @@ 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;
     }
@@ -2587,29 +2746,29 @@ class ReactiveMap extends Map {
         const result = this.delete(key);
         if (hadKey) {
             const evolution = { type: 'del', prop: key };
-            debug.touched1(debug.contentRef(this), evolution, key);
-            debug.touched1(this, evolution, 'size');
+            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(this.get(key));
     }
     has(key) {
-        debug.dependant(debug.contentRef(this), key);
+        proxy.dependant(proxy.contentRef(this), key);
         return this.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);
             // 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.touched1(this, evolution, 'size');
         }
         return this;
     }
@@ -2625,7 +2784,7 @@ class ReactiveWeakSet extends WeakSet {
         this.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;
@@ -2634,11 +2793,11 @@ class ReactiveWeakSet extends WeakSet {
         const had = this.has(value);
         const res = this.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);
+        proxy.dependant(proxy.contentRef(this), value);
         return this.has(value);
     }
 }
@@ -2649,18 +2808,18 @@ 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);
+        const reactiveValue = proxy.reactive(value);
         this.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.touched1(proxy.contentRef(this), evolution, reactiveValue);
+            proxy.touched1(this, evolution, 'size');
         }
         return this;
     }
@@ -2669,8 +2828,8 @@ class ReactiveSet extends Set {
         this.clear();
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
-            debug.touched1(this, evolution, 'size');
-            debug.touched(debug.contentRef(this), evolution);
+            proxy.touched1(this, evolution, 'size');
+            proxy.touched(proxy.contentRef(this), evolution);
         }
     }
     delete(value) {
@@ -2678,64 +2837,67 @@ class ReactiveSet extends Set {
         const res = this.delete(value);
         if (had) {
             const evolution = { type: 'del', prop: value };
-            debug.touched1(debug.contentRef(this), evolution, value);
-            debug.touched1(this, evolution, 'size');
+            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);
+console.time('mutts-reactive-init');
+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);
+console.timeEnd('mutts-reactive-init');
 /**
  * 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,
+    nonReactiveObjects: proxy.nonReactiveObjects,
 };
 
 // In order to avoid async re-entrance, we could use zone.js or something like that.
@@ -2744,7 +2906,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 +2950,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 +3004,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 +3032,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);
@@ -2911,7 +3073,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 +3096,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,7 +3127,7 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.9";
+var version$1 = "1.0.10";
 var pkg = {
 	version: version$1};
 
@@ -2982,6 +3144,7 @@ const globalScope = (typeof globalThis !== 'undefined'
 if (globalScope) {
     // Detect the source of this instance safely across different environments
     let source = 'mutts/index';
+    // biome-ignore lint/security/noGlobalEval: Intentional eval for cross-env import.meta detection
     const viteEval = eval;
     try {
         if (typeof __filename !== 'undefined')
@@ -3013,63 +3176,63 @@ 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.arrayEquals = proxy.arrayEquals;
+exports.asyncZone = proxy.asyncZone;
+exports.atom = proxy.atom;
+exports.atomic = proxy.atomic;
+exports.biDi = proxy.biDi;
+exports.caught = proxy.caught;
+exports.cleanedBy = proxy.cleanedBy;
+exports.cleanup = proxy.cleanup;
+exports.createFlavor = proxy.createFlavor;
+exports.decorator = proxy.decorator;
+exports.deepCompare = proxy.deepCompare;
+exports.defer = proxy.defer;
+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.immutables = proxy.immutables;
+exports.isConstructor = proxy.isConstructor;
+exports.isNonReactive = proxy.isNonReactive;
+exports.isObject = proxy.isObject;
+exports.isReactive = proxy.isReactive;
+exports.legacyDecorator = proxy.legacyDecorator;
+exports.mixin = proxy.mixin;
+exports.modernDecorator = proxy.modernDecorator;
+exports.named = proxy.named;
+exports.objectToProxy = proxy.objectToProxy;
+exports.onEffectThrow = proxy.onEffectThrow;
+exports.proxyToObject = proxy.proxyToObject;
+exports.reactive = proxy.reactive;
+exports.reactiveOptions = proxy.options;
+exports.reset = proxy.reset;
+exports.root = proxy.root;
+exports.stopped = proxy.stopped;
+exports.tag = proxy.tag;
+exports.touched = proxy.touched;
+exports.touched1 = proxy.touched1;
+exports.untracked = proxy.untracked;
+exports.unwrap = proxy.unwrap;
+exports.zip = proxy.zip;
 exports.asyncHook = asyncCore.asyncHook;
 exports.asyncHooks = asyncCore.asyncHooks;
 exports.hooks = asyncCore.hooks;
@@ -3081,6 +3244,7 @@ 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 +3253,24 @@ 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.project = morph;
 exports.register = register;
+exports.resource = resource;
 exports.scan = scan;
 exports.setAt = setAt;
 exports.throttle = throttle;
 exports.unreactive = unreactive;
 exports.watch = watch;
+exports.when = when;
 //# sourceMappingURL=browser.cjs.map