mutts 1.0.10 → 1.0.12

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

@@ -1,4 +1,4 @@
-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';
+import { t as decorator, B as flavored, O as isReactive, $ as reactive, x as effect, a4 as touched, S as link, G as getState, aa as dependant, a5 as touched1, ab as keysOf, ac as markWithRoot, ad as objectsWithDeepWatchers, ae as effectToDeepWatchedObjects, a7 as untracked, af as deepWatchers, a0 as options, L as isNonReactive, a8 as unwrap, ag as registerDeepWatcher, V as named, ah as rootFunctionSymbol, _ as proxyToObject, ai as getRoot, u as deepCompare, aj as optionCall, a2 as root, ak as FoolProof, z as flavorOptions, al as effectHistory, p as captured, am as unreactiveProperties, g as addUnreactiveProps, an as __runInitializers, ao as __esDecorate, n as atomic, ap as batch, aq as contentRef, ar as notifyPropertyChange, as as metaProtos, at as wrapProtos, au as objectParents, av as watchers, aw as effectToReactiveObjects, W as objectToProxy } from './proxy-D2C49sXH.esm.js';
 
 // Integrated with `using` statement via Symbol.dispose
 const fr = new FinalizationRegistry((f) => f());
@@ -744,211 +744,6 @@ function chainPromise(given) {
     return chained;
 }
 
