mutts 1.0.9 → 1.0.10

package/dist/chunks/{index-2vea86wD.esm.js → index-CaaQQlPJ.esm.js}

@@ -1,4 +1,4 @@
-import { r as decorator, a3 as markWithRoot, a4 as rootFunction, V as renamed, a5 as getRoot, a6 as dependant, T as options, a0 as untracked, s as deepCompare, a7 as optionCall, X as root, v as effect, $ as touched1, S as reactive, n as cleanedBy, a8 as __runInitializers, a9 as __esDecorate, F as FoolProof, aa as objectsWithDeepWatchers, ab as effectToDeepWatchedObjects, ac as deepWatchers, H as isNonReactive, a1 as unwrap, ad as stopped, ae as nonReactiveClass, af as unreactiveProperties, ag as nonReactiveMark, ah as nonReactiveObjects, ai as __setFunctionName, aj as __classPrivateFieldGet, ak as __classPrivateFieldSet, al as setEffectName, O as named, B as getActiveEffect, am as projectionInfo, _ as touched, p as contentRef, an as notifyPropertyChange, ao as metaProtos, ap as objectParents, aq as watchers, ar as effectToReactiveObjects, as as proxyToObject, at as objectToProxy, y as flavored } from './index-CtA2AWl3.esm.js';
+import { r as decorator, x as flavored, a3 as markWithRoot, O as named, a4 as rootFunctionSymbol, S as proxyToObject, a5 as getRoot, a6 as dependant, U as options, a0 as untracked, s as deepCompare, a7 as optionCall, W as root, u as effect, $ as touched1, K as isReactive, T as reactive, _ as touched, o as cleanedBy, C as getState, a8 as keysOf, a9 as __runInitializers, aa as __esDecorate, ab as FoolProof, ac as objectsWithDeepWatchers, ad as effectToDeepWatchedObjects, ae as deepWatchers, H as isNonReactive, a1 as unwrap, af as registerDeepWatcher, w as flavorOptions, X as stopped, ag as nonReactiveClass, ah as unreactiveProps, ai as addUnreactiveProps, aj as nonReactiveObjects, ak as __setFunctionName, al as __classPrivateFieldGet, am as __classPrivateFieldSet, l as atomic, an as contentRef, ao as notifyPropertyChange, ap as metaProtos, aq as wrapProtos, ar as objectParents, as as watchers, at as effectToReactiveObjects, P as objectToProxy } from './proxy-r7lARftl.esm.js';
 
 // Integrated with `using` statement via Symbol.dispose
 const fr = new FinalizationRegistry((f) => f());
@@ -105,6 +105,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');
@@ -607,19 +755,21 @@ function getBranch(tree, key) {
     }
     return branch;
 }
-function memoizeFunction(fn) {
+function memoizeFunction(fn, opts) {
     const fnRoot = getRoot(fn);
     const existing = memoizedRegistry.get(fnRoot);
     if (existing)
         return existing;
     const cacheRoot = {};
-    const memoized = 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 = 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);
         }
         dependant(node, 'memoize');
