mutts 1.0.12 → 1.0.13

package/dist/mutts.umd.js

@@ -357,13 +357,10 @@
 	    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)
@@ -371,6 +368,13 @@
 	    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;
@@ -489,7 +493,8 @@
 	    });
 	    return fn;
 	}
-	const _mode = (typeof process !== 'undefined' && process.env?.NODE_ENV) ||
+	const runtimeGlobals$1 = globalThis;
+	const _mode = runtimeGlobals$1.process?.env?.NODE_ENV ||
 	    (typeof ({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('mutts.umd.js', document.baseURI).href)) }) !== 'undefined' && undefined?.MODE) ||
 	    'production';
 	const isDev = _mode === 'development';
@@ -893,46 +898,57 @@
 	var _a$1, _b$1;
 	const events = Symbol('events');
 	const hooks = Symbol('hooks');
+	function getEventMap(target) {
+	    return target[events];
+	}
+	function getHookSet(target) {
+	    return target[hooks];
+	}
 	const eventBehavior = {
 	    on(eventOrEvents, cb) {
+	        const self = this;
+	        const eventMap = getEventMap(self);
 	        if (typeof eventOrEvents === 'object') {
 	            for (const e of Object.keys(eventOrEvents)) {
 	                this.on(e, eventOrEvents[e]);
 	            }
 	        }
 	        else if (cb !== undefined) {
-	            const callbacks = this[events].get(eventOrEvents) ?? new Set();
+	            const callbacks = eventMap.get(eventOrEvents) ?? new Set();
 	            if (!callbacks.has(cb))
 	                callbacks.add(cb);
-	            this[events].set(eventOrEvents, callbacks);
+	            eventMap.set(eventOrEvents, callbacks);
 	        }
 	        return () => this.off(eventOrEvents, cb);
 	    },
 	    off(eventOrEvents, cb) {
+	        const self = this;
+	        const eventMap = getEventMap(self);
 	        if (typeof eventOrEvents === 'object') {
 	            for (const e of Object.keys(eventOrEvents)) {
 	                this.off(e, eventOrEvents[e]);
 	            }
 	        }
 	        else if (cb !== null && cb !== undefined) {
-	            const callbacks = this[events].get(eventOrEvents);
+	            const callbacks = eventMap.get(eventOrEvents);
 	            if (callbacks) {
 	                callbacks.delete(cb);
 	                if (!callbacks.size)
-	                    this[events].delete(eventOrEvents);
+	                    eventMap.delete(eventOrEvents);
 	            }
 	        }
 	        else {
 	            // Remove all listeners for this event
-	            this[events].delete(eventOrEvents);
+	            eventMap.delete(eventOrEvents);
 	        }
 	    },
 	    emit(event, ...args) {
-	        const callbacks = this[events].get(event);
+	        const self = this;
+	        const callbacks = getEventMap(self).get(event);
 	        if (callbacks)
 	            for (const cb of callbacks)
 	                cb.apply(this, args);
-	        for (const cb of this[hooks])
+	        for (const cb of getHookSet(self))
 	            cb.call(this, event, ...args);
 	    },
 	};
@@ -942,7 +958,7 @@
 	        get(target, prop) {
 	            if (typeof prop !== 'string')
 	                return target[prop];
-	            if (use && !eventful[events].has(prop) && !eventful[hooks].size)
+	            if (use && !getEventMap(eventful).has(prop) && !getHookSet(eventful).size)
 	                return () => { };
 	            // Return cached function or create and cache
 	            let cached = cache.get(prop);
@@ -1003,6 +1019,93 @@
 	 * 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.
 	 */
@@ -1035,7 +1138,7 @@
 	    };
 	    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.
@@ -1068,7 +1171,7 @@
 	    // 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 || {});
 	}
 
 	/**
@@ -2065,6 +2168,7 @@
 	 * @returns The marked function
 	 */
 	function markWithRoot(fn, root) {
+	    const marked = fn;
 	    // Check for collision
 	    const existingRef = reverseRoots.get(root);
 	    const existing = existingRef?.deref();
@@ -2079,8 +2183,8 @@
 	    // (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
@@ -2100,11 +2204,30 @@
 	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);
@@ -2112,6 +2235,35 @@
 	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,
@@ -2139,7 +2291,7 @@
 	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)