-const memoizedRegistry = new WeakMap();
-const wrapperRegistry = new WeakMap();
-function getBranch(tree, key) {
-    tree.branches ?? (tree.branches = new WeakMap());
-    let branch = tree.branches.get(key);
-    if (!branch) {
-        branch = {};
-        tree.branches.set(key, branch);
-    }
-    return branch;
-}
-function memoizeFunction(fn, opts) {
-    const fnRoot = getRoot(fn);
-    const existing = memoizedRegistry.get(fnRoot);
-    if (existing)
-        return existing;
-    const cacheRoot = {};
-    const memoized = markWithRoot(function memoized(...args) {
-        if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
-            if (opts?.lenient)
-                return fn.apply(this, args);
-            throw new Error('memoize expects non-null object arguments');
-        }
-        let node = cacheRoot;
-        // Note: decorators add `this` as first argument
-        for (const arg of args) {
-            node = getBranch(node, arg);
-        }
-        dependant(node, 'memoize');
-        if ('result' in node) {
-            if (options.onMemoizationDiscrepancy) {
-                const wasVerification = options.isVerificationRun;
-                options.isVerificationRun = true;
-                try {
-                    const fresh = untracked(() => fn.apply(this, args));
-                    if (!deepCompare(node.result, fresh)) {
-                        optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
-                    }
-                }
-                finally {
-                    options.isVerificationRun = wasVerification;
-                }
-            }
-            return node.result;
-        }
-        // Create memoize internal effect to track dependencies and invalidate cache
-        // Use untracked to prevent the effect creation from being affected by parent effects
-        node.cleanup = root(() => effect.named('memoize')(() => {
-            // Execute the function and track its dependencies
-            // The function execution will automatically track dependencies on reactive objects
-            node.result = fn.apply(this, args);
-            return (reason) => {
-                // When dependencies change, clear the cache and notify consumers
-                delete node.result;
-                touched1(node, { type: 'invalidate', prop: args }, 'memoize');
-                // Lazy memoization: stop the effect so it doesn't re-run immediately.
-                // It will be re-created on next access.
-                if (node.cleanup) {
-                    node.cleanup({ type: 'invalidate', cause: reason });
-                    node.cleanup = undefined;
-                }
-            };
-        }, { opaque: true }));
-        if (options.onMemoizationDiscrepancy) {
-            const wasVerification = options.isVerificationRun;
-            options.isVerificationRun = true;
-            try {
-                const fresh = untracked(() => fn.apply(this, args));
-                if (!deepCompare(node.result, fresh)) {
-                    optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
-                }
-            }
-            finally {
-                options.isVerificationRun = wasVerification;
-            }
-        }
-        return node.result;
-    }, fn);
-    memoizedRegistry.set(fnRoot, memoized);
-    memoizedRegistry.set(memoized, memoized);
-    return memoized;
-}
-function memoizeObject(target, opts) {
-    const existing = memoizedRegistry.get(target);
-    if (existing)
-        return existing;
-    const proxy = new Proxy(target, {
-        get(source, prop, receiver) {
-            // 1. Walk prototype chain to find descriptor
-            let current = source;
-            let desc;
-            while (current) {
-                desc = Object.getOwnPropertyDescriptor(current, prop);
-                if (desc)
-                    break;
-                current = Object.getPrototypeOf(current);
-            }
-            if (!desc)
-                return Reflect.get(source, prop, receiver);
-            // 2. If getter, memoize
-            if (desc.get) {
-                const originalGetter = desc.get;
-                let wrapper = wrapperRegistry.get(originalGetter);
-                if (!wrapper) {
-                    wrapper = markWithRoot(named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
-                        return originalGetter.call(that);
-                    }), {
-                        propertyKey: prop,
-                    });
-                    const origRoot = originalGetter[rootFunctionSymbol];
-                    if (origRoot)
-                        wrapper[rootFunctionSymbol] = origRoot;
-                    wrapperRegistry.set(originalGetter, wrapper);
-                }
-                const memoized = memoizeFunction(wrapper, opts);
-                return memoized(receiver);
-            }
-            // 3. Otherwise forward
-            return Reflect.get(source, prop, receiver);
-        },
-        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
-        set(source, prop, value, _receiver) {
-            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
-            // it recognizes itself and triggers change notifications.
-            return Reflect.set(source, prop, value, source);
-        },
-    });
-    proxyToObject.set(proxy, target);
-    memoizedRegistry.set(target, proxy);
-    return proxy;
-}
-/**
- * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
- *
- * When used as a decorator on getters or methods, it caches the result and automatically
- * invalidates the cache when reactive dependencies change.
- *
- * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
- *
- * @example
- * ```typescript
- * class User {
- *   @memoize
- *   get fullName() {
- *     return `${this.firstName} ${this.lastName}`
- *   }
- * }
- *
- * // Or as a function wrapper
- * const expensive = memoize((obj: SomeObject) => {
- *   return heavyComputation(obj)
- * })
- * ```
- */
-function makeMemoizeDecorator(memoizeOpts) {
-    return decorator({
-        getter(original, target, propertyKey) {
-            return function () {
-                let wrapper = wrapperRegistry.get(original);
-                if (!wrapper) {
-                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
-                        return original.call(that);
-                    }), {
-                        method: original,
-                        propertyKey,
-                    });
-                    const origRoot = original[rootFunctionSymbol];
-                    if (origRoot)
-                        wrapper[rootFunctionSymbol] = origRoot;
-                    wrapperRegistry.set(original, wrapper);
-                }
-                const memoized = memoizeFunction(wrapper, memoizeOpts);
-                return memoized(this);
-            };
-        },
-        method(original, target, name) {
-            return function (...args) {
-                let wrapper = wrapperRegistry.get(original);
-                if (!wrapper) {
-                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
-                        return original.call(that, ...args);
-                    }), {
-                        method: original,
-                        propertyKey: name,
-                    });
-                    const origRoot = original[rootFunctionSymbol];
-                    if (origRoot)
-                        wrapper[rootFunctionSymbol] = origRoot;
-                    wrapperRegistry.set(original, wrapper);
-                }
-                const memoized = memoizeFunction(wrapper, memoizeOpts);
-                return memoized(this, ...args);
-            };
-        },
-        default: (target) => typeof target === 'object'
-            ? memoizeObject(target, memoizeOpts)
-            : memoizeFunction(target, memoizeOpts),
-    });
-}
-const memoize = flavored(makeMemoizeDecorator(), {
-    get lenient() {
-        return makeMemoizeDecorator({ lenient: true });
-    },
-});
-
 function attend(source, callback) {
     const enumerate = typeof source === 'function'
         ? source
@@ -960,14 +755,14 @@ function attend(source, callback) {
                     ? () => source.values()
                     : () => Object.keys(source);
     const keyEffects = new Map();
-    const outer = effect(({ ascend }) => {
+    const outer = effect.named('attend')(({ ascend }) => {
         const keys = new Set();
         for (const key of enumerate())
             keys.add(key);
         for (const key of keys) {
             if (keyEffects.has(key))
                 continue;
-            keyEffects.set(key, ascend(() => effect(() => callback(key))));
+            keyEffects.set(key, ascend(() => effect.named(`attend:${key}`)((access) => callback(key, access))));
         }
         for (const key of Array.from(keyEffects.keys())) {
             if (!keys.has(key)) {
@@ -983,146 +778,10 @@ function attend(source, callback) {
         keyEffects.clear();
     };
 }
-/**
- * Perform a reactive scan over an array of items.
- *
- * This implementation is highly optimized for performance and fine-grained reactivity:
- * - **Incremental Updates**: Changes to an item only trigger re-computation from that
- *   point onwards in the result chain.
- * - **Move Optimization**: If items are moved within the array, their accumulated
- *   values are reused as long as their predecessor remains the same.
- * - **Duplicate Support**: Correctly handles multiple occurrences of the same object
- *   instance using an internal occurrence tracking mechanism.
- * - **Memory Efficient**: Uses `WeakMap` for caching intermediates, which are
- *   automatically cleared when source items are garbage collected.
- *
- * @example
- * ```typescript
- * const source = reactive([{ val: 1 }, { val: 2 }, { val: 3 }])
- * const sum = scan(source, (acc, item) => acc + item.val, 0)
- *
- * expect([...sum]).toEqual([1, 3, 6])
- *
- * // Modifying an item only re-computes subsequent sums
- * source[1].val = 10
- * expect([...sum]).toEqual([1, 11, 14])
- * ```
- *
- * @param source The source array of objects (will be made reactive)
- * @param callback The accumulator function called with (accumulator, currentItem)
- * @param initialValue The starting value for the accumulation
- * @returns A reactive array of accumulated values, with a [cleanup] property to stop the tracking
- */
-function scan(source, callback, initialValue) {
-    const observedSource = reactive(source);
-    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
-    const indexToIntermediate = reactive([]);
-    const intermediaries = new WeakMap();
-    let Intermediate = (() => {
-        var _a;
-        let _instanceExtraInitializers = [];
-        let _get_acc_decorators;
-        return _a = class Intermediate {
-                constructor(val, prev) {
-                    this.val = (__runInitializers(this, _instanceExtraInitializers), val);
-                    this.prev = prev;
-                }
-                get acc() {
-                    const prevAcc = this.prev ? this.prev.acc : initialValue;
-                    return callback(prevAcc, this.val);
-                }
-            },
-            (() => {
-                const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-                _get_acc_decorators = [memoize];
-                __esDecorate(_a, null, _get_acc_decorators, { kind: "getter", name: "acc", static: false, private: false, access: { has: obj => "acc" in obj, get: obj => obj.acc }, metadata: _metadata }, null, _instanceExtraInitializers);
-                if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            })(),
-            _a;
-    })();
-    function disposeIndex(index) {
-        const stop = indexEffects.get(index);
-        if (stop) {
-            stop();
-            indexEffects.delete(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++)
-            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');
-                }
-                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);
-                    });
-                }
-                prev = intermediate;
-            }
-        // Cleanup trailing indices
-        for (const index of Array.from(indexEffects.keys())) {
-            if (index >= length)
-                disposeIndex(index);
-        }
-        // Ensure result length matches source length
-        if (rawResult.length !== length) {
-            FoolProof.set(result, 'length', length, result);
-        }
-    });
-    return cleanedBy(result, ((reason) => {
-        mainEffect(reason);
-        for (const stop of indexEffects.values())
-            stop(reason);
-        indexEffects.clear();
-    }));
-}
 function lift(cb) {
     let result;
     let rawResult;
-    const liftCleanup = effect.named('lift')(markWithRoot((access) => {
+    const liftCleanup = effect.named(`lift:${cb.name}`)(markWithRoot((access) => {
         const source = cb(access);
         if (!source || typeof source !== 'object')
             throw new Error('lift callback must return an array or object');
@@ -1135,11 +794,8 @@ function lift(cb) {
             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];
+            for (const { indexA, sliceA, sliceB } of arrayDiff(res, source).sort((a, b) => a.indexA - b.indexA))
                 res.splice(indexA, sliceA.length, ...sliceB);
-            }
         }
         else {
             for (const key of Object.keys(source)) {
@@ -1166,7 +822,7 @@ function lift(cb) {
                 }
         }
     }, cb));
-    return cleanedBy(result, liftCleanup);
+    return link(result, liftCleanup);
 }
 /**
  * Reactively maps an array source through `fn`, producing a lazy reactive output array.
@@ -1187,7 +843,7 @@ function lift(cb) {
  */
 function morphArray(source, fn, options) {
     if (typeof source !== 'function' && !isReactive(source) && options?.pure === true) {
-        return source.map(fn);
+        return source.map((i) => fn(i));
     }
     let track;
     const itemEffects = new Map();
@@ -1209,17 +865,14 @@ function morphArray(source, fn, options) {
         }
         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 });
-                    };
-                });
-            });
+            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache[indexRef.value] = fn(input, access);
+                return (reason) => {
+                    delete cache[indexRef.value];
+                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop?.({ type: 'invalidate', cause: reason });
+                };
+            }));
             itemEffects.set(key, { stop, index: indexRef });
         }
     }
@@ -1236,7 +889,7 @@ function morphArray(source, fn, options) {
             return Reflect.has(input, prop);
         },
     });