@@ -628,9 +778,9 @@ function memoizeFunction(fn) {
                 const wasVerification = options.isVerificationRun;
                 options.isVerificationRun = true;
                 try {
-                    const fresh = untracked(() => fn(...localArgs));
+                    const fresh = untracked(() => fn.apply(this, args));
                     if (!deepCompare(node.result, fresh)) {
-                        optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, localArgs, 'calculation');
+                        optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
                     }
                 }
                 finally {
@@ -641,18 +791,18 @@ function memoizeFunction(fn) {
         }
         // Create memoize internal effect to track dependencies and invalidate cache
         // Use untracked to prevent the effect creation from being affected by parent effects
-        node.cleanup = root(() => effect(() => {
+        node.cleanup = root(() => effect.named('memoize')(() => {
             // Execute the function and track its dependencies
             // The function execution will automatically track dependencies on reactive objects
-            node.result = fn(...localArgs);
-            return () => {
+            node.result = fn.apply(this, args);
+            return (reason) => {
                 // When dependencies change, clear the cache and notify consumers
                 delete node.result;
-                touched1(node, { type: 'invalidate', prop: localArgs }, 'memoize');
+                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;
                 }
             };
@@ -661,9 +811,9 @@ function memoizeFunction(fn) {
             const wasVerification = options.isVerificationRun;
             options.isVerificationRun = true;
             try {
-                const fresh = untracked(() => fn(...localArgs));
+                const fresh = untracked(() => fn.apply(this, args));
                 if (!deepCompare(node.result, fresh)) {
-                    optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, localArgs, 'comparison');
+                    optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
                 }
             }
             finally {
@@ -676,6 +826,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 = new Proxy(target, {
+        get(source, prop, receiver) {
+            // 1. Walk prototype chain to find descriptor
+            let current = source;
+            let desc;
+            while (current) {
+                desc = Object.getOwnPropertyDescriptor(current, prop);
+                if (desc)
+                    break;
+                current = Object.getPrototypeOf(current);
+            }
+            if (!desc)
+                return Reflect.get(source, prop, receiver);
+            // 2. If getter, memoize
+            if (desc.get) {
+                const originalGetter = desc.get;
+                let wrapper = wrapperRegistry.get(originalGetter);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
+                        return originalGetter.call(that);
+                    }), {
+                        propertyKey: prop,
+                    });
+                    const origRoot = originalGetter[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(originalGetter, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, opts);
+                return memoized(receiver);
+            }
+            // 3. Otherwise forward
+            return Reflect.get(source, prop, receiver);
+        },
+        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
+        set(source, prop, value, _receiver) {
+            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
+            // it recognizes itself and triggers change notifications.
+            return Reflect.set(source, prop, value, source);
+        },
+    });
+    proxyToObject.set(proxy, target);
+    memoizedRegistry.set(target, proxy);
+    return proxy;
+}
 /**
  * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
  *
@@ -699,46 +898,55 @@ function memoizeFunction(fn) {
  * })
  * ```
  */
-const memoize = decorator({
-    getter(original, target, propertyKey) {
-        return function () {
-            let wrapper = wrapperRegistry.get(original);
-            if (!wrapper) {
-                wrapper = markWithRoot(renamed((that) => {
-                    return original.call(that);
-                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`), {
-                    method: original,
-                    propertyKey,
-                    ...(original[rootFunction]
-                        ? { [rootFunction]: original[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 = markWithRoot(renamed((that, ...args) => {
-                    return original.call(that, ...args);
-                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`), {
-                    method: original,
-                    propertyKey: name,
-                    ...(original[rootFunction]
-                        ? { [rootFunction]: original[rootFunction] }
-                        : {}),
-                });
-                wrapperRegistry.set(original, wrapper);
-            }
-            const memoized = memoizeFunction(wrapper);
-            return memoized(this, ...args);
-        };
+function makeMemoizeDecorator(memoizeOpts) {
+    return decorator({
+        getter(original, target, propertyKey) {
+            return function () {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
+                        return original.call(that);
+                    }), {
+                        method: original,
+                        propertyKey,
+                    });
+                    const origRoot = original[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this);
+            };
+        },
+        method(original, target, name) {
+            return function (...args) {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
+                        return original.call(that, ...args);
+                    }), {
+                        method: original,
+                        propertyKey: name,
+                    });
+                    const origRoot = original[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this, ...args);
+            };
+        },
+        default: (target) => typeof target === 'object'
+            ? memoizeObject(target, memoizeOpts)
+            : memoizeFunction(target, memoizeOpts),
+    });
+}
+const memoize = flavored(makeMemoizeDecorator(), {
+    get lenient() {
+        return makeMemoizeDecorator({ lenient: true });
     },
-    default: memoizeFunction,
 });
 
 function attend(source, callback) {
@@ -768,10 +976,10 @@ function attend(source, callback) {
             }
         }
     });
-    return () => {
-        outer();
+    return (reason) => {
+        outer(reason);
         for (const stop of keyEffects.values())
-            stop();
+            stop(reason);
         keyEffects.clear();
     };
 }
@@ -807,7 +1015,8 @@ function attend(source, callback) {
  */
 function scan(source, callback, initialValue) {
     const observedSource = reactive(source);
-    const result = reactive([]);
+    const rawResult = [];
+    const result = reactive(rawResult);
     // Track effects for each index to dispose them when the array shrinks
     const indexEffects = new Map();
     // Mapping from index to its current intermediate object
@@ -840,117 +1049,473 @@ function scan(source, callback, initialValue) {
         if (stop) {
             stop();
             indexEffects.delete(index);
-            untracked(() => {
-                Reflect.deleteProperty(indexToIntermediate, index);
-                Reflect.deleteProperty(result, index);
-            });
+            Reflect.deleteProperty(indexToIntermediate, index);
+            Reflect.deleteProperty(result, index);
         }
     }
     const mainEffect = effect(function scanMainEffect({ ascend }) {
         const length = observedSource.length;
         const occurrenceCount = new Map();
         let prev;
-        for (let i = 0; i < length; i++) {
-            const val = 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 = reactive(new Intermediate(val, prev));
-                list[count] = intermediate;
-            }
-            else {
-                // Update the link.
-                if (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 = effect(function scanIndexSyncEffect() {
-                        const inter = indexToIntermediate[index];
-                        if (inter) {
-                            const accValue = inter.acc;
-                            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 = reactive(new Intermediate(val, prev));
+                    list[count] = intermediate;
+                }
+                else {
+                    // Update the link.
+                    if (untracked(() => intermediate.prev) !== prev) {
+                        intermediate.prev = prev;
+                    }
+                }
+                // Update the reactive mapping for this index
+                if (indexToIntermediate[i] !== intermediate) {
+                    indexToIntermediate[i] = intermediate;
+                }
+                // If we don't have an effect for this index yet, create one
+                if (!indexEffects.has(i)) {
+                    ascend(() => {
+                        const index = i;
+                        const stop = effect(function scanIndexSyncEffect() {
+                            const inter = indexToIntermediate[index];
+                            if (inter) {
+                                const accValue = inter.acc;
                                 result[index] = accValue;
-                            });
-                        }
+                            }
+                        });
+                        indexEffects.set(index, stop);
                     });
-                    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
-        untracked(() => {
-            if (result.length !== length) {
-                FoolProof.set(result, 'length', length, result);
-            }
-        });
+        if (rawResult.length !== length) {
+            FoolProof.set(result, 'length', length, result);
+        }
     });
-    return cleanedBy(result, (() => {
-        mainEffect();
+    return cleanedBy(result, ((reason) => {
+        mainEffect(reason);
         for (const stop of indexEffects.values())
-            stop();
+            stop(reason);
         indexEffects.clear();
     }));
 }
 function lift(cb) {
     let result;
-    const liftCleanup = effect((access) => {
+    let rawResult;
+    const liftCleanup = effect.named('lift')(markWithRoot((access) => {
         const source = cb(access);
         if (!source || typeof source !== 'object')
             throw new Error('lift callback must return an array or object');
+        const sourceProto = Object.getPrototypeOf(source);
         if (!result) {
-            if (Array.isArray(source)) {
-                result = reactive([]);
+            rawResult = Array.isArray(source) ? [] : Object.create(sourceProto);
+            result = reactive(rawResult);
+        }
+        if (sourceProto !== Object.getPrototypeOf(result))
+            throw new Error('lift callback must return the same type as the previous result');
+        if (Array.isArray(source)) {
+            const res = result;
+            const patches = arrayDiff(res, source);
+            for (let i = patches.length - 1; i >= 0; i--) {
+                const { indexA, sliceA, sliceB } = patches[i];
+                res.splice(indexA, sliceA.length, ...sliceB);
             }
-            else {
-                result = 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))
+                        touched1(rawResult, { type: 'set', prop: key }, key);
+                }
+                else {
+                    Object.defineProperty(rawResult, key, newDesc);
+                    touched1(rawResult, { type: 'add', prop: key }, key);
+                }
             }
+            for (const key of Object.keys(rawResult))
+                if (!(key in source)) {
+                    delete rawResult[key];
+                    touched1(rawResult, { type: 'del', prop: key }, key);
+                }
+        }
+    }, cb));
+    return cleanedBy(result, liftCleanup);
+}
+/**
+ * Reactively maps an array source through `fn`, producing a lazy reactive output array.
+ *
+ * Each source item gets its own isolated effect (via `root()`) so that changes to one item
+ * only recompute that item's projection. Structural changes (push, splice, reorder) are detected
+ * via `arrayDiff` and surgically applied to the output cache.
+ *
+ * The source can be a reactive array or a function returning an array. When a function is provided,
+ * the function is re-evaluated inside an effect whenever its dependencies change.
+ *
+ * Output elements are computed lazily — accessing `result[i]` triggers computation if not yet cached.
+ *
+ * @param source - A reactive array or a function returning an array
+ * @param fn - Mapping function applied to each element
+ * @param options - Optional purity hints to skip per-item effects
+ * @returns A readonly reactive array with a `[cleanup]` method to dispose all effects
+ */
+function morphArray(source, fn, options) {
+    if (typeof source !== 'function' && !isReactive(source) && options?.pure === true) {
+        return source.map(fn);
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = [];
+    let input = [];
+    function stopItem(key) {
+        const entry = itemEffects.get(key);
+        if (entry) {
+            entry.stop({ type: 'stopped' });
+            itemEffects.delete(key);
+        }
+    }
+    function computeItem(key, input) {
+        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(input));
+        if (isPure) {
+            track(() => {
+                cache[key] = fn(input);
+            });
+        }
+        else {
+            const indexRef = { value: key };
+            let stop;
+            track(() => {
+                stop = effect.opaque(() => {
+                    cache[indexRef.value] = fn(input);
+                    return (reason) => {
+                        delete cache[indexRef.value];
+                        touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                        stop({ type: 'invalidate', cause: reason });
+                    };
+                });
+            });
+            itemEffects.set(key, { stop, index: indexRef });
         }
-        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];
+    }
+    const proxy = reactive(cache, {
+        get(cache, prop) {
+            const n = typeof prop === 'string' ? Number(prop) : NaN;
+            if (Number.isNaN(n))
+                return cache[prop];
+            if (!(n in cache))
+                computeItem(n, input[n]);
+            return cache[n];
+        },
+        has(_cache, prop) {
+            return Reflect.has(input, prop);
+        },
+    });
+    const stopMain = effect.named('morph:array')(({ ascend }) => {
+        track = ascend;
+        const newInput = [...(typeof source === 'function' ? source() : source)];
+        const diffs = arrayDiff(input, newInput).toSorted((a, b) => b.indexA - a.indexA);
+        if (diffs.length > 0) {
+            for (const diff of diffs) {
+                // Stop items in removed range
+                for (let i = diff.indexA; i < diff.indexA + diff.sliceA.length; i++)
+                    stopItem(i);
+                // Shift existing itemEffects in the Map to match the new indices
+                const shift = diff.sliceB.length - diff.sliceA.length;
+                if (shift !== 0) {
+                    // We need to move entries in the Map.
+                    const entries = Array.from(itemEffects.entries()).sort((a, b) => a[0] - b[0]);
+                    // Remove entries that will be shifted
+                    for (const [idx, entry] of entries) {
+                        if (idx >= diff.indexA + diff.sliceA.length) {
+                            itemEffects.delete(idx);
+                        }
+                    }
+                    // Re-add them with shifted indices
+                    for (const [idx, entry] of entries) {
+                        if (idx >= diff.indexA + diff.sliceA.length) {
+                            const newIdx = idx + shift;
+                            entry.index.value = newIdx;
+                            itemEffects.set(newIdx, entry);
+                        }
+                    }
+                }
+                // Splice the cache
+                cache.splice(diff.indexA, diff.sliceA.length, ...new Array(diff.sliceB.length).fill(undefined));
+                // Make holes for lazy computation
+                for (let i = diff.indexA; i < diff.indexA + diff.sliceB.length; i++)
+                    delete cache[i];
+            }
+            const invalidates = new Set([keysOf]);
+            if (input.length !== newInput.length)
+                invalidates.add('length');
+            for (const diff of diffs) {
+                const max = Math.max(diff.sliceA.length, diff.sliceB.length);
+                for (let i = 0; i < max; i++)
+                    invalidates.add(String(diff.indexA + i));
+            }
+            touched(cache, { type: 'bunch', method: 'morph-input' }, invalidates);
+        }
+        input = newInput;
+    });
+    return cleanedBy(proxy, (reason) => {
+        stopMain(reason);
+        for (const entry of itemEffects.values())
+            entry.stop(reason);
+        itemEffects.clear();
+    });
+}
+/**
+ * Reactively maps a `Map` source through `fn`, producing a reactive output Map.
+ *
+ * Each key gets its own isolated effect so that value changes for one key only recompute
+ * that key's projection. Key additions and removals are tracked via `keysOf` dependency.
+ *
+ * @param source - A reactive Map
+ * @param fn - Mapping function applied to each value
+ * @param options - Optional purity hints to skip per-key effects
+ * @returns A reactive Map with a `[cleanup]` method to dispose all effects
+ */
+function morphMap(source, fn, options) {
+    if (!isReactive(source) && options?.pure === true) {
+        const res = new Map();
+        for (const [k, v] of source)
+            res.set(k, fn(v));
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = new Map();
+    Object.defineProperty(cache, 'constructor', { value: Object, enumerable: false });
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
+        if (stop) {
+            stop({ type: 'stopped' });
+            itemEffects.delete(key);
         }
-        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(() => effect.opaque(() => {
+                cache.set(key, fn(source.get(key)));
+                return (reason) => {
+                    cache.delete(key);
+                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop({ type: 'invalidate', cause: reason });
+                };
+            }));
+            itemEffects.set(key, stop);
+        }
+    }
+    const proxy = reactive(cache, {
+        get(cache, prop) {
+            if (prop === 'get')
+                return (key) => {
+                    if (!cache.has(key) && source.has(key))
+                        computeItem(key, source.get(key));
+                    return cache.get(key);
+                };
+            if (prop === 'has')
+                return (key) => {
+                    return source.has(key);
+                };
+            if (prop === 'keys')
+                return () => {
+                    return source.keys();
+                };
+            if (prop === 'values')
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield proxy.get(key);
+                    }
+                };
+            if (prop === 'entries')
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy.get(key)];
+                    }
+                };
+            if (prop === Symbol.iterator)
+                return function* () {
+                    for (const key of source.keys()) {
+                        yield [key, proxy.get(key)];
+                    }
+                };
+            return cache[prop];
+        },
+    });
+    let stateSnapshot = getState(source);
+    const stopMain = effect.named('morph:map')(({ ascend }) => {
+        track = ascend;
+        dependant(source, keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                cache.delete(evolution.prop);
+                touched1(cache, evolution, evolution.prop);
+            }
         }
     });
