mutts 1.0.12 → 1.0.13

package/dist/chunks/{proxy-D2C49sXH.esm.js → proxy-BtmPFjSr.esm.js}

@@ -136,13 +136,10 @@ function isOwnAccessor(obj, prop) {
     return !!(opd?.get || opd?.set);
 }
 /**
- * Deeply compares two values.
- * For objects, compares prototypes with === and then own properties recursively.
- * Uses a cache to handle circular references.
- * @param a - First value
- * @param b - Second value
- * @param cache - Map for circular reference protection (internal use)
- * @returns True if values are deeply equal
+ * Symbol used to provide custom comparison logic for an object.
+ */
+const CompareSymbol = Symbol.for('mutts.compare');
+/**
  */
 function deepCompare(a, b, cache = new Map()) {
     if (a === b)
@@ -150,6 +147,13 @@ function deepCompare(a, b, cache = new Map()) {
     if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
         return a === b;
     }
+    // Custom comparison support
+    if (typeof a[CompareSymbol] === 'function') {
+        return a[CompareSymbol](b, (x, y) => deepCompare(x, y, cache));
+    }
+    if (typeof b[CompareSymbol] === 'function') {
+        return b[CompareSymbol](a, (x, y) => deepCompare(x, y, cache));
+    }
     // Prototype check
     if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
         return false;
@@ -268,7 +272,8 @@ function named(name, fn) {
     });
     return fn;
 }
-const _mode = (typeof process !== 'undefined' && process.env?.NODE_ENV) ||
+const runtimeGlobals = globalThis;
+const _mode = runtimeGlobals.process?.env?.NODE_ENV ||
     (typeof import.meta !== 'undefined' && import.meta.env?.MODE) ||
     'production';
 const isDev = _mode === 'development';
@@ -444,6 +449,93 @@ const decorator = (description) => {
  * flavoredGreet.loud('World') // "HELLO, WORLD!"
  * ```
  */
+const captionedOptionsSymbol = Symbol('mutts.captioned.options');
+function isTemplateStringsArray(value) {
+    return (Array.isArray(value) &&
+        Object.hasOwn(value, 'raw') &&
+        Array.isArray(value.raw));
+}
+function renderTemplate(strings, values) {
+    let result = strings[0] ?? '';
+    for (let i = 0; i < values.length; i++)
+        result += String(values[i]) + (strings[i + 1] ?? '');
+    return result;
+}
+function renameCallback(caption, callback) {
+    Object.defineProperty(callback, 'name', {
+        value: caption,
+        writable: false,
+        configurable: true,
+    });
+    return callback;
+}
+function isAnonymousCallback(callback) {
+    return !callback.name || callback.name === 'anonymous';
+}
+/**
+ * Wraps a callback-first function so it also accepts a tagged-template call form.
+ *
+ * The template caption is applied to one callback argument before the base
+ * function runs. By default, `captioned` targets the first argument, but
+ * `callbackIndex` can point to any callback position.
+ *
+ * This is intended for APIs such as `effect`, `lift`, or `watch` where naming
+ * is useful but should remain separate from the flavor system.
+ *
+ * Plain calls still work:
+ * `run(callback)`
+ *
+ * Captioned calls add a runtime name to the first callback:
+ * `` run`task:${id}`(callback) ``
+ *
+ * Anonymous uncaptioned callbacks may trigger a warning depending on
+ * `shouldWarnAnonymous`.
+ */
+function captioned(fn, options = {}) {
+    const settings = {
+        callbackIndex: options.callbackIndex ?? 0,
+        name: options.name ?? (fn.name || 'callback'),
+        rename: options.rename ?? ((caption, callback) => renameCallback(caption, callback)),
+        // biome-ignore lint/suspicious/noConsole: This is the whole point here
+        warn: options.warn ?? ((message) => console.warn(message)),
+        shouldWarnAnonymous: options.shouldWarnAnonymous,
+    };
+    fn[captionedOptionsSymbol] = settings;
+    return new Proxy(fn, {
+        get(target, prop, receiver) {
+            if (prop === captionedOptionsSymbol)
+                return settings;
+            return Reflect.get(target, prop, receiver);
+        },
+        apply(target, thisArg, args) {
+            if (isTemplateStringsArray(args[0])) {
+                const caption = renderTemplate(args[0], args.slice(1));
+                return function captionedCall(...callArgs) {
+                    const callback = callArgs[settings.callbackIndex];
+                    if (typeof callback !== 'function')
+                        throw new TypeError(`${settings.name} template calls require a callback at argument index ${settings.callbackIndex}`);
+                    const nextArgs = [...callArgs];
+                    nextArgs[settings.callbackIndex] = settings.rename(caption, callback);
+                    return Reflect.apply(target, this, nextArgs);
+                };
+            }
+            const callback = args[settings.callbackIndex];
+            if (typeof callback === 'function' && isAnonymousCallback(callback)) {
+                const shouldWarn = settings.shouldWarnAnonymous?.(callback, args) ?? true;
+                if (shouldWarn)
+                    settings.warn(`${settings.name}: anonymous callback detected. Use template syntax for automatic naming:\n` +
+                        `  Current: ${settings.name}(() => { ... })\n` +
+                        `  Fix:     ${settings.name}\`descriptive-name\`(() => { ... })\n` +
+                        `The captioned system uses the template literal as the effect name for better debugging.`);
+            }
+            return Reflect.apply(target, thisArg, args);
+        },
+    });
+}
+function inheritCaption(source, target) {
+    const settings = source[captionedOptionsSymbol];
+    return settings ? captioned(target, settings) : target;
+}
 /**
  * Creates a flavored (extensible) version of a function with chainable property modifiers.
  */