-    const stopMain = effect.named('morph:array')(({ ascend }) => {
+    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
         track = ascend;
         const newInput = [...(typeof source === 'function' ? source() : source)];
         const diffs = arrayDiff(input, newInput).toSorted((a, b) => b.indexA - a.indexA);
@@ -1251,7 +904,7 @@ function morphArray(source, fn, options) {
                     // 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) {
+                    for (const [idx, _entry] of entries) {
                         if (idx >= diff.indexA + diff.sliceA.length) {
                             itemEffects.delete(idx);
                         }
@@ -1283,7 +936,7 @@ function morphArray(source, fn, options) {
         }
         input = newInput;
     });
-    return cleanedBy(proxy, (reason) => {
+    return link(proxy, (reason) => {
         stopMain(reason);
         for (const entry of itemEffects.values())
             entry.stop(reason);
@@ -1305,7 +958,7 @@ 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));
+            res.set(k, fn(v, k));
         return res;
     }
     let track;
@@ -1322,15 +975,15 @@ function morphMap(source, fn, options) {
     function computeItem(key, val) {
         const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
         if (isPure) {
-            cache.set(key, track(() => fn(val)));
+            cache.set(key, track(() => fn(val, key)));
         }
         else {
-            const stop = track(() => effect.opaque(() => {
-                cache.set(key, fn(source.get(key)));
+            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache.set(key, fn(source.get(key), key, access));
                 return (reason) => {
                     cache.delete(key);
                     touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop({ type: 'invalidate', cause: reason });
+                    stop?.({ type: 'invalidate', cause: reason });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1374,7 +1027,7 @@ function morphMap(source, fn, options) {
         },
     });
     let stateSnapshot = getState(source);
-    const stopMain = effect.named('morph:map')(({ ascend }) => {
+    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
         track = ascend;
         dependant(source, keysOf);
         while ('evolution' in stateSnapshot) {
@@ -1390,7 +1043,7 @@ function morphMap(source, fn, options) {
             }
         }
     });
-    return cleanedBy(proxy, (reason) => {
+    return link(proxy, (reason) => {
         stopMain(reason);
         for (const stop of itemEffects.values())
             stop(reason);
@@ -1412,7 +1065,7 @@ 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]);
+            res[k] = fn(source[k], k);
         return res;
     }
     let track;
@@ -1428,15 +1081,15 @@ function morphRecord(source, fn, options) {
     function computeItem(key, val) {
         const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
         if (isPure) {
-            cache[key] = track(() => fn(val));
+            cache[key] = track(() => fn(val, key));
         }
         else {
-            const stop = track(() => effect.opaque(() => {
-                cache[key] = fn(source[key]);
+            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache[key] = fn(source[key], key, access);
                 return (reason) => {
                     delete cache[key];
                     touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop({ type: 'invalidate', cause: reason });
+                    stop?.({ type: 'invalidate', cause: reason });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1463,7 +1116,7 @@ function morphRecord(source, fn, options) {
         },
     });
     let stateSnapshot = getState(source);
-    const stopMain = effect.named('morph:record')(({ ascend }) => {
+    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
         track = ascend;
         // Track only structural changes on source
         dependant(source, keysOf);
@@ -1480,7 +1133,7 @@ function morphRecord(source, fn, options) {
             }
         }
     });
-    return cleanedBy(proxy, (reason) => {
+    return link(proxy, (reason) => {
         stopMain(reason);
         for (const stop of itemEffects.values())
             stop(reason);
@@ -1539,7 +1192,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
     const wrappedCallback = markWithRoot((() => callback(target)), callback);
     registerDeepWatcher();
     // Use the existing effect system to register dependencies
-    return effect(() => {
+    return effect.named('deepWatch')(() => {
         // Mark the target object as having deep watchers
         objectsWithDeepWatchers.add(target);
         // Track which objects this effect is watching for cleanup
@@ -1575,35 +1228,24 @@ function deepWatch(target, callback, { immediate = false } = {}) {
                 }
             }
             // Also handle array indices and length
-            // biome-ignore lint/suspicious/useIsArray: Check for both native arrays and reactive arrays
-            if (Array.isArray(obj) || obj instanceof Array) {
-                // Access array length to register dependency on length changes
-                const length = obj.length;
-                // Access all current array elements to register dependencies
-                for (let i = 0; i < length; i++) {
-                    // Access the array element to register dependency
-                    const value = obj[i];
-                    // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
-                    traverseAndTrack(reactiveValue, depth + 1);
-                }
-            }
-            // Handle Set values (deep watch values only, not keys since Sets don't have separate keys)
-            else if (obj instanceof Set) {
-                // Access all Set values to register dependencies
+            // Handle arrays and collections using iterators to ensure proxy tracking is triggered
+            if (typeof obj[Symbol.iterator] === 'function') {
+                // Access the iterator to track additions/removals/collection changes
                 for (const value of obj) {
                     // Make the value reactive if it's an object
                     const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
                     traverseAndTrack(reactiveValue, depth + 1);
                 }
-            }
-            // Handle Map values (deep watch values only, not keys)
-            else if (obj instanceof Map) {
-                // Access all Map values to register dependencies
-                for (const [_key, value] of obj) {
-                    // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
-                    traverseAndTrack(reactiveValue, depth + 1);
+                // Explicitly depend on length so array mutations changing count trigger re-evaluation
+                if ('length' in obj) {
+                    dependant(obj, 'length');
+                }
+                // For Maps, also ensure we track values explicitly if the iterator yields entries
+                if (obj instanceof Map) {
+                    for (const value of obj.values()) {
+                        const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
+                        traverseAndTrack(reactiveValue, depth + 1);
+                    }
                 }
             }
             // Note: WeakSet and WeakMap cannot be iterated, so we can't deep watch their contents
@@ -1640,12 +1282,217 @@ function deepWatch(target, callback, { immediate = false } = {}) {
                         objectsWithDeepWatchers.delete(obj);
                     }
                 }
-                // Clean up the tracking data
-                effectToDeepWatchedObjects.delete(wrappedCallback);
+                // Clean up the tracking data
+                effectToDeepWatchedObjects.delete(wrappedCallback);
+            }
+        };
+    });
+}
+
+const memoizedRegistry = new WeakMap();
+const wrapperRegistry = new WeakMap();
+function getBranch(tree, key) {
+    tree.branches ?? (tree.branches = new WeakMap());
+    let branch = tree.branches.get(key);
+    if (!branch) {
+        branch = {};
+        tree.branches.set(key, branch);
+    }
+    return branch;
+}
+function memoizeFunction(fn, opts) {
+    const fnRoot = getRoot(fn);
+    const existing = memoizedRegistry.get(fnRoot);
+    if (existing)
+        return existing;
+    const cacheRoot = {};
+    const memoized = markWithRoot(function memoized(...args) {
+        if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
+            if (opts?.lenient)
+                return fn.apply(this, args);
+            throw new Error('memoize expects non-null object arguments');
+        }
+        let node = cacheRoot;
+        // Note: decorators add `this` as first argument
+        for (const arg of args) {
+            node = getBranch(node, arg);
+        }
+        dependant(node, 'memoize');
+        if ('result' in node) {
+            if (options.onMemoizationDiscrepancy) {
+                const wasVerification = options.isVerificationRun;
+                options.isVerificationRun = true;
+                try {
+                    const fresh = untracked(() => fn.apply(this, args));
+                    if (!deepCompare(node.result, fresh)) {
+                        optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
+                    }
+                }
+                finally {
+                    options.isVerificationRun = wasVerification;
+                }
+            }
+            return node.result;
+        }
+        // Create memoize internal effect to track dependencies and invalidate cache
+        // Use untracked to prevent the effect creation from being affected by parent effects
+        node.cleanup = root(() => effect.named('memoize')(() => {
+            // Execute the function and track its dependencies
+            // The function execution will automatically track dependencies on reactive objects
+            node.result = fn.apply(this, args);
+            return (reason) => {
+                // When dependencies change, clear the cache and notify consumers
+                delete node.result;
+                touched1(node, { type: 'invalidate', prop: args }, 'memoize');
+                // Lazy memoization: stop the effect so it doesn't re-run immediately.
+                // It will be re-created on next access.
+                if (node.cleanup) {
+                    node.cleanup({ type: 'invalidate', cause: reason });
+                    node.cleanup = undefined;
+                }
+            };
+        }, { opaque: true }));
+        if (options.onMemoizationDiscrepancy) {
+            const wasVerification = options.isVerificationRun;
+            options.isVerificationRun = true;
+            try {
+                const fresh = untracked(() => fn.apply(this, args));
+                if (!deepCompare(node.result, fresh)) {
+                    optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
+                }
+            }
+            finally {
+                options.isVerificationRun = wasVerification;
+            }
+        }
+        return node.result;
+    }, fn);
+    memoizedRegistry.set(fnRoot, memoized);
+    memoizedRegistry.set(memoized, memoized);
+    return memoized;
+}
+function memoizeObject(target, opts) {
+    const existing = memoizedRegistry.get(target);
+    if (existing)
+        return existing;
+    const proxy = new Proxy(target, {
+        get(source, prop, receiver) {
+            // 1. Walk prototype chain to find descriptor
+            let current = source;
+            let desc;
+            while (current) {
+                desc = Object.getOwnPropertyDescriptor(current, prop);
+                if (desc)
+                    break;
+                current = Object.getPrototypeOf(current);
+            }
+            if (!desc)
+                return Reflect.get(source, prop, receiver);
+            // 2. If getter, memoize
+            if (desc.get) {
+                const originalGetter = desc.get;
+                let wrapper = wrapperRegistry.get(originalGetter);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
+                        return originalGetter.call(that);
+                    }), {
+                        propertyKey: prop,
+                    });
+                    const origRoot = originalGetter[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(originalGetter, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, opts);
+                return memoized(receiver);
             }
-        };
+            // 3. Otherwise forward
+            return Reflect.get(source, prop, receiver);
+        },
+        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
+        set(source, prop, value, _receiver) {
+            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
+            // it recognizes itself and triggers change notifications.
+            return Reflect.set(source, prop, value, source);
+        },
+    });
+    proxyToObject.set(proxy, target);
+    memoizedRegistry.set(target, proxy);
+    return proxy;
+}
+/**
+ * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
+ *
+ * When used as a decorator on getters or methods, it caches the result and automatically
+ * invalidates the cache when reactive dependencies change.
+ *
+ * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   @memoize
+ *   get fullName() {
+ *     return `${this.firstName} ${this.lastName}`
+ *   }
+ * }
+ *
+ * // Or as a function wrapper
+ * const expensive = memoize((obj: SomeObject) => {
+ *   return heavyComputation(obj)
+ * })
+ * ```
+ */
+function makeMemoizeDecorator(memoizeOpts) {
+    return decorator({
+        getter(original, target, propertyKey) {
+            return function () {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
+                        return original.call(that);
+                    }), {
+                        method: original,
+                        propertyKey,
+                    });
+                    const origRoot = original[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this);
+            };
+        },
+        method(original, target, name) {
+            return function (...args) {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
+                        return original.call(that, ...args);
+                    }), {
+                        method: original,
+                        propertyKey: name,
+                    });
+                    const origRoot = original[rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this, ...args);
+            };
+        },
+        default: (target) => typeof target === 'object'
+            ? memoizeObject(target, memoizeOpts)
+            : memoizeFunction(target, memoizeOpts),
     });
 }
+const memoize = flavored(makeMemoizeDecorator(), {
+    get lenient() {
+        return makeMemoizeDecorator({ lenient: true });
+    },
+});
 
 /**
  * Organizes a source object's properties into a target object using a callback function.
@@ -1721,7 +1568,7 @@ function organized(source, apply, baseTarget = {}) {
         });
         return apply(accessBase, target);
     });
-    return cleanedBy(target, (reason) => stop(reason));
+    return link(target, (reason) => stop(reason));
 }
 /**
  * Organizes a property on a target object
@@ -1764,7 +1611,7 @@ changed, options = {}) {
 function watchObject(value, changed, { immediate = false, deep = false } = {}) {
     if (deep)
         return deepWatch(value, changed, { immediate });
-    return effect(function watchObjectEffect() {
+    return effect.named('watch:object')(() => {
         dependant(value);
         if (immediate)
             changed(value);
@@ -1774,7 +1621,7 @@ function watchObject(value, changed, { immediate = false, deep = false } = {}) {
 function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
     let oldValue = unsetYet;
     let deepCleanup;
-    const cbCleanup = effect(markWithRoot(function watchCallBackEffect(access) {
+    const cbCleanup = effect.named('watch:callback')(markWithRoot((access) => {
         const newValue = value(access);
         if (oldValue !== newValue) {
             const old = oldValue;
@@ -1792,12 +1639,10 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
             deepCleanup = deepWatch(newValue, (value) => changed(value, value));
         }
     }, value));
-    return Object.defineProperties(() => {
+    return (() => {
         cbCleanup();
         if (deepCleanup)
             deepCleanup();
-    }, {
-        [stopped]: { get: () => cbCleanup[stopped] },
     });
 }
 //#endregion
@@ -1812,7 +1657,7 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
 function when(predicate, timeout) {
     return new Promise((resolve, reject) => {
         let timer;
-        const stop = effect(function whenEffect(access) {
+        const stop = effect.named('watch:when')((access) => {
             try {
                 const value = predicate(access);
                 if (value) {
@@ -1849,7 +1694,7 @@ function shallowNonReactive(obj) {
     obj = unwrap(obj);
     if (isNonReactive(obj))
         return obj;
-    nonReactiveObjects.add(obj);
+    obj[unreactiveProperties] = true;
     return obj;
 }
 function unreactiveApplication(arg1, ...args) {
@@ -1857,13 +1702,19 @@ function unreactiveApplication(arg1, ...args) {
         ? shallowNonReactive(arg1)
         : ((original) => {
             // Copy the parent's unreactive properties if they exist
-            const parentSet = unreactiveProps.get(original.prototype);
-            const set = new Set(parentSet || []);
-            // Add all arguments (including the first one)
-            set.add(arg1);
-            for (const arg of args)
-                set.add(arg);
-            addUnreactiveProps(original.prototype, set);
+            const parentMarker = original.prototype[unreactiveProperties];
+            // If parent is fully unreactive, child is too
+            if (parentMarker === true) {
+                original.prototype[unreactiveProperties] = true;
+            }
+            else {
+                const set = new Set(parentMarker || []);
+                // Add all arguments (including the first one)
+                set.add(arg1);
+                for (const arg of args)
+                    set.add(arg);
+                addUnreactiveProps(original.prototype, set);
+            }
             return original; // Return the class
         });
 }
@@ -1873,11 +1724,26 @@ function unreactiveApplication(arg1, ...args) {
  */
 const unreactive = decorator({
     class(original) {
-        // Called without arguments, mark entire class as non-reactive
-        nonReactiveClass(original);
+        original.prototype[unreactiveProperties] = true;
     },
     default: unreactiveApplication,
 });
+//#endregion
+//#region resource
+function lazyInit(resource, load) {
+    const creation = effectHistory.active;
+    let fresh = true;
+    return new Proxy(resource, {
+        [Symbol.toStringTag]: 'LazyInit',
+        get(target, prop) {
+            if (fresh) {
+                captured(creation, load)();
+                fresh = false;
+            }
+            return target[prop];
+        },
+    });
+}
 /**
  * Creates a reactive resource that automatically tracks async state.
  * @param fetcher - Async function that returns the value. Reactive dependencies are tracked.
@@ -1885,521 +1751,59 @@ const unreactive = decorator({
  * @returns Reactive Resource object with value, loading, error, latest properties
  */
 function resource(fetcher, options = {}) {
-    const state = reactive({
+    const resource = reactive({
         value: options.initialValue,
         loading: true,
         error: undefined,
         latest: options.initialValue,
-        reload: () => {
+        reload() {
             reloadSignal.value++;
         },
     });
     const reloadSignal = reactive({ value: 0 });
+    // Solve race conditions: make sure a new fast request is not overloaded by a slow old one
     let counter = 0;
-    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
-function getRegisterBase() {
-    class RegisterBase extends Indexable(ArrayReadForward, {
-        get(index) {
-            return this[getAt](index);
-        },
-        set(index, value) {
-            this[setAt](index, value);
-        },
-        getLength() {
-            return this.length;
-        },
-        setLength(value) {
-            this.length = value;
-        },
-    }) {
-        toArray() {
-            return Array.from(this);
-        }
-    }
-    return RegisterBase;
-}
-let RegisterClass = (() => {
-    var _RegisterClass_instances, _RegisterClass_keyFn, _RegisterClass_keys, _RegisterClass_values, _RegisterClass_usage, _RegisterClass_valueInfo, _RegisterClass_keyEffects, _RegisterClass_ascend, _RegisterClass_events, _RegisterClass_rekeyValue;
-    let _classDecorators = [unreactive];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    let _classSuper = getRegisterBase();
-    _classThis = class extends _classSuper {
-        get [(_RegisterClass_keyFn = new WeakMap(), _RegisterClass_keys = new WeakMap(), _RegisterClass_values = new WeakMap(), _RegisterClass_usage = new WeakMap(), _RegisterClass_valueInfo = new WeakMap(), _RegisterClass_keyEffects = new WeakMap(), _RegisterClass_ascend = new WeakMap(), _RegisterClass_events = new WeakMap(), _RegisterClass_instances = new WeakSet(), forwardArray)]() {
-            return this.toArray();
-        }
-        on(eventOrEvents, cb) {
-            // @ts-expect-error Delegate to Eventful
-            return __classPrivateFieldGet(this, _RegisterClass_events, "f").on(eventOrEvents, cb);
-        }
-        off(eventOrEvents, cb) {
-            // @ts-expect-error Delegate to Eventful
-            __classPrivateFieldGet(this, _RegisterClass_events, "f").off(eventOrEvents, cb);
-        }
-        /**
-         * Register a global hook that receives all events
-         */
-        hook(cb) {
-            return __classPrivateFieldGet(this, _RegisterClass_events, "f").hook(cb);
-        }
-        constructor(keyFn, initial) {
-            super();
-            _RegisterClass_instances.add(this);
-            _RegisterClass_keyFn.set(this, void 0);
-            _RegisterClass_keys.set(this, void 0);
-            _RegisterClass_values.set(this, void 0);
-            _RegisterClass_usage.set(this, new Map());
-            _RegisterClass_valueInfo.set(this, new Map());
-            _RegisterClass_keyEffects.set(this, new Set());
-            _RegisterClass_ascend.set(this, void 0);
-            _RegisterClass_events.set(this, new Eventful()
-            /**
-             * Register event listeners for CRUD operations
-             */
-            );
-            /* Moved below initialization */
-            let ascendGet;
-            effect(({ ascend }) => {
-                ascendGet = ascend;
-            });
-            __classPrivateFieldSet(this, _RegisterClass_ascend, ascendGet, "f");
-            if (typeof keyFn !== 'function')
-                throw new Error('Register requires a key function');
-            __classPrivateFieldSet(this, _RegisterClass_keyFn, keyFn, "f");
-            __classPrivateFieldSet(this, _RegisterClass_keys, reactive([]), "f");
-            __classPrivateFieldSet(this, _RegisterClass_values, reactive(new Map()), "f");
-            if (initial)
-                this.push(...initial);
-        }
-        ensureKey(value) {
-            let info = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-            if (info)
-                return info.key;
-            info = { key: undefined };
-            __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").set(value, info);
-            __classPrivateFieldGet(this, _RegisterClass_ascend, "f").call(this, () => {
-                const stop = effect(({ reaction }) => {
-                    const nextKey = __classPrivateFieldGet(this, _RegisterClass_keyFn, "f").call(this, value);
-                    this.assertValidKey(nextKey);
-                    const previousKey = info.key;
-                    if (reaction && previousKey !== undefined && !Object.is(nextKey, previousKey))
-                        __classPrivateFieldGet(this, _RegisterClass_instances, "m", _RegisterClass_rekeyValue).call(this, value, previousKey, nextKey);
-                    info.key = nextKey;
-                });
-                info.stop = stop;
-                __classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").add(stop);
-            });
-            if (info.key === undefined)
-                throw new Error('Register key function must return a property key');
-            return info.key;
-        }
-        assertValidKey(key) {
-            const type = typeof key;
-            if (type !== 'string' && type !== 'number' && type !== 'symbol')
-                throw new Error('Register key function must return a property key');
-        }
-        setKeyValue(key, value, index) {
-            const existing = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-            if (existing !== undefined && existing !== value) {
-                this.cleanupValue(existing);
-                __classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-                if (index !== undefined) {
-                    __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', existing, value, key, index);
-                }
-            }
-            else {
-                __classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-            }
-        }
-        cleanupValue(value) {
-            const info = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-            if (!info)
-                return;
-            const stop = info.stop;
-            if (stop) {
-                info.stop = undefined;
-                __classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").delete(stop);
-                stop();
-            }
-            __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").delete(value);
-        }
-        disposeKeyEffects() {
-            for (const value of Array.from(__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").keys()))
-                this.cleanupValue(value);
-            __classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").clear();
-        }
-        incrementUsage(key) {
-            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key) ?? 0;
-            __classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count + 1);
-        }
-        decrementUsage(key, index) {
-            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key);
-            if (!count)
-                return;
-            if (count <= 1) {
-                const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-                __classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(key);
-                __classPrivateFieldGet(this, _RegisterClass_values, "f").delete(key);
-                if (value !== undefined) {
-                    this.cleanupValue(value);
-                    const idx = index ?? __classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-                    __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('delete', value, key, idx);
-                }
-            }
-            else {
-                __classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count - 1);
-            }
-        }
-        normalizeIndex(index, allowEnd = false) {
-            const length = this.length;
-            let resolved = index;
-            if (resolved < 0)
-                resolved = Math.max(length + resolved, 0);
-            if (resolved > length) {
-                if (allowEnd)
-                    resolved = length;
-                else
-                    throw new RangeError('Index out of bounds');
-            }
-            if (!allowEnd && resolved === length)
-                throw new RangeError('Index out of bounds');
-            return resolved;
-        }
-        assignAt(index, key, value) {
-            const oldKey = __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
-            if (oldKey !== undefined && Object.is(oldKey, key)) {
-                const oldValue = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-                this.setKeyValue(key, value);
-                if (oldValue !== undefined && oldValue !== value) {
-                    __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', oldValue, value, key, index);
-                }
-                return;
-            }
-            if (oldKey !== undefined)
-                this.decrementUsage(oldKey);
-            __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index] = key;
-            this.incrementUsage(key);
-            this.setKeyValue(key, value);
-            __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
-        }
-        insertKeyValue(index, key, value) {
-            __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 0, key);
-            this.incrementUsage(key);
-            this.setKeyValue(key, value);
-            __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
-        }
-        rebuildFrom(values) {
-            this.disposeKeyEffects();
-            __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(0, __classPrivateFieldGet(this, _RegisterClass_keys, "f").length);
-            __classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
-            __classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
-            for (const value of values) {
-                const key = this.ensureKey(value);
-                __classPrivateFieldGet(this, _RegisterClass_keys, "f").push(key);
-                this.incrementUsage(key);
-                __classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-            }
-        }
-        get length() {
-            return __classPrivateFieldGet(this, _RegisterClass_keys, "f").length;
-        }
-        [(_RegisterClass_rekeyValue = function _RegisterClass_rekeyValue(value, oldKey, newKey) {
-            if (Object.is(oldKey, newKey))
-                return;
-            const existingValue = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(newKey);
-            if (existingValue !== undefined && existingValue !== value)
-                throw new Error(`Register key collision for key ${String(newKey)}`);
-            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(oldKey);
-            if (!count)
-                return;
-            const existingCount = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(newKey) ?? 0;
-            this.setKeyValue(newKey, value);
-            let index = -1;
-            for (let i = 0; i < __classPrivateFieldGet(this, _RegisterClass_keys, "f").length; i++)
-                if (Object.is(__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i], oldKey)) {
-                    __classPrivateFieldGet(this, _RegisterClass_keys, "f")[i] = newKey;
-                    if (index === -1)
-                        index = i;
-                }
-            __classPrivateFieldGet(this, _RegisterClass_usage, "f").set(newKey, existingCount + count);
-            __classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(oldKey);
-            __classPrivateFieldGet(this, _RegisterClass_values, "f").delete(oldKey);
-            const updatedInfo = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-            if (updatedInfo)
-                updatedInfo.key = newKey;
-            if (index !== -1) {
-                __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('rekey', value, oldKey, newKey, index);
-            }
-        }, getAt)](index) {
-            const key = __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
-            return key === undefined ? undefined : __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-        }
-        [setAt](index, value) {
-            const key = this.ensureKey(value);
-            if (index === this.length) {
-                this.insertKeyValue(index, key, value);
-                return;
-            }
-            const normalized = this.normalizeIndex(index);
-            this.assignAt(normalized, key, value);
-        }
-        push(...items) {
-            for (const item of items) {
-                const key = this.ensureKey(item);
-                this.insertKeyValue(this.length, key, item);
-            }
-            return this.length;
-        }
-        pop() {
-            if (!this.length)
-                return undefined;
-            return this.removeAt(this.length - 1);
-        }
-        shift() {
-            if (!this.length)
-                return undefined;
-            return this.removeAt(0);
-        }
-        unshift(...items) {
-            let index = 0;
-            for (const item of items) {
-                const key = this.ensureKey(item);
-                this.insertKeyValue(index++, key, item);
-            }
-            return this.length;
-        }
-        splice(start, deleteCount, ...items) {
-            const normalizedStart = this.normalizeIndex(start, true);
-            const maxDeletions = this.length - normalizedStart;
-            const actualDelete = Math.min(deleteCount === undefined ? maxDeletions : Math.max(deleteCount, 0), maxDeletions);
-            const keysToInsert = [];
-            for (const item of items)
-                keysToInsert.push(this.ensureKey(item));
-            const removedKeys = __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(normalizedStart, actualDelete, ...keysToInsert);
-            const removedValues = [];
-            for (let i = 0; i < removedKeys.length; i++) {
-                const key = removedKeys[i];
-                if (key === undefined)
-                    continue;
-                const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-                this.decrementUsage(key, normalizedStart + i);
-                removedValues.push(value);
-            }
-            for (let i = 0; i < keysToInsert.length; i++) {
-                const key = keysToInsert[i];
-                const value = items[i];
-                this.incrementUsage(key);
-                this.setKeyValue(key, value);
-            }
-            return removedValues;
-        }
-        clear() {
-            __classPrivateFieldGet(this, _RegisterClass_keys, "f").length = 0;
-            __classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
-            __classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
-            this.disposeKeyEffects();
-        }
-        get(key) {
-            return __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-        }
-        set(key, value) {
-            if (__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
-                this.setKeyValue(key, value);
-        }
-        remove(key) {
-            let index = this.indexOfKey(key);
-            while (index !== -1) {
-                this.removeAt(index);
-                index = this.indexOfKey(key);
-            }
-        }
-        removeAt(index) {
-            const [key] = __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 1);
-            if (key === undefined)
-                return undefined;
-            const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-            this.decrementUsage(key, index);
-            return value;
-        }
-        /**
-         * Keep only the items for which the predicate returns true.
-         * Items for which the predicate returns false are removed.
-         *
-         * The predicate is evaluated once per distinct key; duplicate keys
-         * will follow the same keep/remove decision.
-         */
-        keep(predicate) {
-            const decisions = new Map();
-            for (const [index, key] of __classPrivateFieldGet(this, _RegisterClass_keys, "f").entries()) {
-                if (decisions.has(key)) {
-                    if (!decisions.get(key))
-                        this.removeAt(index);
-                    continue;
-                }
-                const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-                const shouldKeep = predicate(value);
-                decisions.set(key, shouldKeep);
-                if (!shouldKeep)
-                    this.removeAt(index);
-            }
-        }
-        hasKey(key) {
-            return __classPrivateFieldGet(this, _RegisterClass_usage, "f").has(key);
-        }
-        indexOfKey(key) {
-            return __classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-        }
-        mapKeys() {
-            return __classPrivateFieldGet(this, _RegisterClass_values, "f").keys();
-        }
-        update(...values) {
-            for (const value of values) {
-                const key = this.ensureKey(value);
-                if (__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key)) {
-                    const index = __classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-                    this.setKeyValue(key, value, index);
+    return lazyInit(resource, () => {
+        link(resource, effect.named('watch:resource')((access) => {
+            // Track reload signal to enable manual reloading
+            void reloadSignal.value;
+            const id = ++counter;
+            resource.loading = true;
+            resource.error = undefined;
+            try {
+                const result = fetcher(access);
+                if (result instanceof Promise) {
+                    resource.promise = result
+                        .then((val) => {
+                        if (id === counter) {
+                            resource.value = val;
+                            resource.latest = val;
+                            resource.loading = false;
+                        }
+                    })
+                        .catch((err) => {
+                        if (id === counter) {
+                            resource.error = err;
+                            resource.loading = false;
+                        }
+                    });
                 }
-            }
-        }
-        upsert(insert, ...values) {
-            for (const value of values) {
-                const key = this.ensureKey(value);
-                if (__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
-                    this.setKeyValue(key, value);
-                else
-                    insert(value);
-            }
-        }
-        entries() {
-            const self = this;
-            function* iterator() {
-                for (let i = 0; i < __classPrivateFieldGet(self, _RegisterClass_keys, "f").length; i++) {
-                    const val = __classPrivateFieldGet(self, _RegisterClass_values, "f").get(__classPrivateFieldGet(self, _RegisterClass_keys, "f")[i]);
-                    if (val !== undefined)
-                        yield [i, val];
+                else {
+                    resource.promise = Promise.resolve();
+                    resource.value = result;
+                    resource.latest = result;
+                    resource.loading = false;
                 }
             }
-            return iterator();
-        }
-        [Symbol.iterator]() {
-            const self = this;
-            function* iterator() {
-                for (const key of __classPrivateFieldGet(self, _RegisterClass_keys, "f")) {
-                    const value = __classPrivateFieldGet(self, _RegisterClass_values, "f").get(key);
-                    if (value !== undefined)
-                        yield value;
-                }
+            catch (err) {
+                resource.promise = Promise.reject(err);
+                resource.error = err;
+                resource.loading = false;
             }
-            return iterator();
-        }
-        toString() {
-            return `[Register length=${this.length}]`;
-        }
-        at(index) {
-            const resolved = index < 0 ? this.length + index : index;
-            if (resolved < 0 || resolved >= this.length)
-                return undefined;
-            return this[getAt](resolved);
-        }
-        reverse() {
-            __classPrivateFieldGet(this, _RegisterClass_keys, "f").reverse();
-            return this;
-        }
-        sort(compareFn) {
-            const fwdCompareFn = compareFn
-                ? (a, b) => compareFn(__classPrivateFieldGet(this, _RegisterClass_values, "f").get(a), __classPrivateFieldGet(this, _RegisterClass_values, "f").get(b))
-                : undefined;
-            __classPrivateFieldGet(this, _RegisterClass_keys, "f").sort(fwdCompareFn);
-            return this;
-        }
-        fill(value, start = 0, end = this.length) {
-            const values = this.toArray();
-            values.fill(value, start, end);
-            this.rebuildFrom(values);
-            return this;
-        }
-        copyWithin(target, start, end) {
-            const values = this.toArray();
-            values.copyWithin(target, start, end);
-            this.rebuildFrom(values);
-            return this;
-        }
-    };
-    __setFunctionName(_classThis, "RegisterClass");
-    (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-        _classThis = _classDescriptor.value;
-        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        __runInitializers(_classThis, _classExtraInitializers);
-    })();
-    return _classThis;
-})();
-const Register = RegisterClass;
-/**
- * Creates a reactive Register - an ordered, array-like collection with stable key-based identity.
- *
- * Register combines array semantics (indexable access, ordering, iteration) with Map-like
- * key-based lookups. Items with the same key share the same value instance, making it ideal
- * for UI lists keyed by IDs or when you need to preserve identity across reorders.
- *
- * @param keyFn - Function that extracts the key from each item
- * @param initial - Optional initial items to populate the register
- * @returns A reactive Register instance
- *
- * @example
- * ```typescript
- * const users = register(
- *   (user: User) => user.id,
- *   [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
- * )
- *
- * users.push({ id: 3, name: 'Charlie' })
- * const bob = users.get(2) // Get by key
- * ```
- */
-function register(keyFn, initial) {
-    return new RegisterClass(keyFn, initial);
+        }));
+    });
 }
+//#endregion
 
 /**
  * Converts an iterator to a generator that yields reactive values
@@ -2482,6 +1886,7 @@ let ReactiveArrayWrapper = (() => {
     let _classSuper = Array;
     let _instanceExtraInitializers = [];
     let _fill_decorators;
+    let _copyWithin_decorators;
     let _pop_decorators;
     let _push_decorators;
     let _reverse_decorators;
@@ -2506,6 +1911,9 @@ let ReactiveArrayWrapper = (() => {
             fill(value, start, end) {
                 return super.fill(unwrap(value), start, end);
             }
+            copyWithin(target, start, end) {
+                return super.copyWithin(target, start, end);
+            }
             filter(predicate, thisArg) {
                 return reactive(super.filter((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg));
             }
@@ -2607,7 +2015,7 @@ let ReactiveArrayWrapper = (() => {
                 dependant(this, keysOf);
                 return makeReactiveIterator(super.values());
             }
-            [(_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)]() {
+            [(_fill_decorators = [atomic], _copyWithin_decorators = [atomic], _pop_decorators = [atomic], _push_decorators = [atomic], _reverse_decorators = [atomic], _shift_decorators = [atomic], _sort_decorators = [atomic], _splice_decorators = [atomic], _unshift_decorators = [atomic], Symbol.iterator)]() {
                 dependant(this, keysOf);
                 return makeReactiveIterator(super[Symbol.iterator]());
             }
@@ -2620,7 +2028,6 @@ let ReactiveArrayWrapper = (() => {
                     : 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)));
@@ -2641,6 +2048,7 @@ let ReactiveArrayWrapper = (() => {
         (() => {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             __esDecorate(_a, null, _fill_decorators, { kind: "method", name: "fill", static: false, private: false, access: { has: obj => "fill" in obj, get: obj => obj.fill }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(_a, null, _copyWithin_decorators, { kind: "method", name: "copyWithin", static: false, private: false, access: { has: obj => "copyWithin" in obj, get: obj => obj.copyWithin }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(_a, null, _pop_decorators, { kind: "method", name: "pop", static: false, private: false, access: { has: obj => "pop" in obj, get: obj => obj.pop }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(_a, null, _push_decorators, { kind: "method", name: "push", static: false, private: false, access: { has: obj => "push" in obj, get: obj => obj.push }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(_a, null, _reverse_decorators, { kind: "method", name: "reverse", static: false, private: false, access: { has: obj => "reverse" in obj, get: obj => obj.reverse }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -2661,18 +2069,18 @@ class ReactiveWeakMap extends WeakMap {
     // Implement WeakMap interface methods with reactivity
     delete(key) {
         const hadKey = this.has(key);
-        const result = this.delete(key);
+        const result = super.delete(key);
         if (hadKey)
             touched1(contentRef(this), { type: 'del', prop: key }, key);
         return result;
     }
     get(key) {
         dependant(contentRef(this), key);
-        return reactive(this.get(key));
+        return reactive(super.get(key));
     }
     has(key) {
         dependant(contentRef(this), key);
-        return this.has(key);
+        return super.has(key);
     }
     set(key, value) {
         const hadKey = this.has(key);
@@ -2693,16 +2101,18 @@ class ReactiveMap extends Map {
     // Implement Map interface methods with reactivity
     get size() {
         dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
-        return this.size;
+        return super.size;
     }
     clear() {
         const hadEntries = this.size > 0;
-        this.clear();
+        super.clear();
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
             // Clear triggers all effects since all keys are affected
-            touched1(this, evolution, 'size');
-            touched(contentRef(this), evolution);
+            batch(() => {
+                touched1(this, evolution, 'size');
+                touched(contentRef(this), evolution);
+            });
         }
     }
     entries() {
@@ -2737,32 +2147,36 @@ class ReactiveMap extends Map {
     // Implement Map methods with reactivity
     delete(key) {
         const hadKey = this.has(key);
-        const result = this.delete(key);
+        const result = super.delete(key);
         if (hadKey) {
             const evolution = { type: 'del', prop: key };
-            touched1(contentRef(this), evolution, key);
-            touched1(this, evolution, 'size');
+            batch(() => {
+                touched1(contentRef(this), evolution, key);
+                touched1(this, evolution, 'size');
+            });
         }
         return result;
     }
     get(key) {
         dependant(contentRef(this), key);
-        return reactive(this.get(key));
+        return reactive(super.get(key));
     }
     has(key) {
         dependant(contentRef(this), key);
-        return this.has(key);
+        return super.has(key);
     }
     set(key, value) {
         const hadKey = this.has(key);
         const oldValue = this.get(key);
         const reactiveValue = reactive(value);
-        this.set(key, reactiveValue);
+        super.set(key, reactiveValue);
         if (!hadKey || oldValue !== reactiveValue) {
-            notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey);
-            // Also notify size change for Map (WeakMap doesn't track size)
-            const evolution = { type: hadKey ? 'set' : 'add', prop: key };
-            touched1(this, evolution, 'size');
+            batch(() => {
+                notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey);
+                // Also notify size change for Map (WeakMap doesn't track size)
+                const evolution = { type: hadKey ? 'set' : 'add', prop: key };
+                touched1(this, evolution, 'size');
+            });
         }
         return this;
     }
@@ -2775,7 +2189,7 @@ class ReactiveMap extends Map {
 class ReactiveWeakSet extends WeakSet {
     add(value) {
         const had = this.has(value);
-        this.add(value);
+        super.add(value);
         if (!had) {
             // touch the specific value and the collection view
             touched1(contentRef(this), { type: 'add', prop: value }, value);
@@ -2785,14 +2199,14 @@ class ReactiveWeakSet extends WeakSet {
     }
     delete(value) {
         const had = this.has(value);
-        const res = this.delete(value);
+        const res = super.delete(value);
         if (had)
             touched1(contentRef(this), { type: 'del', prop: value }, value);
         return res;
     }
     has(value) {
         dependant(contentRef(this), value);
-        return this.has(value);
+        return super.has(value);
     }
 }
 /**
@@ -2808,31 +2222,37 @@ class ReactiveSet extends Set {
     add(value) {
         const had = this.has(value);
         const reactiveValue = reactive(value);
-        this.add(reactiveValue);
+        super.add(reactiveValue);
         if (!had) {
             const evolution = { type: 'add', prop: reactiveValue };
             // touch for value-specific and aggregate dependencies
-            touched1(contentRef(this), evolution, reactiveValue);
-            touched1(this, evolution, 'size');
+            batch(() => {
+                touched1(contentRef(this), evolution, reactiveValue);
+                touched1(this, evolution, 'size');
+            });
         }
         return this;
     }
     clear() {
         const hadEntries = this.size > 0;
-        this.clear();
+        super.clear();
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
-            touched1(this, evolution, 'size');
-            touched(contentRef(this), evolution);
+            batch(() => {
+                touched1(this, evolution, 'size');
+                touched(contentRef(this), evolution);
+            });
         }
     }
     delete(value) {
         const had = this.has(value);
-        const res = this.delete(value);
+        const res = super.delete(value);
         if (had) {
             const evolution = { type: 'del', prop: value };
-            touched1(contentRef(this), evolution, value);
-            touched1(this, evolution, 'size');
+            batch(() => {
+                touched1(contentRef(this), evolution, value);
+                touched1(this, evolution, 'size');
+            });
         }
         return res;
     }
@@ -2871,14 +2291,12 @@ 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
  */
@@ -2891,7 +2309,6 @@ const profileInfo = {
     objectsWithDeepWatchers,
     deepWatchers,
     effectToDeepWatchedObjects,
-    nonReactiveObjects,
 };
 
 // In order to avoid async re-entrance, we could use zone.js or something like that.
@@ -3057,8 +2474,7 @@ const deprecated = Object.assign(decorator({
     },
 }), {
     warn: (target, propertyKey, message) => {
-        // biome-ignore lint/suspicious/noConsole: To be overridden
-        console.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
+        options.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
     },
 });
 /**
@@ -3121,12 +2537,11 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.10";
+var version$1 = "1.0.12";
 var pkg = {
 	version: version$1};
 
 const { version } = pkg;
-// Singleton verification
 const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
 const globalScope = (typeof globalThis !== 'undefined'
     ? globalThis
@@ -3136,28 +2551,16 @@ const globalScope = (typeof globalThis !== 'undefined'
             ? global
             : false);
 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')
             source = __filename;
-        else {
-            // Using eval to avoid SyntaxError in CJS environments where import.meta is not allowed
-            const meta = viteEval('import.meta');
-            if (meta && meta.url)
-                source = meta.url;
+        else if (typeof import.meta !== 'undefined' && import.meta.url) {
+            source = import.meta.url;
         }
     }
-    catch (e) {
-        // Fallback for environments where neither is available or accessible
-    }
-    const currentSourceInfo = {
-        version,
-        source,
-        timestamp: Date.now(),
-    };
+    catch (_e) { }
+    const currentSourceInfo = { version, source, timestamp: Date.now() };
     if (globalScope[GLOBAL_MUTTS_KEY]) {
         const existing = globalScope[GLOBAL_MUTTS_KEY];
         throw new Error(`[Mutts] Multiple instances detected!\n` +
@@ -3170,5 +2573,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, 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
+export { ArrayReadForward as A, unreactive as B, watch as C, Destroyable as D, Eventful as E, when as F, Indexable as I, DestructionError as a, allocated as b, allocatedValues as c, arrayDiff as d, attend as e, cache as f, cached as g, callOnGC as h, chainPromise as i, debounce as j, deepWatch as k, deprecated as l, descriptor as m, destructor as n, forwardArray as o, getAt as p, isCached as q, lift as r, memoize as s, morph as t, organize as u, organized as v, profileInfo as w, resource as x, setAt as y, throttle as z };
+//# sourceMappingURL=index-BUop6B2U.esm.js.map