mutts 1.0.10 → 1.0.11

package/dist/browser.cjs

@@ -1,11 +1,12 @@
 'use strict';
 
-require('./chunks/async-browser-BU_IfxYD.cjs');
-var proxy = require('./chunks/proxy-Dtg-bJ3T.cjs');
+require('./chunks/async-browser-Dgr5CreQ.cjs');
+var proxy = require('./chunks/proxy-Cc79Lrzj.cjs');
 var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
 require('./chunks/async-node-3PrbVAbB.cjs');
 require('node:async_hooks');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 // Integrated with `using` statement via Symbol.dispose
 const fr = new FinalizationRegistry((f) => f());
 /**
@@ -750,211 +751,6 @@ function chainPromise(given) {
     return chained;
 }
 
-const memoizedRegistry = new WeakMap();
-const wrapperRegistry = new WeakMap();
-function getBranch(tree, key) {
-    tree.branches ?? (tree.branches = new WeakMap());
-    let branch = tree.branches.get(key);
-    if (!branch) {
-        branch = {};
-        tree.branches.set(key, branch);
-    }
-    return branch;
-}
-function memoizeFunction(fn, opts) {
-    const fnRoot = proxy.getRoot(fn);
-    const existing = memoizedRegistry.get(fnRoot);
-    if (existing)
-        return existing;
-    const cacheRoot = {};
-    const memoized = proxy.markWithRoot(function memoized(...args) {
-        if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
-            if (opts?.lenient)
-                return fn.apply(this, args);
-            throw new Error('memoize expects non-null object arguments');
-        }
-        let node = cacheRoot;
-        // Note: decorators add `this` as first argument
-        for (const arg of args) {
-            node = getBranch(node, arg);
-        }
-        proxy.dependant(node, 'memoize');
-        if ('result' in node) {
-            if (proxy.options.onMemoizationDiscrepancy) {
-                const wasVerification = proxy.options.isVerificationRun;
-                proxy.options.isVerificationRun = true;
-                try {
-                    const fresh = proxy.untracked(() => fn.apply(this, args));
-                    if (!proxy.deepCompare(node.result, fresh)) {
-                        proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
-                    }
-                }
-                finally {
-                    proxy.options.isVerificationRun = wasVerification;
-                }
-            }
-            return node.result;
-        }
-        // Create memoize internal effect to track dependencies and invalidate cache
-        // Use untracked to prevent the effect creation from being affected by parent effects
-        node.cleanup = proxy.root(() => proxy.effect.named('memoize')(() => {
-            // Execute the function and track its dependencies
-            // The function execution will automatically track dependencies on reactive objects
-            node.result = fn.apply(this, args);
-            return (reason) => {
-                // When dependencies change, clear the cache and notify consumers
-                delete node.result;
-                proxy.touched1(node, { type: 'invalidate', prop: args }, 'memoize');
-                // Lazy memoization: stop the effect so it doesn't re-run immediately.
-                // It will be re-created on next access.
-                if (node.cleanup) {
-                    node.cleanup({ type: 'invalidate', cause: reason });
-                    node.cleanup = undefined;
-                }
-            };
-        }, { opaque: true }));
-        if (proxy.options.onMemoizationDiscrepancy) {
-            const wasVerification = proxy.options.isVerificationRun;
-            proxy.options.isVerificationRun = true;
-            try {
-                const fresh = proxy.untracked(() => fn.apply(this, args));
-                if (!proxy.deepCompare(node.result, fresh)) {
-                    proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
-                }
-            }
-            finally {
-                proxy.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$1 = new Proxy(target, {
-        get(source, prop, receiver) {
-            // 1. Walk prototype chain to find descriptor
-            let current = source;
-            let desc;
-            while (current) {
-                desc = Object.getOwnPropertyDescriptor(current, prop);
-                if (desc)
-                    break;
-                current = Object.getPrototypeOf(current);
-            }
-            if (!desc)
-                return Reflect.get(source, prop, receiver);
-            // 2. If getter, memoize
-            if (desc.get) {
-                const originalGetter = desc.get;
-                let wrapper = wrapperRegistry.get(originalGetter);
-                if (!wrapper) {
-                    wrapper = proxy.markWithRoot(proxy.named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
-                        return originalGetter.call(that);
-                    }), {
-                        propertyKey: prop,
-                    });
-                    const origRoot = originalGetter[proxy.rootFunctionSymbol];
-                    if (origRoot)
-                        wrapper[proxy.rootFunctionSymbol] = origRoot;
-                    wrapperRegistry.set(originalGetter, wrapper);
-                }
-                const memoized = memoizeFunction(wrapper, opts);
-                return memoized(receiver);
-            }
-            // 3. Otherwise forward
-            return Reflect.get(source, prop, receiver);
-        },
-        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
-        set(source, prop, value, _receiver) {
-            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
-            // it recognizes itself and triggers change notifications.
-            return Reflect.set(source, prop, value, source);
-        },
-    });
-    proxy.proxyToObject.set(proxy$1, target);
-    memoizedRegistry.set(target, proxy$1);
-    return proxy$1;
-}
-/**
- * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
- *
- * 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 proxy.decorator({
-        getter(original, target, propertyKey) {
-            return function () {
-                let wrapper = wrapperRegistry.get(original);
-                if (!wrapper) {
-                    wrapper = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
-                        return original.call(that);
-                    }), {
-                        method: original,
-                        propertyKey,
-                    });
-                    const origRoot = original[proxy.rootFunctionSymbol];
-                    if (origRoot)
-                        wrapper[proxy.rootFunctionSymbol] = origRoot;
-                    wrapperRegistry.set(original, wrapper);
-                }
-                const memoized = memoizeFunction(wrapper, memoizeOpts);
-                return memoized(this);
-            };
-        },
-        method(original, target, name) {
-            return function (...args) {
-                let wrapper = wrapperRegistry.get(original);
-                if (!wrapper) {
-                    wrapper = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
-                        return original.call(that, ...args);
-                    }), {
-                        method: original,
-                        propertyKey: name,
-                    });
-                    const origRoot = original[proxy.rootFunctionSymbol];
-                    if (origRoot)
-                        wrapper[proxy.rootFunctionSymbol] = origRoot;
-                    wrapperRegistry.set(original, wrapper);
-                }
-                const memoized = memoizeFunction(wrapper, memoizeOpts);
-                return memoized(this, ...args);
-            };
-        },
-        default: (target) => typeof target === 'object'
-            ? memoizeObject(target, memoizeOpts)
-            : memoizeFunction(target, memoizeOpts),
-    });
-}
-const memoize = proxy.flavored(makeMemoizeDecorator(), {
-    get lenient() {
-        return makeMemoizeDecorator({ lenient: true });
-    },
-});
-
 function attend(source, callback) {
     const enumerate = typeof source === 'function'
         ? source
@@ -966,14 +762,14 @@ function attend(source, callback) {
                     ? () => source.values()
                     : () => Object.keys(source);
     const keyEffects = new Map();
-    const outer = proxy.effect(({ ascend }) => {
+    const outer = proxy.effect.named('attend')(({ ascend }) => {
         const keys = new Set();
         for (const key of enumerate())
             keys.add(key);
         for (const key of keys) {
             if (keyEffects.has(key))
                 continue;
-            keyEffects.set(key, ascend(() => proxy.effect(() => callback(key))));
+            keyEffects.set(key, ascend(() => proxy.effect.named(`attend:${key}`)((access) => callback(key, access))));
         }
         for (const key of Array.from(keyEffects.keys())) {
             if (!keys.has(key)) {
@@ -989,146 +785,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 = proxy.reactive(source);
-    const rawResult = [];
-    const result = proxy.reactive(rawResult);
-    // Track effects for each index to dispose them when the array shrinks
-    const indexEffects = new Map();
-    // Mapping from index to its current intermediate object
-    const indexToIntermediate = proxy.reactive([]);
-    const intermediaries = new WeakMap();
-    let Intermediate = (() => {
-        var _a;
-        let _instanceExtraInitializers = [];
-        let _get_acc_decorators;
-        return _a = class Intermediate {
-                constructor(val, prev) {
-                    this.val = (proxy.__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];
-                proxy.__esDecorate(_a, null, _get_acc_decorators, { kind: "getter", name: "acc", static: false, private: false, access: { has: obj => "acc" in obj, get: obj => obj.acc }, metadata: _metadata }, null, _instanceExtraInitializers);
-                if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            })(),
-            _a;
-    })();
-    function disposeIndex(index) {
-        const stop = indexEffects.get(index);
-        if (stop) {
-            stop();
-            indexEffects.delete(index);
-            Reflect.deleteProperty(indexToIntermediate, index);
-            Reflect.deleteProperty(result, index);
-        }
-    }
-    const mainEffect = proxy.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 = proxy.reactive(new Intermediate(val, prev));
-                    list[count] = intermediate;
-                }
-                else {
-                    // Update the link.
-                    if (proxy.untracked(() => intermediate.prev) !== prev) {
-                        intermediate.prev = prev;
-                    }
-                }
-                // Update the reactive mapping for this index
-                if (indexToIntermediate[i] !== intermediate) {
-                    indexToIntermediate[i] = intermediate;
-                }
-                // If we don't have an effect for this index yet, create one
-                if (!indexEffects.has(i)) {
-                    ascend(() => {
-                        const index = i;
-                        const stop = proxy.effect(function scanIndexSyncEffect() {
-                            const inter = indexToIntermediate[index];
-                            if (inter) {
-                                const accValue = inter.acc;
-                                result[index] = accValue;
-                            }
-                        });
-                        indexEffects.set(index, stop);
-                    });
-                }
-                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) {
-            proxy.FoolProof.set(result, 'length', length, result);
-        }
-    });
-    return proxy.cleanedBy(result, ((reason) => {
-        mainEffect(reason);
-        for (const stop of indexEffects.values())
-            stop(reason);
-        indexEffects.clear();
-    }));
-}
 function lift(cb) {
     let result;
     let rawResult;
-    const liftCleanup = proxy.effect.named('lift')(proxy.markWithRoot((access) => {
+    const liftCleanup = proxy.effect.named(`lift:${cb.name}`)(proxy.markWithRoot((access) => {
         const source = cb(access);
         if (!source || typeof source !== 'object')
             throw new Error('lift callback must return an array or object');
@@ -1141,11 +801,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)) {
@@ -1172,7 +829,7 @@ function lift(cb) {
                 }
         }
     }, cb));
-    return proxy.cleanedBy(result, liftCleanup);
+    return proxy.link(result, liftCleanup);
 }
 /**
  * Reactively maps an array source through `fn`, producing a lazy reactive output array.
@@ -1193,7 +850,7 @@ function lift(cb) {
  */
 function morphArray(source, fn, options) {
     if (typeof source !== 'function' && !proxy.isReactive(source) && options?.pure === true) {
-        return source.map(fn);
+        return source.map((i) => fn(i));
     }
     let track;
     const itemEffects = new Map();
@@ -1215,17 +872,14 @@ function morphArray(source, fn, options) {
         }
         else {
             const indexRef = { value: key };
-            let stop;
-            track(() => {
-                stop = proxy.effect.opaque(() => {
-                    cache[indexRef.value] = fn(input);
-                    return (reason) => {
-                        delete cache[indexRef.value];
-                        proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                        stop({ type: 'invalidate', cause: reason });
-                    };
-                });
-            });
+            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache[indexRef.value] = fn(input, access);
+                return (reason) => {
+                    delete cache[indexRef.value];
+                    proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    stop?.({ type: 'invalidate', cause: reason });
+                };
+            }));
             itemEffects.set(key, { stop, index: indexRef });
         }
     }