-    return cleanedBy(result, liftCleanup);
+    return cleanedBy(proxy, (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 (!isReactive(source) && options?.pure === true) {
+        const res = {};
+        for (const k of Object.keys(source))
+            res[k] = fn(source[k]);
+        return res;
+    }
+    let track;
+    const itemEffects = new Map();
+    const cache = {};
+    function stopItem(key) {
+        const stop = itemEffects.get(key);
+        if (stop) {
+            stop({ type: 'stopped' });
+            itemEffects.delete(key);
+        }
+    }
+    function computeItem(key, val) {
+        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
+        if (isPure) {
+            cache[key] = track(() => fn(val));
+        }
+        else {
+            const stop = track(() => effect.opaque(() => {
+                cache[key] = fn(source[key]);
+                return (reason) => {
+                    delete cache[key];
+                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop({ type: 'invalidate', cause: reason });
+                };
+            }));
+            itemEffects.set(key, stop);
+        }
+    }
+    function get(prop) {
+        if (!(prop in cache) && prop in source)
+            computeItem(prop, source[prop]);
+        return cache[prop];
+    }
+    const proxy = reactive(cache, {
+        get(_, prop) {
+            return get(prop);
+        },
+        has(_, prop) {
+            return prop in source;
+        },
+        ownKeys() {
+            return Reflect.ownKeys(source);
+        },
+        getOwnPropertyDescriptor(_cache, prop) {
+            if (prop in source)
+                return { configurable: true, enumerable: true, get: () => get(prop) };
+        },
+    });
+    let stateSnapshot = getState(source);
+    const stopMain = effect.named('morph:record')(({ ascend }) => {
+        track = ascend;
+        // Track only structural changes on source
+        dependant(source, keysOf);
+        while ('evolution' in stateSnapshot) {
+            const { evolution } = stateSnapshot;
+            stateSnapshot = stateSnapshot.next;
+            if (evolution.type === 'add') {
+                touched1(cache, evolution, evolution.prop);
+            }
+            else if (evolution.type === 'del') {
+                stopItem(evolution.prop);
+                delete cache[evolution.prop];
+                touched1(cache, evolution, evolution.prop);
+            }
+        }
+    });
+    return cleanedBy(proxy, (reason) => {
+        stopMain(reason);
+        for (const stop of itemEffects.values())
+            stop(reason);
+        itemEffects.clear();
+    });
 }
+/**
+ * Reactively maps a collection (array, Map, or record) through a per-entry function.
+ *
+ * Each entry in the source gets its own reactive context — when only one entry's dependencies
+ * change, only that entry's projection recomputes. Structural changes (additions, removals,
+ * reorders) are detected via diffing and applied surgically.
+ *
+ * Use `morph.pure(source, fn)` when `fn` has no reactive reads (skips per-item effects).
+ *
+ * @example
+ * ```ts
+ * const users = reactive([{ name: 'John' }, { name: 'Jane' }])
+ * const names = morph(users, u => u.name.toUpperCase())
+ * // names[0] = 'JOHN', names[1] = 'JANE'
+ * // Changing users[0].name only recomputes names[0]
+ * ```
+ */
+const morph = flavored(function morph(source, fn, options) {
+    if (Array.isArray(source) || typeof source === 'function')
+        return morphArray(source, fn, options);
+    if (source instanceof Map)
+        return morphMap(source, fn, options);
+    return morphRecord(source, fn, options);
+}, {
+    get pure() {
+        return (source, fn, _opt) => this(source, fn, { pure: true });
+    },
+});
+
 /**
  * Deep watch an object and all its nested properties
  * @param target - The object to watch deeply
@@ -972,6 +1537,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
         throw new Error('Target of deep watching must be an object');
     // Create a wrapper callback that matches EffectTrigger signature
     const wrappedCallback = markWithRoot((() => callback(target)), callback);
+    registerDeepWatcher();
     // Use the existing effect system to register dependencies
     return effect(() => {
         // Mark the target object as having deep watchers
@@ -988,7 +1554,7 @@ 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 > options.maxDeepWatchDepth)
+            if (!obj || visited.has(obj) || typeof obj !== 'object' || depth > options.maxDeepWatchDepth)
                 return;
             // Do not traverse into unreactive objects
             if (isNonReactive(obj))
@@ -1047,8 +1613,9 @@ 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) {
+            untracked(() => callback(target));
+        }
         immediate = true;
         // Return a cleanup function that properly removes deep watcher tracking
         return () => {
@@ -1081,30 +1648,103 @@ function deepWatch(target, callback, { immediate = false } = {}) {
 }
 
 /**
- * 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 reactive(result.value);
-        result = iterator.next();
-    }
+function organized(source, apply, baseTarget = {}) {
+    const observedSource = reactive(source);
+    const target = reactive(baseTarget);
+    const stop = attend(() => {
+        const keys = [];
+        for (const key in observedSource)
+            keys.push(key);
+        return keys;
+    }, (key) => {
+        const sourceKey = key;
+        const accessBase = {
+            key: sourceKey,
+            get: () => FoolProof.get(observedSource, sourceKey, observedSource),
+            set: (value) => FoolProof.set(observedSource, sourceKey, value, observedSource),
+        };
+        Object.defineProperty(accessBase, 'value', {
+            get: accessBase.get,
+            set: accessBase.set,
+            configurable: true,
+            enumerable: true,
+        });
+        return apply(accessBase, target);
+    });
+    return cleanedBy(target, (reason) => stop(reason));
 }
 /**
- * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
- */
-function* makeReactiveEntriesIterator(iterator) {
-    let result = iterator.next();
-    while (!result.done) {
-        const [key, value] = result.value;
-        yield [reactive(key), reactive(value)];
-        result = iterator.next();
-    }
+ * Organizes a property on a target object
+ * Shortcut for defineProperty/delete with touched signal
+ * @param target - The target object
+ * @param property - The property to organize
+ * @param access - The access object
+ * @returns The property descriptor
+ */
+function organize(target, property, access) {
+    Object.defineProperty(target, property, {
+        get: access.get,
+        set: access.set,
+        configurable: true,
+        enumerable: true,
+    });
+    touched1(target, { type: 'set', prop: property }, property);
+    return () => delete target[property];
 }
 
 //#region watch
 const unsetYet = Symbol('unset-yet');
-function watch(value, //object | ((dep: DependencyAccess) => object),
+const watch = flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
 changed, options = {}) {
     return typeof value === 'function'
         ? watchCallBack(value, changed, options)
@@ -1113,7 +1753,14 @@ changed, options = {}) {
             : (() => {
                 throw new Error('watch: value must be a function or an object');
             })();
-}
+}, {
+    get deep() {
+        return flavorOptions(this, { deep: true });
+    },
+    get immediate() {
+        return flavorOptions(this, { immediate: true });
+    },
+});
 function watchObject(value, changed, { immediate = false, deep = false } = {}) {
     if (deep)
         return deepWatch(value, changed, { immediate });
@@ -1129,13 +1776,15 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
     let deepCleanup;
     const cbCleanup = effect(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);
+                    untracked(() => changed(newValue));
             }
             else
