mutts 1.0.13 → 1.0.15

package/dist/chunks/{index-CAdnMJev.cjs → index-Dtj2qZ0d.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var proxy = require('./proxy-DBHj3kGK.cjs');
+var effects = require('./effects-oUauWxxl.cjs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 // Integrated with `using` statement via Symbol.dispose
@@ -83,7 +83,7 @@ function Destroyable(base, destructorObj) {
  * Decorator that marks properties to be stored in the allocated object and passed to the destructor
  * Use with accessor properties or explicit get/set pairs
  */
-const allocated = proxy.decorator({
+const allocated = effects.decorator({
     setter(original, _target, propertyKey) {
         return function (value) {
             this[allocatedValues][propertyKey] = value;
@@ -758,7 +758,7 @@ function chainPromise(given) {
     return chained;
 }
 
-const attend = proxy.captioned(function attend(source, callback) {
+const attend = effects.captioned(function attend(source, callback) {
     const enumerate = typeof source === 'function'
         ? source
         : Array.isArray(source)
@@ -770,7 +770,7 @@ const attend = proxy.captioned(function attend(source, callback) {
                     : () => Object.keys(source);
     const keyEffects = new Map();
     const callbackLabel = callback.name ? callback.name : '';
-    const outer = proxy.effect `attend`(({ ascend }) => {
+    const outer = effects.effect `attend`(({ ascend }) => {
         const keys = new Set();
         for (const key of enumerate())
             keys.add(key);
@@ -778,7 +778,7 @@ const attend = proxy.captioned(function attend(source, callback) {
             if (keyEffects.has(key))
                 continue;
             const indexRef = { value: key };
-            keyEffects.set(key, ascend(() => proxy.effect `attend${callbackLabel ? `:${callbackLabel}` : ''}:${key}`((access) => callback(indexRef.value, access))));
+            keyEffects.set(key, ascend(() => effects.effect `attend${callbackLabel ? `:${callbackLabel}` : ''}:${key}`((access) => callback(indexRef.value, access))));
         }
         for (const key of Array.from(keyEffects.keys())) {
             if (!keys.has(key)) {
@@ -796,7 +796,7 @@ const attend = proxy.captioned(function attend(source, callback) {
 }, {
     name: 'attend',
     callbackIndex: 1,
-    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+    warn: (message) => effects.options.warn(`[reactive] ${message}`),
 });
 /**
  * Lifts a callback that returns an object into a reactive object that automatically
@@ -826,18 +826,18 @@ const attend = proxy.captioned(function attend(source, callback) {
  * @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) {
+const lift = effects.captioned(function lift(cb) {
     let result;
     let rawResult;
     const resultName = `lift:${cb.name || 'anonymous'}`;
-    const liftCleanup = proxy.effect `lift:${cb.name}`(proxy.markWithRoot((access) => {
+    const liftCleanup = effects.effect `lift:${cb.name}`(effects.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 = proxy.tag(resultName, Array.isArray(source) ? [] : Object.create(sourceProto));
-            result = proxy.reactive(rawResult);
+            rawResult = effects.tag(resultName, Array.isArray(source) ? [] : Object.create(sourceProto));
+            result = effects.reactive(rawResult);
         }
         if (sourceProto !== Object.getPrototypeOf(result))
             throw new Error('lift callback must return the same type as the previous result');
@@ -858,24 +858,24 @@ const lift = proxy.captioned(function lift(cb) {
                     if (!sameAccessor &&
                         recordResult[key] !==
                             (oldDesc ? (oldDesc.get ? oldDesc.get() : oldDesc.value) : undefined))
-                        proxy.touched1(rawResult, { type: 'set', prop: key }, key);
+                        effects.touched1(rawResult, { type: 'set', prop: key }, key);
                 }
                 else {
                     Object.defineProperty(rawResult, key, newDesc);
-                    proxy.touched1(rawResult, { type: 'add', prop: key }, key);
+                    effects.touched1(rawResult, { type: 'add', prop: key }, key);
                 }
             }
             for (const key of Object.keys(rawResult))
                 if (!(key in source)) {
                     delete recordResult[key];
-                    proxy.touched1(rawResult, { type: 'del', prop: key }, key);
+                    effects.touched1(rawResult, { type: 'del', prop: key }, key);
                 }
         }
     }, cb));
-    return proxy.link(result, liftCleanup);
+    return effects.link(result, liftCleanup);
 }, {
     name: 'lift',
-    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+    warn: (message) => effects.options.warn(`[reactive] ${message}`),
 });
 /**
  * Reactively maps an array source through `fn`, producing a lazy reactive output array.
@@ -895,23 +895,27 @@ const lift = proxy.captioned(function lift(cb) {
  * @returns A readonly reactive array with a `[cleanup]` method to dispose all effects
  */
 function morphArray(source, fn, options) {
-    if (typeof source !== 'function' && !proxy.isReactive(source) && options?.pure === true) {
-        return source.map((i) => fn(i));
+    if (typeof source !== 'function' && !effects.isReactive(source) && options?.pure === true) {
+        return source.map((i) => fn(i, { index: 0 }));
     }
     let track;
     const itemEffects = new Map();
-    const cache = proxy.tag(`morph:${fn.name || 'anonymous'}`, []);
+    const cache = effects.tag(`morph:${fn.name || 'anonymous'}`, []);
     let input = [];
+    function currentCleanupReason() {
+        const activeEffect = effects.getActiveEffect();
+        if (!activeEffect)
+            return undefined;
+        const node = effects.getEffectNode(activeEffect);
+        return node.currentReason;
+    }
+    function stopEntry(entry) {
+        entry.stop(effects.chainExternalReason({ type: 'stopped', chain: currentCleanupReason() }));
+    }
     function stopItem(key) {
         const entry = itemEffects.get(key);
         if (entry) {
-            const activeEffect = proxy.getActiveEffect();
-            let chain;
-            if (activeEffect) {
-                const node = proxy.getEffectNode(activeEffect);
-                chain = node.currentReason;
-            }
-            entry.stop(proxy.chainExternalReason({ type: 'stopped', chain }));
+            stopEntry(entry);
             itemEffects.delete(key);
         }
     }
@@ -919,33 +923,36 @@ 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.opaque `morph:${fn.name}:${key}`((access) => {
-                cache[indexRef.value] = fn(input, access);
-                return (reason) => {
-                    delete cache[indexRef.value];
-                    proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    const activeEffect = proxy.getActiveEffect();
+            const position = effects.reactive({ index: key });
+            const stop = track(() => effects.effect.opaque `morph:${fn.name}:${key}`((access) => {
+                if (access.reaction) {
+                    delete cache[position.index];
+                    effects.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    const activeEffect = effects.getActiveEffect();
                     let chain;
                     if (activeEffect) {
-                        const node = proxy.getEffectNode(activeEffect);
+                        const node = effects.getEffectNode(activeEffect);
                         chain = node.currentReason;
                     }
                     stop?.({
                         type: 'invalidate',
-                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
-                        chain: proxy.chainExternalReason(chain),
+                        cause: effects.chainExternalReason(!access.reaction || access.reaction === true
+                            ? { type: 'stopped', chain }
+                            : access.reaction),
+                        chain: effects.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, {
+    const proxy = effects.reactive(cache, {
         get(cache, prop) {
             const n = typeof prop === 'string' ? Number(prop) : NaN;
             if (Number.isNaN(n))
@@ -958,42 +965,66 @@ function morphArray(source, fn, options) {
             return Reflect.has(input, prop);
         },
     });
-    const stopMain = proxy.effect `morph:${fn.name}`(({ ascend }) => {
+    const stopMain = effects.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 invalidates = new Set([proxy.keysOf]);
+                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([effects.keysOf]);
             if (input.length !== newInput.length)
                 invalidates.add('length');
             for (const diff of diffs) {
@@ -1001,11 +1032,11 @@ function morphArray(source, fn, options) {
                 for (let i = 0; i < max; i++)
                     invalidates.add(String(diff.indexA + i));
             }
-            proxy.touched(cache, { type: 'bunch', method: 'morph-input' }, invalidates);
+            effects.touched(cache, { type: 'bunch', method: 'morph-input' }, invalidates);
         }
         input = newInput;
     });
-    return proxy.link(proxy$1, (reason) => {
+    return effects.link(proxy, (reason) => {
         stopMain(reason);
         for (const entry of itemEffects.values())
             entry.stop(reason);
@@ -1024,7 +1055,7 @@ function morphArray(source, fn, options) {
  * @returns A reactive Map with a `[cleanup]` method to dispose all effects
  */
 function morphMap(source, fn, options) {
-    if (!proxy.isReactive(source) && options?.pure === true) {
+    if (!effects.isReactive(source) && options?.pure === true) {
         const res = new Map();
         for (const [k, v] of source)
             res.set(k, fn(v, k));
@@ -1032,15 +1063,15 @@ function morphMap(source, fn, options) {
     }
     let track;
     const itemEffects = new Map();
-    const cache = proxy.tag(`morph:${fn.name || 'anonymous'}`, new Map());
+    const cache = effects.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) {
-            const activeEffect = proxy.getActiveEffect();
+            const activeEffect = effects.getActiveEffect();
             let chain;
             if (activeEffect) {
-                const node = proxy.getEffectNode(activeEffect);
+                const node = effects.getEffectNode(activeEffect);
                 chain = node.currentReason;
             }
             stop({ type: 'stopped', chain });
@@ -1053,31 +1084,31 @@ function morphMap(source, fn, options) {
             cache.set(key, track(() => fn(val, key)));
         }
         else {
-            const stop = track(() => proxy.effect.opaque `morph:${fn.name}:${key}`((access) => {
+            const stop = track(() => effects.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));
-                    const activeEffect = proxy.getActiveEffect();
+                    effects.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    const activeEffect = effects.getActiveEffect();
                     let chain;
                     if (activeEffect) {
-                        const node = proxy.getEffectNode(activeEffect);
+                        const node = effects.getEffectNode(activeEffect);
                         chain = node.currentReason;
                     }
                     stop?.({
                         type: 'invalidate',
-                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
-                        chain: proxy.chainExternalReason(chain),
+                        cause: effects.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: effects.chainExternalReason(chain),
                     });
                 };
             }));
             itemEffects.set(key, stop);
         }
     }
-    const proxy$1 = proxy.reactive(cache, {
+    const proxy = effects.reactive(cache, {
         get(cache, prop) {
             if (prop === 'get')
                 return (key) => {
@@ -1096,42 +1127,42 @@ function morphMap(source, fn, options) {
             if (prop === 'values')
                 return function* () {
                     for (const key of source.keys()) {
-                        yield proxy$1.get(key);
+                        yield proxy.get(key);
                     }
                 };
             if (prop === 'entries')
                 return function* () {
                     for (const key of source.keys()) {
-                        yield [key, proxy$1.get(key)];
+                        yield [key, proxy.get(key)];
                     }
                 };
             if (prop === Symbol.iterator)
                 return function* () {
                     for (const key of source.keys()) {
-                        yield [key, proxy$1.get(key)];
+                        yield [key, proxy.get(key)];
                     }
                 };
             return cache[prop];
         },
     });
-    let stateSnapshot = proxy.getState(source);
-    const stopMain = proxy.effect `morph:${fn.name}`(({ ascend }) => {
+    let stateSnapshot = effects.getState(source);
+    const stopMain = effects.effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
-        proxy.dependant(source, proxy.keysOf);
+        effects.dependant(source, effects.keysOf);
         while ('evolution' in stateSnapshot) {
             const { evolution } = stateSnapshot;
             stateSnapshot = stateSnapshot.next;
             if (evolution.type === 'add') {
-                proxy.touched1(cache, evolution, evolution.prop);
+                effects.touched1(cache, evolution, evolution.prop);
             }
             else if (evolution.type === 'del') {
                 stopItem(evolution.prop);
                 cache.delete(evolution.prop);
-                proxy.touched1(cache, evolution, evolution.prop);
+                effects.touched1(cache, evolution, evolution.prop);
             }
         }
     });
-    return proxy.link(proxy$1, (reason) => {
+    return effects.link(proxy, (reason) => {
         stopMain(reason);
         for (const stop of itemEffects.values())
             stop(reason);
@@ -1150,7 +1181,7 @@ function morphMap(source, fn, options) {
  * @returns A reactive record with a `[cleanup]` method to dispose all effects
  */
 function morphRecord(source, fn, options) {
-    if (!proxy.isReactive(source) && options?.pure === true) {
+    if (!effects.isReactive(source) && options?.pure === true) {
         const res = {};
         for (const k of Object.keys(source))
             res[k] = fn(source[k], k);
@@ -1162,10 +1193,10 @@ function morphRecord(source, fn, options) {
     function stopItem(key) {
         const stop = itemEffects.get(key);
         if (stop) {
-            const activeEffect = proxy.getActiveEffect();
+            const activeEffect = effects.getActiveEffect();
             let chain;
             if (activeEffect) {
-                const node = proxy.getEffectNode(activeEffect);
+                const node = effects.getEffectNode(activeEffect);
                 chain = node.currentReason;
             }
             stop({ type: 'stopped', chain });
@@ -1178,21 +1209,21 @@ function morphRecord(source, fn, options) {
             cache[key] = track(() => fn(val, key));
         }
         else {
-            const stop = track(() => proxy.effect.opaque `morph:${fn.name}:${key}`((access) => {
+            const stop = track(() => effects.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));
-                    const activeEffect = proxy.getActiveEffect();
+                    effects.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
+                    const activeEffect = effects.getActiveEffect();
                     let chain;
                     if (activeEffect) {
-                        const node = proxy.getEffectNode(activeEffect);
+                        const node = effects.getEffectNode(activeEffect);
                         chain = node.currentReason;
                     }
                     stop?.({
                         type: 'invalidate',
-                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
-                        chain: proxy.chainExternalReason(chain),
+                        cause: effects.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: effects.chainExternalReason(chain),
                     });
                 };
             }));
@@ -1204,7 +1235,7 @@ function morphRecord(source, fn, options) {
             computeItem(prop, source[prop]);
         return cache[prop];
     }
-    const proxy$1 = proxy.reactive(cache, {
+    const proxy = effects.reactive(cache, {
         get(_, prop) {
             return get(prop);
         },
@@ -1219,25 +1250,25 @@ function morphRecord(source, fn, options) {
                 return { configurable: true, enumerable: true, get: () => get(prop) };
         },
     });
-    let stateSnapshot = proxy.getState(source);
-    const stopMain = proxy.effect `morph:${fn.name}`(({ ascend }) => {
+    let stateSnapshot = effects.getState(source);
+    const stopMain = effects.effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
         // Track only structural changes on source
-        proxy.dependant(source, proxy.keysOf);
+        effects.dependant(source, effects.keysOf);
         while ('evolution' in stateSnapshot) {
             const { evolution } = stateSnapshot;
             stateSnapshot = stateSnapshot.next;
             if (evolution.type === 'add') {
-                proxy.touched1(cache, evolution, evolution.prop);
+                effects.touched1(cache, evolution, evolution.prop);
             }
             else if (evolution.type === 'del') {
                 stopItem(evolution.prop);
                 delete cache[evolution.prop];
-                proxy.touched1(cache, evolution, evolution.prop);
+                effects.touched1(cache, evolution, evolution.prop);
             }
         }
     });
-    return proxy.link(proxy$1, (reason) => {
+    return effects.link(proxy, (reason) => {
         stopMain(reason);
         for (const stop of itemEffects.values())
             stop(reason);
@@ -1261,7 +1292,7 @@ function morphRecord(source, fn, options) {
  * // Changing users[0].name only recomputes names[0]
  * ```
  */
-const morph = proxy.captioned(proxy.flavored(function morph(source, fn, options) {
+const morph = effects.captioned(effects.flavored(function morph(source, fn, options) {
     if (Array.isArray(source) || typeof source === 'function')
         return morphArray(source, fn, options);
     if (source instanceof Map)
@@ -1274,7 +1305,7 @@ const morph = proxy.captioned(proxy.flavored(function morph(source, fn, options)
 }), {
     name: 'morph',
     callbackIndex: 1,
-    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+    warn: (message) => effects.options.warn(`[reactive] ${message}`),
 });
 
 /**
@@ -1297,17 +1328,17 @@ function deepWatch(target, callback, { immediate = false } = {}) {
     if (typeof target !== 'object')
         throw new Error('Target of deep watching must be an object');
     // Create a wrapper callback that matches EffectTrigger signature
-    const wrappedCallback = proxy.markWithRoot((() => callback(target)), callback);
-    proxy.registerDeepWatcher();
+    const wrappedCallback = effects.markWithRoot((() => callback(target)), callback);
+    effects.registerDeepWatcher();
     // Use the existing effect system to register dependencies
-    return proxy.effect `deepWatch`(() => {
+    return effects.effect `deepWatch`(() => {
         // Mark the target object as having deep watchers
-        proxy.objectsWithDeepWatchers.add(target);
+        effects.objectsWithDeepWatchers.add(target);
         // Track which objects this effect is watching for cleanup
-        let effectObjects = proxy.effectToDeepWatchedObjects.get(wrappedCallback);
+        let effectObjects = effects.effectToDeepWatchedObjects.get(wrappedCallback);
         if (!effectObjects) {
             effectObjects = new Set();
-            proxy.effectToDeepWatchedObjects.set(wrappedCallback, effectObjects);
+            effects.effectToDeepWatchedObjects.set(wrappedCallback, effectObjects);
         }
         effectObjects.add(target);
         // Traverse the object graph and register dependencies
@@ -1315,23 +1346,23 @@ function deepWatch(target, callback, { immediate = false } = {}) {
         const visited = new WeakSet();
         function traverseAndTrack(obj, depth = 0) {
             // Prevent infinite recursion and excessive depth
-            if (!obj || visited.has(obj) || typeof obj !== 'object' || depth > proxy.options.maxDeepWatchDepth)
+            if (!obj || visited.has(obj) || typeof obj !== 'object' || depth > effects.options.maxDeepWatchDepth)
                 return;
             // Do not traverse into unreactive objects
-            if (proxy.isNonReactive(obj))
+            if (effects.isNonReactive(obj))
                 return;
             visited.add(obj);
             // Mark this object as having deep watchers
-            proxy.objectsWithDeepWatchers.add(obj);
+            effects.objectsWithDeepWatchers.add(obj);
             effectObjects.add(obj);
             // Traverse all properties to register dependencies
             // unwrap to avoid kicking dependency
-            for (const key in proxy.unwrap(obj)) {
+            for (const key in effects.unwrap(obj)) {
                 if (Object.hasOwn(obj, key)) {
                     // Access the property to register dependency
                     const value = obj[key];
                     // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
+                    const reactiveValue = typeof value === 'object' && value !== null ? effects.reactive(value) : value;
                     traverseAndTrack(reactiveValue, depth + 1);
                 }
             }
@@ -1341,17 +1372,17 @@ function deepWatch(target, callback, { immediate = false } = {}) {
                 // 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;
+                    const reactiveValue = typeof value === 'object' && value !== null ? effects.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');
+                    effects.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;
+                        const reactiveValue = typeof value === 'object' && value !== null ? effects.reactive(value) : value;
                         traverseAndTrack(reactiveValue, depth + 1);
                     }
                 }
@@ -1364,34 +1395,34 @@ 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 `deepWatch:callback`(() => callback(target));
+            effects.untracked `deepWatch:callback`(() => callback(target));
         }
         immediate = true;
         // Return a cleanup function that properly removes deep watcher tracking
         return () => {
             // Get the objects this effect was watching
-            const effectObjects = proxy.effectToDeepWatchedObjects.get(wrappedCallback);
+            const effectObjects = effects.effectToDeepWatchedObjects.get(wrappedCallback);
             if (effectObjects) {
                 // Remove deep watcher tracking from all objects this effect was watching
                 for (const obj of effectObjects) {
                     // Check if this object still has other deep watchers
-                    const watchers = proxy.deepWatchers.get(obj);
+                    const watchers = effects.deepWatchers.get(obj);
                     if (watchers) {
                         // Remove this effect's callback from the watchers
                         watchers.delete(wrappedCallback);
                         // If no more watchers, remove the object from deep watchers tracking
                         if (watchers.size === 0) {
-                            proxy.deepWatchers.delete(obj);
-                            proxy.objectsWithDeepWatchers.delete(obj);
+                            effects.deepWatchers.delete(obj);
+                            effects.objectsWithDeepWatchers.delete(obj);
                         }
                     }
                     else {
                         // No watchers found, remove from deep watchers tracking
-                        proxy.objectsWithDeepWatchers.delete(obj);
+                        effects.objectsWithDeepWatchers.delete(obj);
                     }
                 }
                 // Clean up the tracking data
-                proxy.effectToDeepWatchedObjects.delete(wrappedCallback);
+                effects.effectToDeepWatchedObjects.delete(wrappedCallback);
             }
         };
     });
@@ -1409,12 +1440,12 @@ function getBranch(tree, key) {
     return branch;
 }
 function memoizeFunction(fn, opts) {
-    const fnRoot = proxy.getRoot(fn);
+    const fnRoot = effects.getRoot(fn);
     const existing = memoizedRegistry.get(fnRoot);
     if (existing)
         return existing;
     const cacheRoot = {};
-    const memoized = proxy.markWithRoot(function memoized(...args) {
+    const memoized = effects.markWithRoot(function memoized(...args) {
         if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
             if (opts?.lenient)
                 return fn.apply(this, args);
@@ -1425,62 +1456,65 @@ function memoizeFunction(fn, opts) {
         for (const arg of args) {
             node = getBranch(node, arg);
         }
-        proxy.dependant(node, 'memoize');
+        if (effects.inertDepth > 0) {
+            return fn.apply(this, args);
+        }
+        effects.dependant(node, 'memoize');
         if ('result' in node) {
-            if (proxy.options.onMemoizationDiscrepancy) {
-                const wasVerification = proxy.options.isVerificationRun;
-                proxy.options.isVerificationRun = true;
+            if (effects.options.onMemoizationDiscrepancy) {
+                const wasVerification = effects.options.isVerificationRun;
+                effects.options.isVerificationRun = true;
                 try {
-                    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');
+                    const fresh = effects.untracked `memoize:verify-calculation`(() => fn.apply(this, args));
+                    if (!effects.deepCompare(node.result, fresh)) {
+                        effects.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
                     }
                 }
                 finally {
-                    proxy.options.isVerificationRun = wasVerification;
+                    effects.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 `memoize:root`(() => proxy.effect `memoize`(() => {
+        node.cleanup = effects.root `memoize:root`(() => effects.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);
             return (reason) => {
                 // When dependencies change, clear the cache and notify consumers
                 delete node.result;
-                proxy.touched1(node, { type: 'invalidate', prop: args }, 'memoize');
+                effects.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) {
-                    const activeEffect = proxy.getActiveEffect();
+                    const activeEffect = effects.getActiveEffect();
                     let chain;
                     if (activeEffect) {
-                        const effectNode = proxy.getEffectNode(activeEffect);
+                        const effectNode = effects.getEffectNode(activeEffect);
                         chain = effectNode.currentReason;
                     }
                     node.cleanup({
                         type: 'invalidate',
-                        cause: proxy.chainExternalReason(reason ?? { type: 'stopped', chain }),
-                        chain: proxy.chainExternalReason(chain),
+                        cause: effects.chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: effects.chainExternalReason(chain),
                     });
                     node.cleanup = undefined;
                 }
             };
         }, { opaque: true }));
-        if (proxy.options.onMemoizationDiscrepancy) {
-            const wasVerification = proxy.options.isVerificationRun;
-            proxy.options.isVerificationRun = true;
+        if (effects.options.onMemoizationDiscrepancy) {
+            const wasVerification = effects.options.isVerificationRun;
+            effects.options.isVerificationRun = true;
             try {
-                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');
+                const fresh = effects.untracked `memoize:verify-comparison`(() => fn.apply(this, args));
+                if (!effects.deepCompare(node.result, fresh)) {
+                    effects.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
                 }
             }
             finally {
-                proxy.options.isVerificationRun = wasVerification;
+                effects.options.isVerificationRun = wasVerification;
             }
         }
         return node.result;
@@ -1493,7 +1527,7 @@ function memoizeObject(target, opts) {
     const existing = memoizedRegistry.get(target);
     if (existing)
         return existing;
-    const proxy$1 = new Proxy(target, {
+    const proxy = new Proxy(target, {
         get(source, prop, receiver) {
             // 1. Walk prototype chain to find descriptor
             let current = source;
@@ -1511,14 +1545,14 @@ function memoizeObject(target, opts) {
                 const originalGetter = desc.get;
                 let wrapper = wrapperRegistry.get(originalGetter);
                 if (!wrapper) {
-                    wrapper = proxy.markWithRoot(proxy.named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
+                    wrapper = effects.markWithRoot(effects.named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
                         return originalGetter.call(that);
                     }), {
                         propertyKey: prop,
                     });
-                    const origRoot = originalGetter[proxy.rootFunctionSymbol];
+                    const origRoot = originalGetter[effects.rootFunctionSymbol];
                     if (origRoot)
-                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                        wrapper[effects.rootFunctionSymbol] = origRoot;
                     wrapperRegistry.set(originalGetter, wrapper);
                 }
                 const memoized = memoizeFunction(wrapper, opts);
@@ -1534,9 +1568,9 @@ function memoizeObject(target, opts) {
             return Reflect.set(source, prop, value, source);
         },
     });
-    proxy.proxyToObject.set(proxy$1, target);
-    memoizedRegistry.set(target, proxy$1);
-    return proxy$1;
+    effects.proxyToObject.set(proxy, target);
+    memoizedRegistry.set(target, proxy);
+    return proxy;
 }
 /**
  * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
@@ -1562,20 +1596,20 @@ function memoizeObject(target, opts) {
  * ```
  */
 function makeMemoizeDecorator(memoizeOpts) {
-    return proxy.decorator({
+    return effects.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) => {
+                    wrapper = effects.markWithRoot(effects.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
                         return original.call(that);
                     }), {
                         method: original,
                         propertyKey,
                     });
-                    const origRoot = original[proxy.rootFunctionSymbol];
+                    const origRoot = original[effects.rootFunctionSymbol];
                     if (origRoot)
-                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                        wrapper[effects.rootFunctionSymbol] = origRoot;
                     wrapperRegistry.set(original, wrapper);
                 }
                 const memoized = memoizeFunction(wrapper, memoizeOpts);
@@ -1586,15 +1620,15 @@ function makeMemoizeDecorator(memoizeOpts) {
             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) => {
+                    wrapper = effects.markWithRoot(effects.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];
+                    const origRoot = original[effects.rootFunctionSymbol];
                     if (origRoot)
-                        wrapper[proxy.rootFunctionSymbol] = origRoot;
+                        wrapper[effects.rootFunctionSymbol] = origRoot;
                     wrapperRegistry.set(original, wrapper);
                 }
                 const memoized = memoizeFunction(wrapper, memoizeOpts);
@@ -1606,7 +1640,7 @@ function makeMemoizeDecorator(memoizeOpts) {
             : memoizeFunction(target, memoizeOpts),
     });
 }
-const memoize = proxy.flavored(makeMemoizeDecorator(), {
+const memoize = effects.flavored(makeMemoizeDecorator(), {
     get lenient() {
         return makeMemoizeDecorator({ lenient: true });
     },
@@ -1664,8 +1698,8 @@ const memoize = proxy.flavored(makeMemoizeDecorator(), {
  * });
  */
 function organized(source, apply, baseTarget = {}) {
-    const observedSource = proxy.reactive(source);
-    const target = proxy.reactive(baseTarget);
+    const observedSource = effects.reactive(source);
+    const target = effects.reactive(baseTarget);
     const stop = attend `organized:entries`(function enumerateObservedSourceKeys() {
         const keys = [];
         for (const key in observedSource)
@@ -1675,8 +1709,8 @@ function organized(source, apply, baseTarget = {}) {
         const sourceKey = key;
         const accessBase = {
             key: sourceKey,
-            get: () => proxy.FoolProof.get(observedSource, sourceKey, observedSource),
-            set: (value) => proxy.FoolProof.set(observedSource, sourceKey, value, observedSource),
+            get: () => effects.FoolProof.get(observedSource, sourceKey, observedSource),
+            set: (value) => effects.FoolProof.set(observedSource, sourceKey, value, observedSource),
         };
         Object.defineProperty(accessBase, 'value', {
             get: accessBase.get,
@@ -1686,7 +1720,7 @@ function organized(source, apply, baseTarget = {}) {
         });
         return apply(accessBase, target);
     });
-    return proxy.link(target, (reason) => stop(reason));
+    return effects.link(target, (reason) => stop(reason));
 }
 /**
  * Organizes a property on a target object
@@ -1703,13 +1737,13 @@ function organize(target, property, access) {
         configurable: true,
         enumerable: true,
     });
-    proxy.touched1(target, { type: 'set', prop: property }, property);
+    effects.touched1(target, { type: 'set', prop: property }, property);
     return () => delete target[property];
 }
 
 //#region watch
 const unsetYet = Symbol('unset-yet');
-const watch = proxy.captioned(proxy.flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
+const watch = effects.captioned(effects.flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
 changed, options = {}) {
     return typeof value === 'function'
         ? watchCallBack(value, changed, options)
@@ -1720,20 +1754,20 @@ changed, options = {}) {
             })();
 }, {
     get deep() {
-        return proxy.flavorOptions(this, { deep: true });
+        return effects.flavorOptions(this, { deep: true });
     },
     get immediate() {
-        return proxy.flavorOptions(this, { immediate: true });
+        return effects.flavorOptions(this, { immediate: true });
     },
 }), {
     name: 'watch',
-    warn: (message) => proxy.options.warn(`[reactive] ${message}`),
+    warn: (message) => effects.options.warn(`[reactive] ${message}`),
 });
 function watchObject(value, changed, { immediate = false, deep = false } = {}) {
     if (deep)
         return deepWatch(value, changed, { immediate });
-    return proxy.effect `watch:object`(() => {
-        proxy.dependant(value);
+    return effects.effect `watch:object`(() => {
+        effects.dependant(value);
         if (immediate)
             changed(value);
         immediate = true;
@@ -1742,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 `watch:callback`(proxy.markWithRoot((access) => {
+    const cbCleanup = effects.effect `watch:callback`(effects.markWithRoot((access) => {
         const newValue = value(access);
         if (oldValue !== newValue) {
             const old = oldValue;
             if (old === unsetYet) {
                 if (immediate)
-                    proxy.untracked `watch:changed`(() => changed(newValue));
+                    effects.untracked `watch:changed`(() => changed(newValue));
             }
             else
-                proxy.untracked `watch:changed`(() => changed(newValue, old));
+                effects.untracked `watch:changed`(() => changed(newValue, old));
         }
         oldValue = newValue;
         if (deep) {
@@ -1778,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 `watch:when`((access) => {
+        const stop = effects.effect `watch:when`((access) => {
             try {
                 const value = predicate(access);
                 if (value) {
@@ -1812,10 +1846,10 @@ function when(predicate, timeout) {
  * @param obj - The object to mark as non-reactive
  */
 function shallowNonReactive(obj) {
-    obj = proxy.unwrap(obj);
-    if (proxy.isNonReactive(obj))
+    obj = effects.unwrap(obj);
+    if (effects.isNonReactive(obj))
         return obj;
-    obj[proxy.unreactiveProperties] = true;
+    obj[effects.unreactiveProperties] = true;
     return obj;
 }
 function unreactiveApplication(arg1, ...args) {
@@ -1823,10 +1857,10 @@ function unreactiveApplication(arg1, ...args) {
         ? shallowNonReactive(arg1)
         : ((original) => {
             // Copy the parent's unreactive properties if they exist
-            const parentMarker = original.prototype[proxy.unreactiveProperties];
+            const parentMarker = original.prototype[effects.unreactiveProperties];
             // If parent is fully unreactive, child is too
             if (parentMarker === true) {
-                original.prototype[proxy.unreactiveProperties] = true;
+                original.prototype[effects.unreactiveProperties] = true;
             }
             else {
                 const set = new Set(parentMarker || []);
@@ -1834,7 +1868,7 @@ function unreactiveApplication(arg1, ...args) {
                 set.add(arg1);
                 for (const arg of args)
                     set.add(arg);
-                proxy.addUnreactiveProps(original.prototype, set);
+                effects.addUnreactiveProps(original.prototype, set);
             }
             return original; // Return the class
         });
@@ -1843,22 +1877,22 @@ function unreactiveApplication(arg1, ...args) {
  * Decorator that marks classes or properties as non-reactive
  * Prevents objects from being made reactive
  */
-const unreactive = proxy.decorator({
+const unreactive = effects.decorator({
     class(original) {
-        original.prototype[proxy.unreactiveProperties] = true;
+        original.prototype[effects.unreactiveProperties] = true;
     },
     default: unreactiveApplication,
 });
 //#endregion
 //#region resource
 function lazyInit(resource, load) {
-    const creation = proxy.effectHistory.active;
+    const creation = effects.effectHistory.active;
     let fresh = true;
     return new Proxy(resource, {
         [Symbol.toStringTag]: 'LazyInit',
         get(target, prop) {
             if (fresh) {
-                proxy.captured(creation, load)();
+                effects.captured(creation, load)();
                 fresh = false;
             }
             return target[prop];
@@ -1872,7 +1906,7 @@ function lazyInit(resource, load) {
  * @returns Reactive Resource object with value, loading, error, latest properties
  */
 function resource(fetcher, options = {}) {
-    const resource = proxy.reactive({
+    const resource = effects.reactive({
         value: options.initialValue,
         loading: true,
         error: undefined,
@@ -1881,11 +1915,11 @@ function resource(fetcher, options = {}) {
             reloadSignal.value++;
         },
     });
-    const reloadSignal = proxy.reactive({ value: 0 });
+    const reloadSignal = effects.reactive({ value: 0 });
     // 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 `watch:resource`((access) => {
+        effects.link(resource, effects.effect `watch:resource`((access) => {
             // Track reload signal to enable manual reloading
             void reloadSignal.value;
             const id = ++counter;
@@ -1932,7 +1966,7 @@ function resource(fetcher, options = {}) {
 function* makeReactiveIterator(iterator) {
     let result = iterator.next();
     while (!result.done) {
-        yield proxy.reactive(result.value);
+        yield effects.reactive(result.value);
         result = iterator.next();
     }
 }
@@ -1943,7 +1977,7 @@ function* makeReactiveEntriesIterator(iterator) {
     let result = iterator.next();
     while (!result.done) {
         const [key, value] = result.value;
-        yield [proxy.reactive(key), proxy.reactive(value)];
+        yield [effects.reactive(key), effects.reactive(value)];
         result = iterator.next();
     }
 }
@@ -1955,18 +1989,18 @@ function* index(i, { length = true } = {}) {
 }
 class Indexer extends Array {
     get(i) {
-        proxy.dependant(this, i);
-        return proxy.reactive(this[i]);
+        effects.dependant(this, i);
+        return effects.reactive(this[i]);
     }
     // Returns undefined intentionally: signals the proxy handler that notifications
     // were already dispatched via touched(), preventing double notification
     set(i, value) {
         const added = i >= this.length;
         this[i] = value;
-        proxy.touched(this, { type: 'set', prop: i }, index(i, { length: added }));
+        effects.touched(this, { type: 'set', prop: i }, index(i, { length: added }));
     }
 }
-const indexLess = { get: proxy.FoolProof.get, set: proxy.FoolProof.set };
+const indexLess = { get: effects.FoolProof.get, set: effects.FoolProof.set };
 // Fast numeric-string check: first char is a digit (0-9)
 function asIndex(prop) {
     const c = prop.charCodeAt(0);
@@ -1975,7 +2009,7 @@ function asIndex(prop) {
     const n = +prop; // coerce — faster than parseInt, handles "0", "12", etc.
     return n === (n | 0) && n >= 0 ? n : -1;
 }
-Object.assign(proxy.FoolProof, {
+Object.assign(effects.FoolProof, {
     get(obj, prop, receiver) {
         if (Array.isArray(obj) && typeof prop === 'string') {
             const i = asIndex(prop);
@@ -2017,172 +2051,212 @@ let ReactiveArrayWrapper = (() => {
     let _unshift_decorators;
     return _a = class ReactiveArrayWrapper extends _classSuper {
             at(index) {
-                return proxy.reactive(super.at(index));
+                return effects.reactive(super.at(index));
             }
             concat(...items) {
-                return proxy.reactive(super.concat(...items.map(proxy.unwrap)));
+                return effects.reactive(super.concat(...items.map(effects.unwrap)));
             }
             entries() {
-                proxy.dependant(this, proxy.keysOf);
+                effects.dependant(this, effects.keysOf);
                 return makeReactiveEntriesIterator(super.entries());
             }
             every(predicate, thisArg) {
-                return super.every((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+                return super.every((v, i, a) => predicate.call(thisArg, effects.reactive(v), i, a), thisArg);
             }
             fill(value, start, end) {
-                return super.fill(proxy.unwrap(value), start, end);
+                return super.fill(effects.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));
+                return effects.reactive(super.filter((v, i, a) => predicate.call(thisArg, effects.reactive(v), i, a), thisArg));
             }
             find(predicate, thisArg) {
-                return proxy.reactive(super.find((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
+                return effects.reactive(super.find((v, i, a) => predicate.call(thisArg, effects.reactive(v), i, a), thisArg));
             }
             findIndex(predicate, thisArg) {
-                return super.findIndex((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+                return super.findIndex((v, i, a) => predicate.call(thisArg, effects.reactive(v), i, a), thisArg);
             }
             findLast(predicate, thisArg) {
-                return proxy.reactive(super.findLast((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
+                return effects.reactive(super.findLast((v, i, a) => predicate.call(thisArg, effects.reactive(v), i, a), thisArg));
             }
             findLastIndex(predicate, thisArg) {
-                return super.findLastIndex((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+                return super.findLastIndex((v, i, a) => predicate.call(thisArg, effects.reactive(v), i, a), thisArg);
             }
             flat(depth) {
-                proxy.dependant(this, proxy.keysOf);
-                return proxy.reactive(super.flat(depth));
+                effects.dependant(this, effects.keysOf);
+                return effects.reactive(super.flat(depth));
             }
             flatMap(callbackfn, thisArg) {
-                return proxy.reactive(super.flatMap((v, i, a) => proxy.unwrap(callbackfn.call(thisArg, proxy.reactive(v), i, a)), thisArg));
+                return effects.reactive(super.flatMap((v, i, a) => effects.unwrap(callbackfn.call(thisArg, effects.reactive(v), i, a)), thisArg));
             }
             forEach(callbackfn, thisArg) {
                 super.forEach((v, i, a) => {
-                    callbackfn.call(thisArg, proxy.reactive(v), i, a);
+                    callbackfn.call(thisArg, effects.reactive(v), i, a);
                 }, thisArg);
             }
             includes(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.includes(proxy.unwrap(searchElement), fromIndex)
-                    : super.includes(proxy.unwrap(searchElement));
+                const target = effects.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 = effects.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 = effects.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 (effects.unwrap(this[i]) === target)
+                        return i;
+                return -1;
             }
             join(separator) {
                 return super.join(separator);
             }
             keys() {
-                proxy.dependant(this, 'length');
+                effects.dependant(this, 'length');
                 return super.keys();
             }
             lastIndexOf(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.lastIndexOf(proxy.unwrap(searchElement), fromIndex)
-                    : super.lastIndexOf(proxy.unwrap(searchElement));
+                const target = effects.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 (effects.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));
+                return effects.reactive(super.map((v, i, a) => effects.unwrap(callbackfn.call(thisArg, effects.reactive(v), i, a)), thisArg));
             }
             pop() {
-                return proxy.reactive(super.pop());
+                return effects.reactive(super.pop());
             }
             push(...items) {
-                return super.push(...items.map(proxy.unwrap));
+                return super.push(...items.map(effects.unwrap));
             }
             reduce(callbackfn, initialValue) {
-                return proxy.reactive(arguments.length > 1
-                    ? super.reduce((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a)), initialValue)
-                    : super.reduce((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a))));
+                return effects.reactive(arguments.length > 1
+                    ? super.reduce((acc, v, i, a) => effects.unwrap(callbackfn(acc, effects.reactive(v), i, a)), initialValue)
+                    : super.reduce((acc, v, i, a) => effects.unwrap(callbackfn(acc, effects.reactive(v), i, a))));
             }
             reduceRight(callbackfn, initialValue) {
-                return proxy.reactive(arguments.length > 1
-                    ? super.reduceRight((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a)), initialValue)
-                    : super.reduceRight((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a))));
+                return effects.reactive(arguments.length > 1
+                    ? super.reduceRight((acc, v, i, a) => effects.unwrap(callbackfn(acc, effects.reactive(v), i, a)), initialValue)
+                    : super.reduceRight((acc, v, i, a) => effects.unwrap(callbackfn(acc, effects.reactive(v), i, a))));
             }
             reverse() {
-                return proxy.reactive(super.reverse());
+                return effects.reactive(super.reverse());
             }
             shift() {
-                return proxy.reactive(super.shift());
+                return effects.reactive(super.shift());
             }
             slice(start, end) {
-                return proxy.reactive(super.slice(start, end));
+                return effects.reactive(super.slice(start, end));
             }
             some(predicate, thisArg) {
-                return super.some((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
+                return super.some((v, i, a) => predicate.call(thisArg, effects.reactive(v), i, a), thisArg);
             }
             sort(compareFn) {
                 const wrappedCompare = compareFn
-                    ? (a, b) => compareFn(proxy.reactive(a), proxy.reactive(b))
+                    ? (a, b) => compareFn(effects.reactive(a), effects.reactive(b))
                     : undefined;
                 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(effects.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) {
+                    effects.touched(this, { type: 'set', prop: 'length' }, ['length']);
+                }
+                return effects.reactive(result);
             }
             unshift(...items) {
-                return super.unshift(...items.map(proxy.unwrap));
+                return super.unshift(...items.map(effects.unwrap));
             }
             values() {
-                proxy.dependant(this, proxy.keysOf);
+                effects.dependant(this, effects.keysOf);
                 return makeReactiveIterator(super.values());
             }
-            [(_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);
+            [(_fill_decorators = [effects.atomic], _copyWithin_decorators = [effects.atomic], _pop_decorators = [effects.atomic], _push_decorators = [effects.atomic], _reverse_decorators = [effects.atomic], _shift_decorators = [effects.atomic], _sort_decorators = [effects.atomic], _splice_decorators = [effects.atomic], _unshift_decorators = [effects.atomic], Symbol.iterator)]() {
+                effects.dependant(this, effects.keysOf);
                 return makeReactiveIterator(super[Symbol.iterator]());
             }
             toReversed() {
-                return proxy.reactive(super.toReversed());
+                return effects.reactive(super.toReversed());
             }
             toSorted(compareFn) {
                 const wrappedCompare = compareFn
-                    ? (a, b) => compareFn(proxy.reactive(a), proxy.reactive(b))
+                    ? (a, b) => compareFn(effects.reactive(a), effects.reactive(b))
                     : undefined;
-                return proxy.reactive(super.toSorted(wrappedCompare));
+                return effects.reactive(super.toSorted(wrappedCompare));
             }
             toSpliced(start, deleteCount, ...items) {
                 if (arguments.length > 2)
-                    return proxy.reactive(super.toSpliced(start, deleteCount, ...items.map(proxy.unwrap)));
+                    return effects.reactive(super.toSpliced(start, deleteCount, ...items.map(effects.unwrap)));
                 if (arguments.length === 2)
-                    return proxy.reactive(super.toSpliced(start, deleteCount));
+                    return effects.reactive(super.toSpliced(start, deleteCount));
                 if (arguments.length === 1)
-                    return proxy.reactive(super.toSpliced(start));
-                return proxy.reactive([...this]);
+                    return effects.reactive(super.toSpliced(start));
+                return effects.reactive([...this]);
             }
             with(index, value) {
-                return proxy.reactive(super.with(index, proxy.unwrap(value)));
+                return effects.reactive(super.with(index, effects.unwrap(value)));
             }
             constructor() {
                 super(...arguments);
-                proxy.__runInitializers(this, _instanceExtraInitializers);
+                effects.__runInitializers(this, _instanceExtraInitializers);
             }
         },
         (() => {
             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);
-            proxy.__esDecorate(_a, null, _shift_decorators, { kind: "method", name: "shift", static: false, private: false, access: { has: obj => "shift" in obj, get: obj => obj.shift }, metadata: _metadata }, null, _instanceExtraInitializers);
-            proxy.__esDecorate(_a, null, _sort_decorators, { kind: "method", name: "sort", static: false, private: false, access: { has: obj => "sort" in obj, get: obj => obj.sort }, metadata: _metadata }, null, _instanceExtraInitializers);
-            proxy.__esDecorate(_a, null, _splice_decorators, { kind: "method", name: "splice", static: false, private: false, access: { has: obj => "splice" in obj, get: obj => obj.splice }, metadata: _metadata }, null, _instanceExtraInitializers);
-            proxy.__esDecorate(_a, null, _unshift_decorators, { kind: "method", name: "unshift", static: false, private: false, access: { has: obj => "unshift" in obj, get: obj => obj.unshift }, metadata: _metadata }, null, _instanceExtraInitializers);
+            effects.__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);
+            effects.__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);
+            effects.__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);
+            effects.__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);
+            effects.__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);
+            effects.__esDecorate(_a, null, _shift_decorators, { kind: "method", name: "shift", static: false, private: false, access: { has: obj => "shift" in obj, get: obj => obj.shift }, metadata: _metadata }, null, _instanceExtraInitializers);
+            effects.__esDecorate(_a, null, _sort_decorators, { kind: "method", name: "sort", static: false, private: false, access: { has: obj => "sort" in obj, get: obj => obj.sort }, metadata: _metadata }, null, _instanceExtraInitializers);
+            effects.__esDecorate(_a, null, _splice_decorators, { kind: "method", name: "splice", static: false, private: false, access: { has: obj => "splice" in obj, get: obj => obj.splice }, metadata: _metadata }, null, _instanceExtraInitializers);
+            effects.__esDecorate(_a, null, _unshift_decorators, { kind: "method", name: "unshift", static: false, private: false, access: { has: obj => "unshift" in obj, get: obj => obj.unshift }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         })(),
         _a;
 })();
 
+// 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)
@@ -2193,24 +2267,24 @@ class ReactiveWeakMap extends WeakMap {
         const hadKey = this.has(key);
         const result = super.delete(key);
         if (hadKey)
-            proxy.touched1(proxy.contentRef(this), { type: 'del', prop: key }, key);
+            effects.touched1(effects.contentRef(this), { type: 'del', prop: key }, key);
         return result;
     }
     get(key) {
-        proxy.dependant(proxy.contentRef(this), key);
-        return proxy.reactive(super.get(key));
+        effects.dependant(effects.contentRef(this), key);
+        return effects.reactive(super.get(key));
     }
     has(key) {
-        proxy.dependant(proxy.contentRef(this), key);
+        effects.dependant(effects.contentRef(this), key);
         return super.has(key);
     }
     set(key, value) {
         const hadKey = this.has(key);
         const oldValue = this.get(key);
-        const reactiveValue = proxy.reactive(value);
+        const reactiveValue = effects.reactive(value);
         this.set(key, reactiveValue);
         if (!hadKey || oldValue !== reactiveValue) {
-            proxy.notifyPropertyChange(proxy.contentRef(this), key, oldValue, reactiveValue, hadKey);
+            effects.notifyPropertyChange(effects.contentRef(this), key, oldValue, reactiveValue, hadKey);
         }
         return this;
     }
@@ -2222,7 +2296,7 @@ class ReactiveWeakMap extends WeakMap {
 class ReactiveMap extends Map {
     // Implement Map interface methods with reactivity
     get size() {
-        proxy.dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
+        effects.dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
         return super.size;
     }
     clear() {
@@ -2231,30 +2305,28 @@ 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);
-            });
+            effects.touched1(this, evolution, 'size');
+            effects.touched(effects.contentRef(this), evolution);
         }
     }
     entries() {
-        proxy.dependant(proxy.contentRef(this));
+        effects.dependant(effects.contentRef(this));
         return makeReactiveEntriesIterator(this.entries());
     }
     forEach(callbackfn, thisArg) {
-        proxy.dependant(proxy.contentRef(this));
+        effects.dependant(effects.contentRef(this));
         this.forEach(callbackfn, thisArg);
     }
     keys() {
-        proxy.dependant(proxy.contentRef(this), proxy.keysOf);
+        effects.dependant(effects.contentRef(this), effects.keysOf);
         return this.keys();
     }
     values() {
-        proxy.dependant(proxy.contentRef(this));
+        effects.dependant(effects.contentRef(this));
         return makeReactiveIterator(this.values());
     }
     [Symbol.iterator]() {
-        proxy.dependant(proxy.contentRef(this));
+        effects.dependant(effects.contentRef(this));
         const it = Map.prototype[Symbol.iterator].call(this);
         const nativeNext = it.next.bind(it);
         it.next = () => {
@@ -2262,7 +2334,7 @@ class ReactiveMap extends Map {
             if (result.done)
                 return result;
             const [key, value] = result.value;
-            return { value: [proxy.reactive(key), proxy.reactive(value)], done: false };
+            return { value: [effects.reactive(key), effects.reactive(value)], done: false };
         };
         return it;
     }
@@ -2272,38 +2344,40 @@ 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');
-            });
+            effects.touched1(effects.contentRef(this), evolution, key);
+            effects.touched1(this, evolution, 'size');
         }
         return result;
     }
     get(key) {
-        proxy.dependant(proxy.contentRef(this), key);
-        return proxy.reactive(super.get(key));
+        effects.dependant(effects.contentRef(this), key);
+        return effects.reactive(super.get(key));
     }
     has(key) {
-        proxy.dependant(proxy.contentRef(this), key);
+        effects.dependant(effects.contentRef(this), key);
         return super.has(key);
     }
     set(key, value) {
         const hadKey = this.has(key);
         const oldValue = this.get(key);
-        const reactiveValue = proxy.reactive(value);
+        const reactiveValue = effects.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');
-            });
+            effects.notifyPropertyChange(effects.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 };
+            effects.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)
@@ -2314,7 +2388,7 @@ class ReactiveWeakSet extends WeakSet {
         super.add(value);
         if (!had) {
             // touch the specific value and the collection view
-            proxy.touched1(proxy.contentRef(this), { type: 'add', prop: value }, value);
+            effects.touched1(effects.contentRef(this), { type: 'add', prop: value }, value);
             // no size/allProps for WeakSet
         }
         return this;
@@ -2323,11 +2397,11 @@ class ReactiveWeakSet extends WeakSet {
         const had = this.has(value);
         const res = super.delete(value);
         if (had)
-            proxy.touched1(proxy.contentRef(this), { type: 'del', prop: value }, value);
+            effects.touched1(effects.contentRef(this), { type: 'del', prop: value }, value);
         return res;
     }
     has(value) {
-        proxy.dependant(proxy.contentRef(this), value);
+        effects.dependant(effects.contentRef(this), value);
         return super.has(value);
     }
 }
@@ -2338,20 +2412,18 @@ class ReactiveWeakSet extends WeakSet {
 class ReactiveSet extends Set {
     get size() {
         // size depends on the wrapper instance, like Map counterpart
-        proxy.dependant(this, 'size');
+        effects.dependant(this, 'size');
         return this.size;
     }
     add(value) {
         const had = this.has(value);
-        const reactiveValue = proxy.reactive(value);
+        const reactiveValue = effects.reactive(value);
         super.add(reactiveValue);
         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');
-            });
+            effects.touched1(effects.contentRef(this), evolution, reactiveValue);
+            effects.touched1(this, evolution, 'size');
         }
         return this;
     }
@@ -2360,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);
-            });
+            effects.touched1(this, evolution, 'size');
+            effects.touched(effects.contentRef(this), evolution);
         }
     }
     delete(value) {
@@ -2371,66 +2441,64 @@ 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');
-            });
+            effects.touched1(effects.contentRef(this), evolution, value);
+            effects.touched1(this, evolution, 'size');
         }
         return res;
     }
     has(value) {
-        proxy.dependant(proxy.contentRef(this), value);
+        effects.dependant(effects.contentRef(this), value);
         return this.has(value);
     }
     entries() {
-        proxy.dependant(proxy.contentRef(this));
+        effects.dependant(effects.contentRef(this));
         return makeReactiveEntriesIterator(this.entries());
     }
     forEach(callbackfn, thisArg) {
-        proxy.dependant(proxy.contentRef(this));
+        effects.dependant(effects.contentRef(this));
         this.forEach(callbackfn, thisArg);
     }
     keys() {
-        proxy.dependant(proxy.contentRef(this));
+        effects.dependant(effects.contentRef(this));
         return makeReactiveIterator(this.keys());
     }
     values() {
-        proxy.dependant(proxy.contentRef(this));
+        effects.dependant(effects.contentRef(this));
         return makeReactiveIterator(this.values());
     }
     [Symbol.iterator]() {
-        proxy.dependant(proxy.contentRef(this));
+        effects.dependant(effects.contentRef(this));
         const it = Set.prototype[Symbol.iterator].call(this);
         const nativeNext = it.next.bind(it);
         it.next = () => {
             const result = nativeNext();
             if (result.done)
                 return result;
-            return { value: proxy.reactive(result.value), done: false };
+            return { value: effects.reactive(result.value), done: false };
         };
         return it;
     }
 }
 
 // Register native collection types to use specialized reactive wrappers
-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);
+effects.metaProtos.set(Array, ReactiveArray.prototype);
+effects.metaProtos.set(Set, ReactiveSet.prototype);
+effects.metaProtos.set(WeakSet, ReactiveWeakSet.prototype);
+effects.metaProtos.set(Map, ReactiveMap.prototype);
+effects.metaProtos.set(WeakMap, ReactiveWeakMap.prototype);
+effects.wrapProtos.set(Array, ReactiveArrayWrapper.prototype);
 /**
  * Object containing internal reactive system state for debugging and profiling
  */
 const profileInfo = {
-    objectToProxy: proxy.objectToProxy,
-    proxyToObject: proxy.proxyToObject,
-    effectToReactiveObjects: proxy.effectToReactiveObjects,
-    watchers: proxy.watchers,
-    objectParents: proxy.objectParents,
-    objectsWithDeepWatchers: proxy.objectsWithDeepWatchers,
-    deepWatchers: proxy.deepWatchers,
-    effectToDeepWatchedObjects: proxy.effectToDeepWatchedObjects,
+    objectToProxy: effects.objectToProxy,
+    proxyToObject: effects.proxyToObject,
+    effectToReactiveObjects: effects.effectToReactiveObjects,
+    watchers: effects.watchers,
+    objectParents: effects.objectParents,
+    objectsWithDeepWatchers: effects.objectsWithDeepWatchers,
+    deepWatchers: effects.deepWatchers,
+    effectToDeepWatchedObjects: effects.effectToDeepWatchedObjects,
 };
 
 // In order to avoid async re-entrance, we could use zone.js or something like that.
@@ -2439,7 +2507,7 @@ const syncCalculating = [];
  * Decorator that caches the result of a getter method and only recomputes when dependencies change
  * Prevents circular dependencies and provides automatic cache invalidation
  */
-const cached = proxy.decorator({
+const cached = effects.decorator({
     getter(original, _target, propertyKey) {
         return function () {
             const alreadyCalculating = syncCalculating.findIndex((c) => c.object === this && c.prop === propertyKey);
@@ -2540,7 +2608,7 @@ const descriptor = Object.assign(descriptorBase, {
  * Decorator that marks methods, properties, or classes as deprecated
  * Provides warning messages when deprecated items are used
  */
-const deprecated = Object.assign(proxy.decorator({
+const deprecated = Object.assign(effects.decorator({
     method(original, _target, propertyKey) {
         return function (...args) {
             deprecated.warn(this, propertyKey);
@@ -2568,7 +2636,7 @@ const deprecated = Object.assign(proxy.decorator({
         };
     },
     default(message) {
-        return proxy.decorator({
+        return effects.decorator({
             method(original, _target, propertyKey) {
                 return function (...args) {
                     deprecated.warn(this, propertyKey, message);
@@ -2599,7 +2667,7 @@ const deprecated = Object.assign(proxy.decorator({
     },
 }), {
     warn: (target, propertyKey, message) => {
-        proxy.options.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
+        effects.options.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
     },
 });
 /**
@@ -2608,7 +2676,7 @@ const deprecated = Object.assign(proxy.decorator({
  * @returns A method decorator that debounces method calls
  */
 function debounce(delay) {
-    return proxy.decorator({
+    return effects.decorator({
         method(original, _target, _propertyKey) {
             let timeoutId = null;
             return function (...args) {
@@ -2631,7 +2699,7 @@ function debounce(delay) {
  * @returns A method decorator that throttles method calls
  */
 function throttle(delay) {
-    return proxy.decorator({
+    return effects.decorator({
         method(original, _target, _propertyKey) {
             let lastCallTime = 0;
             let timeoutId = null;
@@ -2662,7 +2730,7 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.13";
+var version$1 = "1.0.15";
 var pkg = {
 	version: version$1};
 
@@ -2681,8 +2749,8 @@ if (globalScope) {
     try {
         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-CAdnMJev.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-CAdnMJev.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-CAdnMJev.cjs', document.baseURI).href));
+        else if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/index-Dtj2qZ0d.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-Dtj2qZ0d.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-Dtj2qZ0d.cjs', document.baseURI).href));
         }
     }
     catch (_e) { }
@@ -2732,4 +2800,4 @@ exports.throttle = throttle;
 exports.unreactive = unreactive;
 exports.watch = watch;
 exports.when = when;
-//# sourceMappingURL=index-CAdnMJev.cjs.map
+//# sourceMappingURL=index-Dtj2qZ0d.cjs.map