@@ -1242,7 +896,7 @@ function morphArray(source, fn, options) {
             return Reflect.has(input, prop);
         },
     });
-    const stopMain = proxy.effect.named('morph:array')(({ ascend }) => {
+    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
         track = ascend;
         const newInput = [...(typeof source === 'function' ? source() : source)];
         const diffs = arrayDiff(input, newInput).toSorted((a, b) => b.indexA - a.indexA);
@@ -1257,7 +911,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);
                         }
@@ -1289,7 +943,7 @@ function morphArray(source, fn, options) {
         }
         input = newInput;
     });
-    return proxy.cleanedBy(proxy$1, (reason) => {
+    return proxy.link(proxy$1, (reason) => {
         stopMain(reason);
         for (const entry of itemEffects.values())
             entry.stop(reason);
@@ -1311,7 +965,7 @@ function morphMap(source, fn, options) {
     if (!proxy.isReactive(source) && options?.pure === true) {
         const res = new Map();
         for (const [k, v] of source)
-            res.set(k, fn(v));
+            res.set(k, fn(v, k));
         return res;
     }
     let track;
@@ -1328,15 +982,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(() => proxy.effect.opaque(() => {
-                cache.set(key, fn(source.get(key)));
+            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache.set(key, fn(source.get(key), key, access));
                 return (reason) => {
                     cache.delete(key);
                     proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop({ type: 'invalidate', cause: reason });
+                    stop?.({ type: 'invalidate', cause: reason });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1380,7 +1034,7 @@ function morphMap(source, fn, options) {
         },
     });
     let stateSnapshot = proxy.getState(source);
-    const stopMain = proxy.effect.named('morph:map')(({ ascend }) => {
+    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
         track = ascend;
         proxy.dependant(source, proxy.keysOf);
         while ('evolution' in stateSnapshot) {
@@ -1396,7 +1050,7 @@ function morphMap(source, fn, options) {
             }
         }
     });
-    return proxy.cleanedBy(proxy$1, (reason) => {
+    return proxy.link(proxy$1, (reason) => {
         stopMain(reason);
         for (const stop of itemEffects.values())
             stop(reason);
@@ -1418,7 +1072,7 @@ function morphRecord(source, fn, options) {
     if (!proxy.isReactive(source) && options?.pure === true) {
         const res = {};
         for (const k of Object.keys(source))
-            res[k] = fn(source[k]);
+            res[k] = fn(source[k], k);
         return res;
     }
     let track;
@@ -1434,15 +1088,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(() => proxy.effect.opaque(() => {
-                cache[key] = fn(source[key]);
+            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+                cache[key] = fn(source[key], key, access);
                 return (reason) => {
                     delete cache[key];
                     proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop({ type: 'invalidate', cause: reason });
+                    stop?.({ type: 'invalidate', cause: reason });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1469,7 +1123,7 @@ function morphRecord(source, fn, options) {
         },
     });
     let stateSnapshot = proxy.getState(source);
-    const stopMain = proxy.effect.named('morph:record')(({ ascend }) => {
+    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
         track = ascend;
         // Track only structural changes on source
         proxy.dependant(source, proxy.keysOf);
@@ -1486,7 +1140,7 @@ function morphRecord(source, fn, options) {
             }
         }
     });
-    return proxy.cleanedBy(proxy$1, (reason) => {
+    return proxy.link(proxy$1, (reason) => {
         stopMain(reason);
         for (const stop of itemEffects.values())
             stop(reason);
@@ -1545,7 +1199,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
     const wrappedCallback = proxy.markWithRoot((() => callback(target)), callback);
     proxy.registerDeepWatcher();
     // Use the existing effect system to register dependencies
-    return proxy.effect(() => {
+    return proxy.effect.named('deepWatch')(() => {
         // Mark the target object as having deep watchers
         proxy.objectsWithDeepWatchers.add(target);
         // Track which objects this effect is watching for cleanup
@@ -1581,35 +1235,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 ? proxy.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 ? proxy.reactive(value) : value;
                     traverseAndTrack(reactiveValue, depth + 1);
                 }
-            }
-            // Handle Map values (deep watch values only, not keys)
-            else if (obj instanceof Map) {
-                // Access all Map values to register dependencies
-                for (const [_key, value] of obj) {
-                    // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
-                    traverseAndTrack(reactiveValue, depth + 1);
+                // Explicitly depend on length so array mutations changing count trigger re-evaluation
+                if ('length' in obj) {
+                    proxy.dependant(obj, 'length');
+                }
+                // For Maps, also ensure we track values explicitly if the iterator yields entries
+                if (obj instanceof Map) {
+                    for (const value of obj.values()) {
+                        const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
+                        traverseAndTrack(reactiveValue, depth + 1);
+                    }
                 }
             }
             // Note: WeakSet and WeakMap cannot be iterated, so we can't deep watch their contents
@@ -1646,12 +1289,217 @@ function deepWatch(target, callback, { immediate = false } = {}) {
                         proxy.objectsWithDeepWatchers.delete(obj);
                     }
                 }
-                // Clean up the tracking data
-                proxy.effectToDeepWatchedObjects.delete(wrappedCallback);
+                // Clean up the tracking data
+                proxy.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 = proxy.getRoot(fn);
+    const existing = memoizedRegistry.get(fnRoot);
+    if (existing)
+        return existing;
+    const cacheRoot = {};
+    const memoized = proxy.markWithRoot(function memoized(...args) {
+        if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
+            if (opts?.lenient)
+                return fn.apply(this, args);
+            throw new Error('memoize expects non-null object arguments');
+        }
+        let node = cacheRoot;
+        // Note: decorators add `this` as first argument
+        for (const arg of args) {
+            node = getBranch(node, arg);
+        }
+        proxy.dependant(node, 'memoize');
+        if ('result' in node) {
+            if (proxy.options.onMemoizationDiscrepancy) {
+                const wasVerification = proxy.options.isVerificationRun;
+                proxy.options.isVerificationRun = true;
+                try {
+                    const fresh = proxy.untracked(() => fn.apply(this, args));
+                    if (!proxy.deepCompare(node.result, fresh)) {
+                        proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
+                    }
+                }
+                finally {
+                    proxy.options.isVerificationRun = wasVerification;
+                }
+            }
+            return node.result;
+        }
+        // Create memoize internal effect to track dependencies and invalidate cache
+        // Use untracked to prevent the effect creation from being affected by parent effects
+        node.cleanup = proxy.root(() => proxy.effect.named('memoize')(() => {
+            // Execute the function and track its dependencies
+            // The function execution will automatically track dependencies on reactive objects
+            node.result = fn.apply(this, args);
+            return (reason) => {
+                // When dependencies change, clear the cache and notify consumers
+                delete node.result;
+                proxy.touched1(node, { type: 'invalidate', prop: args }, 'memoize');
+                // Lazy memoization: stop the effect so it doesn't re-run immediately.
+                // It will be re-created on next access.
+                if (node.cleanup) {
+                    node.cleanup({ type: 'invalidate', cause: reason });
+                    node.cleanup = undefined;
+                }
+            };
+        }, { opaque: true }));
+        if (proxy.options.onMemoizationDiscrepancy) {
+            const wasVerification = proxy.options.isVerificationRun;
+            proxy.options.isVerificationRun = true;
+            try {
+                const fresh = proxy.untracked(() => fn.apply(this, args));
+                if (!proxy.deepCompare(node.result, fresh)) {
+                    proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
+                }
+            }
+            finally {
+                proxy.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$1 = new Proxy(target, {
+        get(source, prop, receiver) {
+            // 1. Walk prototype chain to find descriptor
+            let current = source;
+            let desc;
+            while (current) {
+                desc = Object.getOwnPropertyDescriptor(current, prop);
+                if (desc)
+                    break;
+                current = Object.getPrototypeOf(current);
+            }
+            if (!desc)
+                return Reflect.get(source, prop, receiver);
+            // 2. If getter, memoize
+            if (desc.get) {
+                const originalGetter = desc.get;
+                let wrapper = wrapperRegistry.get(originalGetter);
+                if (!wrapper) {
+                    wrapper = proxy.markWithRoot(proxy.named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
+                        return originalGetter.call(that);
+                    }), {
+                        propertyKey: prop,
+                    });
+                    const origRoot = originalGetter[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(originalGetter, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, opts);
+                return memoized(receiver);
             }
-        };
+            // 3. Otherwise forward
+            return Reflect.get(source, prop, receiver);
+        },
+        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
+        set(source, prop, value, _receiver) {
+            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
+            // it recognizes itself and triggers change notifications.
+            return Reflect.set(source, prop, value, source);
+        },
+    });
+    proxy.proxyToObject.set(proxy$1, target);
+    memoizedRegistry.set(target, proxy$1);
+    return proxy$1;
+}
+/**
+ * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
+ *
+ * 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 proxy.decorator({
+        getter(original, target, propertyKey) {
+            return function () {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
+                        return original.call(that);
+                    }), {
+                        method: original,
+                        propertyKey,
+                    });
+                    const origRoot = original[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this);
+            };
+        },
+        method(original, target, name) {
+            return function (...args) {
+                let wrapper = wrapperRegistry.get(original);
+                if (!wrapper) {
+                    wrapper = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
+                        return original.call(that, ...args);
+                    }), {
+                        method: original,
+                        propertyKey: name,
+                    });
+                    const origRoot = original[proxy.rootFunctionSymbol];
+                    if (origRoot)
+                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                    wrapperRegistry.set(original, wrapper);
+                }
+                const memoized = memoizeFunction(wrapper, memoizeOpts);
+                return memoized(this, ...args);
+            };
+        },
+        default: (target) => typeof target === 'object'
+            ? memoizeObject(target, memoizeOpts)
+            : memoizeFunction(target, memoizeOpts),
     });
 }
+const memoize = proxy.flavored(makeMemoizeDecorator(), {
+    get lenient() {
+        return makeMemoizeDecorator({ lenient: true });
+    },
+});
 
 /**
  * Organizes a source object's properties into a target object using a callback function.
@@ -1727,7 +1575,7 @@ function organized(source, apply, baseTarget = {}) {
         });
         return apply(accessBase, target);
     });
-    return proxy.cleanedBy(target, (reason) => stop(reason));
+    return proxy.link(target, (reason) => stop(reason));
 }
 /**
  * Organizes a property on a target object
@@ -1770,7 +1618,7 @@ changed, options = {}) {
 function watchObject(value, changed, { immediate = false, deep = false } = {}) {
     if (deep)
         return deepWatch(value, changed, { immediate });
-    return proxy.effect(function watchObjectEffect() {
+    return proxy.effect.named('watch:object')(() => {
         proxy.dependant(value);
         if (immediate)
             changed(value);
@@ -1780,7 +1628,7 @@ function watchObject(value, changed, { immediate = false, deep = false } = {}) {
 function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
     let oldValue = unsetYet;
     let deepCleanup;
-    const cbCleanup = proxy.effect(proxy.markWithRoot(function watchCallBackEffect(access) {
+    const cbCleanup = proxy.effect.named('watch:callback')(proxy.markWithRoot((access) => {
         const newValue = value(access);
         if (oldValue !== newValue) {
             const old = oldValue;
@@ -1798,12 +1646,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();
-    }, {
-        [proxy.stopped]: { get: () => cbCleanup[proxy.stopped] },
     });
 }
 //#endregion
@@ -1818,7 +1664,7 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
 function when(predicate, timeout) {
     return new Promise((resolve, reject) => {
         let timer;
-        const stop = proxy.effect(function whenEffect(access) {
+        const stop = proxy.effect.named('watch:when')((access) => {
             try {
                 const value = predicate(access);
                 if (value) {
@@ -1855,7 +1701,7 @@ function shallowNonReactive(obj) {
     obj = proxy.unwrap(obj);
     if (proxy.isNonReactive(obj))
         return obj;
-    proxy.nonReactiveObjects.add(obj);
+    obj[proxy.unreactiveProperties] = true;
     return obj;
 }
 function unreactiveApplication(arg1, ...args) {
@@ -1863,13 +1709,19 @@ function unreactiveApplication(arg1, ...args) {
         ? shallowNonReactive(arg1)
         : ((original) => {
             // Copy the parent's unreactive properties if they exist
-            const parentSet = proxy.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);
-            proxy.addUnreactiveProps(original.prototype, set);
+            const parentMarker = original.prototype[proxy.unreactiveProperties];
+            // If parent is fully unreactive, child is too
+            if (parentMarker === true) {
+                original.prototype[proxy.unreactiveProperties] = true;
+            }
+            else {
+                const set = new Set(parentMarker || []);
+                // Add all arguments (including the first one)
+                set.add(arg1);
+                for (const arg of args)
+                    set.add(arg);
+                proxy.addUnreactiveProps(original.prototype, set);
+            }
             return original; // Return the class
         });
 }
@@ -1879,11 +1731,26 @@ function unreactiveApplication(arg1, ...args) {
  */
 const unreactive = proxy.decorator({
     class(original) {
-        // Called without arguments, mark entire class as non-reactive
-        proxy.nonReactiveClass(original);
+        original.prototype[proxy.unreactiveProperties] = true;
     },
     default: unreactiveApplication,
 });
+//#endregion
+//#region resource
+function lazyInit(resource, load) {
+    const creation = proxy.effectHistory.active;
+    let fresh = true;
+    return new Proxy(resource, {
+        [Symbol.toStringTag]: 'LazyInit',
+        get(target, prop) {
+            if (fresh) {
+                proxy.captured(creation, load)();
+                fresh = false;
+            }
+            return target[prop];
+        },
+    });
+}
 /**
  * Creates a reactive resource that automatically tracks async state.
  * @param fetcher - Async function that returns the value. Reactive dependencies are tracked.
@@ -1891,521 +1758,59 @@ const unreactive = proxy.decorator({
  * @returns Reactive Resource object with value, loading, error, latest properties
  */
 function resource(fetcher, options = {}) {
-    const state = proxy.reactive({
+    const resource = proxy.reactive({
         value: options.initialValue,
         loading: true,
         error: undefined,
         latest: options.initialValue,
-        reload: () => {
+        reload() {
             reloadSignal.value++;
         },
     });
     const reloadSignal = proxy.reactive({ value: 0 });
+    // Solve race conditions: make sure a new fast request is not overloaded by a slow old one
     let counter = 0;
-    const stop = proxy.effect(function resourceEffect(access) {
-        // Track reload signal to enable manual reloading
-        if (reloadSignal.value) ;
-        const id = ++counter;
-        state.loading = true;
-        state.error = undefined;
-        try {
-            const result = fetcher(access);
-            if (result instanceof Promise) {
-                result.then((val) => {
-                    if (id === counter) {
-                        state.value = val;
-                        state.latest = val;
-                        state.loading = false;
-                    }
-                }, (err) => {
-                    if (id === counter) {
-                        state.error = err;
-                        state.loading = false;
-                    }
-                });
-            }
-            else {
-                state.value = result;
-                state.latest = result;
-                state.loading = false;
-            }
-        }
-        catch (err) {
-            state.error = err;
-            state.loading = false;
-        }
-    });
-    state.stop = stop;
-    return state;
-}
-//#endregion
-
-// Helper to work around TypeScript limitation: base class expressions cannot reference class type parameters
-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 proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").on(eventOrEvents, cb);
-        }
-        off(eventOrEvents, cb) {
-            // @ts-expect-error Delegate to Eventful
-            proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").off(eventOrEvents, cb);
-        }
-        /**
-         * Register a global hook that receives all events
-         */
-        hook(cb) {
-            return proxy.__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;
-            proxy.effect(({ ascend }) => {
-                ascendGet = ascend;
-            });
-            proxy.__classPrivateFieldSet(this, _RegisterClass_ascend, ascendGet, "f");
-            if (typeof keyFn !== 'function')
-                throw new Error('Register requires a key function');
-            proxy.__classPrivateFieldSet(this, _RegisterClass_keyFn, keyFn, "f");
-            proxy.__classPrivateFieldSet(this, _RegisterClass_keys, proxy.reactive([]), "f");
-            proxy.__classPrivateFieldSet(this, _RegisterClass_values, proxy.reactive(new Map()), "f");
-            if (initial)
-                this.push(...initial);
-        }
-        ensureKey(value) {
-            let info = proxy.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-            if (info)
-                return info.key;
-            info = { key: undefined };
-            proxy.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").set(value, info);
-            proxy.__classPrivateFieldGet(this, _RegisterClass_ascend, "f").call(this, () => {
-                const stop = proxy.effect(({ reaction }) => {
-                    const nextKey = proxy.__classPrivateFieldGet(this, _RegisterClass_keyFn, "f").call(this, value);
-                    this.assertValidKey(nextKey);
-                    const previousKey = info.key;
-                    if (reaction && previousKey !== undefined && !Object.is(nextKey, previousKey))
-                        proxy.__classPrivateFieldGet(this, _RegisterClass_instances, "m", _RegisterClass_rekeyValue).call(this, value, previousKey, nextKey);
-                    info.key = nextKey;
-                });
-                info.stop = stop;
-                proxy.__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 = proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-            if (existing !== undefined && existing !== value) {
-                this.cleanupValue(existing);
-                proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-                if (index !== undefined) {
-                    proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', existing, value, key, index);
-                }
-            }
-            else {
-                proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-            }
-        }
-        cleanupValue(value) {
-            const info = proxy.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-            if (!info)
-                return;
-            const stop = info.stop;
-            if (stop) {
-                info.stop = undefined;
-                proxy.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").delete(stop);
-                stop();
-            }
-            proxy.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").delete(value);
-        }
-        disposeKeyEffects() {
-            for (const value of Array.from(proxy.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").keys()))
-                this.cleanupValue(value);
-            proxy.__classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").clear();
-        }
-        incrementUsage(key) {
-            const count = proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key) ?? 0;
-            proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count + 1);
-        }
-        decrementUsage(key, index) {
-            const count = proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key);
-            if (!count)
-                return;
-            if (count <= 1) {
-                const value = proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-                proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(key);
-                proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").delete(key);
-                if (value !== undefined) {
-                    this.cleanupValue(value);
-                    const idx = index ?? proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-                    proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('delete', value, key, idx);
-                }
-            }
-            else {
-                proxy.__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 = proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
-            if (oldKey !== undefined && Object.is(oldKey, key)) {
-                const oldValue = proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-                this.setKeyValue(key, value);
-                if (oldValue !== undefined && oldValue !== value) {
-                    proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', oldValue, value, key, index);
-                }
-                return;
-            }
-            if (oldKey !== undefined)
-                this.decrementUsage(oldKey);
-            proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index] = key;
-            this.incrementUsage(key);
-            this.setKeyValue(key, value);
-            proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
-        }
-        insertKeyValue(index, key, value) {
-            proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 0, key);
-            this.incrementUsage(key);
-            this.setKeyValue(key, value);
-            proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
-        }
-        rebuildFrom(values) {
-            this.disposeKeyEffects();
-            proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(0, proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length);
-            proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
-            proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
-            for (const value of values) {
-                const key = this.ensureKey(value);
-                proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").push(key);
-                this.incrementUsage(key);
-                proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-            }
-        }
-        get length() {
-            return proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length;
-        }
-        [(_RegisterClass_rekeyValue = function _RegisterClass_rekeyValue(value, oldKey, newKey) {
-            if (Object.is(oldKey, newKey))
-                return;
-            const existingValue = proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(newKey);
-            if (existingValue !== undefined && existingValue !== value)
-                throw new Error(`Register key collision for key ${String(newKey)}`);
-            const count = proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(oldKey);
-            if (!count)
-                return;
-            const existingCount = proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").get(newKey) ?? 0;
-            this.setKeyValue(newKey, value);
-            let index = -1;
-            for (let i = 0; i < proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length; i++)
-                if (Object.is(proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i], oldKey)) {
-                    proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i] = newKey;
-                    if (index === -1)
-                        index = i;
-                }
-            proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").set(newKey, existingCount + count);
-            proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(oldKey);
-            proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").delete(oldKey);
-            const updatedInfo = proxy.__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-            if (updatedInfo)
-                updatedInfo.key = newKey;
-            if (index !== -1) {
-                proxy.__classPrivateFieldGet(this, _RegisterClass_events, "f").emit('rekey', value, oldKey, newKey, index);
-            }
-        }, getAt)](index) {
-            const key = proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
-            return key === undefined ? undefined : proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-        }
-        [setAt](index, value) {
-            const key = this.ensureKey(value);
-            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 = proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(normalizedStart, actualDelete, ...keysToInsert);
-            const removedValues = [];
-            for (let i = 0; i < removedKeys.length; i++) {
-                const key = removedKeys[i];
-                if (key === undefined)
-                    continue;
-                const value = proxy.__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() {
-            proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").length = 0;
-            proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
-            proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
-            this.disposeKeyEffects();
-        }
-        get(key) {
-            return proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-        }
-        set(key, value) {
-            if (proxy.__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] = proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 1);
-            if (key === undefined)
-                return undefined;
-            const value = proxy.__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 proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").entries()) {
-                if (decisions.has(key)) {
-                    if (!decisions.get(key))
-                        this.removeAt(index);
-                    continue;
-                }
-                const value = proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-                const shouldKeep = predicate(value);
-                decisions.set(key, shouldKeep);
-                if (!shouldKeep)
-                    this.removeAt(index);
-            }
-        }
-        hasKey(key) {
-            return proxy.__classPrivateFieldGet(this, _RegisterClass_usage, "f").has(key);
-        }
-        indexOfKey(key) {
-            return proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-        }
-        mapKeys() {
-            return proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").keys();
-        }
-        update(...values) {
-            for (const value of values) {
-                const key = this.ensureKey(value);
-                if (proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key)) {
-                    const index = proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-                    this.setKeyValue(key, value, index);
+    return lazyInit(resource, () => {
+        proxy.link(resource, proxy.effect.named('watch:resource')((access) => {
+            // Track reload signal to enable manual reloading
+            void reloadSignal.value;
+            const id = ++counter;
+            resource.loading = true;
+            resource.error = undefined;
+            try {
+                const result = fetcher(access);
+                if (result instanceof Promise) {
+                    resource.promise = result
+                        .then((val) => {
+                        if (id === counter) {
+                            resource.value = val;
+                            resource.latest = val;
+                            resource.loading = false;
+                        }
+                    })
+                        .catch((err) => {
+                        if (id === counter) {
+                            resource.error = err;
+                            resource.loading = false;
+                        }
+                    });
                 }
-            }
-        }
-        upsert(insert, ...values) {
-            for (const value of values) {
-                const key = this.ensureKey(value);
-                if (proxy.__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 < proxy.__classPrivateFieldGet(self, _RegisterClass_keys, "f").length; i++) {
-                    const val = proxy.__classPrivateFieldGet(self, _RegisterClass_values, "f").get(proxy.__classPrivateFieldGet(self, _RegisterClass_keys, "f")[i]);
-                    if (val !== undefined)
-                        yield [i, val];
+                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 proxy.__classPrivateFieldGet(self, _RegisterClass_keys, "f")) {
-                    const value = proxy.__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() {
-            proxy.__classPrivateFieldGet(this, _RegisterClass_keys, "f").reverse();
-            return this;
-        }
-        sort(compareFn) {
-            const fwdCompareFn = compareFn
-                ? (a, b) => compareFn(proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(a), proxy.__classPrivateFieldGet(this, _RegisterClass_values, "f").get(b))
-                : undefined;
-            proxy.__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;
-        }
-    };
-    proxy.__setFunctionName(_classThis, "RegisterClass");
-    (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-        proxy.__esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-        _classThis = _classDescriptor.value;
-        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        proxy.__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
@@ -2488,6 +1893,7 @@ let ReactiveArrayWrapper = (() => {
     let _classSuper = Array;
     let _instanceExtraInitializers = [];
     let _fill_decorators;
+    let _copyWithin_decorators;
     let _pop_decorators;
     let _push_decorators;
     let _reverse_decorators;
@@ -2512,6 +1918,9 @@ let ReactiveArrayWrapper = (() => {
             fill(value, start, end) {
                 return super.fill(proxy.unwrap(value), start, end);
             }
+            copyWithin(target, start, end) {
+                return super.copyWithin(target, start, end);
+            }
             filter(predicate, thisArg) {
                 return proxy.reactive(super.filter((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
             }
@@ -2613,7 +2022,7 @@ let ReactiveArrayWrapper = (() => {
                 proxy.dependant(this, proxy.keysOf);
                 return makeReactiveIterator(super.values());
             }
-            [(_fill_decorators = [proxy.atomic], _pop_decorators = [proxy.atomic], _push_decorators = [proxy.atomic], _reverse_decorators = [proxy.atomic], _shift_decorators = [proxy.atomic], _sort_decorators = [proxy.atomic], _splice_decorators = [proxy.atomic], _unshift_decorators = [proxy.atomic], Symbol.iterator)]() {
+            [(_fill_decorators = [proxy.atomic], _copyWithin_decorators = [proxy.atomic], _pop_decorators = [proxy.atomic], _push_decorators = [proxy.atomic], _reverse_decorators = [proxy.atomic], _shift_decorators = [proxy.atomic], _sort_decorators = [proxy.atomic], _splice_decorators = [proxy.atomic], _unshift_decorators = [proxy.atomic], Symbol.iterator)]() {
                 proxy.dependant(this, proxy.keysOf);
                 return makeReactiveIterator(super[Symbol.iterator]());
             }
@@ -2626,7 +2035,6 @@ let ReactiveArrayWrapper = (() => {
                     : undefined;
                 return proxy.reactive(super.toSorted(wrappedCompare));
             }
-            // biome-ignore lint/complexity/noArguments: Needed to distinguish fn() from fn(undefined)
             toSpliced(start, deleteCount, ...items) {
                 if (arguments.length > 2)
                     return proxy.reactive(super.toSpliced(start, deleteCount, ...items.map(proxy.unwrap)));
@@ -2647,6 +2055,7 @@ let ReactiveArrayWrapper = (() => {
         (() => {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             proxy.__esDecorate(_a, null, _fill_decorators, { kind: "method", name: "fill", static: false, private: false, access: { has: obj => "fill" in obj, get: obj => obj.fill }, metadata: _metadata }, null, _instanceExtraInitializers);
+            proxy.__esDecorate(_a, null, _copyWithin_decorators, { kind: "method", name: "copyWithin", static: false, private: false, access: { has: obj => "copyWithin" in obj, get: obj => obj.copyWithin }, metadata: _metadata }, null, _instanceExtraInitializers);
             proxy.__esDecorate(_a, null, _pop_decorators, { kind: "method", name: "pop", static: false, private: false, access: { has: obj => "pop" in obj, get: obj => obj.pop }, metadata: _metadata }, null, _instanceExtraInitializers);
             proxy.__esDecorate(_a, null, _push_decorators, { kind: "method", name: "push", static: false, private: false, access: { has: obj => "push" in obj, get: obj => obj.push }, metadata: _metadata }, null, _instanceExtraInitializers);
             proxy.__esDecorate(_a, null, _reverse_decorators, { kind: "method", name: "reverse", static: false, private: false, access: { has: obj => "reverse" in obj, get: obj => obj.reverse }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -2667,18 +2076,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)
             proxy.touched1(proxy.contentRef(this), { type: 'del', prop: key }, key);
         return result;
     }
     get(key) {
         proxy.dependant(proxy.contentRef(this), key);
-        return proxy.reactive(this.get(key));
+        return proxy.reactive(super.get(key));
     }
     has(key) {
         proxy.dependant(proxy.contentRef(this), key);
-        return this.has(key);
+        return super.has(key);
     }
     set(key, value) {
         const hadKey = this.has(key);
@@ -2699,16 +2108,18 @@ class ReactiveMap extends Map {
     // Implement Map interface methods with reactivity
     get size() {
         proxy.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
-            proxy.touched1(this, evolution, 'size');
-            proxy.touched(proxy.contentRef(this), evolution);
+            proxy.batch(() => {
+                proxy.touched1(this, evolution, 'size');
+                proxy.touched(proxy.contentRef(this), evolution);
+            });
         }
     }
     entries() {
@@ -2743,32 +2154,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 };
-            proxy.touched1(proxy.contentRef(this), evolution, key);
-            proxy.touched1(this, evolution, 'size');
+            proxy.batch(() => {
+                proxy.touched1(proxy.contentRef(this), evolution, key);
+                proxy.touched1(this, evolution, 'size');
+            });
         }
         return result;
     }
     get(key) {
         proxy.dependant(proxy.contentRef(this), key);
-        return proxy.reactive(this.get(key));
+        return proxy.reactive(super.get(key));
     }
     has(key) {
         proxy.dependant(proxy.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 = proxy.reactive(value);
-        this.set(key, reactiveValue);
+        super.set(key, reactiveValue);
         if (!hadKey || oldValue !== reactiveValue) {
-            proxy.notifyPropertyChange(proxy.contentRef(this), key, oldValue, reactiveValue, hadKey);
-            // Also notify size change for Map (WeakMap doesn't track size)
-            const evolution = { type: hadKey ? 'set' : 'add', prop: key };
-            proxy.touched1(this, evolution, 'size');
+            proxy.batch(() => {
+                proxy.notifyPropertyChange(proxy.contentRef(this), key, oldValue, reactiveValue, hadKey);
+                // Also notify size change for Map (WeakMap doesn't track size)
+                const evolution = { type: hadKey ? 'set' : 'add', prop: key };
+                proxy.touched1(this, evolution, 'size');
+            });
         }
         return this;
     }
@@ -2781,7 +2196,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
             proxy.touched1(proxy.contentRef(this), { type: 'add', prop: value }, value);
@@ -2791,14 +2206,14 @@ class ReactiveWeakSet extends WeakSet {
     }
     delete(value) {
         const had = this.has(value);
-        const res = this.delete(value);
+        const res = super.delete(value);
         if (had)
             proxy.touched1(proxy.contentRef(this), { type: 'del', prop: value }, value);
         return res;
     }
     has(value) {
         proxy.dependant(proxy.contentRef(this), value);
-        return this.has(value);
+        return super.has(value);
     }
 }
 /**
@@ -2814,31 +2229,37 @@ class ReactiveSet extends Set {
     add(value) {
         const had = this.has(value);
         const reactiveValue = proxy.reactive(value);
-        this.add(reactiveValue);
+        super.add(reactiveValue);
         if (!had) {
             const evolution = { type: 'add', prop: reactiveValue };
             // touch for value-specific and aggregate dependencies
-            proxy.touched1(proxy.contentRef(this), evolution, reactiveValue);
-            proxy.touched1(this, evolution, 'size');
+            proxy.batch(() => {
+                proxy.touched1(proxy.contentRef(this), evolution, reactiveValue);
+                proxy.touched1(this, evolution, 'size');
+            });
         }
         return this;
     }
     clear() {
         const hadEntries = this.size > 0;
-        this.clear();
+        super.clear();
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
-            proxy.touched1(this, evolution, 'size');
-            proxy.touched(proxy.contentRef(this), evolution);
+            proxy.batch(() => {
+                proxy.touched1(this, evolution, 'size');
+                proxy.touched(proxy.contentRef(this), evolution);
+            });
         }
     }
     delete(value) {
         const had = this.has(value);
-        const res = this.delete(value);
+        const res = super.delete(value);
         if (had) {
             const evolution = { type: 'del', prop: value };
-            proxy.touched1(proxy.contentRef(this), evolution, value);
-            proxy.touched1(this, evolution, 'size');
+            proxy.batch(() => {
+                proxy.touched1(proxy.contentRef(this), evolution, value);
+                proxy.touched1(this, evolution, 'size');
+            });
         }
         return res;
     }
@@ -2877,14 +2298,12 @@ class ReactiveSet extends Set {
 }
 
 // Register native collection types to use specialized reactive wrappers
-console.time('mutts-reactive-init');
 proxy.metaProtos.set(Array, ReactiveArray.prototype);
 proxy.metaProtos.set(Set, ReactiveSet.prototype);
 proxy.metaProtos.set(WeakSet, ReactiveWeakSet.prototype);
 proxy.metaProtos.set(Map, ReactiveMap.prototype);
 proxy.metaProtos.set(WeakMap, ReactiveWeakMap.prototype);
 proxy.wrapProtos.set(Array, ReactiveArrayWrapper.prototype);
-console.timeEnd('mutts-reactive-init');
 /**
  * Object containing internal reactive system state for debugging and profiling
  */
@@ -2897,7 +2316,6 @@ const profileInfo = {
     objectsWithDeepWatchers: proxy.objectsWithDeepWatchers,
     deepWatchers: proxy.deepWatchers,
     effectToDeepWatchedObjects: proxy.effectToDeepWatchedObjects,
-    nonReactiveObjects: proxy.nonReactiveObjects,
 };
 
 // In order to avoid async re-entrance, we could use zone.js or something like that.
@@ -3063,8 +2481,7 @@ const deprecated = Object.assign(proxy.decorator({
     },
 }), {
     warn: (target, propertyKey, message) => {
-        // biome-ignore lint/suspicious/noConsole: To be overridden
-        console.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
+        proxy.options.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
     },
 });
 /**
@@ -3127,12 +2544,11 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.10";
+var version$1 = "1.0.11";
 var pkg = {
 	version: version$1};
 
 const { version } = pkg;
-// Singleton verification
 const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
 const globalScope = (typeof globalThis !== 'undefined'
     ? globalThis
@@ -3142,28 +2558,16 @@ const globalScope = (typeof globalThis !== 'undefined'
             ? global
             : false);
 if (globalScope) {
-    // Detect the source of this instance safely across different environments
     let source = 'mutts/index';
-    // 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 ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('browser.cjs', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('browser.cjs', document.baseURI).href))) {
+            source = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('browser.cjs', document.baseURI).href));
         }
     }
-    catch (e) {
-        // Fallback for environments where neither is available or accessible
-    }
-    const currentSourceInfo = {
-        version,
-        source,
-        timestamp: Date.now(),
-    };
+    catch (_e) { }
+    const currentSourceInfo = { version, source, timestamp: Date.now() };
     if (globalScope[GLOBAL_MUTTS_KEY]) {
         const existing = globalScope[GLOBAL_MUTTS_KEY];
         throw new Error(`[Mutts] Multiple instances detected!\n` +
@@ -3190,18 +2594,21 @@ exports.Zone = proxy.Zone;
 exports.ZoneAggregator = proxy.ZoneAggregator;
 exports.ZoneHistory = proxy.ZoneHistory;
 exports.addBatchCleanup = proxy.addBatchCleanup;
+exports.addUnreactiveProps = proxy.addUnreactiveProps;
 exports.arrayEquals = proxy.arrayEquals;
+exports.assertUntracked = proxy.assertUntracked;
 exports.asyncZone = proxy.asyncZone;
 exports.atom = proxy.atom;
 exports.atomic = proxy.atomic;
 exports.biDi = proxy.biDi;
+exports.captured = proxy.captured;
 exports.caught = proxy.caught;
-exports.cleanedBy = proxy.cleanedBy;
-exports.cleanup = proxy.cleanup;
 exports.createFlavor = proxy.createFlavor;
+exports.debugPreset = proxy.debugPreset;
 exports.decorator = proxy.decorator;
 exports.deepCompare = proxy.deepCompare;
 exports.defer = proxy.defer;
+exports.devPreset = proxy.devPreset;
 exports.effect = proxy.effect;
 exports.effectAggregator = proxy.effectAggregator;
 exports.flavorOptions = proxy.flavorOptions;
@@ -3210,26 +2617,30 @@ exports.formatCleanupReason = proxy.formatCleanupReason;
 exports.getActivationLog = proxy.getActivationLog;
 exports.getActiveEffect = proxy.getActiveEffect;
 exports.getState = proxy.getState;
-exports.immutables = proxy.immutables;
 exports.isConstructor = proxy.isConstructor;
+exports.isDev = proxy.isDev;
 exports.isNonReactive = proxy.isNonReactive;
 exports.isObject = proxy.isObject;
+exports.isProd = proxy.isProd;
 exports.isReactive = proxy.isReactive;
+exports.isTest = proxy.isTest;
 exports.legacyDecorator = proxy.legacyDecorator;
+exports.link = proxy.link;
 exports.mixin = proxy.mixin;
 exports.modernDecorator = proxy.modernDecorator;
 exports.named = proxy.named;
 exports.objectToProxy = proxy.objectToProxy;
 exports.onEffectThrow = proxy.onEffectThrow;
+exports.prodPreset = proxy.prodPreset;
 exports.proxyToObject = proxy.proxyToObject;
 exports.reactive = proxy.reactive;
 exports.reactiveOptions = proxy.options;
 exports.reset = proxy.reset;
 exports.root = proxy.root;
-exports.stopped = proxy.stopped;
 exports.tag = proxy.tag;
 exports.touched = proxy.touched;
 exports.touched1 = proxy.touched1;
+exports.unlink = proxy.unlink;
 exports.untracked = proxy.untracked;
 exports.unwrap = proxy.unwrap;
 exports.zip = proxy.zip;
@@ -3241,7 +2652,6 @@ exports.Destroyable = Destroyable;
 exports.DestructionError = DestructionError;
 exports.Eventful = Eventful;
 exports.Indexable = Indexable;
-exports.Register = Register;
 exports.allocated = allocated;
 exports.allocatedValues = allocatedValues;
 exports.arrayDiff = arrayDiff;
@@ -3265,9 +2675,7 @@ exports.organize = organize;
 exports.organized = organized;
 exports.profileInfo = profileInfo;
 exports.project = morph;
-exports.register = register;
 exports.resource = resource;
-exports.scan = scan;
 exports.setAt = setAt;
 exports.throttle = throttle;
 exports.unreactive = unreactive;