@@ -476,7 +568,7 @@ function createFlavor(fn, transform, name) {
     };
     if (name)
         named(name, fct);
-    return flavored(fct, fn.flavors || {});
+    return flavored(inheritCaption(fn, fct), fn.flavors || {});
 }
 /**
  * Creates a new flavored function that merges options objects at a specific index.
@@ -509,7 +601,7 @@ function flavorOptions(fn, defaultOptions, opts = {}) {
     // Preserve arity and options track
     Object.defineProperty(fct, 'length', { value: fn.length });
     fct.optionsIndex = targetIndex;
-    return flavored(fct, fn.flavors || {});
+    return flavored(inheritCaption(fn, fct), fn.flavors || {});
 }
 
 /// <reference lib="esnext.collection" />
@@ -1103,6 +1195,7 @@ function resetRegistry() {
  * @returns The marked function
  */
 function markWithRoot(fn, root) {
+    const marked = fn;
     // Check for collision
     const existingRef = reverseRoots.get(root);
     const existing = existingRef?.deref();
@@ -1117,8 +1210,8 @@ function markWithRoot(fn, root) {
     // (Last writer wins for the check)
     reverseRoots.set(root, new WeakRef(fn));
     // Store root mapping as symbol property on the function
-    fn[rootFunctionSymbol] = getRoot(root);
-    return fn;
+    marked[rootFunctionSymbol] = getRoot(root);
+    return marked;
 }
 /**
  * Gets the root function of a function for effect tracking
@@ -1138,11 +1231,30 @@ function getRoot(fn) {
 const effectHistory = tag('effectHistory', new ZoneHistory());
 tag('effectHistory.present', effectHistory.present);
 asyncZone.add(effectHistory);
+const externalReason = tag('externalReason', new Zone());
+asyncZone.add(externalReason);
 /**
  * Aggregator for zones that need to be tracked along effects.
  * ie. in each effect, the active zone of the given zoning will be the one active at effect's definition
  */
 const effectAggregator = tag('effectAggregator', new ZoneAggregator(effectHistory.present));
+effectAggregator.add(externalReason);
+function chainExternalReason(reason) {
+    const external = externalReason.active;
+    if (!external)
+        return reason;
+    if (!reason)
+        return external;
+    let current = reason;
+    while (current) {
+        if (current.type === 'external' &&
+            external.type === 'external' &&
+            current.detail === external.detail)
+            return reason;
+        current = current.chain;
+    }
+    return { ...reason, chain: chainExternalReason(reason.chain) };
+}
 function isRunning(effect) {
     const root = getRoot(effect);
     return effectHistory.some((e) => getRoot(e) === root);
@@ -1150,6 +1262,35 @@ function isRunning(effect) {
 function getActiveEffect() {
     return effectHistory.present.active;
 }
+/**
+ * Captures the current effect context so that deferred code can later
+ * create child effects parented to this point in the effect tree.
+ *
+ * @returns An opaque token to pass to `withEffectContext()`
+ *
+ * @example
+ * ```ts
+ * const ctx = effectContext() // inside an effect or root()
+ * // later, in a deferred callback:
+ * withEffectContext(ctx, () => {
+ *   effect(() => { /* child of the captured context *​/ })
+ * })
+ * ```
+ */
+function effectContext() {
+    return effectHistory.active;
+}
+/**
+ * Runs `fn` within a previously captured effect context.
+ * Any effects created inside `fn` become children of the captured parent.
+ *
+ * @param ctx - The context token from `effectContext()`, or `undefined` for root context
+ * @param fn - The function to execute within the restored context
+ * @returns The return value of `fn`
+ */
+function withEffectContext(ctx, fn) {
+    return effectHistory.with(ctx, fn);
+}
 const cleanups = new WeakMap();
 /**
  * Attach cleanup dependencies to an object. When `unlink(obj)` is called,
@@ -1177,7 +1318,7 @@ const cleanups = new WeakMap();
 function link(obj, ...cleanupFns) {
     const set = cleanups.get(obj);
     if (!set)
-        cleanups.set(obj, new Set(cleanupFns.filter(Boolean)));
+        cleanups.set(obj, new Set(cleanupFns.filter((fn) => fn !== undefined)));
     else
         for (const fn of cleanupFns)
             if (fn)
@@ -1243,18 +1384,61 @@ function formatCleanupReason(reason, depth = 0) {
                     parts.push(',');
                 parts.push(...formatTrigger(reason.triggers[i]));
             }
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'stopped': {
+            const parts = [`${indent}stopped`];
+            if (reason.detail)
+                parts.push(`(${reason.detail})`);
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'external': {
+            const parts = [`${indent}external:`, reason.detail];
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'gc': {
+            const parts = [`${indent}gc`];
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'error': {
+            const parts = [`${indent}error:`, reason.error];
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'lineage': {
+            const parts = [
+                `${indent}lineage ←\n`,
+                ...formatCleanupReason(reason.parent, depth + 1),
+            ];
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'invalidate': {
+            const parts = [
+                `${indent}invalidate ←\n`,
+                ...formatCleanupReason(reason.cause, depth + 1),
+            ];
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
             return parts;
         }
-        case 'stopped':
-            return [`${indent}stopped`];
-        case 'gc':
-            return [`${indent}gc`];
-        case 'error':
-            return [`${indent}error:`, reason.error];
-        case 'lineage':
-            return [`${indent}lineage ←\n`, ...formatCleanupReason(reason.parent, depth + 1)];
-        case 'invalidate':
-            return [`${indent}invalidate ←\n`, ...formatCleanupReason(reason.cause, depth + 1)];
         case 'multiple': {
             const parts = [];
             for (let i = 0; i < reason.reasons.length; i++) {
@@ -1262,6 +1446,9 @@ function formatCleanupReason(reason, depth = 0) {
                     parts.push('\n');
                 parts.push(...formatCleanupReason(reason.reasons[i], depth));
             }
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
             return parts;
         }
     }
@@ -1462,6 +1649,8 @@ const options = {
     asyncMode: 'cancel',
     // biome-ignore lint/suspicious/noConsole: This is the whole point here
     warn: (...args) => console.warn(...args),
+    // biome-ignore lint/suspicious/noConsole: This is the whole point here
+    error: (...args) => console.error(...args),
     /**
      * Introspection and debug aids. Set to `null` to disable all debug overhead in production.
      *
@@ -1591,7 +1780,7 @@ function dependant(obj, prop = allProps) {
         return;
     const node = getEffectNode(currentActiveEffect);
     if ('dependencyHook' in node) {
-        node.dependencyHook(obj, prop);
+        node.dependencyHook?.(obj, prop);
     }
     let objectWatchers = watchers.get(obj);
     if (!objectWatchers) {
@@ -1657,6 +1846,9 @@ function formatRoots(roots, limit = 20) {
     const end = names.slice(-10);
     return `${start.join(' → ')} ... (${names.length - 15} more) ... ${end.join(' → ')}`;
 }
+function externalReasonFrom(fn) {
+    return fn.name ? { type: 'external', detail: fn.name } : undefined;
+}
 // Nested map structure for efficient counting and batch cleanup
 // batchId -> effect root -> obj -> prop -> count
 let activationRegistry;
@@ -2099,6 +2291,14 @@ function addToBatch(effect, caller, immediate, reason) {
     // Build reason from pending triggers if not provided
     if (!reason && node.pendingTriggers) {
         reason = { type: 'propChange', triggers: node.pendingTriggers };
+        // Add chain: if this is being triggered from another effect, get its reason
+        if (caller) {
+            const callerNode = getEffectNode(caller);
+            if (callerNode.currentReason) {
+                reason.chain = callerNode.currentReason;
+            }
+        }
+        reason = chainExternalReason(reason);
     }
     node.pendingTriggers = undefined;
     if (reason) {
@@ -2367,7 +2567,7 @@ function executeNext(effectuatedRoots) {
 }
 // Track which sub-effects have been executed to prevent infinite loops
 // These are all the effects triggered under `activeEffect` and all their sub-effects
-function batch(effect, immediate) {
+function batch(effect, immediate, caller) {
     if (broken) {
         throw new ReactiveError('[reactive] Reactive system is broken after an unrecoverable error. Call reset() to recover.', { code: ReactiveErrorCode.BrokenEffects });
     }
@@ -2383,11 +2583,12 @@ function batch(effect, immediate) {
         optionCall('beginChain', roots);
     }
     // TODO: Consider this has been produced but was useless - it might be more correct ?const caller = executingStack.length > 0 ? getActiveEffect() : undefined
-    const caller = getActiveEffect();
+    const activeCaller = getActiveEffect();
+    const callerToUse = caller || activeCaller;
     // Optimization: If nested and NOT immediate, just join the existing batch
     if (!isNewBatch && !immediate) {
         for (let i = 0; i < effect.length; i++) {
-            addToBatch(effect[i], caller);
+            addToBatch(effect[i], callerToUse);
         }
         return;
     }
@@ -2426,7 +2627,7 @@ function batch(effect, immediate) {
         else {
             // Add initial effects to batch and compute dependencies
             for (let i = 0; i < effect.length; i++) {
-                addToBatch(effect[i], caller, false);
+                addToBatch(effect[i], callerToUse, false);
             }
             computeAllInDegrees(currentBatch);
         }
@@ -2480,6 +2681,11 @@ function batch(effect, immediate) {
         success = true;
         return firstReturn.value;
     }
+    catch (error) {
+        if (batchStack.length === 1)
+            optionCall('error', '[reactive] Root batch failure before broken state:', error);
+        throw error;
+    }
     finally {
         if (!success && batchStack.length === 1) {
             broken = true;
@@ -2580,7 +2786,7 @@ const fr = new FinalizationRegistry((f) => f());
  * @param options - Options for effect execution
  * @returns A cleanup function to stop the effect
  */
-const effect = named(effectMarker.leave, flavored(function effect(fn, effectOptions = {}) {
+const effect = captioned(named(effectMarker.leave, flavored(function effect(fn, effectOptions = {}) {
     if (effectOptions?.name)
         Object.defineProperty(fn, 'name', { value: effectOptions.name });
     // Use per-effect asyncMode or fall back to global option
@@ -2593,7 +2799,10 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
             const prevCleanup = node.cleanup;
             node.cleanup = undefined;
             try {
-                untracked(() => prevCleanup(node.nextReason || { type: 'stopped' }));
+                untracked `effect:cleanup`(() => prevCleanup(chainExternalReason(node.nextReason || {
+                    type: 'stopped',
+                    chain: node.currentReason,
+                })));
             }
             catch (error) {
                 // If we want to report them, we could use options.warn or similar
@@ -2626,6 +2835,9 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
         }
         // Set reaction reason for the upcoming run
         access.reaction = node.nextReason || access.reaction;
+        node.currentReason =
+            node.nextReason ||
+                (access.reaction && access.reaction !== true ? access.reaction : undefined);
         node.nextReason = undefined;
         optionCall('enter', getRoot(fn));
         optionCall('effectRun', getRoot(fn), access.reaction);
@@ -2688,7 +2900,8 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
                 // This ensures that when we cancel, the original promise's .catch() handlers are triggered
                 // We do this by rejecting the race promise, which makes the original promise chain see the rejection
                 // through the zone-wrapped .then()/.catch() handlers
-                runningPromise = runningPromise.catch((error) => {
+                runningPromise = runningPromise
+                    .catch((error) => {
                     // Propagate async errors to the effect's error handler
                     // This ensures onEffectThrow handlers are triggered for async errors
                     if (error !== cancelError) {
@@ -2696,6 +2909,10 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
                     }
                     // If thrower didn't throw (handled), we absorb the error.
                     // If thrower threw (unhandled), it propagates as a new unhandled rejection, which is correct.
+                })
+                    .finally(() => {
+                    // Clear currentReason when async effect completes
+                    node.currentReason = undefined;
                 });
             }
             else {
@@ -2706,7 +2923,13 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
         catch (error) {
             debugHooks.decorateError(error, runEffect);
             // catcher:self`
-            errorToThrow = error;
+            errorToThrow = error instanceof Error ? error : new Error(String(error));
+        }
+        finally {
+            // Clear currentReason for synchronous effects
+            if (!runningPromise) {
+                node.currentReason = undefined;
+            }
         }
         // Create cleanup function for next run
         node.cleanup = (reason) => {
@@ -2737,8 +2960,11 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
                 const childReason = reason
                     ? reason.type === 'lineage'
                         ? reason
-                        : { type: 'lineage', parent: reason }
-                    : { type: 'stopped' };
+                        : { type: 'lineage', parent: reason, chain: node.currentReason }
+                    : (chainExternalReason({ type: 'stopped', chain: node.currentReason }) ?? {
+                        type: 'stopped',
+                        chain: node.currentReason,
+                    });
                 for (const childCleanup of children)
                     childCleanup(childReason);
                 delete node.children;
@@ -2751,7 +2977,7 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
     const node = getEffectNode(runEffect);
     if (debugHooks.isDevtoolsEnabled()) {
         const stack = debugHooks.captureStack(); // Robustly skips internal mutts frames
-        if (Array.isArray(stack) && stack.length > 0) {
+        if (stack) {
             node.creationStack = stack;
         }
     }
@@ -2811,7 +3037,7 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
             runningPromise = null;
         }
         try {
-            node.cleanup?.(reason || { type: 'stopped' });
+            node.cleanup?.(chainExternalReason(reason || { type: 'stopped', chain: node.currentReason }));
         }
         catch (error) {
             // Cleanup errors should basically be ignored or at least not stop the world
@@ -2854,30 +3080,35 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
     named(name) {
         return flavorOptions(this, { name }, { name: 'named' });
     },
-}));
-/**
- * Executes a function without tracking dependencies but maintains parent cleanup relationship
- * Effects created inside will still be cleaned up when the parent effect is destroyed
- * @param fn - The function to execute
- */
-function untracked(fn) {
-    return effectHistory.present.root(fn);
-}
+})), {
+    name: 'effect',
+    warn: (message) => options.warn(`[reactive] ${message}`),
+    shouldWarnAnonymous: (_callback, args) => !(args[1] && typeof args[1] === 'object' && 'name' in args[1]),
+});
+const untracked = captioned(function untracked(fn) {
+    const external = externalReasonFrom(fn);
+    return external
+        ? externalReason.with(external, () => effectHistory.present.root(fn))
+        : effectHistory.present.root(fn);
+});
 /**
  * Executes a function from a virgin/root context - no parent effect, no tracking
  * Creates completely independent effects that won't be cleaned up by any parent
  * @param fn - The function to execute
  */
-function root(fn) {
-    return effectHistory.root(fn);
-}
+const root = captioned(function root(fn) {
+    const external = externalReasonFrom(fn);
+    return external
+        ? externalReason.with(external, () => effectHistory.root(fn))
+        : effectHistory.root(fn);
+});
 function biDi(received, get, set) {
     if (typeof get !== 'function') {
         set = get.set;
         get = get.get;
     }
     let programmaticallySetValue = Symbol();
-    effect.named('biDi')(markWithRoot(() => {
+    effect `biDi`(markWithRoot(() => {
         const newValue = get();
         const pValue = programmaticallySetValue;
         programmaticallySetValue = Symbol();
@@ -3028,7 +3259,8 @@ function collectEffects(obj, evolution, effects, objectWatchers, ...keyChains) {
             const deps = objectWatchers.get(key);
             if (deps) {
                 // Make sure `some.prop++` does not keep a dependency to `some.props`
-                deps.delete(sourceEffect);
+                if (sourceEffect)
+                    deps.delete(sourceEffect);
                 for (const effect of deps) {
                     const runningChain = isRunning(effect);
                     if (runningChain) {
@@ -3074,6 +3306,7 @@ function touched(obj, evolution, props) {
         else
             collectEffects(obj, evolution, effects, objectWatchers, objectWatchers.keys());
         const triggers = Array.from(effects.keys());
+        const sourceEffect = getActiveEffect();
         optionCall('touched', obj, evolution, props, triggers);
         // Store pending triggers for CleanupReason before batching
         if (options.introspection?.gatherReasons) {
@@ -3095,7 +3328,7 @@ function touched(obj, evolution, props) {
                 });
             }
         }
-        batch(triggers);
+        batch(triggers, undefined, sourceEffect);
     }
     // Bubble up changes if this object has deep watchers
     if (objectsWithDeepWatchers.has(obj)) {
@@ -3169,7 +3402,7 @@ function touchedOpaque(obj, evolution, prop) {
     }
     if (effects.size > 0) {
         optionCall('touched', obj, evolution, [prop], Array.from(effects));
-        batch(Array.from(effects));
+        batch(Array.from(effects), undefined, sourceEffect);
     }
 }
 
@@ -3191,9 +3424,10 @@ function addUnreactiveProps(proto, set) {
             return proto;
         }
         // Merge sets
-        set = proto[unreactiveProperties] = new Set(proto[unreactiveProperties]);
+        const merged = new Set(existing);
+        proto[unreactiveProperties] = merged;
         for (const p of set)
-            existing.add(p);
+            merged.add(p);
     }
     // If no set, mark as fully unreactive, otherwise create set
     else
@@ -3292,7 +3526,7 @@ function notifyPropertyChange(targetObj, prop, oldValue, newValue, hadProperty)
         const origin = { obj: unwrappedObj, prop };
         // Deep touch: only notify nested property changes with origin filtering
         // Don't notify direct property change - the whole point is to avoid parent effects re-running
-        const changes = untracked(() => recursiveTouch(oldValue, newValue, new WeakMap(), [], origin));
+        const changes = untracked `deepTouch:recursive`(() => recursiveTouch(oldValue, newValue, new WeakMap(), [], origin));
         // When deep touch found no child differences, the object identity still changed.
         // Migrate watchers from old → new so the dependency chain is preserved.
         if (changes.length === 0) {
@@ -3518,6 +3752,17 @@ const subsRegister = new WeakMap();
 // Internal untracked flag for setter/getter operations - only used when testing oldValue while setting a value
 // TODO: `touched` trigger also compares to old value and should use the internalUntracked flag
 let internalUntracked = false;
+function wrapReactiveValue(obj, prop, value) {
+    if (!isReactive(value) && typeof value === 'object' && value !== null) {
+        const reactiveValue = reactiveObject(value);
+        // Only create back-references if this object needs them
+        if (needsBackReferences(obj)) {
+            addBackReference(reactiveValue, obj, prop);
+        }
+        return reactiveValue;
+    }
+    return value;
+}
 const reactiveHandlers = {
     [Symbol.toStringTag]: 'MutTs Reactive',
     get(obj, prop, receiver) {
@@ -3545,6 +3790,10 @@ const reactiveHandlers = {
         // Symbols: fast-path — no reactivity tracking
         if (typeof prop === 'symbol' || prop === 'constructor' || isUnreactiveProp(obj, prop))
             return FoolProof.get(obj, prop, receiver);
+        if (!getActiveEffect()) {
+            const value = (subsRegister.get(obj)?.get || FoolProof.get)(obj, prop, receiver);
+            return wrapReactiveValue(obj, prop, value);
+        }
         // Check if property exists using a trap-free walk to avoid triggering
         // the has-trap cascade on prototype chains of reactive proxies.
         const isOwnProp = Object.hasOwn(obj, prop);
@@ -3584,15 +3833,7 @@ const reactiveHandlers = {
         // For arrays, use FoolProof.get (Indexer path) for numeric index reactivity.
         // For all other objects, inline Reflect.get directly (skips 3 function calls).
         const value = (subsRegister.get(obj)?.get || FoolProof.get)(obj, prop, receiver);
-        if (!isReactive(value) && typeof value === 'object' && value !== null) {
-            const reactiveValue = reactiveObject(value);
-            // Only create back-references if this object needs them
-            if (needsBackReferences(obj)) {
-                addBackReference(reactiveValue, obj, prop);
-            }
-            return reactiveValue;
-        }
-        return value;
+        return wrapReactiveValue(obj, prop, value);
     },
     set(obj, prop, value, receiver) {
         const unwrapped = unwrap(receiver);
@@ -3768,5 +4009,5 @@ const reactive = decorator({
     default: reactiveObject,
 });
 
-export { reactive as $, AZone as A, flavored as B, formatCleanupReason as C, DecoratorError as D, getActivationLog as E, getActiveEffect as F, getState as G, hooks as H, IterableWeakMap as I, isConstructor as J, isDev as K, isNonReactive as L, isObject as M, isProd as N, isReactive as O, isTest as P, legacyDecorator as Q, ReactiveBase as R, link as S, mixin as T, modernDecorator as U, named as V, objectToProxy as W, onEffectThrow as X, prodPreset as Y, Zone as Z, proxyToObject as _, IterableWeakSet as a, options as a0, reset as a1, root as a2, tag as a3, touched as a4, touched1 as a5, unlink as a6, untracked as a7, unwrap as a8, zip as a9, allProps as aA, dependant as aa, keysOf as ab, markWithRoot as ac, objectsWithDeepWatchers as ad, effectToDeepWatchedObjects as ae, deepWatchers as af, registerDeepWatcher as ag, rootFunctionSymbol as ah, getRoot as ai, optionCall as aj, FoolProof as ak, effectHistory as al, unreactiveProperties as am, __runInitializers as an, __esDecorate as ao, batch as ap, contentRef as aq, notifyPropertyChange as ar, metaProtos as as, wrapProtos as at, objectParents as au, watchers as av, effectToReactiveObjects as aw, effectMarker as ax, getEffectNode as ay, setDebugHooks as az, ReactiveError as b, ReactiveErrorCode as c, ZoneAggregator as d, ZoneHistory as e, addBatchCleanup as f, addUnreactiveProps as g, arrayEquals as h, assertUntracked as i, asyncHook as j, asyncHooks as k, asyncZone as l, atom as m, atomic as n, biDi as o, captured as p, caught as q, createFlavor as r, debugPreset as s, decorator as t, deepCompare as u, defer as v, devPreset as w, effect as x, effectAggregator as y, flavorOptions as z };
-//# sourceMappingURL=proxy-D2C49sXH.esm.js.map
+export { objectToProxy as $, AZone as A, effectContext as B, CompareSymbol as C, DecoratorError as D, flavorOptions as E, flavored as F, formatCleanupReason as G, getActivationLog as H, IterableWeakMap as I, getActiveEffect as J, getState as K, hooks as L, inheritCaption as M, isConstructor as N, isDev as O, isNonReactive as P, isObject as Q, ReactiveBase as R, isProd as S, isReactive as T, isTest as U, legacyDecorator as V, link as W, mixin as X, modernDecorator as Y, Zone as Z, named as _, IterableWeakSet as a, onEffectThrow as a0, prodPreset as a1, proxyToObject as a2, reactive as a3, options as a4, reset as a5, root as a6, tag as a7, touched as a8, touched1 as a9, wrapProtos as aA, objectParents as aB, watchers as aC, effectToReactiveObjects as aD, effectMarker as aE, setDebugHooks as aF, allProps as aG, unlink as aa, untracked as ab, unwrap as ac, withEffectContext as ad, zip as ae, markWithRoot as af, dependant as ag, getEffectNode as ah, chainExternalReason as ai, keysOf as aj, objectsWithDeepWatchers as ak, effectToDeepWatchedObjects as al, deepWatchers as am, registerDeepWatcher as an, rootFunctionSymbol as ao, getRoot as ap, optionCall as aq, FoolProof as ar, effectHistory as as, unreactiveProperties as at, __runInitializers as au, __esDecorate as av, batch as aw, contentRef as ax, notifyPropertyChange as ay, metaProtos as az, ReactiveError as b, ReactiveErrorCode as c, ZoneAggregator as d, ZoneHistory as e, addBatchCleanup as f, addUnreactiveProps as g, arrayEquals as h, assertUntracked as i, asyncHook as j, asyncHooks as k, asyncZone as l, atom as m, atomic as n, biDi as o, captioned as p, captured as q, caught as r, createFlavor as s, debugPreset as t, decorator as u, deepCompare as v, defer as w, devPreset as x, effect as y, effectAggregator as z };
+//# sourceMappingURL=proxy-BtmPFjSr.esm.js.map