mutts 1.0.11 → 1.0.13

package/dist/chunks/{proxy-Cc79Lrzj.cjs → proxy-DBHj3kGK.cjs}

@@ -1,8 +1,29 @@
 'use strict';
 
-var asyncCore = require('./async-core-CRLKP3l-.cjs');
-
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// Queue for hooks registered before the environment is ready (circular dependency fix)
+const hooks = new Set();
+const asyncHooks = {
+    addHook(hook) {
+        hooks.add(hook);
+        return () => hooks.delete(hook);
+    },
+    /**
+     * [Hack] Sanitize a promise (or value) to prevent context leaks.
+     * Default: Identity function.
+     * Browser: Uses Macrotask wrapping to break microtask chains.
+     */
+    sanitizePromise(p) {
+        return p;
+    },
+};
+/**
+ * Register a hook that will be called whenever an asynchronous operation is initiated.
+ * The hook should return a restorer function which will be called just before the async callback runs.
+ * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
+ */
+const asyncHook = (hook) => asyncHooks.addHook(hook);
+
 /**
  * Yields tuples containing elements from each input array, stopping at the longest array length
  * @param args - Arrays to zip together
@@ -118,13 +139,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)
@@ -132,6 +150,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;
@@ -250,8 +275,9 @@ function named(name, fn) {
     });
     return fn;
 }
-const _mode = (typeof process !== 'undefined' && process.env?.NODE_ENV) ||
-    (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/proxy-Cc79Lrzj.cjs', document.baseURI).href)) }) !== 'undefined' && undefined?.MODE) ||
+const runtimeGlobals = globalThis;
+const _mode = runtimeGlobals.process?.env?.NODE_ENV ||
+    (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/proxy-DBHj3kGK.cjs', document.baseURI).href)) }) !== 'undefined' && undefined?.MODE) ||
     'production';
 const isDev = _mode === 'development';
 const isProd = _mode === 'production';
@@ -426,6 +452,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.
  */
@@ -458,7 +571,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.
@@ -491,7 +604,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" />
@@ -924,7 +1037,7 @@ class AZone {
         }
         // [HACK]: Sanitization
         // See BROWSER_ASYNC_POLYFILL.md
-        return asyncCore.asyncHooks.sanitizePromise(res);
+        return asyncHooks.sanitizePromise(res);
     }
     root(fn) {
         const prev = this.enter();
@@ -1039,7 +1152,7 @@ _ZoneAggregator_zones = new WeakMap();
  * ```
  */
 const asyncZone = tag('async', new ZoneAggregator());
-asyncCore.asyncHooks.addHook(() => {
+asyncHooks.addHook(() => {
     // capture state before async boundary
     const zone = asyncZone.active;
     return () => {
@@ -1085,6 +1198,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();
@@ -1099,8 +1213,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
@@ -1120,11 +1234,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);
@@ -1132,6 +1265,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,
@@ -1159,7 +1321,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)
@@ -1225,18 +1387,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++) {
@@ -1244,6 +1449,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;
         }
     }
@@ -1444,6 +1652,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.
      *
@@ -1573,7 +1783,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 = exports.watchers.get(obj);
     if (!objectWatchers) {
@@ -1639,6 +1849,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;
@@ -2081,6 +2294,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) {
@@ -2349,7 +2570,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: exports.ReactiveErrorCode.BrokenEffects });
     }
@@ -2365,11 +2586,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;
     }
@@ -2408,7 +2630,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);
         }
@@ -2462,6 +2684,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;
@@ -2562,7 +2789,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
@@ -2575,7 +2802,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
@@ -2608,6 +2838,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);
@@ -2670,7 +2903,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) {
@@ -2678,6 +2912,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 {
@@ -2688,7 +2926,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) => {
@@ -2719,8 +2963,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;
@@ -2733,7 +2980,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;
         }
     }
@@ -2793,7 +3040,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
@@ -2836,30 +3083,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();
@@ -3010,7 +3262,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) {
@@ -3056,6 +3309,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) {
@@ -3077,7 +3331,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)) {
@@ -3151,7 +3405,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);
     }
 }
 
@@ -3173,9 +3427,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
@@ -3274,7 +3529,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) {
@@ -3500,6 +3755,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) {
@@ -3527,6 +3793,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);
@@ -3566,15 +3836,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);
@@ -3751,6 +4013,7 @@ const reactive = decorator({
 });
 
 exports.AZone = AZone;
+exports.CompareSymbol = CompareSymbol;
 exports.DecoratorError = DecoratorError;
 exports.FoolProof = FoolProof;
 exports.IterableWeakMap = IterableWeakMap;
@@ -3767,13 +4030,17 @@ exports.addUnreactiveProps = addUnreactiveProps;
 exports.allProps = allProps;
 exports.arrayEquals = arrayEquals;
 exports.assertUntracked = assertUntracked;
+exports.asyncHook = asyncHook;
+exports.asyncHooks = asyncHooks;
 exports.asyncZone = asyncZone;
 exports.atom = atom;
 exports.atomic = atomic;
 exports.batch = batch;
 exports.biDi = biDi;
+exports.captioned = captioned;
 exports.captured = captured;
 exports.caught = caught;
+exports.chainExternalReason = chainExternalReason;
 exports.contentRef = contentRef;
 exports.createFlavor = createFlavor;
 exports.debugPreset = debugPreset;
@@ -3785,6 +4052,7 @@ exports.dependant = dependant;
 exports.devPreset = devPreset;
 exports.effect = effect;
 exports.effectAggregator = effectAggregator;
+exports.effectContext = effectContext;
 exports.effectHistory = effectHistory;
 exports.effectMarker = effectMarker;
 exports.effectToDeepWatchedObjects = effectToDeepWatchedObjects;
@@ -3796,6 +4064,8 @@ exports.getActiveEffect = getActiveEffect;
 exports.getEffectNode = getEffectNode;
 exports.getRoot = getRoot;
 exports.getState = getState;
+exports.hooks = hooks;
+exports.inheritCaption = inheritCaption;
 exports.isConstructor = isConstructor;
 exports.isDev = isDev;
 exports.isNonReactive = isNonReactive;
@@ -3833,6 +4103,7 @@ exports.unlink = unlink;
 exports.unreactiveProperties = unreactiveProperties;
 exports.untracked = untracked;
 exports.unwrap = unwrap;
+exports.withEffectContext = withEffectContext;
 exports.wrapProtos = wrapProtos;
 exports.zip = zip;
-//# sourceMappingURL=proxy-Cc79Lrzj.cjs.map
+//# sourceMappingURL=proxy-DBHj3kGK.cjs.map