-                changed(newValue, oldValue);
+                untracked(() => changed(newValue, old));
+        }
         oldValue = newValue;
         if (deep) {
             if (deepCleanup)
@@ -1152,6 +1801,45 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
     });
 }
 //#endregion
+//#region when
+/**
+ * Returns a promise that resolves when the predicate returns a truthy value.
+ * The predicate is evaluated reactively — it re-runs whenever its dependencies change.
+ * @param predicate - Reactive function that returns a value; resolves when truthy
+ * @param timeout - Optional timeout in milliseconds — rejects if condition is not met within this duration
+ * @returns Promise that resolves with the first truthy return value
+ */
+function when(predicate, timeout) {
+    return new Promise((resolve, reject) => {
+        let timer;
+        const stop = effect(function whenEffect(access) {
+            try {
+                const value = predicate(access);
+                if (value) {
+                    if (timer !== undefined)
+                        clearTimeout(timer);
+                    timer = undefined;
+                    queueMicrotask(() => stop());
+                    resolve(value);
+                }
+            }
+            catch (error) {
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                timer = undefined;
+                reject(error);
+            }
+        });
+        if (timeout !== undefined) {
+            timer = setTimeout(() => {
+                stop();
+                timer = undefined;
+                reject(new Error(`when: timed out after ${timeout}ms`));
+            }, timeout);
+        }
+    });
+}
+//#endregion
 //#region nonReactive
 /**
  * Mark an object as non-reactive. This object and all its properties will never be made reactive.
@@ -1161,19 +1849,7 @@ function shallowNonReactive(obj) {
     obj = unwrap(obj);
     if (isNonReactive(obj))
         return obj;
-    try {
-        Object.defineProperty(obj, nonReactiveMark, {
-            value: true,
-            writable: false,
-            enumerable: false,
-            configurable: true,
-        });
-    }
-    catch { }
-    if (!(nonReactiveMark in obj))
-        nonReactiveObjects.add(obj);
-    // Finally, not deep
-    //for (const key in obj) deepNonReactive(obj[key])
+    nonReactiveObjects.add(obj);
     return obj;
 }
 function unreactiveApplication(arg1, ...args) {
@@ -1181,11 +1857,13 @@ function unreactiveApplication(arg1, ...args) {
         ? shallowNonReactive(arg1)
         : ((original) => {
             // Copy the parent's unreactive properties if they exist
-            original.prototype[unreactiveProperties] = new Set(original.prototype[unreactiveProperties] || []);
+            const parentSet = unreactiveProps.get(original.prototype);
+            const set = new Set(parentSet || []);
             // Add all arguments (including the first one)
-            original.prototype[unreactiveProperties].add(arg1);
+            set.add(arg1);
             for (const arg of args)
-                original.prototype[unreactiveProperties].add(arg);
+                set.add(arg);
+            addUnreactiveProps(original.prototype, set);
             return original; // Return the class
         });
 }
@@ -1200,6 +1878,60 @@ const unreactive = decorator({
     },
     default: unreactiveApplication,
 });
+/**
+ * Creates a reactive resource that automatically tracks async state.
+ * @param fetcher - Async function that returns the value. Reactive dependencies are tracked.
+ * @param options - Resource options (initialValue)
+ * @returns Reactive Resource object with value, loading, error, latest properties
+ */
+function resource(fetcher, options = {}) {
+    const state = reactive({
+        value: options.initialValue,
+        loading: true,
+        error: undefined,
+        latest: options.initialValue,
+        reload: () => {
+            reloadSignal.value++;
+        },
+    });
+    const reloadSignal = reactive({ value: 0 });
+    let counter = 0;
+    const stop = effect(function resourceEffect(access) {
+        // Track reload signal to enable manual reloading
+        if (reloadSignal.value) ;
+        const id = ++counter;
+        state.loading = true;
+        state.error = undefined;
+        try {
+            const result = fetcher(access);
+            if (result instanceof Promise) {
+                result.then((val) => {
+                    if (id === counter) {
+                        state.value = val;
+                        state.latest = val;
+                        state.loading = false;
+                    }
+                }, (err) => {
+                    if (id === counter) {
+                        state.error = err;
+                        state.loading = false;
+                    }
+                });
+            }
+            else {
+                state.value = result;
+                state.latest = result;
+                state.loading = false;
+            }
+        }
+        catch (err) {
+            state.error = err;
+            state.loading = false;
+        }
+    });
+    state.stop = stop;
+    return state;
+}
 //#endregion
 
 // Helper to work around TypeScript limitation: base class expressions cannot reference class type parameters
