mutts 1.0.12 → 1.0.14

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

@@ -1,4 +1,4 @@
-import { t as decorator, B as flavored, O as isReactive, $ as reactive, x as effect, a4 as touched, S as link, G as getState, aa as dependant, a5 as touched1, ab as keysOf, ac as markWithRoot, ad as objectsWithDeepWatchers, ae as effectToDeepWatchedObjects, a7 as untracked, af as deepWatchers, a0 as options, L as isNonReactive, a8 as unwrap, ag as registerDeepWatcher, V as named, ah as rootFunctionSymbol, _ as proxyToObject, ai as getRoot, u as deepCompare, aj as optionCall, a2 as root, ak as FoolProof, z as flavorOptions, al as effectHistory, p as captured, am as unreactiveProperties, g as addUnreactiveProps, an as __runInitializers, ao as __esDecorate, n as atomic, ap as batch, aq as contentRef, ar as notifyPropertyChange, as as metaProtos, at as wrapProtos, au as objectParents, av as watchers, aw as effectToReactiveObjects, W as objectToProxy } from './proxy-D2C49sXH.esm.js';
+import { u as decorator, p as captioned, aa as options, y as effect, ap as markWithRoot, Y as link, F as flavored, af as tag, a9 as reactive, ai as touched1, U as isReactive, ah as touched, K as getState, aq as dependant, J as getActiveEffect, ar as getEffectNode, as as chainExternalReason, at as keysOf, au as objectsWithDeepWatchers, av as effectToDeepWatchedObjects, ak as untracked, aw as deepWatchers, Q as isNonReactive, al as unwrap, ax as registerDeepWatcher, a2 as named, ay as rootFunctionSymbol, a8 as proxyToObject, az as getRoot, aA as inertDepth, v as deepCompare, aB as optionCall, ad as root, aC as FoolProof, E as flavorOptions, aD as effectHistory, q as captured, aE as unreactiveProperties, g as addUnreactiveProps, aF as __runInitializers, aG as __esDecorate, n as atomic, aH as contentRef, aI as notifyPropertyChange, aJ as metaProtos, aK as wrapProtos, aL as objectParents, aM as watchers, aN as effectToReactiveObjects, a3 as objectToProxy } from './proxy-C2lnvvbx.esm.js';
 
 // Integrated with `using` statement via Symbol.dispose
 const fr = new FinalizationRegistry((f) => f());
@@ -256,46 +256,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);
     },
 };
@@ -305,7 +316,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);
@@ -744,7 +755,7 @@ function chainPromise(given) {
     return chained;
 }
 
