mutts 1.0.12 → 1.0.14

package/dist/chunks/{index-yK0HVxHv.cjs → index-BnTNC9eC.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var proxy = require('./proxy-BvM4yewA.cjs');
+var proxy = require('./proxy-HA_QQnd5.cjs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 // Integrated with `using` statement via Symbol.dispose
@@ -259,46 +259,57 @@ function buildPatches(history, A, B, offset, finalX, finalY, finalD, finalK, vOf
 var _a, _b;
 const events = Symbol('events');
 const hooks = Symbol('hooks');
+function getEventMap(target) {
+    return target[events];
+}
+function getHookSet(target) {
+    return target[hooks];
+}
 const eventBehavior = {
     on(eventOrEvents, cb) {
+        const self = this;
+        const eventMap = getEventMap(self);
         if (typeof eventOrEvents === 'object') {
             for (const e of Object.keys(eventOrEvents)) {
                 this.on(e, eventOrEvents[e]);
             }
         }
         else if (cb !== undefined) {
-            const callbacks = this[events].get(eventOrEvents) ?? new Set();
+            const callbacks = eventMap.get(eventOrEvents) ?? new Set();
             if (!callbacks.has(cb))
                 callbacks.add(cb);
-            this[events].set(eventOrEvents, callbacks);
+            eventMap.set(eventOrEvents, callbacks);
         }
         return () => this.off(eventOrEvents, cb);
     },
     off(eventOrEvents, cb) {
+        const self = this;
+        const eventMap = getEventMap(self);
         if (typeof eventOrEvents === 'object') {
             for (const e of Object.keys(eventOrEvents)) {
                 this.off(e, eventOrEvents[e]);
             }
         }
         else if (cb !== null && cb !== undefined) {
-            const callbacks = this[events].get(eventOrEvents);
+            const callbacks = eventMap.get(eventOrEvents);
             if (callbacks) {
                 callbacks.delete(cb);
                 if (!callbacks.size)
-                    this[events].delete(eventOrEvents);
+                    eventMap.delete(eventOrEvents);
             }
         }
         else {
             // Remove all listeners for this event
-            this[events].delete(eventOrEvents);
+            eventMap.delete(eventOrEvents);
         }
     },
     emit(event, ...args) {
-        const callbacks = this[events].get(event);
+        const self = this;
+        const callbacks = getEventMap(self).get(event);
         if (callbacks)
             for (const cb of callbacks)
                 cb.apply(this, args);
-        for (const cb of this[hooks])
+        for (const cb of getHookSet(self))
             cb.call(this, event, ...args);
     },
 };
@@ -308,7 +319,7 @@ function perEvent(eventful, fct, use) {
         get(target, prop) {
             if (typeof prop !== 'string')
                 return target[prop];
-            if (use && !eventful[events].has(prop) && !eventful[hooks].size)
+            if (use && !getEventMap(eventful).has(prop) && !getHookSet(eventful).size)
                 return () => { };
             // Return cached function or create and cache
             let cached = cache.get(prop);
@@ -747,7 +758,7 @@ function chainPromise(given) {
     return chained;
 }
 
-function attend(source, callback) {
+const attend = proxy.captioned(function attend(source, callback) {
     const enumerate = typeof source === 'function'
         ? source
         : Array.isArray(source)
@@ -758,14 +769,16 @@ function attend(source, callback) {
                     ? () => source.values()
                     : () => Object.keys(source);
     const keyEffects = new Map();
-    const outer = proxy.effect.named('attend')(({ ascend }) => {
+    const callbackLabel = callback.name ? callback.name : '';
+    const outer = proxy.effect `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.named(`attend:${key}`)((access) => callback(key, access))));
+            const indexRef = { value: key };
+            keyEffects.set(key, ascend(() => proxy.effect `attend${callbackLabel ? `:${callbackLabel}` : ''}:${key}`((access) => callback(indexRef.value, access))));
         }
         for (const key of Array.from(keyEffects.keys())) {
             if (!keys.has(key)) {
@@ -780,17 +793,50 @@ function attend(source, callback) {
             stop(reason);
         keyEffects.clear();
     };
-}
-function lift(cb) {
+}, {
+    name: 'attend',
+    callbackIndex: 1,
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+});
+/**
+ * Lifts a callback that returns an object into a reactive object that automatically
+ * synchronizes with the source object returned by the callback.
+ *
+ * The returned reactive object will update whenever the callback's dependencies change,
+ * efficiently syncing only the properties that differ from the previous result using
+ * Object.assign(). Properties that no longer exist in the source are automatically removed.
+ *
+ * @example
+ * ```typescript
+ * const user = reactive({ name: 'John', age: 30 })
+ * const profile = lift(() => ({
+ *   displayName: user.name.toUpperCase(),
+ *   isAdult: user.age >= 18,
+ *   description: `${user.name} is ${user.age} years old`
+ * }))
+ *
+ * console.log(profile.displayName) // JOHN
+ * console.log(profile.isAdult) // true
+ *
+ * user.name = 'Jane'
+ * console.log(profile.displayName) // JANE
+ * console.log(profile.description) // Jane is 30 years old
+ * ```
+ *
+ * @param cb Callback function that returns an object
+ * @returns A reactive object synchronized with the callback's result, with a [cleanup] property to stop tracking
+ */
+const lift = proxy.captioned(function lift(cb) {
     let result;
     let rawResult;
-    const liftCleanup = proxy.effect.named(`lift:${cb.name}`)(proxy.markWithRoot((access) => {
+    const resultName = `lift:${cb.name || 'anonymous'}`;
+    const liftCleanup = proxy.effect `lift:${cb.name}`(proxy.markWithRoot((access) => {
         const source = cb(access);
         if (!source || typeof source !== 'object')
             throw new Error('lift callback must return an array or object');
         const sourceProto = Object.getPrototypeOf(source);
         if (!result) {
-            rawResult = Array.isArray(source) ? [] : Object.create(sourceProto);
+            rawResult = proxy.tag(resultName, Array.isArray(source) ? [] : Object.create(sourceProto));
             result = proxy.reactive(rawResult);
         }
         if (sourceProto !== Object.getPrototypeOf(result))
@@ -801,6 +847,7 @@ function lift(cb) {
                 res.splice(indexA, sliceA.length, ...sliceB);
         }
         else {
+            const recordResult = rawResult;
             for (const key of Object.keys(source)) {
                 const had = key in rawResult;
                 const newDesc = Object.getOwnPropertyDescriptor(source, key);
@@ -809,7 +856,7 @@ function lift(cb) {
                     const sameAccessor = oldDesc && newDesc.get && oldDesc.get === newDesc.get;
                     Object.defineProperty(rawResult, key, newDesc);
                     if (!sameAccessor &&
-                        rawResult[key] !==
+                        recordResult[key] !==
                             (oldDesc ? (oldDesc.get ? oldDesc.get() : oldDesc.value) : undefined))
                         proxy.touched1(rawResult, { type: 'set', prop: key }, key);
                 }
@@ -820,13 +867,16 @@ function lift(cb) {
             }
             for (const key of Object.keys(rawResult))
                 if (!(key in source)) {
-                    delete rawResult[key];
+                    delete recordResult[key];
                     proxy.touched1(rawResult, { type: 'del', prop: key }, key);
                 }
         }
     }, cb));
     return proxy.link(result, liftCleanup);
-}
+}, {
+    name: 'lift',
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+});
 /**
  * Reactively maps an array source through `fn`, producing a lazy reactive output array.
  *
@@ -846,16 +896,26 @@ function lift(cb) {
  */
 function morphArray(source, fn, options) {
     if (typeof source !== 'function' && !proxy.isReactive(source) && options?.pure === true) {
-        return source.map((i) => fn(i));
+        return source.map((i) => fn(i, { index: 0 }));
     }
     let track;
     const itemEffects = new Map();
-    const cache = [];
+    const cache = proxy.tag(`morph:${fn.name || 'anonymous'}`, []);
     let input = [];
+    function currentCleanupReason() {
+        const activeEffect = proxy.getActiveEffect();
+        if (!activeEffect)
+            return undefined;
+        const node = proxy.getEffectNode(activeEffect);
+        return node.currentReason;
+    }
+    function stopEntry(entry) {
+        entry.stop(proxy.chainExternalReason({ type: 'stopped', chain: currentCleanupReason() }));
+    }
     function stopItem(key) {
         const entry = itemEffects.get(key);
         if (entry) {
-            entry.stop({ type: 'stopped' });
+            stopEntry(entry);
             itemEffects.delete(key);
         }
     }
@@ -863,20 +923,33 @@ function morphArray(source, fn, options) {
         const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(input));
         if (isPure) {
             track(() => {
-                cache[key] = fn(input);
+                cache[key] = fn(input, { index: key });
             });
         }
         else {
-            const indexRef = { value: key };
-            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
-                cache[indexRef.value] = fn(input, access);
-                return (reason) => {
-                    delete cache[indexRef.value];
+            const position = proxy.reactive({ index: key });
+            const stop = track(() => proxy.effect.opaque `morph:${fn.name}:${key}`((access) => {
+                if (access.reaction) {
+                    delete cache[position.index];
                     proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
-                };
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = proxy.getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(!access.reaction || access.reaction === true
+                            ? { type: 'stopped', chain }
+                            : access.reaction),
+                        chain: proxy.chainExternalReason(chain),
+                    });
+                }
+                else
+                    cache[position.index] = fn(input, position, access);
             }));
-            itemEffects.set(key, { stop, index: indexRef });
+            itemEffects.set(key, { stop, position });
         }
     }
     const proxy$1 = proxy.reactive(cache, {
@@ -892,40 +965,64 @@ function morphArray(source, fn, options) {
             return Reflect.has(input, prop);
         },
     });
-    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = proxy.effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
         const newInput = [...(typeof source === 'function' ? source() : source)];
         const diffs = arrayDiff(input, newInput).toSorted((a, b) => b.indexA - a.indexA);
         if (diffs.length > 0) {
+            const reusable = new Map();
+            for (const [index, entry] of itemEffects) {
+                const value = input[index];
+                const entries = reusable.get(value);
+                if (entries)
+                    entries.push({ index, entry });
+                else
+                    reusable.set(value, [{ index, entry }]);
+            }
+            const nextEffects = new Map();
+            const reused = new Set();
+            const nextCache = new Map();
+            for (let index = 0; index < newInput.length; index++) {
+                const entries = reusable.get(newInput[index]);
+                const reusedEntry = entries?.shift();
+                if (!reusedEntry)
+                    continue;
+                const { index: previousIndex, entry } = reusedEntry;
+                reused.add(previousIndex);
+                nextEffects.set(index, entry);
+                if (entry.position.index !== index)
+                    entry.position.index = index;
+                else if (Object.hasOwn(cache, previousIndex))
+                    nextCache.set(index, cache[previousIndex]);
+            }
+            for (const [index, entry] of itemEffects) {
+                if (!reused.has(index))
+                    stopEntry(entry);
+            }
+            itemEffects.clear();
+            for (const [index, entry] of nextEffects)
+                itemEffects.set(index, entry);
+            const previousLength = cache.length;
+            cache.length = newInput.length;
+            for (let i = 0; i < Math.max(previousLength, newInput.length); i++)
+                delete cache[i];
+            for (const [index, value] of nextCache)
+                cache[index] = value;
+            const eagerIndices = new Set();
             for (const diff of diffs) {
-                // Stop items in removed range
-                for (let i = diff.indexA; i < diff.indexA + diff.sliceA.length; i++)
-                    stopItem(i);
-                // Shift existing itemEffects in the Map to match the new indices
-                const shift = diff.sliceB.length - diff.sliceA.length;
-                if (shift !== 0) {
-                    // We need to move entries in the Map.
-                    const entries = Array.from(itemEffects.entries()).sort((a, b) => a[0] - b[0]);
-                    // Remove entries that will be shifted
-                    for (const [idx, _entry] of entries) {
-                        if (idx >= diff.indexA + diff.sliceA.length) {
-                            itemEffects.delete(idx);
-                        }
-                    }
-                    // Re-add them with shifted indices
-                    for (const [idx, entry] of entries) {
-                        if (idx >= diff.indexA + diff.sliceA.length) {
-                            const newIdx = idx + shift;
-                            entry.index.value = newIdx;
-                            itemEffects.set(newIdx, entry);
-                        }
-                    }
-                }
-                // Splice the cache
-                cache.splice(diff.indexA, diff.sliceA.length, ...new Array(diff.sliceB.length).fill(undefined));
-                // Make holes for lazy computation
-                for (let i = diff.indexA; i < diff.indexA + diff.sliceB.length; i++)
-                    delete cache[i];
+                const max = Math.max(diff.sliceA.length, diff.sliceB.length);
+                for (let i = 0; i < max; i++)
+                    eagerIndices.add(diff.indexA + i);
+            }
+            for (const index of eagerIndices) {
+                if (index < 0 || index >= newInput.length || Object.hasOwn(cache, index))
+                    continue;
+                const value = newInput[index];
+                const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(value));
+                if (isPure)
+                    continue;
+                stopItem(index);
+                computeItem(index, value);
             }
             const invalidates = new Set([proxy.keysOf]);
             if (input.length !== newInput.length)
@@ -966,12 +1063,18 @@ function morphMap(source, fn, options) {
     }
     let track;
     const itemEffects = new Map();
-    const cache = new Map();
+    const cache = proxy.tag(`morph:${fn.name || 'anonymous'}`, new Map());
     Object.defineProperty(cache, 'constructor', { value: Object, enumerable: false });
     function stopItem(key) {
         const stop = itemEffects.get(key);
         if (stop) {
-            stop({ type: 'stopped' });
+            const activeEffect = proxy.getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = proxy.getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            stop({ type: 'stopped', chain });
             itemEffects.delete(key);
         }
     }
@@ -981,12 +1084,25 @@ function morphMap(source, fn, options) {
             cache.set(key, track(() => fn(val, key)));
         }
         else {
-            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
-                cache.set(key, fn(source.get(key), key, access));
+            const stop = track(() => proxy.effect.opaque `morph:${fn.name}:${key}`((access) => {
+                const next = source.get(key);
+                if (next === undefined && !source.has(key))
+                    return;
+                cache.set(key, fn(next, key, access));
                 return (reason) => {
                     cache.delete(key);
                     proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = proxy.getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: proxy.chainExternalReason(chain),
+                    });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1030,7 +1146,7 @@ function morphMap(source, fn, options) {
         },
     });
     let stateSnapshot = proxy.getState(source);
-    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = proxy.effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
         proxy.dependant(source, proxy.keysOf);
         while ('evolution' in stateSnapshot) {
@@ -1077,7 +1193,13 @@ function morphRecord(source, fn, options) {
     function stopItem(key) {
         const stop = itemEffects.get(key);
         if (stop) {
-            stop({ type: 'stopped' });
+            const activeEffect = proxy.getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = proxy.getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            stop({ type: 'stopped', chain });
             itemEffects.delete(key);
         }
     }
@@ -1087,12 +1209,22 @@ function morphRecord(source, fn, options) {
             cache[key] = track(() => fn(val, key));
         }
         else {
-            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+            const stop = track(() => proxy.effect.opaque `morph:${fn.name}:${key}`((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 });
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = proxy.getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: proxy.chainExternalReason(chain),
+                    });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1119,7 +1251,7 @@ function morphRecord(source, fn, options) {
         },
     });
     let stateSnapshot = proxy.getState(source);
-    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = proxy.effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
         // Track only structural changes on source
         proxy.dependant(source, proxy.keysOf);
@@ -1160,7 +1292,7 @@ function morphRecord(source, fn, options) {
  * // Changing users[0].name only recomputes names[0]
  * ```
  */
-const morph = proxy.flavored(function morph(source, fn, options) {
+const morph = proxy.captioned(proxy.flavored(function morph(source, fn, options) {
     if (Array.isArray(source) || typeof source === 'function')
         return morphArray(source, fn, options);
     if (source instanceof Map)
@@ -1170,6 +1302,10 @@ const morph = proxy.flavored(function morph(source, fn, options) {
     get pure() {
         return (source, fn, _opt) => this(source, fn, { pure: true });
     },
+}), {
+    name: 'morph',
+    callbackIndex: 1,
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
 });
 
 /**
@@ -1195,7 +1331,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.named('deepWatch')(() => {
+    return proxy.effect `deepWatch`(() => {
         // Mark the target object as having deep watchers
         proxy.objectsWithDeepWatchers.add(target);
         // Track which objects this effect is watching for cleanup
@@ -1259,7 +1395,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
         traverseAndTrack(target);
         // Only call the callback if immediate is true or if it's not the first run
         if (immediate) {
-            proxy.untracked(() => callback(target));
+            proxy.untracked `deepWatch:callback`(() => callback(target));
         }
         immediate = true;
         // Return a cleanup function that properly removes deep watcher tracking
@@ -1320,13 +1456,16 @@ function memoizeFunction(fn, opts) {
         for (const arg of args) {
             node = getBranch(node, arg);
         }
+        if (proxy.inertDepth > 0) {
+            return fn.apply(this, args);
+        }
         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));
+                    const fresh = proxy.untracked `memoize:verify-calculation`(() => fn.apply(this, args));
                     if (!proxy.deepCompare(node.result, fresh)) {
                         proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
                     }
@@ -1339,7 +1478,7 @@ function memoizeFunction(fn, opts) {
         }
         // 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')(() => {
+        node.cleanup = proxy.root `memoize:root`(() => proxy.effect `memoize`(() => {
             // Execute the function and track its dependencies
             // The function execution will automatically track dependencies on reactive objects
             node.result = fn.apply(this, args);
@@ -1350,7 +1489,17 @@ function memoizeFunction(fn, opts) {
                 // 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 });
+                    const activeEffect = proxy.getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const effectNode = proxy.getEffectNode(activeEffect);
+                        chain = effectNode.currentReason;
+                    }
+                    node.cleanup({
+                        type: 'invalidate',
+                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: proxy.chainExternalReason(chain),
+                    });
                     node.cleanup = undefined;
                 }
             };
@@ -1359,7 +1508,7 @@ function memoizeFunction(fn, opts) {
             const wasVerification = proxy.options.isVerificationRun;
             proxy.options.isVerificationRun = true;
             try {
-                const fresh = proxy.untracked(() => fn.apply(this, args));
+                const fresh = proxy.untracked `memoize:verify-comparison`(() => fn.apply(this, args));
                 if (!proxy.deepCompare(node.result, fresh)) {
                     proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
                 }
@@ -1551,12 +1700,12 @@ const memoize = proxy.flavored(makeMemoizeDecorator(), {
 function organized(source, apply, baseTarget = {}) {
     const observedSource = proxy.reactive(source);
     const target = proxy.reactive(baseTarget);
-    const stop = attend(() => {
+    const stop = attend `organized:entries`(function enumerateObservedSourceKeys() {
         const keys = [];
         for (const key in observedSource)
             keys.push(key);
         return keys;
-    }, (key) => {
+    }, function applyObservedSourceKey(key) {
         const sourceKey = key;
         const accessBase = {
             key: sourceKey,
@@ -1594,7 +1743,7 @@ function organize(target, property, access) {
 
 //#region watch
 const unsetYet = Symbol('unset-yet');
-const watch = proxy.flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
+const watch = proxy.captioned(proxy.flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
 changed, options = {}) {
     return typeof value === 'function'
         ? watchCallBack(value, changed, options)
@@ -1610,11 +1759,14 @@ changed, options = {}) {
     get immediate() {
         return proxy.flavorOptions(this, { immediate: true });
     },
+}), {
+    name: 'watch',
+    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
 });
 function watchObject(value, changed, { immediate = false, deep = false } = {}) {
     if (deep)
         return deepWatch(value, changed, { immediate });
-    return proxy.effect.named('watch:object')(() => {
+    return proxy.effect `watch:object`(() => {
         proxy.dependant(value);
         if (immediate)
             changed(value);
@@ -1624,16 +1776,16 @@ 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.named('watch:callback')(proxy.markWithRoot((access) => {
+    const cbCleanup = proxy.effect `watch:callback`(proxy.markWithRoot((access) => {
         const newValue = value(access);
         if (oldValue !== newValue) {
             const old = oldValue;
             if (old === unsetYet) {
                 if (immediate)
-                    proxy.untracked(() => changed(newValue));
+                    proxy.untracked `watch:changed`(() => changed(newValue));
             }
             else
-                proxy.untracked(() => changed(newValue, old));
+                proxy.untracked `watch:changed`(() => changed(newValue, old));
         }
         oldValue = newValue;
         if (deep) {
@@ -1660,7 +1812,7 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
 function when(predicate, timeout) {
     return new Promise((resolve, reject) => {
         let timer;
-        const stop = proxy.effect.named('watch:when')((access) => {
+        const stop = proxy.effect `watch:when`((access) => {
             try {
                 const value = predicate(access);
                 if (value) {
@@ -1767,7 +1919,7 @@ function resource(fetcher, options = {}) {
     // Solve race conditions: make sure a new fast request is not overloaded by a slow old one
     let counter = 0;
     return lazyInit(resource, () => {
-        proxy.link(resource, proxy.effect.named('watch:resource')((access) => {
+        proxy.link(resource, proxy.effect `watch:resource`((access) => {
             // Track reload signal to enable manual reloading
             void reloadSignal.value;
             const id = ++counter;
@@ -1933,6 +2085,7 @@ let ReactiveArrayWrapper = (() => {
                 return super.findLastIndex((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
             }
             flat(depth) {
+                proxy.dependant(this, proxy.keysOf);
                 return proxy.reactive(super.flat(depth));
             }
             flatMap(callbackfn, thisArg) {
@@ -1944,14 +2097,28 @@ let ReactiveArrayWrapper = (() => {
                 }, thisArg);
             }
             includes(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.includes(proxy.unwrap(searchElement), fromIndex)
-                    : super.includes(proxy.unwrap(searchElement));
+                const target = proxy.unwrap(searchElement);
+                const length = this.length;
+                let start = fromIndex ?? 0;
+                if (start < 0)
+                    start = Math.max(length + start, 0);
+                for (let i = start; i < length; i++) {
+                    const value = proxy.unwrap(this[i]);
+                    if (value === target)
+                        return true;
+                }
+                return false;
             }
             indexOf(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.indexOf(proxy.unwrap(searchElement), fromIndex)
-                    : super.indexOf(proxy.unwrap(searchElement));
+                const target = proxy.unwrap(searchElement);
+                const length = this.length;
+                let start = fromIndex ?? 0;
+                if (start < 0)
+                    start = Math.max(length + start, 0);
+                for (let i = start; i < length; i++)
+                    if (proxy.unwrap(this[i]) === target)
+                        return i;
+                return -1;
             }
             join(separator) {
                 return super.join(separator);
@@ -1961,9 +2128,17 @@ let ReactiveArrayWrapper = (() => {
                 return super.keys();
             }
             lastIndexOf(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.lastIndexOf(proxy.unwrap(searchElement), fromIndex)
-                    : super.lastIndexOf(proxy.unwrap(searchElement));
+                const target = proxy.unwrap(searchElement);
+                const length = this.length;
+                let start = fromIndex ?? length - 1;
+                if (start < 0)
+                    start = length + start;
+                if (start >= length)
+                    start = length - 1;
+                for (let i = start; i >= 0; i--)
+                    if (proxy.unwrap(this[i]) === target)
+                        return i;
+                return -1;
             }
             map(callbackfn, thisArg) {
                 return proxy.reactive(super.map((v, i, a) => proxy.unwrap(callbackfn.call(thisArg, proxy.reactive(v), i, a)), thisArg));
@@ -2003,13 +2178,25 @@ let ReactiveArrayWrapper = (() => {
                 return super.sort(wrappedCompare);
             }
             splice(start, deleteCount, ...items) {
+                const length = this.length;
+                const normalizedStart = start < 0 ? Math.max(length + start, 0) : Math.min(start, length);
+                const actualDeleteCount = arguments.length === 1
+                    ? length - normalizedStart
+                    : Math.min(Math.max(deleteCount, 0), length - normalizedStart);
+                const structural = actualDeleteCount > 0 || items.length > 0;
+                let result;
                 if (arguments.length > 2)
-                    return proxy.reactive(super.splice(start, deleteCount, ...items.map(proxy.unwrap)));
-                if (arguments.length === 2)
-                    return proxy.reactive(super.splice(start, deleteCount));
-                if (arguments.length === 1)
-                    return proxy.reactive(super.splice(start));
-                return proxy.reactive([]);
+                    result = super.splice(start, deleteCount, ...items.map(proxy.unwrap));
+                else if (arguments.length === 2)
+                    result = super.splice(start, deleteCount);
+                else if (arguments.length === 1)
+                    result = super.splice(start);
+                else
+                    result = [];
+                if (structural && this.length === length) {
+                    proxy.touched(this, { type: 'set', prop: 'length' }, ['length']);
+                }
+                return proxy.reactive(result);
             }
             unshift(...items) {
                 return super.unshift(...items.map(proxy.unwrap));
@@ -2064,6 +2251,12 @@ let ReactiveArrayWrapper = (() => {
         _a;
 })();
 
+// These abstract classes are prototype tables for the reactive proxy, not classes
+// that are instantiated directly. `this` is the original Map/WeakMap target when
+// a method is reached through the proxy meta-prototype path, so calls like
+// `this.get()` or `this.entries()` intentionally re-enter the proxy machinery.
+// Do not mechanically rewrite them to `super.*` as if these were real subclass
+// instances; that would bypass parts of the designed reactive dispatch.
 /**
  * Reactive wrapper around JavaScript's WeakMap class
  * Only tracks individual key operations, no size tracking (WeakMap limitation)
@@ -2112,10 +2305,8 @@ class ReactiveMap extends Map {
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
             // Clear triggers all effects since all keys are affected
-            proxy.batch(() => {
-                proxy.touched1(this, evolution, 'size');
-                proxy.touched(proxy.contentRef(this), evolution);
-            });
+            proxy.touched1(this, evolution, 'size');
+            proxy.touched(proxy.contentRef(this), evolution);
         }
     }
     entries() {
@@ -2153,10 +2344,8 @@ class ReactiveMap extends Map {
         const result = super.delete(key);
         if (hadKey) {
             const evolution = { type: 'del', prop: key };
-            proxy.batch(() => {
-                proxy.touched1(proxy.contentRef(this), evolution, key);
-                proxy.touched1(this, evolution, 'size');
-            });
+            proxy.touched1(proxy.contentRef(this), evolution, key);
+            proxy.touched1(this, evolution, 'size');
         }
         return result;
     }
@@ -2174,17 +2363,21 @@ class ReactiveMap extends Map {
         const reactiveValue = proxy.reactive(value);
         super.set(key, reactiveValue);
         if (!hadKey || oldValue !== reactiveValue) {
-            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');
-            });
+            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;
     }
 }
 
+// These abstract classes are prototype tables for the reactive proxy, not classes
+// that are instantiated directly. `this` is the original Set/WeakSet target when
+// a method is reached through the proxy meta-prototype path, so calls like
+// `this.has()` or `this.entries()` intentionally re-enter the proxy machinery.
+// Do not mechanically rewrite them to `super.*` as if these were real subclass
+// instances; that would bypass parts of the designed reactive dispatch.
 /**
  * Reactive wrapper around JavaScript's WeakSet class
  * Only tracks individual value operations, no size tracking (WeakSet limitation)
@@ -2229,10 +2422,8 @@ class ReactiveSet extends Set {
         if (!had) {
             const evolution = { type: 'add', prop: reactiveValue };
             // touch for value-specific and aggregate dependencies
-            proxy.batch(() => {
-                proxy.touched1(proxy.contentRef(this), evolution, reactiveValue);
-                proxy.touched1(this, evolution, 'size');
-            });
+            proxy.touched1(proxy.contentRef(this), evolution, reactiveValue);
+            proxy.touched1(this, evolution, 'size');
         }
         return this;
     }
@@ -2241,10 +2432,8 @@ class ReactiveSet extends Set {
         super.clear();
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
-            proxy.batch(() => {
-                proxy.touched1(this, evolution, 'size');
-                proxy.touched(proxy.contentRef(this), evolution);
-            });
+            proxy.touched1(this, evolution, 'size');
+            proxy.touched(proxy.contentRef(this), evolution);
         }
     }
     delete(value) {
@@ -2252,10 +2441,8 @@ class ReactiveSet extends Set {
         const res = super.delete(value);
         if (had) {
             const evolution = { type: 'del', prop: value };
-            proxy.batch(() => {
-                proxy.touched1(proxy.contentRef(this), evolution, value);
-                proxy.touched1(this, evolution, 'size');
-            });
+            proxy.touched1(proxy.contentRef(this), evolution, value);
+            proxy.touched1(this, evolution, 'size');
         }
         return res;
     }
@@ -2359,59 +2546,62 @@ function isCached(object, propertyKey) {
 function cache(object, propertyKey, value) {
     Object.defineProperty(object, propertyKey, { value });
 }
+function descriptorBase(descriptor) {
+    return function descriptorDecorator(...properties) {
+        return (Base) => {
+            return class extends Base {
+                constructor(...args) {
+                    super(...args);
+                    for (const key of properties) {
+                        const existing = Object.getOwnPropertyDescriptor(this, key);
+                        Object.defineProperty(this, key, Object.assign(existing || {}, descriptor));
+                    }
+                }
+            };
+        };
+    };
+}
 /**
  * Creates a decorator that modifies property descriptors for specified properties
  * @param descriptor - The descriptor properties to apply
  * @returns A class decorator that applies the descriptor to specified properties
  */
-const descriptor = proxy.flavored(function descriptor(descriptor) {
-    return (...properties) => (Base) => {
-        return class extends Base {
-            constructor(...args) {
-                super(...args);
-                for (const key of properties) {
-                    const existing = Object.getOwnPropertyDescriptor(this, key);
-                    Object.defineProperty(this, key, Object.assign(existing || {}, descriptor));
-                }
-            }
-        };
-    };
-}, {
+const descriptor = Object.assign(descriptorBase, {
     /**
      * enumerable: true
      */
     get enumerable() {
-        return descriptor({ enumerable: true });
+        return descriptorBase({ enumerable: true });
     },
     /**
      * enumerable: false
      */
     get hidden() {
-        return descriptor({ enumerable: false });
+        return descriptorBase({ enumerable: false });
     },
     /**
      * configurable: true
      */
     get configurable() {
-        return descriptor({ configurable: true });
+        return descriptorBase({ configurable: true });
     },
     /**
      * configurable: false
      */
     get frozen() {
-        return descriptor({ configurable: false });
+        return descriptorBase({ configurable: false });
     },
     /**
      * writable: true
      */
     get writable() {
-        return descriptor({ writable: true });
+        return descriptorBase({ writable: true });
     },
     /**
      * writable: false
      */
     get readonly() {
-        return descriptor({ writable: false });
+        return descriptorBase({ writable: false });
     },
 });
 /**
@@ -2540,26 +2730,27 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.12";
+var version$1 = "1.0.14";
 var pkg = {
 	version: version$1};
 
 const { version } = pkg;
 const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
+const runtimeGlobals = globalThis;
 const globalScope = (typeof globalThis !== 'undefined'
     ? globalThis
-    : typeof window !== 'undefined'
-        ? window
-        : typeof global !== 'undefined'
-            ? global
+    : runtimeGlobals.window
+        ? runtimeGlobals.window
+        : runtimeGlobals.global
+            ? runtimeGlobals.global
             : false);
 if (globalScope) {
     let source = 'mutts/index';
     try {
-        if (typeof __filename !== 'undefined')
-            source = __filename;
-        else if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-yK0HVxHv.cjs', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-yK0HVxHv.cjs', document.baseURI).href))) {
-            source = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-yK0HVxHv.cjs', document.baseURI).href));
+        if (runtimeGlobals.__filename)
+            source = runtimeGlobals.__filename;
+        else if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-BnTNC9eC.cjs', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-BnTNC9eC.cjs', document.baseURI).href))) {
+            source = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-BnTNC9eC.cjs', document.baseURI).href));
         }
     }
     catch (_e) { }
@@ -2609,4 +2800,4 @@ exports.throttle = throttle;
 exports.unreactive = unreactive;
 exports.watch = watch;
 exports.when = when;
-//# sourceMappingURL=index-yK0HVxHv.cjs.map
+//# sourceMappingURL=index-BnTNC9eC.cjs.map