@@ -1670,410 +2402,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 = getActiveEffect();
-    return active ? effectProjectionMetadata.get(active) : undefined;
-}
-function setActiveProjection(projection) {
-    const active = 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, projectionInfo, {
-            value: metadata,
-            writable: false,
-            enumerable: false,
-            configurable: true,
-        });
-    }
-    return cleanedBy(target, () => {
-        onDispose();
-        for (const stop of effectMap.values())
-            stop?.();
-        effectMap.clear();
-    });
-}
-function projectArray(source, apply) {
-    source = reactive(source);
-    const target = reactive([]);
-    const indexEffects = new Map();
-    function normalizeTargetLength(length) {
-        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 = effect(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 = effect(named(`project:${source[Symbol.toStringTag]}[${index}]`, ({ reaction }) => {
-                    if (!reaction)
-                        setActiveProjection({ source, key: index, target, depth, parent });
-                    const previous = untracked(() => target[index]);
-                    const accessBase = {
-                        key: index,
-                        source,
-                        get: () => FoolProof.get(source, index, source),
-                        set: (value) => FoolProof.set(source, index, value, source),
-                        old: previous,
-                    };
-                    defineAccessValue(accessBase);
-                    target[index] = apply(accessBase, target);
-                }));
-                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 = reactive(source);
-    const rawTarget = new Map();
-    const target = 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 = 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 = effect(function projectRegisterKeyEffect({ reaction }) {
-                    if (!reaction)
-                        setActiveProjection({ source, key, target, depth, parent });
-                    const previous = 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);
-                });
-                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 = reactive(source);
-    const target = 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 = 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 = effect(function projectRecordKeyEffect({ reaction }) {
-                    if (!reaction)
-                        setActiveProjection({ source, key, target, depth, parent });
-                    const sourceKey = key;
-                    const previous = untracked(() => target[key]);
-                    const accessBase = {
-                        key: sourceKey,
-                        source: source,
-                        get: () => FoolProof.get(source, sourceKey, source),
-                        set: (value) => FoolProof.set(source, sourceKey, value, source),
-                        old: previous,
-                    };
-                    defineAccessValue(accessBase);
-                    const produced = apply(accessBase, target);
-                    target[sourceKey] = produced;
-                });
-                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 = reactive(source);
-    const rawTarget = new Map();
-    const target = 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 reactive(result.value);
+        result = iterator.next();
     }
-    const parent = getActiveProjection();
-    const depth = parent ? parent.depth + 1 : 0;
-    const cleanupKeys = 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 = effect(function projectMapKeyEffect({ reaction }) {
-                    if (!reaction)
-                        setActiveProjection({ source, key, target, depth, parent });
-                    const previous = 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);
-                });
-                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 = reactive(source);
-    const target = reactive(baseTarget);
-    const stop = attend(() => {
-        const keys = [];
-        for (const key in observedSource)
-            keys.push(key);
-        return keys;
-    }, (key) => {
-        const sourceKey = key;
-        const accessBase = {
-            key: sourceKey,
-            get: () => FoolProof.get(observedSource, sourceKey, observedSource),
-            set: (value) => FoolProof.set(observedSource, sourceKey, value, observedSource),
-        };
-        Object.defineProperty(accessBase, 'value', {
-            get: accessBase.get,
-            set: accessBase.set,
-            configurable: true,
-            enumerable: true,
-        });
-        return apply(accessBase, target);
-    });
-    return cleanedBy(target, 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,
-    });
-    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 = reactive(descriptors);
-    const stop = attend(() => Reflect.ownKeys(descriptors), (key) => {
-        const desc = descriptors[key];
-        if (desc) {
-            Object.defineProperty(target, key, {
-                enumerable: true,
-                ...desc,
-                configurable: true,
-            });
-            touched1(target, { type: 'set', prop: key }, key);
-        }
-        return () => Reflect.deleteProperty(target, key);
-    });
-    return cleanedBy(target, stop);
+function* makeReactiveEntriesIterator(iterator) {
+    let result = iterator.next();
+    while (!result.done) {
+        const [key, value] = result.value;
+        yield [reactive(key), reactive(value)];
+        result = iterator.next();
+    }
 }
 
 function* index(i, { length = true } = {}) {
@@ -2081,14 +2428,6 @@ 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) {
         dependant(this, i);
@@ -2103,20 +2442,28 @@ class Indexer extends Array {
     }
 }
 const indexLess = { get: FoolProof.get, set: FoolProof.set };