-function attend(source, callback) {
+const attend = captioned(function attend(source, callback) {
     const enumerate = typeof source === 'function'
         ? source
         : Array.isArray(source)
@@ -755,14 +766,16 @@ function attend(source, callback) {
                     ? () => source.values()
                     : () => Object.keys(source);
     const keyEffects = new Map();
-    const outer = effect.named('attend')(({ ascend }) => {
+    const callbackLabel = callback.name ? callback.name : '';
+    const outer = 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(() => effect.named(`attend:${key}`)((access) => callback(key, access))));
+            const indexRef = { value: key };
+            keyEffects.set(key, ascend(() => effect `attend${callbackLabel ? `:${callbackLabel}` : ''}:${key}`((access) => callback(indexRef.value, access))));
         }
         for (const key of Array.from(keyEffects.keys())) {
             if (!keys.has(key)) {
@@ -777,17 +790,50 @@ function attend(source, callback) {
             stop(reason);
         keyEffects.clear();
     };
-}
-function lift(cb) {
+}, {
+    name: 'attend',
+    callbackIndex: 1,
+    warn: (message) => 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 = captioned(function lift(cb) {
     let result;
     let rawResult;
-    const liftCleanup = effect.named(`lift:${cb.name}`)(markWithRoot((access) => {
+    const resultName = `lift:${cb.name || 'anonymous'}`;
+    const liftCleanup = effect `lift:${cb.name}`(markWithRoot((access) => {
         const source = cb(access);
         if (!source || typeof source !== 'object')
             throw new Error('lift callback must return an array or object');
         const sourceProto = Object.getPrototypeOf(source);
         if (!result) {
-            rawResult = Array.isArray(source) ? [] : Object.create(sourceProto);
+            rawResult = tag(resultName, Array.isArray(source) ? [] : Object.create(sourceProto));
             result = reactive(rawResult);
         }
         if (sourceProto !== Object.getPrototypeOf(result))
@@ -798,6 +844,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);
@@ -806,7 +853,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))
                         touched1(rawResult, { type: 'set', prop: key }, key);
                 }
@@ -817,13 +864,16 @@ function lift(cb) {
             }
             for (const key of Object.keys(rawResult))
                 if (!(key in source)) {
-                    delete rawResult[key];
+                    delete recordResult[key];
                     touched1(rawResult, { type: 'del', prop: key }, key);
                 }
         }
     }, cb));
     return link(result, liftCleanup);
-}
+}, {
+    name: 'lift',
+    warn: (message) => options.warn(`[reactive] ${message}`),
+});
 /**
  * Reactively maps an array source through `fn`, producing a lazy reactive output array.
  *
@@ -843,16 +893,26 @@ function lift(cb) {
  */
 function morphArray(source, fn, options) {
     if (typeof source !== 'function' && !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 = tag(`morph:${fn.name || 'anonymous'}`, []);
     let input = [];
+    function currentCleanupReason() {
+        const activeEffect = getActiveEffect();
+        if (!activeEffect)
+            return undefined;
+        const node = getEffectNode(activeEffect);
+        return node.currentReason;
+    }
+    function stopEntry(entry) {
+        entry.stop(chainExternalReason({ type: 'stopped', chain: currentCleanupReason() }));
+    }
     function stopItem(key) {
         const entry = itemEffects.get(key);
         if (entry) {
-            entry.stop({ type: 'stopped' });
+            stopEntry(entry);
             itemEffects.delete(key);
         }
     }
@@ -860,20 +920,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(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
-                cache[indexRef.value] = fn(input, access);
-                return (reason) => {
-                    delete cache[indexRef.value];
+            const position = reactive({ index: key });
+            const stop = track(() => effect.opaque `morph:${fn.name}:${key}`((access) => {
+                if (access.reaction) {
+                    delete cache[position.index];
                     touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
-                };
+                    const activeEffect = getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: chainExternalReason(!access.reaction || access.reaction === true
+                            ? { type: 'stopped', chain }
+                            : access.reaction),
+                        chain: chainExternalReason(chain),
+                    });
+                }
+                else
+                    cache[position.index] = fn(input, position, access);
             }));
-            itemEffects.set(key, { stop, index: indexRef });
+            itemEffects.set(key, { stop, position });
         }
     }
     const proxy = reactive(cache, {
@@ -889,40 +962,64 @@ function morphArray(source, fn, options) {
             return Reflect.has(input, prop);
         },
     });
-    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = 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([keysOf]);
             if (input.length !== newInput.length)
@@ -963,12 +1060,18 @@ function morphMap(source, fn, options) {
     }
     let track;
     const itemEffects = new Map();
-    const cache = new Map();
+    const cache = 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 = getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            stop({ type: 'stopped', chain });
             itemEffects.delete(key);
         }
     }
@@ -978,12 +1081,25 @@ function morphMap(source, fn, options) {
             cache.set(key, track(() => fn(val, key)));
         }
         else {
-            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
-                cache.set(key, fn(source.get(key), key, access));
+            const stop = track(() => 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);
                     touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
+                    const activeEffect = getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: chainExternalReason(chain),
+                    });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1027,7 +1143,7 @@ function morphMap(source, fn, options) {
         },
     });
     let stateSnapshot = getState(source);