@@ -2205,18 +2357,61 @@
 	                    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++) {
@@ -2224,6 +2419,9 @@
 	                    parts.push('\n');
 	                parts.push(...formatCleanupReason(reason.reasons[i], depth));
 	            }
+	            if (reason.chain) {
+	                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+	            }
 	            return parts;
 	        }
 	    }
@@ -2424,6 +2622,8 @@
 	    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.
 	     *
@@ -2553,7 +2753,7 @@
 	        return;
 	    const node = getEffectNode(currentActiveEffect);
 	    if ('dependencyHook' in node) {
-	        node.dependencyHook(obj, prop);
+	        node.dependencyHook?.(obj, prop);
 	    }
 	    let objectWatchers = watchers.get(obj);
 	    if (!objectWatchers) {
@@ -2619,6 +2819,9 @@
 	    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;
@@ -3061,6 +3264,14 @@
 	    // 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) {
@@ -3329,7 +3540,7 @@
 	}
 	// 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 });
 	    }
@@ -3345,11 +3556,12 @@
 	        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;
 	    }
@@ -3388,7 +3600,7 @@
 	        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);
 	        }
@@ -3442,6 +3654,11 @@
 	        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;
@@ -3542,7 +3759,7 @@
 	 * @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
@@ -3555,7 +3772,10 @@
 	            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
@@ -3588,6 +3808,9 @@
 	        }
 	        // 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);
@@ -3650,7 +3873,8 @@
 	                // 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) {
@@ -3658,6 +3882,10 @@
 	                    }
 	                    // 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 {
@@ -3667,7 +3895,13 @@
 	        }
 	        catch (error) {
 	            // 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) => {
@@ -3698,8 +3932,11 @@
 	                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;
@@ -3763,7 +4000,7 @@
 	            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
@@ -3806,30 +4043,35 @@
 	    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();
@@ -3980,7 +4222,8 @@
 	            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) {
@@ -4025,6 +4268,7 @@
 	        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) {
@@ -4046,7 +4290,7 @@
 	                });
 	            }
 	        }
-	        batch(triggers);
+	        batch(triggers, undefined, sourceEffect);
 	    }
 	    // Bubble up changes if this object has deep watchers
 	    if (objectsWithDeepWatchers.has(obj)) {
@@ -4066,7 +4310,7 @@
 	    if (!deps)
 	        return;
 	    const effects = new Set();
-	    getActiveEffect();
+	    const sourceEffect = getActiveEffect();
 	    const gather = options.introspection?.gatherReasons;
 	    if (gather) {
 	        const lineageConfig = gather.lineages;
@@ -4118,7 +4362,7 @@
 	    }
 	    if (effects.size > 0) {
 	        optionCall('touched', obj, evolution, [prop], Array.from(effects));
-	        batch(Array.from(effects));
+	        batch(Array.from(effects), undefined, sourceEffect);
 	    }
 	}
 
@@ -4140,9 +4384,10 @@
 	            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
@@ -4241,7 +4486,7 @@
 	        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) {
@@ -4467,6 +4712,17 @@
 	// 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) {
@@ -4494,6 +4750,10 @@
 	        // 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);
@@ -4533,15 +4793,7 @@
 	        // 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);
@@ -4717,7 +4969,7 @@
 	    default: reactiveObject,
 	});
 