+// Fast numeric-string check: first char is a digit (0-9)
+function asIndex(prop) {
+    const c = prop.charCodeAt(0);
+    if (c < 48 || c > 57)
+        return -1; // not 0-9
+    const n = +prop; // coerce — faster than parseInt, handles "0", "12", etc.
+    return n === (n | 0) && n >= 0 ? n : -1;
+}
 Object.assign(FoolProof, {
     get(obj, prop, receiver) {
-        if (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);
     },
@@ -2125,374 +2472,186 @@ class ReactiveArray extends Array {
     toJSON() {
         return this;
     }
-    get length() {
-        dependant(this, 'length');
-        return this.length;
-    }
-    set length(value) {
-        const oldLength = this.length;
-        if (oldLength === value)
-            return;
-        try {
-            this.length = value;
-        }
-        finally {
-            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;
-        dependant(this, actualIndex);
-        if (index < 0)
-            dependant(this, 'length');
-        if (actualIndex < 0 || actualIndex >= this.length)
-            return undefined;
-        return reactive(this[actualIndex]);
-    }
-    // Immutable versions of mutator methods
-    toReversed() {
-        dependant(this);
-        return reactive(this.toReversed());
-    }
-    toSorted(compareFn) {
-        dependant(this);
-        return reactive(this.toSorted(compareFn));
-    }
-    toSpliced(start, deleteCount, ...items) {
-        dependant(this);
-        return deleteCount === undefined
-            ? this.toSpliced(start)
-            : this.toSpliced(start, deleteCount, ...items);
-    }
-    with(index, value) {
-        dependant(this);
-        return reactive(this.with(index, value));
-    }
-    // Iterator methods with reactivity tracking
-    entries() {
-        dependant(this);
-        return makeReactiveEntriesIterator(this.entries());
-    }
-    keys() {
-        dependant(this, 'length');
-        return this.keys();
-    }
-    values() {
-        dependant(this);
-        return makeReactiveIterator(this.values());
-    }
-    [Symbol.iterator]() {
-        dependant(this);
-        const nativeIterator = this[Symbol.iterator]();
-        return {
-            next() {
-                const result = nativeIterator.next();
-                if (result.done) {
-                    return result;
-                }
-                return { value: 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 = unwrap(searchElement);
-        for (; i < length; i++) {
-            dependant(this, i);
-            const item = this[i];
-            if (item === searchElement || item === unwrappedSearch || 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 reactive(super.at(index));
             }
-        }
-        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 = unwrap(searchElement);
-        for (; i >= 0; i--) {
-            dependant(this, i);
-            const item = this[i];
-            if (item === searchElement || item === unwrappedSearch || 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.
-        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++) {
-                dependant(this, i);
-                const val = reactive(this[i]);
-                if (predicate.call(thisArg, val, i, this)) {
-                    return val;
-                }
+            concat(...items) {
+                return reactive(super.concat(...items.map(unwrap)));
+            }
+            entries() {
+                dependant(this, keysOf);
+                return makeReactiveEntriesIterator(super.entries());
+            }
+            every(predicate, thisArg) {
+                return super.every((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            fill(value, start, end) {
+                return super.fill(unwrap(value), start, end);
+            }
+            filter(predicate, thisArg) {
+                return reactive(super.filter((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg));
+            }
+            find(predicate, thisArg) {
+                return reactive(super.find((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg));
+            }
+            findIndex(predicate, thisArg) {
+                return super.findIndex((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            findLast(predicate, thisArg) {
+                return reactive(super.findLast((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg));
+            }
+            findLastIndex(predicate, thisArg) {
+                return super.findLastIndex((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            flat(depth) {
+                return reactive(super.flat(depth));
+            }
+            flatMap(callbackfn, thisArg) {
+                return reactive(super.flatMap((v, i, a) => unwrap(callbackfn.call(thisArg, reactive(v), i, a)), thisArg));
+            }
+            forEach(callbackfn, thisArg) {
+                super.forEach((v, i, a) => {
+                    callbackfn.call(thisArg, reactive(v), i, a);
+                }, thisArg);
+            }
+            includes(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.includes(unwrap(searchElement), fromIndex)
+                    : super.includes(unwrap(searchElement));
+            }
+            indexOf(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.indexOf(unwrap(searchElement), fromIndex)
+                    : super.indexOf(unwrap(searchElement));
+            }
+            join(separator) {
+                return super.join(separator);
+            }
+            keys() {
+                dependant(this, 'length');
+                return super.keys();
+            }
+            lastIndexOf(searchElement, fromIndex) {
+                return arguments.length > 1
+                    ? super.lastIndexOf(unwrap(searchElement), fromIndex)
+                    : super.lastIndexOf(unwrap(searchElement));
+            }
+            map(callbackfn, thisArg) {
+                return reactive(super.map((v, i, a) => unwrap(callbackfn.call(thisArg, reactive(v), i, a)), thisArg));
+            }
+            pop() {
+                return reactive(super.pop());
+            }
+            push(...items) {
+                return super.push(...items.map(unwrap));
+            }
+            reduce(callbackfn, initialValue) {
+                return reactive(arguments.length > 1
+                    ? super.reduce((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a)), initialValue)
+                    : super.reduce((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a))));
+            }
+            reduceRight(callbackfn, initialValue) {
+                return reactive(arguments.length > 1
+                    ? super.reduceRight((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a)), initialValue)
+                    : super.reduceRight((acc, v, i, a) => unwrap(callbackfn(acc, reactive(v), i, a))));
+            }
+            reverse() {
+                return reactive(super.reverse());
+            }
+            shift() {
+                return reactive(super.shift());
+            }
+            slice(start, end) {
+                return reactive(super.slice(start, end));
+            }
+            some(predicate, thisArg) {
+                return super.some((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
+            }
+            sort(compareFn) {
+                const wrappedCompare = compareFn
+                    ? (a, b) => compareFn(reactive(a), reactive(b))
+                    : undefined;
+                return super.sort(wrappedCompare);
             }
-            dependant(this, 'length');
-            return undefined;
-        }
-        const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
-        const index = this.indexOf(predicateOrElement, fromIndex);
-        if (index === -1)
-            return undefined;
-        return reactive(this[index]);
-    }
-    findIndex(predicateOrElement, thisArg) {
-        if (typeof predicateOrElement === 'function') {
-            const predicate = predicateOrElement;
-            const length = this.length;
-            for (let i = 0; i < length; i++) {
-                dependant(this, i);
-                const val = reactive(this[i]);
-                if (predicate.call(thisArg, val, i, this)) {
-                    return i;
-                }
+            splice(start, deleteCount, ...items) {
+                if (arguments.length > 2)
+                    return reactive(super.splice(start, deleteCount, ...items.map(unwrap)));
+                if (arguments.length === 2)
+                    return reactive(super.splice(start, deleteCount));
+                if (arguments.length === 1)
+                    return reactive(super.splice(start));
+                return reactive([]);
             }
-            dependant(this, 'length');
-            return -1;
-        }
-        const fromIndex = typeof thisArg === 'number' ? thisArg : undefined;
-        return this.indexOf(predicateOrElement, fromIndex);
-    }
-    flat(depth) {
-        dependant(this);
-        return reactive(depth === undefined ? this.flat() : this.flat(depth));
-    }
-    flatMap(callbackfn, thisArg) {
-        dependant(this);
-        return reactive(this.flatMap((item, index, array) => callbackfn.call(thisArg, reactive(item), index, array), thisArg));
-    }
-    filter(callbackfn, thisArg) {
-        dependant(this);
-        return reactive(this.filter((item, index, array) => callbackfn(reactive(item), index, array), thisArg));
-    }
-    map(callbackfn, thisArg) {
-        dependant(this);
-        return reactive(this.map((item, index, array) => callbackfn(reactive(item), index, array), thisArg));
-    }
-    reduce(callbackfn, initialValue) {
-        dependant(this);
-        const result = initialValue === undefined
-            ? this.reduce(callbackfn)
-            : this.reduce(callbackfn, initialValue);
-        return reactive(result);
-    }
-    reduceRight(callbackfn, initialValue) {
-        dependant(this);
-        const result = initialValue !== undefined
-            ? this.reduceRight(callbackfn, initialValue)
-            : this.reduceRight(callbackfn);
-        return reactive(result);
-    }
-    slice(start, end) {
-        for (const i of range(start || 0, end || this.length - 1))
-            dependant(this, i);
-        return start === undefined
-            ? this.slice()
-            : end === undefined
-                ? this.slice(start)
-                : this.slice(start, end);
-    }
-    concat(...items) {
-        dependant(this);
-        return reactive(this.concat(...items));
-    }
-    join(separator) {
-        dependant(this);
-        return this.join(separator);
-    }
-    forEach(callbackfn, thisArg) {
-        dependant(this);
-        this.forEach((value, index, array) => {
-            callbackfn.call(thisArg, reactive(value), index, array);
-        });
-    }
-    every(callbackfn, thisArg) {
-        const length = this.length;
-        for (let i = 0; i < length; i++) {
-            dependant(this, i);
-            if (!callbackfn.call(thisArg, reactive(this[i]), i, this)) {
-                return false;
+            unshift(...items) {
+                return super.unshift(...items.map(unwrap));
             }
-        }
-        dependant(this, 'length');
-        return true;
-    }
-    some(callbackfn, thisArg) {
-        const length = this.length;
-        for (let i = 0; i < length; i++) {
-            dependant(this, i);
-            if (callbackfn.call(thisArg, reactive(this[i]), i, this)) {
-                return true;
+            values() {
+                dependant(this, keysOf);
+                return makeReactiveIterator(super.values());
             }
-        }
-        dependant(this, 'length');
-        return false;
-    }
-    // Side-effectful
-    push(...items) {
-        const oldLength = this.length;
-        try {
-            return this.push(...items);
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'push' }, range(oldLength, oldLength + items.length - 1, { length: true }));
-        }
-    }
-    pop() {
-        if (this.length === 0)
-            return undefined;
-        try {
-            return reactive(this.pop());
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'pop' }, index(this.length));
-        }
-    }
-    shift() {
-        if (this.length === 0)
-            return undefined;
-        try {
-            return reactive(this.shift());
-        }
-        finally {
-            touched(this, { type: 'bunch', method: 'shift' }, range(0, this.length + 1, { length: true }));
-        }
-    }
-    unshift(...items) {
-        try {
-            return this.unshift(...items);
-        }
-        finally {
-            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 reactive(this.splice(start));
-            return reactive(this.splice(start, deleteCount, ...items));
-        }
-        finally {
-            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 {
-            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(reactive(a), reactive(b)));
-        }
-        finally {
-            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) {
-                touched(this, { type: 'bunch', method: 'fill' }, range(k, final - 1));
+            [(_fill_decorators = [atomic], _pop_decorators = [atomic], _push_decorators = [atomic], _reverse_decorators = [atomic], _shift_decorators = [atomic], _sort_decorators = [atomic], _splice_decorators = [atomic], _unshift_decorators = [atomic], Symbol.iterator)]() {
+                dependant(this, keysOf);
+                return makeReactiveIterator(super[Symbol.iterator]());
             }
-        }
-    }
-    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) {
-                touched(this, { type: 'bunch', method: 'copyWithin' }, range(to, to + count - 1));
+            toReversed() {
+                return reactive(super.toReversed());
+            }
+            toSorted(compareFn) {
+                const wrappedCompare = compareFn
+                    ? (a, b) => compareFn(reactive(a), reactive(b))
+                    : undefined;
+                return reactive(super.toSorted(wrappedCompare));
+            }
+            // biome-ignore lint/complexity/noArguments: Needed to distinguish fn() from fn(undefined)
+            toSpliced(start, deleteCount, ...items) {
+                if (arguments.length > 2)
+                    return reactive(super.toSpliced(start, deleteCount, ...items.map(unwrap)));
+                if (arguments.length === 2)
+                    return reactive(super.toSpliced(start, deleteCount));
+                if (arguments.length === 1)
+                    return reactive(super.toSpliced(start));
+                return reactive([...this]);
+            }
+            with(index, value) {
+                return reactive(super.with(index, unwrap(value)));
+            }
+            constructor() {
+                super(...arguments);
+                __runInitializers(this, _instanceExtraInitializers);
             }
-        }
-    }
-}
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(_a, null, _fill_decorators, { kind: "method", name: "fill", static: false, private: false, access: { has: obj => "fill" in obj, get: obj => obj.fill }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _pop_decorators, { kind: "method", name: "pop", static: false, private: false, access: { has: obj => "pop" in obj, get: obj => obj.pop }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _push_decorators, { kind: "method", name: "push", static: false, private: false, access: { has: obj => "push" in obj, get: obj => obj.push }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _reverse_decorators, { kind: "method", name: "reverse", static: false, private: false, access: { has: obj => "reverse" in obj, get: obj => obj.reverse }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _shift_decorators, { kind: "method", name: "shift", static: false, private: false, access: { has: obj => "shift" in obj, get: obj => obj.shift }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _sort_decorators, { kind: "method", name: "sort", static: false, private: false, access: { has: obj => "sort" in obj, get: obj => obj.sort }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _splice_decorators, { kind: "method", name: "splice", static: false, private: false, access: { has: obj => "splice" in obj, get: obj => obj.splice }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _unshift_decorators, { kind: "method", name: "unshift", static: false, private: false, access: { has: obj => "unshift" in obj, get: obj => obj.unshift }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
 
 /**
  * Reactive wrapper around JavaScript's WeakMap class
@@ -2555,7 +2714,7 @@ class ReactiveMap extends Map {
         this.forEach(callbackfn, thisArg);
     }
     keys() {
-        dependant(contentRef(this));
+        dependant(contentRef(this), keysOf);
         return this.keys();
     }
     values() {
@@ -2712,11 +2871,14 @@ class ReactiveSet extends Set {
 }
 
 // Register native collection types to use specialized reactive wrappers
+console.time('mutts-reactive-init');
 metaProtos.set(Array, ReactiveArray.prototype);
 metaProtos.set(Set, ReactiveSet.prototype);
 metaProtos.set(WeakSet, ReactiveWeakSet.prototype);
 metaProtos.set(Map, ReactiveMap.prototype);
 metaProtos.set(WeakMap, ReactiveWeakMap.prototype);
+wrapProtos.set(Array, ReactiveArrayWrapper.prototype);
+console.timeEnd('mutts-reactive-init');
 /**
  * Object containing internal reactive system state for debugging and profiling
  */
@@ -2959,7 +3121,7 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.9";
+var version$1 = "1.0.10";
 var pkg = {
 	version: version$1};
 
@@ -2976,6 +3138,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')
@@ -3007,5 +3170,5 @@ if (globalScope) {
     globalScope[GLOBAL_MUTTS_KEY] = currentSourceInfo;
 }
 
-export { ArrayReadForward as A, setAt as B, throttle as C, Destroyable as D, Eventful as E, unreactive as F, watch as G, Indexable as I, Register as R, DestructionError as a, allocated as b, allocatedValues as c, attend as d, cache as e, cached as f, callOnGC as g, chainPromise as h, debounce as i, deepWatch as j, deprecated as k, describe as l, descriptor as m, destructor as n, forwardArray as o, getActiveProjection as p, getAt as q, isCached as r, lift as s, memoize as t, organize as u, organized as v, profileInfo as w, project as x, register as y, scan as z };
-//# sourceMappingURL=index-2vea86wD.esm.js.map
+export { ArrayReadForward as A, setAt as B, throttle as C, Destroyable as D, Eventful as E, unreactive as F, watch as G, when as H, Indexable as I, Register as R, DestructionError as a, allocated as b, allocatedValues as c, arrayDiff as d, attend as e, cache as f, cached as g, callOnGC as h, chainPromise as i, debounce as j, deepWatch as k, deprecated as l, descriptor as m, destructor as n, forwardArray as o, getAt as p, isCached as q, lift as r, memoize as s, morph as t, organize as u, organized as v, profileInfo as w, register as x, resource as y, scan as z };
+//# sourceMappingURL=index-CaaQQlPJ.esm.js.map