-    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
         dependant(source, keysOf);
         while ('evolution' in stateSnapshot) {
@@ -1074,7 +1190,13 @@ function morphRecord(source, fn, options) {
     function stopItem(key) {
         const stop = itemEffects.get(key);
         if (stop) {
-            stop({ type: 'stopped' });
+            const activeEffect = getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            stop({ type: 'stopped', chain });
             itemEffects.delete(key);
         }
     }
@@ -1084,12 +1206,22 @@ function morphRecord(source, fn, options) {
             cache[key] = track(() => fn(val, key));
         }
         else {
-            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+            const stop = track(() => effect.opaque `morph:${fn.name}:${key}`((access) => {
                 cache[key] = fn(source[key], key, access);
                 return (reason) => {
                     delete cache[key];
                     touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
+                    const activeEffect = getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: chainExternalReason(chain),
+                    });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1116,7 +1248,7 @@ function morphRecord(source, fn, options) {
         },
     });
     let stateSnapshot = getState(source);
-    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
         // Track only structural changes on source
         dependant(source, keysOf);
@@ -1157,7 +1289,7 @@ function morphRecord(source, fn, options) {
  * // Changing users[0].name only recomputes names[0]
  * ```
  */
-const morph = flavored(function morph(source, fn, options) {
+const morph = captioned(flavored(function morph(source, fn, options) {
     if (Array.isArray(source) || typeof source === 'function')
         return morphArray(source, fn, options);
     if (source instanceof Map)
@@ -1167,6 +1299,10 @@ const morph = flavored(function morph(source, fn, options) {
     get pure() {
         return (source, fn, _opt) => this(source, fn, { pure: true });
     },
+}), {
+    name: 'morph',
+    callbackIndex: 1,
+    warn: (message) => options.warn(`[reactive] ${message}`),
 });
 
 /**
@@ -1192,7 +1328,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
     const wrappedCallback = markWithRoot((() => callback(target)), callback);
     registerDeepWatcher();
     // Use the existing effect system to register dependencies
-    return effect.named('deepWatch')(() => {
+    return effect `deepWatch`(() => {
         // Mark the target object as having deep watchers
         objectsWithDeepWatchers.add(target);
         // Track which objects this effect is watching for cleanup
@@ -1256,7 +1392,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) {
-            untracked(() => callback(target));
+            untracked `deepWatch:callback`(() => callback(target));
         }
         immediate = true;
         // Return a cleanup function that properly removes deep watcher tracking
@@ -1317,13 +1453,16 @@ function memoizeFunction(fn, opts) {
         for (const arg of args) {
             node = getBranch(node, arg);
         }
+        if (inertDepth > 0) {
+            return fn.apply(this, args);
+        }
         dependant(node, 'memoize');
         if ('result' in node) {
             if (options.onMemoizationDiscrepancy) {
                 const wasVerification = options.isVerificationRun;
                 options.isVerificationRun = true;
                 try {
-                    const fresh = untracked(() => fn.apply(this, args));
+                    const fresh = untracked `memoize:verify-calculation`(() => fn.apply(this, args));
                     if (!deepCompare(node.result, fresh)) {
                         optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
                     }
@@ -1336,7 +1475,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 = root(() => effect.named('memoize')(() => {
+        node.cleanup = root `memoize:root`(() => 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);
@@ -1347,7 +1486,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 = getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const effectNode = getEffectNode(activeEffect);
+                        chain = effectNode.currentReason;
+                    }
+                    node.cleanup({
+                        type: 'invalidate',
+                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: chainExternalReason(chain),
+                    });
                     node.cleanup = undefined;
                 }
             };
@@ -1356,7 +1505,7 @@ function memoizeFunction(fn, opts) {
             const wasVerification = options.isVerificationRun;
             options.isVerificationRun = true;
             try {
-                const fresh = untracked(() => fn.apply(this, args));
+                const fresh = untracked `memoize:verify-comparison`(() => fn.apply(this, args));
                 if (!deepCompare(node.result, fresh)) {
                     optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
                 }
@@ -1548,12 +1697,12 @@ const memoize = flavored(makeMemoizeDecorator(), {
 function organized(source, apply, baseTarget = {}) {
     const observedSource = reactive(source);
     const target = 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,
@@ -1591,7 +1740,7 @@ function organize(target, property, access) {
 
 //#region watch
 const unsetYet = Symbol('unset-yet');
-const watch = flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
+const watch = captioned(flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
 changed, options = {}) {
     return typeof value === 'function'
         ? watchCallBack(value, changed, options)
@@ -1607,11 +1756,14 @@ changed, options = {}) {
     get immediate() {
         return flavorOptions(this, { immediate: true });
     },
+}), {
+    name: 'watch',
+    warn: (message) => options.warn(`[reactive] ${message}`),
 });
 function watchObject(value, changed, { immediate = false, deep = false } = {}) {
     if (deep)
         return deepWatch(value, changed, { immediate });
-    return effect.named('watch:object')(() => {
+    return effect `watch:object`(() => {
         dependant(value);
         if (immediate)
             changed(value);
@@ -1621,16 +1773,16 @@ function watchObject(value, changed, { immediate = false, deep = false } = {}) {
 function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
     let oldValue = unsetYet;
     let deepCleanup;
-    const cbCleanup = effect.named('watch:callback')(markWithRoot((access) => {
+    const cbCleanup = effect `watch:callback`(markWithRoot((access) => {
         const newValue = value(access);
         if (oldValue !== newValue) {
             const old = oldValue;
             if (old === unsetYet) {
                 if (immediate)
-                    untracked(() => changed(newValue));
+                    untracked `watch:changed`(() => changed(newValue));
             }
             else
-                untracked(() => changed(newValue, old));
+                untracked `watch:changed`(() => changed(newValue, old));
         }
         oldValue = newValue;
         if (deep) {
@@ -1657,7 +1809,7 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
 function when(predicate, timeout) {
     return new Promise((resolve, reject) => {
         let timer;
-        const stop = effect.named('watch:when')((access) => {
+        const stop = effect `watch:when`((access) => {
             try {
                 const value = predicate(access);
                 if (value) {
@@ -1764,7 +1916,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, () => {
-        link(resource, effect.named('watch:resource')((access) => {
+        link(resource, effect `watch:resource`((access) => {
             // Track reload signal to enable manual reloading
             void reloadSignal.value;
             const id = ++counter;
@@ -1930,6 +2082,7 @@ let ReactiveArrayWrapper = (() => {
                 return super.findLastIndex((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
             }
             flat(depth) {
+                dependant(this, keysOf);
                 return reactive(super.flat(depth));
             }
             flatMap(callbackfn, thisArg) {
@@ -1941,14 +2094,28 @@ let ReactiveArrayWrapper = (() => {
                 }, thisArg);
             }
             includes(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.includes(unwrap(searchElement), fromIndex)
-                    : super.includes(unwrap(searchElement));
+                const target = 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 = unwrap(this[i]);
+                    if (value === target)
+                        return true;
+                }
+                return false;
             }
             indexOf(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.indexOf(unwrap(searchElement), fromIndex)
-                    : super.indexOf(unwrap(searchElement));
+                const target = 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 (unwrap(this[i]) === target)
+                        return i;
+                return -1;
             }
             join(separator) {
                 return super.join(separator);
@@ -1958,9 +2125,17 @@ let ReactiveArrayWrapper = (() => {
                 return super.keys();
             }
             lastIndexOf(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.lastIndexOf(unwrap(searchElement), fromIndex)
-                    : super.lastIndexOf(unwrap(searchElement));
+                const target = 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 (unwrap(this[i]) === target)
+                        return i;
+                return -1;
             }
             map(callbackfn, thisArg) {
                 return reactive(super.map((v, i, a) => unwrap(callbackfn.call(thisArg, reactive(v), i, a)), thisArg));
@@ -2000,13 +2175,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 reactive(super.splice(start, deleteCount, ...items.map(unwrap)));
-                if (arguments.length === 2)
-                    return reactive(super.splice(start, deleteCount));
-                if (arguments.length === 1)
-                    return reactive(super.splice(start));
-                return reactive([]);
+                    result = super.splice(start, deleteCount, ...items.map(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) {
+                    touched(this, { type: 'set', prop: 'length' }, ['length']);
+                }
+                return reactive(result);
             }
             unshift(...items) {
                 return super.unshift(...items.map(unwrap));
@@ -2061,6 +2248,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)
@@ -2109,10 +2302,8 @@ class ReactiveMap extends Map {
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
             // Clear triggers all effects since all keys are affected
-            batch(() => {
-                touched1(this, evolution, 'size');
-                touched(contentRef(this), evolution);
-            });
+            touched1(this, evolution, 'size');
+            touched(contentRef(this), evolution);
         }
     }
     entries() {
@@ -2150,10 +2341,8 @@ class ReactiveMap extends Map {
         const result = super.delete(key);
         if (hadKey) {
             const evolution = { type: 'del', prop: key };
-            batch(() => {
-                touched1(contentRef(this), evolution, key);
-                touched1(this, evolution, 'size');
-            });
+            touched1(contentRef(this), evolution, key);
+            touched1(this, evolution, 'size');
         }
         return result;
     }
@@ -2171,17 +2360,21 @@ class ReactiveMap extends Map {
         const reactiveValue = reactive(value);
         super.set(key, reactiveValue);
         if (!hadKey || oldValue !== reactiveValue) {
-            batch(() => {
-                notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey);
-                // Also notify size change for Map (WeakMap doesn't track size)
-                const evolution = { type: hadKey ? 'set' : 'add', prop: key };
-                touched1(this, evolution, 'size');
-            });
+            notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey);
+            // Also notify size change for Map (WeakMap doesn't track size)
+            const evolution = { type: hadKey ? 'set' : 'add', prop: key };
+            touched1(this, evolution, 'size');
         }
         return this;
     }
 }
 
+// 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)
@@ -2226,10 +2419,8 @@ class ReactiveSet extends Set {
         if (!had) {
             const evolution = { type: 'add', prop: reactiveValue };
             // touch for value-specific and aggregate dependencies
-            batch(() => {
-                touched1(contentRef(this), evolution, reactiveValue);
-                touched1(this, evolution, 'size');
-            });
+            touched1(contentRef(this), evolution, reactiveValue);
+            touched1(this, evolution, 'size');
         }
         return this;
     }
@@ -2238,10 +2429,8 @@ class ReactiveSet extends Set {
         super.clear();
         if (hadEntries) {
             const evolution = { type: 'bunch', method: 'clear' };
-            batch(() => {
-                touched1(this, evolution, 'size');
-                touched(contentRef(this), evolution);
-            });
+            touched1(this, evolution, 'size');
+            touched(contentRef(this), evolution);
         }
     }
     delete(value) {
@@ -2249,10 +2438,8 @@ class ReactiveSet extends Set {
         const res = super.delete(value);
         if (had) {
             const evolution = { type: 'del', prop: value };
-            batch(() => {
-                touched1(contentRef(this), evolution, value);
-                touched1(this, evolution, 'size');
-            });
+            touched1(contentRef(this), evolution, value);
+            touched1(this, evolution, 'size');
         }
         return res;
     }
@@ -2356,59 +2543,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 = 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 });
     },
 });
 /**
@@ -2537,24 +2727,25 @@ 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;
+        if (runtimeGlobals.__filename)
+            source = runtimeGlobals.__filename;
         else if (typeof import.meta !== 'undefined' && import.meta.url) {
             source = import.meta.url;
         }
@@ -2574,4 +2765,4 @@ if (globalScope) {
 }
 
 export { ArrayReadForward as A, unreactive as B, watch as C, Destroyable as D, Eventful as E, when as F, Indexable as I, DestructionError as a, allocated as b, allocatedValues as c, arrayDiff as d, attend as e, cache as f, cached as g, callOnGC as h, chainPromise as i, debounce as j, deepWatch as k, deprecated as l, descriptor as m, destructor as n, forwardArray as o, getAt as p, isCached as q, lift as r, memoize as s, morph as t, organize as u, organized as v, profileInfo as w, resource as x, setAt as y, throttle as z };
-//# sourceMappingURL=index-BUop6B2U.esm.js.map
+//# sourceMappingURL=index-CAWVZL7P.esm.js.map