-	function attend(source, callback) {
+	const attend = captioned(function attend(source, callback) {
 	    const enumerate = typeof source === 'function'
 	        ? source
 	        : Array.isArray(source)
@@ -4728,14 +4980,16 @@
 	                    ? () => source.values()
 	                    : () => Object.keys(source);
 	    const keyEffects = new Map();
-	    const outer = effect.named('attend')(({ ascend }) => {
+	    const callbackLabel = callback.name ? callback.name : '';
+	    const outer = effect `attend`(({ ascend }) => {
 	        const keys = new Set();
 	        for (const key of enumerate())
 	            keys.add(key);
 	        for (const key of keys) {
 	            if (keyEffects.has(key))
 	                continue;
-	            keyEffects.set(key, ascend(() => effect.named(`attend:${key}`)((access) => callback(key, access))));
+	            const indexRef = { value: key };
+	            keyEffects.set(key, ascend(() => effect `attend${callbackLabel ? `:${callbackLabel}` : ''}:${key}`((access) => callback(indexRef.value, access))));
 	        }
 	        for (const key of Array.from(keyEffects.keys())) {
 	            if (!keys.has(key)) {
@@ -4750,17 +5004,50 @@
 	            stop(reason);
 	        keyEffects.clear();
 	    };
-	}
-	function lift(cb) {
+	}, {
+	    name: 'attend',
+	    callbackIndex: 1,
+	    warn: (message) => options.warn(`[reactive] ${message}`),
+	});
+	/**
+	 * Lifts a callback that returns an object into a reactive object that automatically
+	 * synchronizes with the source object returned by the callback.
+	 *
+	 * The returned reactive object will update whenever the callback's dependencies change,
+	 * efficiently syncing only the properties that differ from the previous result using
+	 * Object.assign(). Properties that no longer exist in the source are automatically removed.
+	 *
+	 * @example
+	 * ```typescript
+	 * const user = reactive({ name: 'John', age: 30 })
+	 * const profile = lift(() => ({
+	 *   displayName: user.name.toUpperCase(),
+	 *   isAdult: user.age >= 18,
+	 *   description: `${user.name} is ${user.age} years old`
+	 * }))
+	 *
+	 * console.log(profile.displayName) // JOHN
+	 * console.log(profile.isAdult) // true
+	 *
+	 * user.name = 'Jane'
+	 * console.log(profile.displayName) // JANE
+	 * console.log(profile.description) // Jane is 30 years old
+	 * ```
+	 *
+	 * @param cb Callback function that returns an object
+	 * @returns A reactive object synchronized with the callback's result, with a [cleanup] property to stop tracking
+	 */
+	const lift = captioned(function lift(cb) {
 	    let result;
 	    let rawResult;
-	    const liftCleanup = effect.named(`lift:${cb.name}`)(markWithRoot((access) => {
+	    const resultName = `lift:${cb.name || 'anonymous'}`;
+	    const liftCleanup = effect `lift:${cb.name}`(markWithRoot((access) => {
 	        const source = cb(access);
 	        if (!source || typeof source !== 'object')
 	            throw new Error('lift callback must return an array or object');
 	        const sourceProto = Object.getPrototypeOf(source);
 	        if (!result) {
-	            rawResult = Array.isArray(source) ? [] : Object.create(sourceProto);
+	            rawResult = tag(resultName, Array.isArray(source) ? [] : Object.create(sourceProto));
 	            result = reactive(rawResult);
 	        }
 	        if (sourceProto !== Object.getPrototypeOf(result))
@@ -4771,6 +5058,7 @@
 	                res.splice(indexA, sliceA.length, ...sliceB);
 	        }
 	        else {
+	            const recordResult = rawResult;
 	            for (const key of Object.keys(source)) {
 	                const had = key in rawResult;
 	                const newDesc = Object.getOwnPropertyDescriptor(source, key);
@@ -4779,7 +5067,7 @@
 	                    const sameAccessor = oldDesc && newDesc.get && oldDesc.get === newDesc.get;
 	                    Object.defineProperty(rawResult, key, newDesc);
 	                    if (!sameAccessor &&
-	                        rawResult[key] !==
+	                        recordResult[key] !==
 	                            (oldDesc ? (oldDesc.get ? oldDesc.get() : oldDesc.value) : undefined))
 	                        touched1(rawResult, { type: 'set', prop: key }, key);
 	                }
@@ -4790,13 +5078,16 @@
 	            }
 	            for (const key of Object.keys(rawResult))
 	                if (!(key in source)) {
-	                    delete rawResult[key];
+	                    delete recordResult[key];
 	                    touched1(rawResult, { type: 'del', prop: key }, key);
 	                }
 	        }
 	    }, cb));
 	    return link(result, liftCleanup);
-	}
+	}, {
+	    name: 'lift',
+	    warn: (message) => options.warn(`[reactive] ${message}`),
+	});
 	/**
 	 * Reactively maps an array source through `fn`, producing a lazy reactive output array.
 	 *
@@ -4820,12 +5111,18 @@
 	    }
 	    let track;
 	    const itemEffects = new Map();
-	    const cache = [];
+	    const cache = tag(`morph:${fn.name || 'anonymous'}`, []);
 	    let input = [];
 	    function stopItem(key) {
 	        const entry = itemEffects.get(key);
 	        if (entry) {
-	            entry.stop({ type: 'stopped' });
+	            const activeEffect = getActiveEffect();
+	            let chain;
+	            if (activeEffect) {
+	                const node = getEffectNode(activeEffect);
+	                chain = node.currentReason;
+	            }
+	            entry.stop(chainExternalReason({ type: 'stopped', chain }));
 	            itemEffects.delete(key);
 	        }
 	    }
@@ -4838,12 +5135,22 @@
 	        }
 	        else {
 	            const indexRef = { value: key };
-	            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+	            const stop = track(() => effect.opaque `morph:${fn.name}:${key}`((access) => {
 	                cache[indexRef.value] = fn(input, access);
 	                return (reason) => {
 	                    delete cache[indexRef.value];
 	                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-	                    stop?.({ type: 'invalidate', cause: reason });
+	                    const activeEffect = getActiveEffect();
+	                    let chain;
+	                    if (activeEffect) {
+	                        const node = getEffectNode(activeEffect);
+	                        chain = node.currentReason;
+	                    }
+	                    stop?.({
+	                        type: 'invalidate',
+	                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+	                        chain: chainExternalReason(chain),
+	                    });
 	                };
 	            }));
 	            itemEffects.set(key, { stop, index: indexRef });
@@ -4862,7 +5169,7 @@
 	            return Reflect.has(input, prop);
 	        },
 	    });
-	    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
+	    const stopMain = effect `morph:${fn.name}`(({ ascend }) => {
 	        track = ascend;
 	        const newInput = [...(typeof source === 'function' ? source() : source)];
 	        const diffs = arrayDiff(input, newInput).toSorted((a, b) => b.indexA - a.indexA);
@@ -4936,12 +5243,18 @@
 	    }
 	    let track;
 	    const itemEffects = new Map();
-	    const cache = new Map();
+	    const cache = tag(`morph:${fn.name || 'anonymous'}`, new Map());
 	    Object.defineProperty(cache, 'constructor', { value: Object, enumerable: false });
 	    function stopItem(key) {
 	        const stop = itemEffects.get(key);
 	        if (stop) {
-	            stop({ type: 'stopped' });
+	            const activeEffect = getActiveEffect();
+	            let chain;
+	            if (activeEffect) {
+	                const node = getEffectNode(activeEffect);
+	                chain = node.currentReason;
+	            }
+	            stop({ type: 'stopped', chain });
 	            itemEffects.delete(key);
 	        }
 	    }
@@ -4951,12 +5264,25 @@
 	            cache.set(key, track(() => fn(val, key)));
 	        }
 	        else {
-	            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
-	                cache.set(key, fn(source.get(key), key, access));
+	            const stop = track(() => effect.opaque `morph:${fn.name}:${key}`((access) => {
+	                const next = source.get(key);
+	                if (next === undefined && !source.has(key))
+	                    return;
+	                cache.set(key, fn(next, key, access));
 	                return (reason) => {
 	                    cache.delete(key);
 	                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-	                    stop?.({ type: 'invalidate', cause: reason });
+	                    const activeEffect = getActiveEffect();
+	                    let chain;
+	                    if (activeEffect) {
+	                        const node = getEffectNode(activeEffect);
+	                        chain = node.currentReason;
+	                    }
+	                    stop?.({
+	                        type: 'invalidate',
+	                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+	                        chain: chainExternalReason(chain),
+	                    });
 	                };
 	            }));
 	            itemEffects.set(key, stop);
@@ -5000,7 +5326,7 @@
 	        },
 	    });
 	    let stateSnapshot = getState(source);
-	    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
+	    const stopMain = effect `morph:${fn.name}`(({ ascend }) => {
 	        track = ascend;
 	        dependant(source, keysOf);
 	        while ('evolution' in stateSnapshot) {
@@ -5047,7 +5373,13 @@
 	    function stopItem(key) {
 	        const stop = itemEffects.get(key);
 	        if (stop) {
-	            stop({ type: 'stopped' });
+	            const activeEffect = getActiveEffect();
+	            let chain;
+	            if (activeEffect) {
+	                const node = getEffectNode(activeEffect);
+	                chain = node.currentReason;
+	            }
+	            stop({ type: 'stopped', chain });
 	            itemEffects.delete(key);
 	        }
 	    }
@@ -5057,12 +5389,22 @@
 	            cache[key] = track(() => fn(val, key));
 	        }
 	        else {
-	            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+	            const stop = track(() => effect.opaque `morph:${fn.name}:${key}`((access) => {
 	                cache[key] = fn(source[key], key, access);
 	                return (reason) => {
 	                    delete cache[key];
 	                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-	                    stop?.({ type: 'invalidate', cause: reason });
+	                    const activeEffect = getActiveEffect();
+	                    let chain;
+	                    if (activeEffect) {
+	                        const node = getEffectNode(activeEffect);
+	                        chain = node.currentReason;
+	                    }
+	                    stop?.({
+	                        type: 'invalidate',
+	                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+	                        chain: chainExternalReason(chain),
+	                    });
 	                };
 	            }));
 	            itemEffects.set(key, stop);
@@ -5089,7 +5431,7 @@
 	        },
 	    });
 	    let stateSnapshot = getState(source);
-	    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
+	    const stopMain = effect `morph:${fn.name}`(({ ascend }) => {
 	        track = ascend;
 	        // Track only structural changes on source
 	        dependant(source, keysOf);
@@ -5130,7 +5472,7 @@
 	 * // Changing users[0].name only recomputes names[0]
 	 * ```
 	 */
-	const morph = flavored(function morph(source, fn, options) {
+	const morph = captioned(flavored(function morph(source, fn, options) {
 	    if (Array.isArray(source) || typeof source === 'function')
 	        return morphArray(source, fn, options);
 	    if (source instanceof Map)
@@ -5140,6 +5482,10 @@
 	    get pure() {
 	        return (source, fn, _opt) => this(source, fn, { pure: true });
 	    },
+	}), {
+	    name: 'morph',
+	    callbackIndex: 1,
+	    warn: (message) => options.warn(`[reactive] ${message}`),
 	});
 
 	/**
@@ -5165,7 +5511,7 @@
 	    const wrappedCallback = markWithRoot((() => callback(target)), callback);
 	    registerDeepWatcher();
 	    // Use the existing effect system to register dependencies
-	    return effect.named('deepWatch')(() => {
+	    return effect `deepWatch`(() => {
 	        // Mark the target object as having deep watchers
 	        objectsWithDeepWatchers.add(target);
 	        // Track which objects this effect is watching for cleanup
@@ -5229,7 +5575,7 @@
 	        traverseAndTrack(target);
 	        // Only call the callback if immediate is true or if it's not the first run
 	        if (immediate) {
-	            untracked(() => callback(target));
+	            untracked `deepWatch:callback`(() => callback(target));
 	        }
 	        immediate = true;
 	        // Return a cleanup function that properly removes deep watcher tracking
@@ -5296,7 +5642,7 @@
 	                const wasVerification = options.isVerificationRun;
 	                options.isVerificationRun = true;
 	                try {
-	                    const fresh = untracked(() => fn.apply(this, args));
+	                    const fresh = untracked `memoize:verify-calculation`(() => fn.apply(this, args));
 	                    if (!deepCompare(node.result, fresh)) {
 	                        optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
 	                    }
@@ -5309,7 +5655,7 @@
 	        }
 	        // Create memoize internal effect to track dependencies and invalidate cache
 	        // Use untracked to prevent the effect creation from being affected by parent effects
-	        node.cleanup = root(() => effect.named('memoize')(() => {
+	        node.cleanup = root `memoize:root`(() => effect `memoize`(() => {
 	            // Execute the function and track its dependencies
 	            // The function execution will automatically track dependencies on reactive objects
 	            node.result = fn.apply(this, args);
@@ -5320,7 +5666,17 @@
 	                // Lazy memoization: stop the effect so it doesn't re-run immediately.
 	                // It will be re-created on next access.
 	                if (node.cleanup) {
-	                    node.cleanup({ type: 'invalidate', cause: reason });
+	                    const activeEffect = getActiveEffect();
+	                    let chain;
+	                    if (activeEffect) {
+	                        const effectNode = getEffectNode(activeEffect);
+	                        chain = effectNode.currentReason;
+	                    }
+	                    node.cleanup({
+	                        type: 'invalidate',
+	                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+	                        chain: chainExternalReason(chain),
+	                    });
 	                    node.cleanup = undefined;
 	                }
 	            };
@@ -5329,7 +5685,7 @@
 	            const wasVerification = options.isVerificationRun;
 	            options.isVerificationRun = true;
 	            try {
-	                const fresh = untracked(() => fn.apply(this, args));
+	                const fresh = untracked `memoize:verify-comparison`(() => fn.apply(this, args));
 	                if (!deepCompare(node.result, fresh)) {
 	                    optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
 	                }
@@ -5521,12 +5877,12 @@
 	function organized(source, apply, baseTarget = {}) {
 	    const observedSource = reactive(source);
 	    const target = reactive(baseTarget);
-	    const stop = attend(() => {
+	    const stop = attend `organized:entries`(function enumerateObservedSourceKeys() {
 	        const keys = [];
 	        for (const key in observedSource)
 	            keys.push(key);
 	        return keys;
-	    }, (key) => {
+	    }, function applyObservedSourceKey(key) {
 	        const sourceKey = key;
 	        const accessBase = {
 	            key: sourceKey,
@@ -5564,7 +5920,7 @@
 
 	//#region watch
 	const unsetYet = Symbol('unset-yet');
-	const watch = flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
+	const watch = captioned(flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
 	changed, options = {}) {
 	    return typeof value === 'function'
 	        ? watchCallBack(value, changed, options)
@@ -5580,11 +5936,14 @@
 	    get immediate() {
 	        return flavorOptions(this, { immediate: true });
 	    },
+	}), {
+	    name: 'watch',
+	    warn: (message) => options.warn(`[reactive] ${message}`),
 	});
 	function watchObject(value, changed, { immediate = false, deep = false } = {}) {
 	    if (deep)
 	        return deepWatch(value, changed, { immediate });
-	    return effect.named('watch:object')(() => {
+	    return effect `watch:object`(() => {
 	        dependant(value);
 	        if (immediate)
 	            changed(value);
@@ -5594,16 +5953,16 @@
 	function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
 	    let oldValue = unsetYet;
 	    let deepCleanup;
-	    const cbCleanup = effect.named('watch:callback')(markWithRoot((access) => {
+	    const cbCleanup = effect `watch:callback`(markWithRoot((access) => {
 	        const newValue = value(access);
 	        if (oldValue !== newValue) {
 	            const old = oldValue;
 	            if (old === unsetYet) {
 	                if (immediate)
-	                    untracked(() => changed(newValue));
+	                    untracked `watch:changed`(() => changed(newValue));
 	            }
 	            else
-	                untracked(() => changed(newValue, old));
+	                untracked `watch:changed`(() => changed(newValue, old));
 	        }
 	        oldValue = newValue;
 	        if (deep) {
@@ -5630,7 +5989,7 @@
 	function when(predicate, timeout) {
 	    return new Promise((resolve, reject) => {
 	        let timer;
-	        const stop = effect.named('watch:when')((access) => {
+	        const stop = effect `watch:when`((access) => {
 	            try {
 	                const value = predicate(access);
 	                if (value) {
@@ -5737,7 +6096,7 @@
 	    // Solve race conditions: make sure a new fast request is not overloaded by a slow old one
 	    let counter = 0;
 	    return lazyInit(resource, () => {
-	        link(resource, effect.named('watch:resource')((access) => {
+	        link(resource, effect `watch:resource`((access) => {
 	            // Track reload signal to enable manual reloading
 	            void reloadSignal.value;
 	            const id = ++counter;
@@ -5903,6 +6262,7 @@
 	                return super.findLastIndex((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
 	            }
 	            flat(depth) {
+	                dependant(this, keysOf);
 	                return reactive(super.flat(depth));
 	            }
 	            flatMap(callbackfn, thisArg) {
@@ -6329,59 +6689,62 @@
 	function cache(object, propertyKey, value) {
 	    Object.defineProperty(object, propertyKey, { value });
 	}
+	function descriptorBase(descriptor) {
+	    return function descriptorDecorator(...properties) {
+	        return (Base) => {
+	            return class extends Base {
+	                constructor(...args) {
+	                    super(...args);
+	                    for (const key of properties) {
+	                        const existing = Object.getOwnPropertyDescriptor(this, key);
+	                        Object.defineProperty(this, key, Object.assign(existing || {}, descriptor));
+	                    }
+	                }
+	            };
+	        };
+	    };
+	}
 	/**
 	 * Creates a decorator that modifies property descriptors for specified properties
 	 * @param descriptor - The descriptor properties to apply
 	 * @returns A class decorator that applies the descriptor to specified properties
 	 */
-	const descriptor = flavored(function descriptor(descriptor) {
-	    return (...properties) => (Base) => {
-	        return class extends Base {
-	            constructor(...args) {
-	                super(...args);
-	                for (const key of properties) {
-	                    const existing = Object.getOwnPropertyDescriptor(this, key);
-	                    Object.defineProperty(this, key, Object.assign(existing || {}, descriptor));
-	                }
-	            }
-	        };
-	    };
-	}, {
+	const descriptor = Object.assign(descriptorBase, {
 	    /**
 	     * enumerable: true
 	     */
 	    get enumerable() {
-	        return descriptor({ enumerable: true });
+	        return descriptorBase({ enumerable: true });
 	    },
 	    /**
 	     * enumerable: false
 	     */
 	    get hidden() {
-	        return descriptor({ enumerable: false });
+	        return descriptorBase({ enumerable: false });
 	    },
 	    /**
 	     * configurable: true
 	     */
 	    get configurable() {
-	        return descriptor({ configurable: true });
+	        return descriptorBase({ configurable: true });
 	    },
 	    /**
 	     * configurable: false
 	     */
 	    get frozen() {
-	        return descriptor({ configurable: false });
+	        return descriptorBase({ configurable: false });
 	    },
 	    /**
 	     * writable: true
 	     */
 	    get writable() {
-	        return descriptor({ writable: true });
+	        return descriptorBase({ writable: true });
 	    },
 	    /**
 	     * writable: false
 	     */
 	    get readonly() {
-	        return descriptor({ writable: false });
+	        return descriptorBase({ writable: false });
 	    },
 	});
 	/**
@@ -6510,24 +6873,25 @@
 	    });
 	}
 
-	var version$1 = "1.0.12";
+	var version$1 = "1.0.13";
 	var pkg = {
 		version: version$1};
 
 	const { version } = pkg;
 	const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
+	const runtimeGlobals = globalThis;
 	const globalScope = (typeof globalThis !== 'undefined'
 	    ? globalThis
-	    : typeof window !== 'undefined'
-	        ? window
-	        : typeof global !== 'undefined'
-	            ? global
+	    : runtimeGlobals.window
+	        ? runtimeGlobals.window
+	        : runtimeGlobals.global
+	            ? runtimeGlobals.global
 	            : false);
 	if (globalScope) {
 	    let source = 'mutts/index';
 	    try {
-	        if (typeof __filename !== 'undefined')
-	            source = __filename;
+	        if (runtimeGlobals.__filename)
+	            source = runtimeGlobals.__filename;
 	        else if (typeof ({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('mutts.umd.js', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('mutts.umd.js', document.baseURI).href))) {
 	            source = (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('mutts.umd.js', document.baseURI).href));
 	        }
@@ -6548,6 +6912,7 @@
 
 	exports.AZone = AZone;
 	exports.ArrayReadForward = ArrayReadForward;
+	exports.CompareSymbol = CompareSymbol;
 	exports.DecoratorError = DecoratorError;
 	exports.Destroyable = Destroyable;
 	exports.DestructionError = DestructionError;
@@ -6577,6 +6942,7 @@
 	exports.cache = cache;
 	exports.cached = cached;
 	exports.callOnGC = callOnGC;
+	exports.captioned = captioned;
 	exports.captured = captured;
 	exports.caught = caught;
 	exports.chainPromise = chainPromise;
@@ -6593,6 +6959,7 @@
 	exports.devPreset = devPreset;
 	exports.effect = effect;
 	exports.effectAggregator = effectAggregator;
+	exports.effectContext = effectContext;
 	exports.flavorOptions = flavorOptions;
 	exports.flavored = flavored;
 	exports.formatCleanupReason = formatCleanupReason;
@@ -6602,6 +6969,7 @@
 	exports.getAt = getAt;
 	exports.getState = getState;
 	exports.hooks = hooks$1;
+	exports.inheritCaption = inheritCaption;
 	exports.isCached = isCached;
 	exports.isConstructor = isConstructor;
 	exports.isDev = isDev;
@@ -6624,7 +6992,6 @@
 	exports.organized = organized;
 	exports.prodPreset = prodPreset;
 	exports.profileInfo = profileInfo;
-	exports.project = morph;
 	exports.proxyToObject = proxyToObject;
 	exports.reactive = reactive;
 	exports.reactiveOptions = options;
@@ -6642,6 +7009,7 @@
 	exports.unwrap = unwrap;
 	exports.watch = watch;
 	exports.when = when;
+	exports.withEffectContext = withEffectContext;
 	exports.zip = zip;
 
 }));