mutts 1.0.10 → 1.0.12

package/dist/mutts.umd.js

@@ -4,6 +4,7 @@
 	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Mutts = {}));
 })(this, (function (exports) { 'use strict';
 
+	var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 	// Queue for hooks registered before the environment is ready (circular dependency fix)
 	const hooks$1 = new Set();
 	const asyncHooks = {
@@ -64,21 +65,23 @@
 	            return fn.apply(this, args);
 	        }
 	        finally {
-	            if (originals$1.queueMicrotask) {
+	            /* cf BROWSER_ASYNC_POLYFILL.md
+	            // Note: my fear about this code: in between 2~3~4 microtask waits, some other microtasks might have started, stopped, ...
+	            // We might be in the middle of another promise hook trying to setup the zone
+	            // TODO We might wish to have a flag :asyncZone.acquired - like a semaphore - that we falsify here and set back when we setup the zone
+	            // - but this might perhaps be an overkill creating more problems than it solves
+	            if (originals.queueMicrotask) {
 	                // Double microtask ensures we run after the first await resumption microtask
-	                originals$1.queueMicrotask.call(globalThis, () => {
-	                    originals$1.queueMicrotask.call(globalThis, () => {
-	                        originals$1.queueMicrotask.call(globalThis, () => {
-	                            for (let i = undoers.length - 1; i >= 0; i--)
-	                                undoers[i]();
-	                        });
-	                    });
-	                });
-	            }
-	            else {
-	                for (let i = undoers.length - 1; i >= 0; i--)
-	                    undoers[i]();
-	            }
+	                originals.queueMicrotask.call(globalThis, () => {
+	                    originals.queueMicrotask.call(globalThis, () => {
+	                        originals.queueMicrotask.call(globalThis, () => {
+	                            for (let i = undoers.length - 1; i >= 0; i--) undoers[i]()
+	                        })
+	                    })
+	                })
+	            } else {
+	                for (let i = undoers.length - 1; i >= 0; i--) undoers[i]()
+	            }*/
 	        }
 	    };
 	}
@@ -336,16 +339,16 @@
 	        if (hasNode && obj instanceof Node) {
 	            obj[prop] = value;
 	            return true;
-	        }
-	        if (!(obj instanceof Object) && !Reflect.has(obj, prop)) {
+	        } /*
+	        if (!(obj instanceof Object) && !Object.hasOwn(obj, prop)) {
 	            Object.defineProperty(obj, prop, {
 	                value,
 	                configurable: true,
 	                writable: true,
 	                enumerable: true,
-	            });
-	            return true;
-	        }
+	            })
+	            return true
+	        }*/
 	        return Reflect.set(obj, prop, value, receiver);
 	    },
 	};
@@ -369,15 +372,8 @@
 	        return a === b;
 	    }
 	    // Prototype check
-	    const protoA = Object.getPrototypeOf(a);
-	    const protoB = Object.getPrototypeOf(b);
-	    if (protoA !== protoB) {
-	        console.warn(`[deepCompare] prototype mismatch:`, {
-	            nameA: a?.constructor?.name,
-	            nameB: b?.constructor?.name,
-	        });
+	    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
 	        return false;
-	    }
 	    // Circular reference protection
 	    let compared = cache.get(a);
 	    if (compared?.has(b))
@@ -389,39 +385,21 @@
 	    compared.add(b);
 	    // Handle specific object types
 	    if (Array.isArray(a)) {
-	        if (!Array.isArray(b)) {
-	            console.warn(`[deepCompare] B is not an array`);
+	        if (!Array.isArray(b) || a.length !== b.length)
 	            return false;
-	        }
-	        if (a.length !== b.length) {
-	            console.warn(`[deepCompare] array length mismatch:`, { lenA: a.length, lenB: b.length });
-	            return false;
-	        }
 	        for (let i = 0; i < a.length; i++) {
-	            if (!deepCompare(a[i], b[i], cache)) {
-	                console.warn(`[deepCompare] array element mismatch at index ${i}`);
+	            if (!deepCompare(a[i], b[i], cache))
 	                return false;
-	            }
 	        }
 	        return true;
 	    }
-	    if (a instanceof Date) {
-	        const match = b instanceof Date && a.getTime() === b.getTime();
-	        if (!match)
-	            console.warn(`[deepCompare] Date mismatch`);
-	        return match;
-	    }
-	    if (a instanceof RegExp) {
-	        const match = b instanceof RegExp && a.toString() === b.toString();
-	        if (!match)
-	            console.warn(`[deepCompare] RegExp mismatch`);
-	        return match;
-	    }
+	    if (a instanceof Date)
+	        return b instanceof Date && a.getTime() === b.getTime();
+	    if (a instanceof RegExp)
+	        return b instanceof RegExp && a.toString() === b.toString();
 	    if (a instanceof Set) {
-	        if (!(b instanceof Set) || a.size !== b.size) {
-	            console.warn(`[deepCompare] Set size mismatch`);
+	        if (!(b instanceof Set) || a.size !== b.size)
 	            return false;
-	        }
 	        for (const val of a) {
 	            let found = false;
 	            for (const bVal of b) {
@@ -430,18 +408,14 @@
 	                    break;
 	                }
 	            }
-	            if (!found) {
-	                console.warn(`[deepCompare] missing Set element`);
+	            if (!found)
 	                return false;
-	            }
 	        }
 	        return true;
 	    }
 	    if (a instanceof Map) {
-	        if (!(b instanceof Map) || a.size !== b.size) {
-	            console.warn(`[deepCompare] Map size mismatch`);
+	        if (!(b instanceof Map) || a.size !== b.size)
 	            return false;
-	        }
 	        for (const [key, val] of a) {
 	            if (!b.has(key)) {
 	                let foundMatch = false;
@@ -451,16 +425,11 @@
 	                        break;
 	                    }
 	                }
-	                if (!foundMatch) {
-	                    console.warn(`[deepCompare] missing Map key`);
+	                if (!foundMatch)
 	                    return false;
-	                }
 	            }
-	            else {
-	                if (!deepCompare(val, b.get(key), cache)) {
-	                    console.warn(`[deepCompare] Map value mismatch for key`);
-	                    return false;
-	                }
+	            else if (!deepCompare(val, b.get(key), cache)) {
+	                return false;
 	            }
 	        }
 	        return true;
@@ -468,29 +437,11 @@
 	    // Compare own properties
 	    const keysA = Object.keys(a);
 	    const keysB = Object.keys(b);
-	    if (keysA.length !== keysB.length) {
-	        console.warn(`[deepCompare] keys length mismatch:`, {
-	            lenA: keysA.length,
-	            lenB: keysB.length,
-	            keysA,
-	            keysB,
-	            a,
-	            b,
-	        });
+	    if (keysA.length !== keysB.length)
 	        return false;
-	    }
 	    for (const key of keysA) {
-	        if (!Object.hasOwn(b, key)) {
-	            console.warn(`[deepCompare] missing key ${String(key)} in B`);
+	        if (!Object.hasOwn(b, key) || !deepCompare(a[key], b[key], cache))
 	            return false;
-	        }
-	        if (!deepCompare(a[key], b[key], cache)) {
-	            console.warn(`[deepCompare] value mismatch for key ${String(key)}:`, {
-	                valA: a[key],
-	                valB: b[key],
-	            });
-	            return false;
-	        }
 	    }
 	    return true;
 	}
@@ -538,6 +489,12 @@
 	    });
 	    return fn;
 	}
+	const _mode = (typeof process !== 'undefined' && 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';
+	const isProd = _mode === 'production';
+	const isTest = _mode === 'test';
 
 	// biome-ignore-all lint/suspicious/noConfusingVoidType: We *love* voids
 	// Standardized decorator system that works with both Legacy and Modern decorators
@@ -1103,9 +1060,7 @@
 	        const isObject = currentOptions !== null &&
 	            typeof currentOptions === 'object' &&
 	            !Array.isArray(currentOptions);
-	        newArgs[targetIndex] = isObject
-	            ? { ...defaultOptions, ...currentOptions }
-	            : defaultOptions;
+	        newArgs[targetIndex] = isObject ? { ...defaultOptions, ...currentOptions } : defaultOptions;
 	        return fn.apply(this, newArgs);
 	    };
 	    if (opts.name)
@@ -1852,6 +1807,17 @@
 	    return chained;
 	}
 
+	const debugHooks = {
+	    isDevtoolsEnabled: () => false,
+	    registerEffect: () => { },
+	    getTriggerChain: () => [],
+	    captureStack: () => [],
+	    captureLineage: () => new Error().stack,
+	    formatStack: (stack) => [stack],
+	    recordTriggerLink: () => { },
+	    decorateError: () => { },
+	};
+
 	/******************************************************************************
 	Copyright (c) Microsoft Corporation.
 
@@ -1903,38 +1869,17 @@
 	    }
 	    return useValue ? value : void 0;
 	}
-	function __setFunctionName(f, name, prefix) {
-	    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-	    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-	}
 	function __classPrivateFieldGet(receiver, state, kind, f) {
 	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
 	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
 	    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 	}
 
-	function __classPrivateFieldSet(receiver, state, value, kind, f) {
-	    if (kind === "m") throw new TypeError("Private method is not writable");
-	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-	    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-	}
-
 	typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
 	    var e = new Error(message);
 	    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 	};
 
-	const debugHooks = {
-	    isDevtoolsEnabled: () => false,
-	    registerEffect: () => { },
-	    getTriggerChain: () => [],
-	    captureStack: () => [],
-	    captureLineage: () => new Error().stack,
-	    formatStack: (stack) => [stack],
-	    recordTriggerLink: () => { },
-	};
-
 	var _ZoneAggregator_zones;
 	function isu(z) {
 	    return z;
@@ -2062,13 +2007,27 @@
 	    }
 	}
 	_ZoneAggregator_zones = new WeakMap();
+	/**
+	 * Aggregator of zones that should be preserved across async boundaries.
+	 * If you add a zone here, it will be preserved across async boundaries.
+	 *
+	 * @example
+	 * ```ts
+	 * import { Zone, asyncZone } from 'mutts'
+	 * const userZone = new Zone<User>()
+	 * asyncZone.add(userZone)
+	 * ```
+	 */
 	const asyncZone = tag('async', new ZoneAggregator());
 	asyncHooks.addHook(() => {
+	    // capture state before async boundary
 	    const zone = asyncZone.active;
 	    return () => {
+	        // restore state after async boundary, temporarily
 	        const prev = asyncZone.active;
 	        asyncZone.active = zone;
 	        return () => {
+	            // restore previous state from before our restore
 	            asyncZone.active = prev;
 	        };
 	    };
@@ -2138,6 +2097,75 @@
 	    return fn;
 	}
 
+	const effectHistory = tag('effectHistory', new ZoneHistory());
+	tag('effectHistory.present', effectHistory.present);
+	asyncZone.add(effectHistory);
+	/**
+	 * 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));
+	function isRunning(effect) {
+	    const root = getRoot(effect);
+	    return effectHistory.some((e) => getRoot(e) === root);
+	}
+	function getActiveEffect() {
+	    return effectHistory.present.active;
+	}
+	const cleanups = new WeakMap();
+	/**
+	 * Attach cleanup dependencies to an object. When `unlink(obj)` is called,
+	 * each dependency is disposed: functions are invoked with the cleanup reason,
+	 * objects are recursively `unlink`ed. This forms a cleanup tree.
+	 *
+	 * @param obj - The owner object
+	 * @param cleanupFns - Cleanup callbacks and/or child objects to unlink recursively
+	 * @returns The owner object (for chaining)
+	 *
+	 * @example
+	 * ```ts
+	 * // Functions are called with CleanupReason
+	 * link(parent, () => console.log('disposed'))
+	 *
+	 * // Objects are recursively unlinked
+	 * link(parent, childA, childB)
+	 *
+	 * // Mixed
+	 * link(parent, childObj, () => timer.clear())
+	 *
+	 * unlink(parent) // disposes childA, childB, calls the function
+	 * ```
+	 */
+	function link(obj, ...cleanupFns) {
+	    const set = cleanups.get(obj);
+	    if (!set)
+	        cleanups.set(obj, new Set(cleanupFns.filter(Boolean)));
+	    else
+	        for (const fn of cleanupFns)
+	            if (fn)
+	                set.add(fn);
+	    return obj;
+	}
+	/**
+	 * Dispose an object's cleanup dependencies. Functions are called with the
+	 * reason; linked objects are recursively unlinked. The cleanup set is removed
+	 * so calling `unlink` twice is safe (second call is a no-op).
+	 *
+	 * @param obj - The object to dispose
+	 * @param reason - Optional cleanup reason propagated to callbacks
+	 */
+	function unlink(obj, reason) {
+	    const set = cleanups.get(obj);
+	    if (set) {
+	        cleanups.delete(obj);
+	        for (const fn of set)
+	            if (typeof fn === 'function')
+	                fn(reason);
+	            else
+	                unlink(fn, reason);
+	    }
+	}
+
 	const effectMarker = {
 	    enter: 'effect:enter',
 	    leave: 'effect:leave',
@@ -2200,6 +2228,11 @@
 	        }
 	    }
 	}
+	// Track native reactivity
+	/**
+	 * Symbol to mark class properties as non-reactive
+	 */
+	const unreactiveProperties = Symbol('unreactive-properties');
 	/**
 	 * Symbol representing all properties in reactive tracking
 	 */
@@ -2209,14 +2242,6 @@
 	 * Used by ownKeys proxy trap — Object.keys(), for..in, Map.keys() depend on this.
 	 */
 	const keysOf = Symbol('keys-of');
-	/**
-	 * Symbol to check if an effect is stopped
-	 */
-	const stopped = Symbol('stopped');
-	/**
-	 * Symbol to access effect cleanup function
-	 */
-	const cleanup = Symbol('cleanup');
 	/**
 	 * Structured error codes for machine-readable diagnosis
 	 */
@@ -2290,6 +2315,12 @@
 	     * @param runningChain - The array of effects from the detected one to the currently running one
 	     */
 	    skipRunningEffect: (_effect) => { },
+	    /**
+	     * Debug purpose: called when an effect starts executing.
+	     * @param effect - The effect being executed (root function)
+	     * @param reaction - false for initial creation, true/CleanupReason for subsequent runs
+	     */
+	    effectRun: (_effect, _reaction) => { },
 	    /**
 	     * Debug purpose: maximum effect chain (like call stack max depth)
 	     * Used to prevent infinite loops
@@ -2416,34 +2447,6 @@
 	        enableHistory: true,
 	        historySize: 50,
 	    },
-	    /**
-	     * Configuration for zone hooks - control which async APIs are hooked
-	     * Each option controls whether the corresponding async API is wrapped to preserve effect context
-	     * Only applies when asyncMode is enabled (truthy)
-	     * @deprecated Should take all when we made sure PIXI.create, Game.create, ... are -> .root()
-	     */
-	    zones: {
-	        /**
-	         * Hook setTimeout to preserve effect context
-	         * @default true
-	         */
-	        setTimeout: true,
-	        /**
-	         * Hook setInterval to preserve effect context
-	         * @default true
-	         */
-	        setInterval: true,
-	        /**
-	         * Hook requestAnimationFrame (runs in untracked context when hooked)
-	         * @default true
-	         */
-	        requestAnimationFrame: true,
-	        /**
-	         * Hook queueMicrotask to preserve effect context
-	         * @default true
-	         */
-	        queueMicrotask: true,
-	    },
 	};
 	function optionCall(name, ...args) {
 	    const fn = options[name];
@@ -2457,6 +2460,36 @@
 	        options.warn(`options.${name} threw`, error);
 	    }
 	}
+	/** Production preset: no introspection, heuristic cycle detection, minimal overhead */
+	const prodPreset = {
+	    maxEffectReaction: 'throw',
+	    cycleHandling: 'production',
+	    introspection: null,
+	    onMemoizationDiscrepancy: undefined,
+	};
+	/** Development preset (default): introspection on, early cycle detection, warnings */
+	const devPreset = {
+	    maxEffectReaction: 'warn',
+	    cycleHandling: 'development',
+	    introspection: {
+	        gatherReasons: { lineages: 'touch' },
+	        logErrors: true,
+	        enableHistory: true,
+	        historySize: 50,
+	    },
+	    onMemoizationDiscrepancy: undefined,
+	};
+	/** Debug preset: full diagnostics, throws on violations, rich lineage capture */
+	const debugPreset = {
+	    maxEffectReaction: 'debug',
+	    cycleHandling: 'debug',
+	    introspection: {
+	        gatherReasons: { lineages: 'both' },
+	        logErrors: true,
+	        enableHistory: true,
+	        historySize: 200,
+	    },
+	};
 	// --- Proxy State (Merged from proxy-state.ts) ---
 	const objectToProxy = new WeakMap();
 	const proxyToObject = new WeakMap();
@@ -2476,54 +2509,28 @@
 	    return proxyToObject.has(obj);
 	}
 
-	const effectHistory = tag('effectHistory', new ZoneHistory());
-	tag('effectHistory.present', effectHistory.present);
-	asyncZone.add(effectHistory);
-	/**
-	 * 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));
-	function isRunning(effect) {
-	    const root = getRoot(effect);
-	    return effectHistory.some((e) => getRoot(e) === root);
-	}
-	function getActiveEffect() {
-	    return effectHistory.present.active;
-	}
-	/**
-	 * ADD a cleanup function to an object using the cleanup symbol.
-	 * The cleanup function will be called when the object needs to be disposed.
-	 *
-	 * Note: most of the time, you don't need to use this function directly.
-	 * The main use if for the cleanup function to be stored with the object, as GC calls the cleanup function when the *function* is garbage collected.
-	 *
-	 * @param obj - The object to attach the cleanup function to
-	 * @param cleanupFn - The cleanup function to attach
-	 * @returns The object with the cleanup function attached
-	 */
-	function cleanedBy(obj, cleanupFn) {
-	    const oldCleanup = obj[cleanup];
-	    return Object.defineProperty(obj, cleanup, {
-	        value: oldCleanup
-	            ? Object.defineProperties((reason) => {
-	                oldCleanup(reason);
-	                cleanupFn(reason);
-	            }, {
-	                [stopped]: { get: () => oldCleanup[stopped] || cleanupFn[stopped] },
-	            })
-	            : cleanupFn,
-	        writable: false,
-	        enumerable: false,
-	        configurable: true,
-	    });
-	}
-
 	// Track dependency stacks per (obj, prop, effect)
 	let dependencyStacks = new WeakMap();
+	let assertUntrackedFlag = false;
 	function resetTracking() {
 	    dependencyStacks = new WeakMap();
 	}
+	/**
+	 * Executes a function and throws if any reactive dependencies are tracked during execution.
+	 * Used to assert that code runs in an untracked context.
+	 */
+	function assertUntracked(fn) {
+	    if (assertUntrackedFlag) {
+	        throw new Error('assertUntracked: nested calls are not supported');
+	    }
+	    assertUntrackedFlag = true;
+	    try {
+	        return fn();
+	    }
+	    finally {
+	        assertUntrackedFlag = false;
+	    }
+	}
 	function getDependencyStack(effect, obj, prop) {
 	    const objStacks = dependencyStacks.get(obj);
 	    if (!objStacks)
@@ -2536,14 +2543,17 @@
 	 * @param prop - The property name (defaults to allProps)
 	 */
 	function dependant(obj, prop = allProps) {
+	    if (assertUntrackedFlag) {
+	        throw new Error(`Reactive dependency tracking detected in assertUntracked context: ${String(prop)} on ${obj}`);
+	    }
 	    obj = unwrap(obj);
 	    const currentActiveEffect = getActiveEffect();
 	    // Early return if no active effect, tracking disabled, or invalid prop
 	    if (!currentActiveEffect || (typeof prop === 'symbol' && prop !== allProps && prop !== keysOf))
 	        return;
-	    if ('dependencyHook' in currentActiveEffect) {
-	        // @ts-expect-error We declared it nowhere - it's okay as it's really internal and for edge-case debug purpose only
-	        currentActiveEffect.dependencyHook(obj, prop);
+	    const node = getEffectNode(currentActiveEffect);
+	    if ('dependencyHook' in node) {
+	        node.dependencyHook(obj, prop);
 	    }
 	    let objectWatchers = watchers.get(obj);
 	    if (!objectWatchers) {
@@ -2680,6 +2690,7 @@
 	// consequencesClosure: for each effect, all effects that it triggers (directly or indirectly)
 	let causesClosure = new WeakMap();
 	let consequencesClosure = new WeakMap();
+	// Batch re-entrance depth and broken state
 	let broken = false;
 	/**
 	 * Gets or creates an IterableWeakSet for a closure map
@@ -3333,6 +3344,7 @@
 	            throw new Error('Activation registry already exists');
 	        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();
 	    // Optimization: If nested and NOT immediate, just join the existing batch
 	    if (!isNewBatch && !immediate) {
@@ -3486,6 +3498,22 @@
 	        };
 	    },
 	});
+	/**
+	 * Wraps `fn` so it runs within `effect`'s zone context when invoked later.
+	 *
+	 * Useful for deferred callbacks (event listeners, `DOMContentLoaded`, etc.)
+	 * that need sub-effects parented to the original effect.
+	 *
+	 * @param prev - The effect whose context should be restored, or `undefined` for root context
+	 * @param fn - The function to wrap
+	 * @returns A function with the same signature that restores the effect context before calling `fn`
+	 */
+	function captured(prev, fn) {
+	    prev ?? (prev = effectHistory.active);
+	    return named(effectMarker.leave, (...args) => {
+	        return effectHistory.with(prev, () => fn(...args));
+	    });
+	}
 	/**
 	 * Runs `fn` atomically and **always immediately**, batching all reactive effects
 	 * triggered inside it so they fire only once after `fn` completes.
@@ -3508,19 +3536,13 @@
 	    return batch(fn, 'immediate');
 	}
 	const fr = new FinalizationRegistry((f) => f());
-	/**
-	 * @param fn - The effect function to run - provides the cleaner
-	 * @returns The cleanup function
-	 */
 	/**
 	 * Creates a reactive effect that automatically re-runs when dependencies change
 	 * @param fn - The effect function that provides dependencies and may return a cleanup function or Promise
 	 * @param options - Options for effect execution
 	 * @returns A cleanup function to stop the effect
 	 */
-	const effect = named(effectMarker.leave, flavored(function effect(
-	// biome-ignore lint/suspicious/noConfusingVoidType: Effect callbacks commonly return void
-	fn, effectOptions = {}) {
+	const effect = 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
@@ -3544,6 +3566,7 @@
 	        if (runningPromise) {
 	            if (asyncMode === 'cancel' && cancelPrevious) {
 	                // Cancel previous execution
+	                abort();
 	                cancelPrevious();
 	                cancelPrevious = null;
 	                runningPromise = null;
@@ -3567,11 +3590,33 @@
 	        access.reaction = node.nextReason || access.reaction;
 	        node.nextReason = undefined;
 	        optionCall('enter', getRoot(fn));
+	        optionCall('effectRun', getRoot(fn), access.reaction);
 	        let result;
 	        let caught = 0;
-	        // Default thrower (self)
-	        let thrower = (error) => {
-	            throw error;
+	        // Define bubbling thrower
+	        const thrower = (error) => {
+	            const catches = node.catchers;
+	            const reason = { type: 'error', error };
+	            if (catches)
+	                while (caught < catches.length) {
+	                    cleanupReaction(reason);
+	                    try {
+	                        reactionCleanup = catches[caught](error);
+	                        return;
+	                    }
+	                    catch (_e) {
+	                        caught++;
+	                    }
+	                }
+	            if (parent) {
+	                const parentNode = getEffectNode(parent);
+	                if (parentNode.forwardThrow)
+	                    parentNode.forwardThrow(error);
+	                else
+	                    throw error;
+	            }
+	            else
+	                throw error;
 	        };
 	        node.forwardThrow = thrower;
 	        let errorToThrow;
@@ -3627,6 +3672,7 @@
 	        // Create cleanup function for next run
 	        node.cleanup = (reason) => {
 	            node.cleanup = undefined;
+	            abort();
 	            cleanupReaction(reason);
 	            delete node.catchers;
 	            // Remove this effect from all reactive objects it's watching
@@ -3637,13 +3683,11 @@
 	                    if (objectWatchers) {
 	                        for (const [prop, deps] of objectWatchers.entries()) {
 	                            deps.delete(runEffect);
-	                            if (deps.size === 0) {
+	                            if (deps.size === 0)
 	                                objectWatchers.delete(prop);
-	                            }
 	                        }
-	                        if (objectWatchers.size === 0) {
+	                        if (objectWatchers.size === 0)
 	                            watchers.delete(reactiveObj);
-	                        }
 	                    }
 	                }
 	                effectToReactiveObjects.delete(runEffect);
@@ -3661,33 +3705,6 @@
 	                delete node.children;
 	            }
 	        };
-	        // Define bubbling thrower
-	        thrower = (error) => {
-	            const catches = node.catchers;
-	            const reason = { type: 'error', error };
-	            if (catches)
-	                while (caught < catches.length) {
-	                    cleanupReaction(reason);
-	                    try {
-	                        reactionCleanup = catches[caught](error);
-	                        return;
-	                    }
-	                    catch (e) {
-	                        caught++;
-	                    }
-	                }
-	            if (parent) {
-	                const parentNode = getEffectNode(parent);
-	                if (parentNode.forwardThrow)
-	                    parentNode.forwardThrow(error);
-	                else
-	                    throw error;
-	            }
-	            else
-	                throw error;
-	        };
-	        // Update the node's forwardThrow to the bubbling one
-	        node.forwardThrow = thrower;
 	        if (errorToThrow)
 	            thrower(errorToThrow);
 	    };
@@ -3700,31 +3717,36 @@
 	    node.parent = parent;
 	    // let thrower: CatchFunction | undefined // Moved inside runEffect
 	    let effectStopped = false;
+	    let abortController;
 	    const access = {
 	        tracked,
 	        ascend: named(effectMarker.leave, (fn) => ascended(named(effectMarker.enter, () => fn.call(null)))),
 	        //named(effectMarker.enter, (fn) => ascended(fn)),
 	        reaction: false,
+	        get signal() {
+	            if (!abortController) {
+	                abortController = new AbortController();
+	            }
+	            return abortController.signal;
+	        },
 	    };
 	    let runningPromise = null;
 	    let cancelPrevious = null;
-	    if (effectOptions?.dependencyHook) {
+	    if (effectOptions?.dependencyHook)
 	        node.dependencyHook = effectOptions.dependencyHook;
-	    }
 	    // Mark the runEffect callback with the original function as its root
 	    markWithRoot(runEffect, fn);
-	    function augmentedRv(rv) {
-	        return Object.defineProperties(rv, {
-	            [stopped]: {
-	                get: () => effectStopped,
-	            },
-	        });
-	    }
 	    // Register strict mode if enabled
 	    if (effectOptions?.opaque) {
 	        node.isOpaque = true;
 	    }
 	    // Store parent relationship for hierarchy traversal - ALREADY DONE ABOVE via getEffectNode
+	    const abort = () => {
+	        if (abortController) {
+	            abortController.abort(new ReactiveError('[reactive] Effect aborted due to dependency change or stop'));
+	            abortController = undefined;
+	        }
+	    };
 	    batch(runEffect, 'immediate');
 	    // Only ROOT effects are registered for GC cleanup and zone tracking
 	    const isRootEffect = !parent;
@@ -3734,6 +3756,7 @@
 	        effectStopped = true;
 	        node.stopped = true;
 	        // Cancel any running async work
+	        abort();
 	        if (cancelPrevious) {
 	            cancelPrevious();
 	            cancelPrevious = null;
@@ -3752,7 +3775,7 @@
 	        fr.unregister(stopEffect);
 	    };
 	    if (isRootEffect) {
-	        const callIfCollected = augmentedRv((reason) => stopEffect(reason));
+	        const callIfCollected = (reason) => stopEffect(reason);
 	        fr.register(callIfCollected, () => {
 	            stopEffect({ type: 'gc' });
 	            optionCall('garbageCollected', fn);
@@ -3766,16 +3789,16 @@
 	            parentNode.children = new Set();
 	        }
 	        const children = parentNode.children;
-	        const subEffectCleanup = augmentedRv((reason) => {
+	        const subEffectCleanup = (reason) => {
 	            children.delete(subEffectCleanup);
 	            // Execute this child effect cleanup (which triggers its own mainCleanup)
 	            stopEffect(reason);
-	        });
+	        };
 	        children.add(subEffectCleanup);
 	        return subEffectCleanup;
 	    }
 	    // Should not be reachable given isRootEffect check, but for type safety
-	    return augmentedRv((reason) => stopEffect(reason));
+	    return (reason) => stopEffect(reason);
 	}, {
 	    get opaque() {
 	        return flavorOptions(this, { opaque: true }, { name: 'opaque' });
@@ -3806,9 +3829,11 @@
 	        get = get.get;
 	    }
 	    let programmaticallySetValue = Symbol();
-	    effect(markWithRoot(() => {
+	    effect.named('biDi')(markWithRoot(() => {
 	        const newValue = get();
-	        if (unwrap(newValue) !== programmaticallySetValue)
+	        const pValue = programmaticallySetValue;
+	        programmaticallySetValue = Symbol();
+	        if (unwrap(newValue) !== pValue)
 	            received(newValue);
 	    }, received));
 	    return set
@@ -3879,16 +3904,16 @@
 	    const parents = objectParents.get(changedObject);
 	    if (!parents)
 	        return;
-	    for (const { parent, prop } of parents) {
+	    for (const { parent } of parents) {
 	        // Trigger deep watchers on parent
 	        const parentDeepWatchers = deepWatchers.get(parent);
 	        if (parentDeepWatchers) {
 	            if (options.introspection?.gatherReasons) {
 	                const gatherReasons = options.introspection.gatherReasons;
 	                const lineageConfig = gatherReasons.lineages;
-	                let touchStack;
+	                let touchLineage;
 	                if (lineageConfig === 'touch' || lineageConfig === 'both') {
-	                    touchStack = debugHooks.captureLineage();
+	                    touchLineage = debugHooks.captureLineage();
 	                }
 	                for (const watcher of parentDeepWatchers) {
 	                    const dependencyStack = lineageConfig === 'dependency' || lineageConfig === 'both'
@@ -3901,7 +3926,7 @@
 	                        obj: parent,
 	                        evolution,
 	                        dependency: dependencyStack,
-	                        touch: touchStack,
+	                        touch: touchLineage,
 	                    });
 	                }
 	            }
@@ -3949,11 +3974,13 @@
 	    return state;
 	}
 	function collectEffects(obj, evolution, effects, objectWatchers, ...keyChains) {
-	    getActiveEffect();
+	    const sourceEffect = getActiveEffect();
 	    for (const keys of keyChains)
 	        for (const key of keys) {
 	            const deps = objectWatchers.get(key);
 	            if (deps) {
+	                // Make sure `some.prop++` does not keep a dependency to `some.props`
+	                deps.delete(sourceEffect);
 	                for (const effect of deps) {
 	                    const runningChain = isRunning(effect);
 	                    if (runningChain) {
@@ -4003,9 +4030,9 @@
 	        if (options.introspection?.gatherReasons) {
 	            const gatherReasons = options.introspection.gatherReasons;
 	            const lineageConfig = gatherReasons.lineages;
-	            let touchStack;
+	            let touchLineage;
 	            if (lineageConfig === 'touch' || lineageConfig === 'both') {
-	                touchStack = debugHooks.captureLineage();
+	                touchLineage = debugHooks.captureLineage();
 	            }
 	            for (const [effect, dependencyStack] of effects) {
 	                const node = getEffectNode(effect);
@@ -4015,7 +4042,7 @@
 	                    obj,
 	                    evolution,
 	                    dependency: dependencyStack,
-	                    touch: touchStack,
+	                    touch: touchLineage,
 	                });
 	            }
 	        }
@@ -4054,10 +4081,10 @@
 	            }
 	            effects.add(effect);
 	            if (gather) {
-	                let touchStack;
+	                let touchLineage;
 	                let dependencyStack;
 	                if (lineageConfig === 'touch' || lineageConfig === 'both') {
-	                    touchStack = debugHooks.captureLineage();
+	                    touchLineage = debugHooks.captureLineage();
 	                }
 	                if (lineageConfig === 'dependency' || lineageConfig === 'both') {
 	                    dependencyStack = getDependencyStack(effect, obj, prop);
@@ -4068,7 +4095,7 @@
 	                    obj,
 	                    evolution,
 	                    dependency: dependencyStack,
-	                    touch: touchStack,
+	                    touch: touchLineage,
 	                });
 	            }
 	            recordActivation(effect, obj, evolution, prop);
@@ -4095,264 +4122,60 @@
 	    }
 	}
 
-	const memoizedRegistry = new WeakMap();
-	const wrapperRegistry = new WeakMap();
-	function getBranch(tree, key) {
-	    tree.branches ?? (tree.branches = new WeakMap());
-	    let branch = tree.branches.get(key);
-	    if (!branch) {
-	        branch = {};
-	        tree.branches.set(key, branch);
+	const absent = Symbol('absent');
+	/**
+	 * Add unreactive properties to a prototype.
+	 * If no set is provided, marks the entire object/prototype as non-reactive (sets [unreactiveProperties] = true).
+	 * If a set is provided, merges with existing unreactive properties (never overrides true).
+	 */
+	function addUnreactiveProps(proto, set) {
+	    if (unreactiveProperties in proto) {
+	        const existing = proto[unreactiveProperties];
+	        // If already fully unreactive, don't change
+	        if (existing === true)
+	            return proto;
+	        // If no set provided, upgrade to fully unreactive
+	        if (!set) {
+	            proto[unreactiveProperties] = true;
+	            return proto;
+	        }
+	        // Merge sets
+	        set = proto[unreactiveProperties] = new Set(proto[unreactiveProperties]);
+	        for (const p of set)
+	            existing.add(p);
+	    }
+	    // If no set, mark as fully unreactive, otherwise create set
+	    else
+	        proto[unreactiveProperties] = set ? new Set(set) : true;
+	    return proto;
+	}
+	/** Check if a property is marked unreactive on obj or any of its prototypes (trap-free) */
+	function isUnreactiveProp(obj, prop) {
+	    if (typeof prop === 'symbol' || prop === 'constructor')
+	        return true;
+	    const marker = obj[unreactiveProperties];
+	    return (marker === true || // Fully unreactive
+	        marker?.has?.(prop) || // Property is unreactive
+	        false);
+	}
+	function nonReactive(...obj) {
+	    for (const o of obj) {
+	        o[unreactiveProperties] = true;
 	    }
-	    return branch;
-	}
-	function memoizeFunction(fn, opts) {
-	    const fnRoot = getRoot(fn);
-	    const existing = memoizedRegistry.get(fnRoot);
-	    if (existing)
-	        return existing;
-	    const cacheRoot = {};
-	    const memoized = markWithRoot(function memoized(...args) {
-	        if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
-	            if (opts?.lenient)
-	                return fn.apply(this, args);
-	            throw new Error('memoize expects non-null object arguments');
-	        }
-	        let node = cacheRoot;
-	        // Note: decorators add `this` as first argument
-	        for (const arg of args) {
-	            node = getBranch(node, arg);
-	        }
-	        dependant(node, 'memoize');
-	        if ('result' in node) {
-	            if (options.onMemoizationDiscrepancy) {
-	                const wasVerification = options.isVerificationRun;
-	                options.isVerificationRun = true;
-	                try {
-	                    const fresh = untracked(() => fn.apply(this, args));
-	                    if (!deepCompare(node.result, fresh)) {
-	                        optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
-	                    }
-	                }
-	                finally {
-	                    options.isVerificationRun = wasVerification;
-	                }
-	            }
-	            return node.result;
-	        }
-	        // Create memoize internal effect to track dependencies and invalidate cache
-	        // Use untracked to prevent the effect creation from being affected by parent effects
-	        node.cleanup = root(() => effect.named('memoize')(() => {
-	            // Execute the function and track its dependencies
-	            // The function execution will automatically track dependencies on reactive objects
-	            node.result = fn.apply(this, args);
-	            return (reason) => {
-	                // When dependencies change, clear the cache and notify consumers
-	                delete node.result;
-	                touched1(node, { type: 'invalidate', prop: args }, 'memoize');
-	                // Lazy memoization: stop the effect so it doesn't re-run immediately.
-	                // It will be re-created on next access.
-	                if (node.cleanup) {
-	                    node.cleanup({ type: 'invalidate', cause: reason });
-	                    node.cleanup = undefined;
-	                }
-	            };
-	        }, { opaque: true }));
-	        if (options.onMemoizationDiscrepancy) {
-	            const wasVerification = options.isVerificationRun;
-	            options.isVerificationRun = true;
-	            try {
-	                const fresh = untracked(() => fn.apply(this, args));
-	                if (!deepCompare(node.result, fresh)) {
-	                    optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
-	                }
-	            }
-	            finally {
-	                options.isVerificationRun = wasVerification;
-	            }
-	        }
-	        return node.result;
-	    }, fn);
-	    memoizedRegistry.set(fnRoot, memoized);
-	    memoizedRegistry.set(memoized, memoized);
-	    return memoized;
-	}
-	function memoizeObject(target, opts) {
-	    const existing = memoizedRegistry.get(target);
-	    if (existing)
-	        return existing;
-	    const proxy = new Proxy(target, {
-	        get(source, prop, receiver) {
-	            // 1. Walk prototype chain to find descriptor
-	            let current = source;
-	            let desc;
-	            while (current) {
-	                desc = Object.getOwnPropertyDescriptor(current, prop);
-	                if (desc)
-	                    break;
-	                current = Object.getPrototypeOf(current);
-	            }
-	            if (!desc)
-	                return Reflect.get(source, prop, receiver);
-	            // 2. If getter, memoize
-	            if (desc.get) {
-	                const originalGetter = desc.get;
-	                let wrapper = wrapperRegistry.get(originalGetter);
-	                if (!wrapper) {
-	                    wrapper = markWithRoot(named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
-	                        return originalGetter.call(that);
-	                    }), {
-	                        propertyKey: prop,
-	                    });
-	                    const origRoot = originalGetter[rootFunctionSymbol];
-	                    if (origRoot)
-	                        wrapper[rootFunctionSymbol] = origRoot;
-	                    wrapperRegistry.set(originalGetter, wrapper);
-	                }
-	                const memoized = memoizeFunction(wrapper, opts);
-	                return memoized(receiver);
-	            }
-	            // 3. Otherwise forward
-	            return Reflect.get(source, prop, receiver);
-	        },
-	        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
-	        set(source, prop, value, _receiver) {
-	            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
-	            // it recognizes itself and triggers change notifications.
-	            return Reflect.set(source, prop, value, source);
-	        },
-	    });
-	    proxyToObject.set(proxy, target);
-	    memoizedRegistry.set(target, proxy);
-	    return proxy;
-	}
-	/**
-	 * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
-	 *
-	 * When used as a decorator on getters or methods, it caches the result and automatically
-	 * invalidates the cache when reactive dependencies change.
-	 *
-	 * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
-	 *
-	 * @example
-	 * ```typescript
-	 * class User {
-	 *   @memoize
-	 *   get fullName() {
-	 *     return `${this.firstName} ${this.lastName}`
-	 *   }
-	 * }
-	 *
-	 * // Or as a function wrapper
-	 * const expensive = memoize((obj: SomeObject) => {
-	 *   return heavyComputation(obj)
-	 * })
-	 * ```
-	 */
-	function makeMemoizeDecorator(memoizeOpts) {
-	    return decorator({
-	        getter(original, target, propertyKey) {
-	            return function () {
-	                let wrapper = wrapperRegistry.get(original);
-	                if (!wrapper) {
-	                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
-	                        return original.call(that);
-	                    }), {
-	                        method: original,
-	                        propertyKey,
-	                    });
-	                    const origRoot = original[rootFunctionSymbol];
-	                    if (origRoot)
-	                        wrapper[rootFunctionSymbol] = origRoot;
-	                    wrapperRegistry.set(original, wrapper);
-	                }
-	                const memoized = memoizeFunction(wrapper, memoizeOpts);
-	                return memoized(this);
-	            };
-	        },
-	        method(original, target, name) {
-	            return function (...args) {
-	                let wrapper = wrapperRegistry.get(original);
-	                if (!wrapper) {
-	                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
-	                        return original.call(that, ...args);
-	                    }), {
-	                        method: original,
-	                        propertyKey: name,
-	                    });
-	                    const origRoot = original[rootFunctionSymbol];
-	                    if (origRoot)
-	                        wrapper[rootFunctionSymbol] = origRoot;
-	                    wrapperRegistry.set(original, wrapper);
-	                }
-	                const memoized = memoizeFunction(wrapper, memoizeOpts);
-	                return memoized(this, ...args);
-	            };
-	        },
-	        default: (target) => typeof target === 'object'
-	            ? memoizeObject(target, memoizeOpts)
-	            : memoizeFunction(target, memoizeOpts),
-	    });
-	}
-	const memoize = flavored(makeMemoizeDecorator(), {
-	    get lenient() {
-	        return makeMemoizeDecorator({ lenient: true });
-	    },
-	});
-
-	const nonReactiveObjects = new WeakSet();
-	const nonReactiveClasses = new WeakSet();
-	const unreactiveProps = new WeakMap();
-	let unreactivePropsCount = 0;
-	function addUnreactiveProps(proto, set) {
-	    unreactiveProps.set(proto, set);
-	    unreactivePropsCount++;
-	}
-	/** Check if a property is marked unreactive on obj or any of its prototypes (trap-free) */
-	function isUnreactiveProp(obj, prop) {
-	    if (!unreactivePropsCount)
-	        return false;
-	    let target = obj;
-	    while (target) {
-	        if (unreactiveProps.get(target)?.has(prop))
-	            return true;
-	        target = Object.getPrototypeOf(target);
-	    }
-	    return false;
-	}
-	const immutables = new Set();
-	const absent = Symbol('absent');
-	function markNonReactive(...obj) {
-	    for (const o of obj)
-	        nonReactiveObjects.add(o);
-	    return obj[0];
+	    return obj[0];
 	}
 	function nonReactiveClass(...cls) {
 	    for (const c of cls)
 	        if (c)
-	            nonReactiveClasses.add(c.prototype);
+	            c.prototype[unreactiveProperties] = true;
 	    return cls[0];
 	}
 	function isNonReactive(obj) {
-	    if (obj === null || typeof obj !== 'object')
-	        return true;
-	    if (nonReactiveObjects.has(obj))
-	        return true;
-	    // Walk the prototype chain on the raw object to check for non-reactive classes
-	    let proto = Object.getPrototypeOf(obj);
-	    while (proto) {
-	        if (nonReactiveClasses.has(proto))
-	            return true;
-	        proto = Object.getPrototypeOf(proto);
-	    }
-	    for (const fn of immutables)
-	        if (fn(obj))
-	            return true;
-	    return false;
+	    return !obj || obj[unreactiveProperties] === true;
 	}
 	nonReactiveClass(Date, RegExp, Error, Promise, Function);
 	if (typeof window !== 'undefined') {
-	    markNonReactive(window, document);
+	    nonReactive(window, document);
 	    nonReactiveClass(Node, Element, HTMLElement, EventTarget, HTMLCollection, NodeList);
 	}
 
@@ -4374,10 +4197,33 @@
 	    if ((typeof oldValue !== 'object' && !Array.isArray(oldValue)) ||
 	        (typeof newValue !== 'object' && !Array.isArray(newValue)))
 	        return false;
-	    if (isNonReactive(oldValue) || isNonReactive(newValue))
+	    if (isNonReactive(oldValue) /*|| isNonReactive(newValue)*/)
 	        return false;
 	    return getPrototypeToken(oldValue) === getPrototypeToken(newValue);
 	}
+	/**
+	 * Migrate all watcher registrations from oldRef to newRef.
+	 * Called when deep touch replaces an object identity without any child value differences,
+	 * to prevent watcher orphaning (effects still pointing at the discarded old object).
+	 */
+	function migrateWatchers(oldRef, newRef) {
+	    const oldMap = watchers.get(oldRef);
+	    if (!oldMap)
+	        return;
+	    // Move the entire watcher map
+	    watchers.set(newRef, oldMap);
+	    watchers.delete(oldRef);
+	    // Update the reverse map (effect → objects it watches)
+	    for (const deps of oldMap.values()) {
+	        for (const effect of deps) {
+	            const objects = effectToReactiveObjects.get(effect);
+	            if (objects) {
+	                objects.delete(oldRef);
+	                objects.add(newRef);
+	            }
+	        }
+	    }
+	}
 	/**
 	 * Centralized function to handle property change notifications with optional recursive touch
 	 * @param targetObj - The object whose property changed
@@ -4395,7 +4241,15 @@
 	        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
-	        dispatchNotifications(untracked(() => recursiveTouch(oldValue, newValue, new WeakMap(), [], origin)));
+	        const changes = untracked(() => 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) {
+	            migrateWatchers(unwrap(oldValue), unwrap(newValue));
+	        }
+	        else {
+	            dispatchNotifications(changes);
+	        }
 	        // Notify opaque listeners (like memoize) that always want to know about identity changes
 	        touchedOpaque(targetObj, evolution, prop);
 	    }
@@ -4482,12 +4336,11 @@
 	    for (const key of oldKeys)
 	        if (!newKeys.has(key))
 	            local.push({ target: oldObj, evolution: { type: 'del', prop: key }, prop: key, origin });
-	    for (const key of newKeys)
-	        if (!oldKeys.has(key))
-	            local.push({ target: oldObj, evolution: { type: 'add', prop: key }, prop: key, origin });
 	    for (const key of newKeys) {
-	        if (!oldKeys.has(key))
+	        if (!oldKeys.has(key)) {
+	            local.push({ target: oldObj, evolution: { type: 'add', prop: key }, prop: key, origin });
 	            continue;
+	        }
 	        const oldEntry = unwrap(oldObj[key]);
 	        const newEntry = unwrap(newObj[key]);
 	        if (shouldRecurseTouch(oldEntry, newEntry)) {
@@ -4529,11 +4382,10 @@
 	        if (originWatchers) {
 	            const originEffects = new Map();
 	            collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, [allProps], [origin.prop]);
-	            for (const effect of originEffects.keys())
-	                allowedEffects.add(effect);
+	            allowedEffects = new Set(originEffects.keys());
 	        }
 	        // If no allowed effects, skip all notifications (no one should be notified)
-	        if (allowedEffects.size === 0)
+	        if (!allowedEffects?.size)
 	            return;
 	    }
 	    for (const notification of notifications) {
@@ -4546,7 +4398,6 @@
 	        let currentEffects;
 	        const propsArray = [prop];
 	        if (objectWatchers) {
-	            // console.log(`[DEBUG] dispatchNotifications: processing ${obj.constructor.name} (has watchers)`)
 	            currentEffects = new Map();
 	            const broad = evolution.type !== 'set' ? [allProps, keysOf] : [allProps];
 	            collectEffects(obj, evolution, currentEffects, objectWatchers, broad, propsArray);
@@ -4582,9 +4433,9 @@
 	        if (options.introspection?.gatherReasons) {
 	            const gatherReasons = options.introspection.gatherReasons;
 	            const lineageConfig = gatherReasons.lineages;
-	            let touchStack;
+	            let touchLineage;
 	            if (lineageConfig === 'touch' || lineageConfig === 'both') {
-	                touchStack = debugHooks.captureLineage();
+	                touchLineage = debugHooks.captureLineage();
 	            }
 	            for (const effect of combinedEffects) {
 	                const node = getEffectNode(effect);
@@ -4598,7 +4449,7 @@
 	                        obj: unwrap(target),
 	                        evolution,
 	                        dependency: dependencyStack,
-	                        touch: touchStack,
+	                        touch: touchLineage,
 	                    });
 	                }
 	            }
@@ -4611,11 +4462,16 @@
 	const wrapProtos = new WeakMap();
 	const arrayLengths = new WeakMap();
 	const hasReentry = new Set();
-	const subsRegister = new WeakMap();
 	// Sub-proxy registration for custom reactive behaviors
+	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;
 	const reactiveHandlers = {
 	    [Symbol.toStringTag]: 'MutTs Reactive',
 	    get(obj, prop, receiver) {
+	        if (internalUntracked)
+	            return FoolProof.get(obj, prop, receiver);
 	        if (obj && typeof obj === 'object' && prop !== Symbol.toStringTag) {
 	            const metaProto = metaProtos.get(obj.constructor);
 	            if (metaProto && Object.hasOwn(metaProto, prop)) {
@@ -4635,15 +4491,21 @@
 	            if (wrapProto && Object.hasOwn(wrapProto, prop))
 	                return wrapProto[prop];
 	        }
-	        // Symbols: fast-path — no reactivity tracking, no unreactive check needed
-	        if (typeof prop === 'symbol')
-	            return FoolProof.get(obj, prop, receiver);
-	        // Check if this property is marked as unreactive (WeakMap lookup — no proxy traps)
-	        if (isUnreactiveProp(obj, prop))
+	        // Symbols: fast-path — no reactivity tracking
+	        if (typeof prop === 'symbol' || prop === 'constructor' || isUnreactiveProp(obj, prop))
 	            return FoolProof.get(obj, prop, receiver);
 	        // 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);
+	        // For accessor properties, check the unwrapped object to see if it's an accessor
+	        // This ensures ignoreAccessors works correctly even after operations like Object.setPrototypeOf
+	        // Skip for null-proto objects (pounce scopes) — they never have accessors
+	        const shouldIgnoreAccessor = options.ignoreAccessors &&
+	            isOwnProp &&
+	            Object.getPrototypeOf(obj) !== null &&
+	            (isOwnAccessor(receiver, prop) || isOwnAccessor(obj, prop));
+	        // Check if property exists using a trap-free walk to avoid triggering
+	        // the has-trap cascade on prototype chains of reactive proxies.
 	        let hasProp = isOwnProp;
 	        let owner = isOwnProp ? obj : undefined;
 	        if (!isOwnProp) {
@@ -4658,29 +4520,20 @@
 	            }
 	        }
 	        const isInheritedAccess = hasProp && !isOwnProp;
-	        // For accessor properties, check the unwrapped object to see if it's an accessor
-	        // This ensures ignoreAccessors works correctly even after operations like Object.setPrototypeOf
-	        // Skip for null-proto objects (pounce scopes) — they never have accessors
-	        const shouldIgnoreAccessor = options.ignoreAccessors &&
-	            isOwnProp &&
-	            Object.getPrototypeOf(obj) !== null &&
-	            (isOwnAccessor(receiver, prop) || isOwnAccessor(obj, prop));
 	        // Depend if...
 	        if (!hasProp ||
 	            (!(options.instanceMembers && isInheritedAccess && obj instanceof Object) &&
 	                !shouldIgnoreAccessor))
 	            dependant(obj, prop);
-	        // Two-Point Tracking: for inherited access on null-proto chains, only track
-	        // the owning ancestor — not every intermediate level.  This relies on the
-	        // "structural stability" contract: key presence in the chain is fixed at
-	        // creation time, so intermediate levels never gain/lose shadowing properties.
+	        // Two-Point Tracking: for inherited access on null-proto chains, also track
+	        // the owning ancestor so that writing directly to it triggers dependent effects.
 	        if (isInheritedAccess && owner && (!options.instanceMembers || !(obj instanceof Object))) {
 	            dependant(owner, prop);
 	        }
 	        // 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 (typeof value === 'object' && value !== null) {
+	        if (!isReactive(value) && typeof value === 'object' && value !== null) {
 	            const reactiveValue = reactiveObject(value);
 	            // Only create back-references if this object needs them
 	            if (needsBackReferences(obj)) {
@@ -4691,9 +4544,19 @@
 	        return value;
 	    },
 	    set(obj, prop, value, receiver) {
-	        const unwrappedReceiver = unwrap(receiver);
+	        const unwrapped = unwrap(receiver);
+	        if (obj !== unwrapped)
+	            return Object.defineProperty(unwrapped, prop, {
+	                value,
+	                configurable: true,
+	                writable: true,
+	                enumerable: true,
+	            });
+	        if (internalUntracked)
+	            throw new Error('Internal untracked: setting a value in an getter in a set operation');
+	        //return FoolProof.set(obj, prop, value, receiver)
 	        // Check if this property is marked as unreactive
-	        if (isUnreactiveProp(obj, prop) || obj !== unwrappedReceiver)
+	        if (isUnreactiveProp(obj, prop))
 	            return FoolProof.set(obj, prop, value, receiver);
 	        const newValue = unwrap(value);
 	        // metaProto setter dispatch (e.g., reactive array length)
@@ -4710,16 +4573,19 @@
 	        // Read old value, using withEffect(undefined, ...) for getter-only accessors to avoid
 	        // breaking memoization dependency tracking during SET operations
 	        let oldVal = absent;
-	        // TODO: Pffft... Find a way to "generalize" this case?
 	        const isArrayLength = prop === 'length' && Array.isArray(obj);
-	        if (Reflect.has(unwrappedReceiver, prop)) {
-	            // We *need* to use `receiver` and not `obj` here, otherwise we break
-	            // the dependency tracking for memoized getters
-	            oldVal = isArrayLength
-	                ? arrayLengths.get(obj) === newValue
-	                    ? newValue
-	                    : absent
-	                : untracked(() => Reflect.get(obj, prop, receiver));
+	        internalUntracked = true;
+	        try {
+	            if (Reflect.has(obj, prop)) {
+	                oldVal = isArrayLength
+	                    ? arrayLengths.get(obj) === newValue
+	                        ? newValue
+	                        : absent
+	                    : Reflect.get(obj, prop, receiver);
+	            }
+	        }
+	        finally {
+	            internalUntracked = false;
 	        }
 	        if (objectsWithDeepWatchers.has(obj)) {
 	            if (typeof oldVal === 'object' && oldVal !== null) {
@@ -4748,7 +4614,8 @@
 	                cycle: [], // We don't have the full cycle here, but we know it involves obj
 	            });
 	        hasReentry.add(obj);
-	        dependant(obj, prop);
+	        if (!internalUntracked && !isUnreactiveProp(obj, prop))
+	            dependant(obj, prop);
 	        const rv = (subsRegister.get(obj)?.has || Reflect.has)(obj, prop);
 	        hasReentry.delete(obj);
 	        return rv;
@@ -4774,7 +4641,8 @@
 	        return subsRegister.get(obj)?.ownKeys?.(obj) || Reflect.ownKeys(obj);
 	    },
 	    getOwnPropertyDescriptor(obj, prop) {
-	        return subsRegister.get(obj)?.getOwnPropertyDescriptor?.(obj, prop) || Reflect.getOwnPropertyDescriptor(obj, prop);
+	        return (subsRegister.get(obj)?.getOwnPropertyDescriptor?.(obj, prop) ||
+	            Reflect.getOwnPropertyDescriptor(obj, prop));
 	    },
 	};
 	const reactiveClasses = new WeakSet();
@@ -4860,14 +4728,14 @@
 	                    ? () => source.values()
 	                    : () => Object.keys(source);
 	    const keyEffects = new Map();
-	    const outer = effect(({ ascend }) => {
+	    const outer = effect.named('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(() => callback(key))));
+	            keyEffects.set(key, ascend(() => effect.named(`attend:${key}`)((access) => callback(key, access))));
 	        }
 	        for (const key of Array.from(keyEffects.keys())) {
 	            if (!keys.has(key)) {
@@ -4883,146 +4751,10 @@
 	        keyEffects.clear();
 	    };
 	}
-	/**
-	 * Perform a reactive scan over an array of items.
-	 *
-	 * This implementation is highly optimized for performance and fine-grained reactivity:
-	 * - **Incremental Updates**: Changes to an item only trigger re-computation from that
-	 *   point onwards in the result chain.
-	 * - **Move Optimization**: If items are moved within the array, their accumulated
-	 *   values are reused as long as their predecessor remains the same.
-	 * - **Duplicate Support**: Correctly handles multiple occurrences of the same object
-	 *   instance using an internal occurrence tracking mechanism.
-	 * - **Memory Efficient**: Uses `WeakMap` for caching intermediates, which are
-	 *   automatically cleared when source items are garbage collected.
-	 *
-	 * @example
-	 * ```typescript
-	 * const source = reactive([{ val: 1 }, { val: 2 }, { val: 3 }])
-	 * const sum = scan(source, (acc, item) => acc + item.val, 0)
-	 *
-	 * expect([...sum]).toEqual([1, 3, 6])
-	 *
-	 * // Modifying an item only re-computes subsequent sums
-	 * source[1].val = 10
-	 * expect([...sum]).toEqual([1, 11, 14])
-	 * ```
-	 *
-	 * @param source The source array of objects (will be made reactive)
-	 * @param callback The accumulator function called with (accumulator, currentItem)
-	 * @param initialValue The starting value for the accumulation
-	 * @returns A reactive array of accumulated values, with a [cleanup] property to stop the tracking
-	 */
-	function scan(source, callback, initialValue) {
-	    const observedSource = reactive(source);
-	    const rawResult = [];
-	    const result = reactive(rawResult);
-	    // Track effects for each index to dispose them when the array shrinks
-	    const indexEffects = new Map();
-	    // Mapping from index to its current intermediate object
-	    const indexToIntermediate = reactive([]);
-	    const intermediaries = new WeakMap();
-	    let Intermediate = (() => {
-	        var _a;
-	        let _instanceExtraInitializers = [];
-	        let _get_acc_decorators;
-	        return _a = class Intermediate {
-	                constructor(val, prev) {
-	                    this.val = (__runInitializers(this, _instanceExtraInitializers), val);
-	                    this.prev = prev;
-	                }
-	                get acc() {
-	                    const prevAcc = this.prev ? this.prev.acc : initialValue;
-	                    return callback(prevAcc, this.val);
-	                }
-	            },
-	            (() => {
-	                const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-	                _get_acc_decorators = [memoize];
-	                __esDecorate(_a, null, _get_acc_decorators, { kind: "getter", name: "acc", static: false, private: false, access: { has: obj => "acc" in obj, get: obj => obj.acc }, metadata: _metadata }, null, _instanceExtraInitializers);
-	                if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-	            })(),
-	            _a;
-	    })();
-	    function disposeIndex(index) {
-	        const stop = indexEffects.get(index);
-	        if (stop) {
-	            stop();
-	            indexEffects.delete(index);
-	            Reflect.deleteProperty(indexToIntermediate, index);
-	            Reflect.deleteProperty(result, index);
-	        }
-	    }
-	    const mainEffect = effect(function scanMainEffect({ ascend }) {
-	        const length = observedSource.length;
-	        const occurrenceCount = new Map();
-	        let prev;
-	        for (let i = 0; i < length; i++)
-	            if (i in observedSource) {
-	                const val = observedSource[i];
-	                if (!(val &&
-	                    (typeof val === 'object' || typeof val === 'function' || typeof val === 'symbol'))) {
-	                    throw new Error('scan: items must be objects (WeakKey) for intermediate caching');
-	                }
-	                const count = occurrenceCount.get(val) ?? 0;
-	                occurrenceCount.set(val, count + 1);
-	                let list = intermediaries.get(val);
-	                if (!list) {
-	                    list = [];
-	                    intermediaries.set(val, list);
-	                }
-	                let intermediate = list[count];
-	                if (!intermediate) {
-	                    intermediate = reactive(new Intermediate(val, prev));
-	                    list[count] = intermediate;
-	                }
-	                else {
-	                    // Update the link.
-	                    if (untracked(() => intermediate.prev) !== prev) {
-	                        intermediate.prev = prev;
-	                    }
-	                }
-	                // Update the reactive mapping for this index
-	                if (indexToIntermediate[i] !== intermediate) {
-	                    indexToIntermediate[i] = intermediate;
-	                }
-	                // If we don't have an effect for this index yet, create one
-	                if (!indexEffects.has(i)) {
-	                    ascend(() => {
-	                        const index = i;
-	                        const stop = effect(function scanIndexSyncEffect() {
-	                            const inter = indexToIntermediate[index];
-	                            if (inter) {
-	                                const accValue = inter.acc;
-	                                result[index] = accValue;
-	                            }
-	                        });
-	                        indexEffects.set(index, stop);
-	                    });
-	                }
-	                prev = intermediate;
-	            }
-	        // Cleanup trailing indices
-	        for (const index of Array.from(indexEffects.keys())) {
-	            if (index >= length)
-	                disposeIndex(index);
-	        }
-	        // Ensure result length matches source length
-	        if (rawResult.length !== length) {
-	            FoolProof.set(result, 'length', length, result);
-	        }
-	    });
-	    return cleanedBy(result, ((reason) => {
-	        mainEffect(reason);
-	        for (const stop of indexEffects.values())
-	            stop(reason);
-	        indexEffects.clear();
-	    }));
-	}
 	function lift(cb) {
 	    let result;
 	    let rawResult;
-	    const liftCleanup = effect.named('lift')(markWithRoot((access) => {
+	    const liftCleanup = effect.named(`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');
@@ -5035,11 +4767,8 @@
 	            throw new Error('lift callback must return the same type as the previous result');
 	        if (Array.isArray(source)) {
 	            const res = result;
-	            const patches = arrayDiff(res, source);
-	            for (let i = patches.length - 1; i >= 0; i--) {
-	                const { indexA, sliceA, sliceB } = patches[i];
+	            for (const { indexA, sliceA, sliceB } of arrayDiff(res, source).sort((a, b) => a.indexA - b.indexA))
 	                res.splice(indexA, sliceA.length, ...sliceB);
-	            }
 	        }
 	        else {
 	            for (const key of Object.keys(source)) {
@@ -5066,7 +4795,7 @@
 	                }
 	        }
 	    }, cb));
-	    return cleanedBy(result, liftCleanup);
+	    return link(result, liftCleanup);
 	}
 	/**
 	 * Reactively maps an array source through `fn`, producing a lazy reactive output array.
@@ -5087,7 +4816,7 @@
 	 */
 	function morphArray(source, fn, options) {
 	    if (typeof source !== 'function' && !isReactive(source) && options?.pure === true) {
-	        return source.map(fn);
+	        return source.map((i) => fn(i));
 	    }
 	    let track;
 	    const itemEffects = new Map();
@@ -5109,17 +4838,14 @@
 	        }
 	        else {
 	            const indexRef = { value: key };
-	            let stop;
-	            track(() => {
-	                stop = effect.opaque(() => {
-	                    cache[indexRef.value] = fn(input);
-	                    return (reason) => {
-	                        delete cache[indexRef.value];
-	                        touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-	                        stop({ type: 'invalidate', cause: reason });
-	                    };
-	                });
-	            });
+	            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((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 });
+	                };
+	            }));
 	            itemEffects.set(key, { stop, index: indexRef });
 	        }
 	    }
@@ -5136,7 +4862,7 @@
 	            return Reflect.has(input, prop);
 	        },
 	    });
-	    const stopMain = effect.named('morph:array')(({ ascend }) => {
+	    const stopMain = effect.named(`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);
@@ -5151,7 +4877,7 @@
 	                    // We need to move entries in the Map.
 	                    const entries = Array.from(itemEffects.entries()).sort((a, b) => a[0] - b[0]);
 	                    // Remove entries that will be shifted
-	                    for (const [idx, entry] of entries) {
+	                    for (const [idx, _entry] of entries) {
 	                        if (idx >= diff.indexA + diff.sliceA.length) {
 	                            itemEffects.delete(idx);
 	                        }
@@ -5183,7 +4909,7 @@
 	        }
 	        input = newInput;
 	    });
-	    return cleanedBy(proxy, (reason) => {
+	    return link(proxy, (reason) => {
 	        stopMain(reason);
 	        for (const entry of itemEffects.values())
 	            entry.stop(reason);
@@ -5205,7 +4931,7 @@
 	    if (!isReactive(source) && options?.pure === true) {
 	        const res = new Map();
 	        for (const [k, v] of source)
-	            res.set(k, fn(v));
+	            res.set(k, fn(v, k));
 	        return res;
 	    }
 	    let track;
@@ -5222,15 +4948,15 @@
 	    function computeItem(key, val) {
 	        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
 	        if (isPure) {
-	            cache.set(key, track(() => fn(val)));
+	            cache.set(key, track(() => fn(val, key)));
 	        }
 	        else {
-	            const stop = track(() => effect.opaque(() => {
-	                cache.set(key, fn(source.get(key)));
+	            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+	                cache.set(key, fn(source.get(key), key, access));
 	                return (reason) => {
 	                    cache.delete(key);
 	                    touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-	                    stop({ type: 'invalidate', cause: reason });
+	                    stop?.({ type: 'invalidate', cause: reason });
 	                };
 	            }));
 	            itemEffects.set(key, stop);
@@ -5274,7 +5000,7 @@
 	        },
 	    });
 	    let stateSnapshot = getState(source);
-	    const stopMain = effect.named('morph:map')(({ ascend }) => {
+	    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
 	        track = ascend;
 	        dependant(source, keysOf);
 	        while ('evolution' in stateSnapshot) {
@@ -5290,7 +5016,7 @@
 	            }
 	        }
 	    });
-	    return cleanedBy(proxy, (reason) => {
+	    return link(proxy, (reason) => {
 	        stopMain(reason);
 	        for (const stop of itemEffects.values())
 	            stop(reason);
@@ -5312,7 +5038,7 @@
 	    if (!isReactive(source) && options?.pure === true) {
 	        const res = {};
 	        for (const k of Object.keys(source))
-	            res[k] = fn(source[k]);
+	            res[k] = fn(source[k], k);
 	        return res;
 	    }
 	    let track;
@@ -5328,15 +5054,15 @@
 	    function computeItem(key, val) {
 	        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
 	        if (isPure) {
-	            cache[key] = track(() => fn(val));
+	            cache[key] = track(() => fn(val, key));
 	        }
 	        else {
-	            const stop = track(() => effect.opaque(() => {
-	                cache[key] = fn(source[key]);
+	            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((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 });
+	                    stop?.({ type: 'invalidate', cause: reason });
 	                };
 	            }));
 	            itemEffects.set(key, stop);
@@ -5363,7 +5089,7 @@
 	        },
 	    });
 	    let stateSnapshot = getState(source);
-	    const stopMain = effect.named('morph:record')(({ ascend }) => {
+	    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
 	        track = ascend;
 	        // Track only structural changes on source
 	        dependant(source, keysOf);
@@ -5380,7 +5106,7 @@
 	            }
 	        }
 	    });
-	    return cleanedBy(proxy, (reason) => {
+	    return link(proxy, (reason) => {
 	        stopMain(reason);
 	        for (const stop of itemEffects.values())
 	            stop(reason);
@@ -5439,7 +5165,7 @@
 	    const wrappedCallback = markWithRoot((() => callback(target)), callback);
 	    registerDeepWatcher();
 	    // Use the existing effect system to register dependencies
-	    return effect(() => {
+	    return effect.named('deepWatch')(() => {
 	        // Mark the target object as having deep watchers
 	        objectsWithDeepWatchers.add(target);
 	        // Track which objects this effect is watching for cleanup
@@ -5475,77 +5201,271 @@
 	                }
 	            }
 	            // Also handle array indices and length
-	            // biome-ignore lint/suspicious/useIsArray: Check for both native arrays and reactive arrays
-	            if (Array.isArray(obj) || obj instanceof Array) {
-	                // Access array length to register dependency on length changes
-	                const length = obj.length;
-	                // Access all current array elements to register dependencies
-	                for (let i = 0; i < length; i++) {
-	                    // Access the array element to register dependency
-	                    const value = obj[i];
+	            // Handle arrays and collections using iterators to ensure proxy tracking is triggered
+	            if (typeof obj[Symbol.iterator] === 'function') {
+	                // Access the iterator to track additions/removals/collection changes
+	                for (const value of obj) {
 	                    // Make the value reactive if it's an object
 	                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
 	                    traverseAndTrack(reactiveValue, depth + 1);
 	                }
+	                // Explicitly depend on length so array mutations changing count trigger re-evaluation
+	                if ('length' in obj) {
+	                    dependant(obj, 'length');
+	                }
+	                // For Maps, also ensure we track values explicitly if the iterator yields entries
+	                if (obj instanceof Map) {
+	                    for (const value of obj.values()) {
+	                        const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
+	                        traverseAndTrack(reactiveValue, depth + 1);
+	                    }
+	                }
 	            }
-	            // Handle Set values (deep watch values only, not keys since Sets don't have separate keys)
-	            else if (obj instanceof Set) {
-	                // Access all Set values to register dependencies
-	                for (const value of obj) {
-	                    // Make the value reactive if it's an object
-	                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
-	                    traverseAndTrack(reactiveValue, depth + 1);
+	            // Note: WeakSet and WeakMap cannot be iterated, so we can't deep watch their contents
+	            // They will only trigger when the collection itself is replaced
+	        }
+	        // Traverse the target object to register all dependencies
+	        // This will register dependencies on all current properties and array elements
+	        traverseAndTrack(target);
+	        // Only call the callback if immediate is true or if it's not the first run
+	        if (immediate) {
+	            untracked(() => callback(target));
+	        }
+	        immediate = true;
+	        // Return a cleanup function that properly removes deep watcher tracking
+	        return () => {
+	            // Get the objects this effect was watching
+	            const effectObjects = effectToDeepWatchedObjects.get(wrappedCallback);
+	            if (effectObjects) {
+	                // Remove deep watcher tracking from all objects this effect was watching
+	                for (const obj of effectObjects) {
+	                    // Check if this object still has other deep watchers
+	                    const watchers = deepWatchers.get(obj);
+	                    if (watchers) {
+	                        // Remove this effect's callback from the watchers
+	                        watchers.delete(wrappedCallback);
+	                        // If no more watchers, remove the object from deep watchers tracking
+	                        if (watchers.size === 0) {
+	                            deepWatchers.delete(obj);
+	                            objectsWithDeepWatchers.delete(obj);
+	                        }
+	                    }
+	                    else {
+	                        // No watchers found, remove from deep watchers tracking
+	                        objectsWithDeepWatchers.delete(obj);
+	                    }
+	                }
+	                // Clean up the tracking data
+	                effectToDeepWatchedObjects.delete(wrappedCallback);
+	            }
+	        };
+	    });
+	}
+
+	const memoizedRegistry = new WeakMap();
+	const wrapperRegistry = new WeakMap();
+	function getBranch(tree, key) {
+	    tree.branches ?? (tree.branches = new WeakMap());
+	    let branch = tree.branches.get(key);
+	    if (!branch) {
+	        branch = {};
+	        tree.branches.set(key, branch);
+	    }
+	    return branch;
+	}
+	function memoizeFunction(fn, opts) {
+	    const fnRoot = getRoot(fn);
+	    const existing = memoizedRegistry.get(fnRoot);
+	    if (existing)
+	        return existing;
+	    const cacheRoot = {};
+	    const memoized = markWithRoot(function memoized(...args) {
+	        if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
+	            if (opts?.lenient)
+	                return fn.apply(this, args);
+	            throw new Error('memoize expects non-null object arguments');
+	        }
+	        let node = cacheRoot;
+	        // Note: decorators add `this` as first argument
+	        for (const arg of args) {
+	            node = getBranch(node, arg);
+	        }
+	        dependant(node, 'memoize');
+	        if ('result' in node) {
+	            if (options.onMemoizationDiscrepancy) {
+	                const wasVerification = options.isVerificationRun;
+	                options.isVerificationRun = true;
+	                try {
+	                    const fresh = untracked(() => fn.apply(this, args));
+	                    if (!deepCompare(node.result, fresh)) {
+	                        optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
+	                    }
+	                }
+	                finally {
+	                    options.isVerificationRun = wasVerification;
+	                }
+	            }
+	            return node.result;
+	        }
+	        // Create memoize internal effect to track dependencies and invalidate cache
+	        // Use untracked to prevent the effect creation from being affected by parent effects
+	        node.cleanup = root(() => effect.named('memoize')(() => {
+	            // Execute the function and track its dependencies
+	            // The function execution will automatically track dependencies on reactive objects
+	            node.result = fn.apply(this, args);
+	            return (reason) => {
+	                // When dependencies change, clear the cache and notify consumers
+	                delete node.result;
+	                touched1(node, { type: 'invalidate', prop: args }, 'memoize');
+	                // Lazy memoization: stop the effect so it doesn't re-run immediately.
+	                // It will be re-created on next access.
+	                if (node.cleanup) {
+	                    node.cleanup({ type: 'invalidate', cause: reason });
+	                    node.cleanup = undefined;
+	                }
+	            };
+	        }, { opaque: true }));
+	        if (options.onMemoizationDiscrepancy) {
+	            const wasVerification = options.isVerificationRun;
+	            options.isVerificationRun = true;
+	            try {
+	                const fresh = untracked(() => fn.apply(this, args));
+	                if (!deepCompare(node.result, fresh)) {
+	                    optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
 	                }
 	            }
-	            // Handle Map values (deep watch values only, not keys)
-	            else if (obj instanceof Map) {
-	                // Access all Map values to register dependencies
-	                for (const [_key, value] of obj) {
-	                    // Make the value reactive if it's an object
-	                    const reactiveValue = typeof value === 'object' && value !== null ? reactive(value) : value;
-	                    traverseAndTrack(reactiveValue, depth + 1);
+	            finally {
+	                options.isVerificationRun = wasVerification;
+	            }
+	        }
+	        return node.result;
+	    }, fn);
+	    memoizedRegistry.set(fnRoot, memoized);
+	    memoizedRegistry.set(memoized, memoized);
+	    return memoized;
+	}
+	function memoizeObject(target, opts) {
+	    const existing = memoizedRegistry.get(target);
+	    if (existing)
+	        return existing;
+	    const proxy = new Proxy(target, {
+	        get(source, prop, receiver) {
+	            // 1. Walk prototype chain to find descriptor
+	            let current = source;
+	            let desc;
+	            while (current) {
+	                desc = Object.getOwnPropertyDescriptor(current, prop);
+	                if (desc)
+	                    break;
+	                current = Object.getPrototypeOf(current);
+	            }
+	            if (!desc)
+	                return Reflect.get(source, prop, receiver);
+	            // 2. If getter, memoize
+	            if (desc.get) {
+	                const originalGetter = desc.get;
+	                let wrapper = wrapperRegistry.get(originalGetter);
+	                if (!wrapper) {
+	                    wrapper = markWithRoot(named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
+	                        return originalGetter.call(that);
+	                    }), {
+	                        propertyKey: prop,
+	                    });
+	                    const origRoot = originalGetter[rootFunctionSymbol];
+	                    if (origRoot)
+	                        wrapper[rootFunctionSymbol] = origRoot;
+	                    wrapperRegistry.set(originalGetter, wrapper);
 	                }
+	                const memoized = memoizeFunction(wrapper, opts);
+	                return memoized(receiver);
 	            }
-	            // Note: WeakSet and WeakMap cannot be iterated, so we can't deep watch their contents
-	            // They will only trigger when the collection itself is replaced
-	        }
-	        // Traverse the target object to register all dependencies
-	        // This will register dependencies on all current properties and array elements
-	        traverseAndTrack(target);
-	        // Only call the callback if immediate is true or if it's not the first run
-	        if (immediate) {
-	            untracked(() => callback(target));
-	        }
-	        immediate = true;
-	        // Return a cleanup function that properly removes deep watcher tracking
-	        return () => {
-	            // Get the objects this effect was watching
-	            const effectObjects = effectToDeepWatchedObjects.get(wrappedCallback);
-	            if (effectObjects) {
-	                // Remove deep watcher tracking from all objects this effect was watching
-	                for (const obj of effectObjects) {
-	                    // Check if this object still has other deep watchers
-	                    const watchers = deepWatchers.get(obj);
-	                    if (watchers) {
-	                        // Remove this effect's callback from the watchers
-	                        watchers.delete(wrappedCallback);
-	                        // If no more watchers, remove the object from deep watchers tracking
-	                        if (watchers.size === 0) {
-	                            deepWatchers.delete(obj);
-	                            objectsWithDeepWatchers.delete(obj);
-	                        }
-	                    }
-	                    else {
-	                        // No watchers found, remove from deep watchers tracking
-	                        objectsWithDeepWatchers.delete(obj);
-	                    }
+	            // 3. Otherwise forward
+	            return Reflect.get(source, prop, receiver);
+	        },
+	        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
+	        set(source, prop, value, _receiver) {
+	            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
+	            // it recognizes itself and triggers change notifications.
+	            return Reflect.set(source, prop, value, source);
+	        },
+	    });
+	    proxyToObject.set(proxy, target);
+	    memoizedRegistry.set(target, proxy);
+	    return proxy;
+	}
+	/**
+	 * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
+	 *
+	 * When used as a decorator on getters or methods, it caches the result and automatically
+	 * invalidates the cache when reactive dependencies change.
+	 *
+	 * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
+	 *
+	 * @example
+	 * ```typescript
+	 * class User {
+	 *   @memoize
+	 *   get fullName() {
+	 *     return `${this.firstName} ${this.lastName}`
+	 *   }
+	 * }
+	 *
+	 * // Or as a function wrapper
+	 * const expensive = memoize((obj: SomeObject) => {
+	 *   return heavyComputation(obj)
+	 * })
+	 * ```
+	 */
+	function makeMemoizeDecorator(memoizeOpts) {
+	    return decorator({
+	        getter(original, target, propertyKey) {
+	            return function () {
+	                let wrapper = wrapperRegistry.get(original);
+	                if (!wrapper) {
+	                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
+	                        return original.call(that);
+	                    }), {
+	                        method: original,
+	                        propertyKey,
+	                    });
+	                    const origRoot = original[rootFunctionSymbol];
+	                    if (origRoot)
+	                        wrapper[rootFunctionSymbol] = origRoot;
+	                    wrapperRegistry.set(original, wrapper);
 	                }
-	                // Clean up the tracking data
-	                effectToDeepWatchedObjects.delete(wrappedCallback);
-	            }
-	        };
+	                const memoized = memoizeFunction(wrapper, memoizeOpts);
+	                return memoized(this);
+	            };
+	        },
+	        method(original, target, name) {
+	            return function (...args) {
+	                let wrapper = wrapperRegistry.get(original);
+	                if (!wrapper) {
+	                    wrapper = markWithRoot(named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
+	                        return original.call(that, ...args);
+	                    }), {
+	                        method: original,
+	                        propertyKey: name,
+	                    });
+	                    const origRoot = original[rootFunctionSymbol];
+	                    if (origRoot)
+	                        wrapper[rootFunctionSymbol] = origRoot;
+	                    wrapperRegistry.set(original, wrapper);
+	                }
+	                const memoized = memoizeFunction(wrapper, memoizeOpts);
+	                return memoized(this, ...args);
+	            };
+	        },
+	        default: (target) => typeof target === 'object'
+	            ? memoizeObject(target, memoizeOpts)
+	            : memoizeFunction(target, memoizeOpts),
 	    });
 	}
+	const memoize = flavored(makeMemoizeDecorator(), {
+	    get lenient() {
+	        return makeMemoizeDecorator({ lenient: true });
+	    },
+	});
 
 	/**
 	 * Organizes a source object's properties into a target object using a callback function.
@@ -5621,7 +5541,7 @@
 	        });
 	        return apply(accessBase, target);
 	    });
-	    return cleanedBy(target, (reason) => stop(reason));
+	    return link(target, (reason) => stop(reason));
 	}
 	/**
 	 * Organizes a property on a target object
@@ -5664,7 +5584,7 @@
 	function watchObject(value, changed, { immediate = false, deep = false } = {}) {
 	    if (deep)
 	        return deepWatch(value, changed, { immediate });
-	    return effect(function watchObjectEffect() {
+	    return effect.named('watch:object')(() => {
 	        dependant(value);
 	        if (immediate)
 	            changed(value);
@@ -5674,7 +5594,7 @@
 	function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
 	    let oldValue = unsetYet;
 	    let deepCleanup;
-	    const cbCleanup = effect(markWithRoot(function watchCallBackEffect(access) {
+	    const cbCleanup = effect.named('watch:callback')(markWithRoot((access) => {
 	        const newValue = value(access);
 	        if (oldValue !== newValue) {
 	            const old = oldValue;
@@ -5692,12 +5612,10 @@
 	            deepCleanup = deepWatch(newValue, (value) => changed(value, value));
 	        }
 	    }, value));
-	    return Object.defineProperties(() => {
+	    return (() => {
 	        cbCleanup();
 	        if (deepCleanup)
 	            deepCleanup();
-	    }, {
-	        [stopped]: { get: () => cbCleanup[stopped] },
 	    });
 	}
 	//#endregion
@@ -5712,7 +5630,7 @@
 	function when(predicate, timeout) {
 	    return new Promise((resolve, reject) => {
 	        let timer;
-	        const stop = effect(function whenEffect(access) {
+	        const stop = effect.named('watch:when')((access) => {
 	            try {
 	                const value = predicate(access);
 	                if (value) {
@@ -5749,7 +5667,7 @@
 	    obj = unwrap(obj);
 	    if (isNonReactive(obj))
 	        return obj;
-	    nonReactiveObjects.add(obj);
+	    obj[unreactiveProperties] = true;
 	    return obj;
 	}
 	function unreactiveApplication(arg1, ...args) {
@@ -5757,13 +5675,19 @@
 	        ? shallowNonReactive(arg1)
 	        : ((original) => {
 	            // Copy the parent's unreactive properties if they exist
-	            const parentSet = unreactiveProps.get(original.prototype);
-	            const set = new Set(parentSet || []);
-	            // Add all arguments (including the first one)
-	            set.add(arg1);
-	            for (const arg of args)
-	                set.add(arg);
-	            addUnreactiveProps(original.prototype, set);
+	            const parentMarker = original.prototype[unreactiveProperties];
+	            // If parent is fully unreactive, child is too
+	            if (parentMarker === true) {
+	                original.prototype[unreactiveProperties] = true;
+	            }
+	            else {
+	                const set = new Set(parentMarker || []);
+	                // Add all arguments (including the first one)
+	                set.add(arg1);
+	                for (const arg of args)
+	                    set.add(arg);
+	                addUnreactiveProps(original.prototype, set);
+	            }
 	            return original; // Return the class
 	        });
 	}
@@ -5773,11 +5697,26 @@
 	 */
 	const unreactive = decorator({
 	    class(original) {
-	        // Called without arguments, mark entire class as non-reactive
-	        nonReactiveClass(original);
+	        original.prototype[unreactiveProperties] = true;
 	    },
 	    default: unreactiveApplication,
 	});
+	//#endregion
+	//#region resource
+	function lazyInit(resource, load) {
+	    const creation = effectHistory.active;
+	    let fresh = true;
+	    return new Proxy(resource, {
+	        [Symbol.toStringTag]: 'LazyInit',
+	        get(target, prop) {
+	            if (fresh) {
+	                captured(creation, load)();
+	                fresh = false;
+	            }
+	            return target[prop];
+	        },
+	    });
+	}
 	/**
 	 * Creates a reactive resource that automatically tracks async state.
 	 * @param fetcher - Async function that returns the value. Reactive dependencies are tracked.
@@ -5785,521 +5724,59 @@
 	 * @returns Reactive Resource object with value, loading, error, latest properties
 	 */
 	function resource(fetcher, options = {}) {
-	    const state = reactive({
+	    const resource = reactive({
 	        value: options.initialValue,
 	        loading: true,
 	        error: undefined,
 	        latest: options.initialValue,
-	        reload: () => {
+	        reload() {
 	            reloadSignal.value++;
 	        },
 	    });
 	    const reloadSignal = reactive({ value: 0 });
+	    // Solve race conditions: make sure a new fast request is not overloaded by a slow old one
 	    let counter = 0;
-	    const stop = effect(function resourceEffect(access) {
-	        // Track reload signal to enable manual reloading
-	        if (reloadSignal.value) ;
-	        const id = ++counter;
-	        state.loading = true;
-	        state.error = undefined;
-	        try {
-	            const result = fetcher(access);
-	            if (result instanceof Promise) {
-	                result.then((val) => {
-	                    if (id === counter) {
-	                        state.value = val;
-	                        state.latest = val;
-	                        state.loading = false;
-	                    }
-	                }, (err) => {
-	                    if (id === counter) {
-	                        state.error = err;
-	                        state.loading = false;
-	                    }
-	                });
-	            }
-	            else {
-	                state.value = result;
-	                state.latest = result;
-	                state.loading = false;
-	            }
-	        }
-	        catch (err) {
-	            state.error = err;
-	            state.loading = false;
-	        }
-	    });
-	    state.stop = stop;
-	    return state;
-	}
-	//#endregion
-
-	// Helper to work around TypeScript limitation: base class expressions cannot reference class type parameters
-	function getRegisterBase() {
-	    class RegisterBase extends Indexable(ArrayReadForward, {
-	        get(index) {
-	            return this[getAt](index);
-	        },
-	        set(index, value) {
-	            this[setAt](index, value);
-	        },
-	        getLength() {
-	            return this.length;
-	        },
-	        setLength(value) {
-	            this.length = value;
-	        },
-	    }) {
-	        toArray() {
-	            return Array.from(this);
-	        }
-	    }
-	    return RegisterBase;
-	}
-	let RegisterClass = (() => {
-	    var _RegisterClass_instances, _RegisterClass_keyFn, _RegisterClass_keys, _RegisterClass_values, _RegisterClass_usage, _RegisterClass_valueInfo, _RegisterClass_keyEffects, _RegisterClass_ascend, _RegisterClass_events, _RegisterClass_rekeyValue;
-	    let _classDecorators = [unreactive];
-	    let _classDescriptor;
-	    let _classExtraInitializers = [];
-	    let _classThis;
-	    let _classSuper = getRegisterBase();
-	    _classThis = class extends _classSuper {
-	        get [(_RegisterClass_keyFn = new WeakMap(), _RegisterClass_keys = new WeakMap(), _RegisterClass_values = new WeakMap(), _RegisterClass_usage = new WeakMap(), _RegisterClass_valueInfo = new WeakMap(), _RegisterClass_keyEffects = new WeakMap(), _RegisterClass_ascend = new WeakMap(), _RegisterClass_events = new WeakMap(), _RegisterClass_instances = new WeakSet(), forwardArray)]() {
-	            return this.toArray();
-	        }
-	        on(eventOrEvents, cb) {
-	            // @ts-expect-error Delegate to Eventful
-	            return __classPrivateFieldGet(this, _RegisterClass_events, "f").on(eventOrEvents, cb);
-	        }
-	        off(eventOrEvents, cb) {
-	            // @ts-expect-error Delegate to Eventful
-	            __classPrivateFieldGet(this, _RegisterClass_events, "f").off(eventOrEvents, cb);
-	        }
-	        /**
-	         * Register a global hook that receives all events
-	         */
-	        hook(cb) {
-	            return __classPrivateFieldGet(this, _RegisterClass_events, "f").hook(cb);
-	        }
-	        constructor(keyFn, initial) {
-	            super();
-	            _RegisterClass_instances.add(this);
-	            _RegisterClass_keyFn.set(this, void 0);
-	            _RegisterClass_keys.set(this, void 0);
-	            _RegisterClass_values.set(this, void 0);
-	            _RegisterClass_usage.set(this, new Map());
-	            _RegisterClass_valueInfo.set(this, new Map());
-	            _RegisterClass_keyEffects.set(this, new Set());
-	            _RegisterClass_ascend.set(this, void 0);
-	            _RegisterClass_events.set(this, new Eventful()
-	            /**
-	             * Register event listeners for CRUD operations
-	             */
-	            );
-	            /* Moved below initialization */
-	            let ascendGet;
-	            effect(({ ascend }) => {
-	                ascendGet = ascend;
-	            });
-	            __classPrivateFieldSet(this, _RegisterClass_ascend, ascendGet, "f");
-	            if (typeof keyFn !== 'function')
-	                throw new Error('Register requires a key function');
-	            __classPrivateFieldSet(this, _RegisterClass_keyFn, keyFn, "f");
-	            __classPrivateFieldSet(this, _RegisterClass_keys, reactive([]), "f");
-	            __classPrivateFieldSet(this, _RegisterClass_values, reactive(new Map()), "f");
-	            if (initial)
-	                this.push(...initial);
-	        }
-	        ensureKey(value) {
-	            let info = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-	            if (info)
-	                return info.key;
-	            info = { key: undefined };
-	            __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").set(value, info);
-	            __classPrivateFieldGet(this, _RegisterClass_ascend, "f").call(this, () => {
-	                const stop = effect(({ reaction }) => {
-	                    const nextKey = __classPrivateFieldGet(this, _RegisterClass_keyFn, "f").call(this, value);
-	                    this.assertValidKey(nextKey);
-	                    const previousKey = info.key;
-	                    if (reaction && previousKey !== undefined && !Object.is(nextKey, previousKey))
-	                        __classPrivateFieldGet(this, _RegisterClass_instances, "m", _RegisterClass_rekeyValue).call(this, value, previousKey, nextKey);
-	                    info.key = nextKey;
-	                });
-	                info.stop = stop;
-	                __classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").add(stop);
-	            });
-	            if (info.key === undefined)
-	                throw new Error('Register key function must return a property key');
-	            return info.key;
-	        }
-	        assertValidKey(key) {
-	            const type = typeof key;
-	            if (type !== 'string' && type !== 'number' && type !== 'symbol')
-	                throw new Error('Register key function must return a property key');
-	        }
-	        setKeyValue(key, value, index) {
-	            const existing = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-	            if (existing !== undefined && existing !== value) {
-	                this.cleanupValue(existing);
-	                __classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-	                if (index !== undefined) {
-	                    __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', existing, value, key, index);
-	                }
-	            }
-	            else {
-	                __classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-	            }
-	        }
-	        cleanupValue(value) {
-	            const info = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-	            if (!info)
-	                return;
-	            const stop = info.stop;
-	            if (stop) {
-	                info.stop = undefined;
-	                __classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").delete(stop);
-	                stop();
-	            }
-	            __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").delete(value);
-	        }
-	        disposeKeyEffects() {
-	            for (const value of Array.from(__classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").keys()))
-	                this.cleanupValue(value);
-	            __classPrivateFieldGet(this, _RegisterClass_keyEffects, "f").clear();
-	        }
-	        incrementUsage(key) {
-	            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key) ?? 0;
-	            __classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count + 1);
-	        }
-	        decrementUsage(key, index) {
-	            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(key);
-	            if (!count)
-	                return;
-	            if (count <= 1) {
-	                const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-	                __classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(key);
-	                __classPrivateFieldGet(this, _RegisterClass_values, "f").delete(key);
-	                if (value !== undefined) {
-	                    this.cleanupValue(value);
-	                    const idx = index ?? __classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-	                    __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('delete', value, key, idx);
-	                }
-	            }
-	            else {
-	                __classPrivateFieldGet(this, _RegisterClass_usage, "f").set(key, count - 1);
-	            }
-	        }
-	        normalizeIndex(index, allowEnd = false) {
-	            const length = this.length;
-	            let resolved = index;
-	            if (resolved < 0)
-	                resolved = Math.max(length + resolved, 0);
-	            if (resolved > length) {
-	                if (allowEnd)
-	                    resolved = length;
-	                else
-	                    throw new RangeError('Index out of bounds');
-	            }
-	            if (!allowEnd && resolved === length)
-	                throw new RangeError('Index out of bounds');
-	            return resolved;
-	        }
-	        assignAt(index, key, value) {
-	            const oldKey = __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
-	            if (oldKey !== undefined && Object.is(oldKey, key)) {
-	                const oldValue = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-	                this.setKeyValue(key, value);
-	                if (oldValue !== undefined && oldValue !== value) {
-	                    __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('update', oldValue, value, key, index);
-	                }
-	                return;
-	            }
-	            if (oldKey !== undefined)
-	                this.decrementUsage(oldKey);
-	            __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index] = key;
-	            this.incrementUsage(key);
-	            this.setKeyValue(key, value);
-	            __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
-	        }
-	        insertKeyValue(index, key, value) {
-	            __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 0, key);
-	            this.incrementUsage(key);
-	            this.setKeyValue(key, value);
-	            __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('add', value, key, index);
-	        }
-	        rebuildFrom(values) {
-	            this.disposeKeyEffects();
-	            __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(0, __classPrivateFieldGet(this, _RegisterClass_keys, "f").length);
-	            __classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
-	            __classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
-	            for (const value of values) {
-	                const key = this.ensureKey(value);
-	                __classPrivateFieldGet(this, _RegisterClass_keys, "f").push(key);
-	                this.incrementUsage(key);
-	                __classPrivateFieldGet(this, _RegisterClass_values, "f").set(key, value);
-	            }
-	        }
-	        get length() {
-	            return __classPrivateFieldGet(this, _RegisterClass_keys, "f").length;
-	        }
-	        [(_RegisterClass_rekeyValue = function _RegisterClass_rekeyValue(value, oldKey, newKey) {
-	            if (Object.is(oldKey, newKey))
-	                return;
-	            const existingValue = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(newKey);
-	            if (existingValue !== undefined && existingValue !== value)
-	                throw new Error(`Register key collision for key ${String(newKey)}`);
-	            const count = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(oldKey);
-	            if (!count)
-	                return;
-	            const existingCount = __classPrivateFieldGet(this, _RegisterClass_usage, "f").get(newKey) ?? 0;
-	            this.setKeyValue(newKey, value);
-	            let index = -1;
-	            for (let i = 0; i < __classPrivateFieldGet(this, _RegisterClass_keys, "f").length; i++)
-	                if (Object.is(__classPrivateFieldGet(this, _RegisterClass_keys, "f")[i], oldKey)) {
-	                    __classPrivateFieldGet(this, _RegisterClass_keys, "f")[i] = newKey;
-	                    if (index === -1)
-	                        index = i;
-	                }
-	            __classPrivateFieldGet(this, _RegisterClass_usage, "f").set(newKey, existingCount + count);
-	            __classPrivateFieldGet(this, _RegisterClass_usage, "f").delete(oldKey);
-	            __classPrivateFieldGet(this, _RegisterClass_values, "f").delete(oldKey);
-	            const updatedInfo = __classPrivateFieldGet(this, _RegisterClass_valueInfo, "f").get(value);
-	            if (updatedInfo)
-	                updatedInfo.key = newKey;
-	            if (index !== -1) {
-	                __classPrivateFieldGet(this, _RegisterClass_events, "f").emit('rekey', value, oldKey, newKey, index);
-	            }
-	        }, getAt)](index) {
-	            const key = __classPrivateFieldGet(this, _RegisterClass_keys, "f")[index];
-	            return key === undefined ? undefined : __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-	        }
-	        [setAt](index, value) {
-	            const key = this.ensureKey(value);
-	            if (index === this.length) {
-	                this.insertKeyValue(index, key, value);
-	                return;
-	            }
-	            const normalized = this.normalizeIndex(index);
-	            this.assignAt(normalized, key, value);
-	        }
-	        push(...items) {
-	            for (const item of items) {
-	                const key = this.ensureKey(item);
-	                this.insertKeyValue(this.length, key, item);
-	            }
-	            return this.length;
-	        }
-	        pop() {
-	            if (!this.length)
-	                return undefined;
-	            return this.removeAt(this.length - 1);
-	        }
-	        shift() {
-	            if (!this.length)
-	                return undefined;
-	            return this.removeAt(0);
-	        }
-	        unshift(...items) {
-	            let index = 0;
-	            for (const item of items) {
-	                const key = this.ensureKey(item);
-	                this.insertKeyValue(index++, key, item);
-	            }
-	            return this.length;
-	        }
-	        splice(start, deleteCount, ...items) {
-	            const normalizedStart = this.normalizeIndex(start, true);
-	            const maxDeletions = this.length - normalizedStart;
-	            const actualDelete = Math.min(deleteCount === undefined ? maxDeletions : Math.max(deleteCount, 0), maxDeletions);
-	            const keysToInsert = [];
-	            for (const item of items)
-	                keysToInsert.push(this.ensureKey(item));
-	            const removedKeys = __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(normalizedStart, actualDelete, ...keysToInsert);
-	            const removedValues = [];
-	            for (let i = 0; i < removedKeys.length; i++) {
-	                const key = removedKeys[i];
-	                if (key === undefined)
-	                    continue;
-	                const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-	                this.decrementUsage(key, normalizedStart + i);
-	                removedValues.push(value);
-	            }
-	            for (let i = 0; i < keysToInsert.length; i++) {
-	                const key = keysToInsert[i];
-	                const value = items[i];
-	                this.incrementUsage(key);
-	                this.setKeyValue(key, value);
-	            }
-	            return removedValues;
-	        }
-	        clear() {
-	            __classPrivateFieldGet(this, _RegisterClass_keys, "f").length = 0;
-	            __classPrivateFieldGet(this, _RegisterClass_usage, "f").clear();
-	            __classPrivateFieldGet(this, _RegisterClass_values, "f").clear();
-	            this.disposeKeyEffects();
-	        }
-	        get(key) {
-	            return __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-	        }
-	        set(key, value) {
-	            if (__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
-	                this.setKeyValue(key, value);
-	        }
-	        remove(key) {
-	            let index = this.indexOfKey(key);
-	            while (index !== -1) {
-	                this.removeAt(index);
-	                index = this.indexOfKey(key);
-	            }
-	        }
-	        removeAt(index) {
-	            const [key] = __classPrivateFieldGet(this, _RegisterClass_keys, "f").splice(index, 1);
-	            if (key === undefined)
-	                return undefined;
-	            const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-	            this.decrementUsage(key, index);
-	            return value;
-	        }
-	        /**
-	         * Keep only the items for which the predicate returns true.
-	         * Items for which the predicate returns false are removed.
-	         *
-	         * The predicate is evaluated once per distinct key; duplicate keys
-	         * will follow the same keep/remove decision.
-	         */
-	        keep(predicate) {
-	            const decisions = new Map();
-	            for (const [index, key] of __classPrivateFieldGet(this, _RegisterClass_keys, "f").entries()) {
-	                if (decisions.has(key)) {
-	                    if (!decisions.get(key))
-	                        this.removeAt(index);
-	                    continue;
-	                }
-	                const value = __classPrivateFieldGet(this, _RegisterClass_values, "f").get(key);
-	                const shouldKeep = predicate(value);
-	                decisions.set(key, shouldKeep);
-	                if (!shouldKeep)
-	                    this.removeAt(index);
-	            }
-	        }
-	        hasKey(key) {
-	            return __classPrivateFieldGet(this, _RegisterClass_usage, "f").has(key);
-	        }
-	        indexOfKey(key) {
-	            return __classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-	        }
-	        mapKeys() {
-	            return __classPrivateFieldGet(this, _RegisterClass_values, "f").keys();
-	        }
-	        update(...values) {
-	            for (const value of values) {
-	                const key = this.ensureKey(value);
-	                if (__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key)) {
-	                    const index = __classPrivateFieldGet(this, _RegisterClass_keys, "f").indexOf(key);
-	                    this.setKeyValue(key, value, index);
+	    return lazyInit(resource, () => {
+	        link(resource, effect.named('watch:resource')((access) => {
+	            // Track reload signal to enable manual reloading
+	            void reloadSignal.value;
+	            const id = ++counter;
+	            resource.loading = true;
+	            resource.error = undefined;
+	            try {
+	                const result = fetcher(access);
+	                if (result instanceof Promise) {
+	                    resource.promise = result
+	                        .then((val) => {
+	                        if (id === counter) {
+	                            resource.value = val;
+	                            resource.latest = val;
+	                            resource.loading = false;
+	                        }
+	                    })
+	                        .catch((err) => {
+	                        if (id === counter) {
+	                            resource.error = err;
+	                            resource.loading = false;
+	                        }
+	                    });
 	                }
-	            }
-	        }
-	        upsert(insert, ...values) {
-	            for (const value of values) {
-	                const key = this.ensureKey(value);
-	                if (__classPrivateFieldGet(this, _RegisterClass_values, "f").has(key))
-	                    this.setKeyValue(key, value);
-	                else
-	                    insert(value);
-	            }
-	        }
-	        entries() {
-	            const self = this;
-	            function* iterator() {
-	                for (let i = 0; i < __classPrivateFieldGet(self, _RegisterClass_keys, "f").length; i++) {
-	                    const val = __classPrivateFieldGet(self, _RegisterClass_values, "f").get(__classPrivateFieldGet(self, _RegisterClass_keys, "f")[i]);
-	                    if (val !== undefined)
-	                        yield [i, val];
+	                else {
+	                    resource.promise = Promise.resolve();
+	                    resource.value = result;
+	                    resource.latest = result;
+	                    resource.loading = false;
 	                }
 	            }
-	            return iterator();
-	        }
-	        [Symbol.iterator]() {
-	            const self = this;
-	            function* iterator() {
-	                for (const key of __classPrivateFieldGet(self, _RegisterClass_keys, "f")) {
-	                    const value = __classPrivateFieldGet(self, _RegisterClass_values, "f").get(key);
-	                    if (value !== undefined)
-	                        yield value;
-	                }
+	            catch (err) {
+	                resource.promise = Promise.reject(err);
+	                resource.error = err;
+	                resource.loading = false;
 	            }
-	            return iterator();
-	        }
-	        toString() {
-	            return `[Register length=${this.length}]`;
-	        }
-	        at(index) {
-	            const resolved = index < 0 ? this.length + index : index;
-	            if (resolved < 0 || resolved >= this.length)
-	                return undefined;
-	            return this[getAt](resolved);
-	        }
-	        reverse() {
-	            __classPrivateFieldGet(this, _RegisterClass_keys, "f").reverse();
-	            return this;
-	        }
-	        sort(compareFn) {
-	            const fwdCompareFn = compareFn
-	                ? (a, b) => compareFn(__classPrivateFieldGet(this, _RegisterClass_values, "f").get(a), __classPrivateFieldGet(this, _RegisterClass_values, "f").get(b))
-	                : undefined;
-	            __classPrivateFieldGet(this, _RegisterClass_keys, "f").sort(fwdCompareFn);
-	            return this;
-	        }
-	        fill(value, start = 0, end = this.length) {
-	            const values = this.toArray();
-	            values.fill(value, start, end);
-	            this.rebuildFrom(values);
-	            return this;
-	        }
-	        copyWithin(target, start, end) {
-	            const values = this.toArray();
-	            values.copyWithin(target, start, end);
-	            this.rebuildFrom(values);
-	            return this;
-	        }
-	    };
-	    __setFunctionName(_classThis, "RegisterClass");
-	    (() => {
-	        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-	        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-	        _classThis = _classDescriptor.value;
-	        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-	        __runInitializers(_classThis, _classExtraInitializers);
-	    })();
-	    return _classThis;
-	})();
-	const Register = RegisterClass;
-	/**
-	 * Creates a reactive Register - an ordered, array-like collection with stable key-based identity.
-	 *
-	 * Register combines array semantics (indexable access, ordering, iteration) with Map-like
-	 * key-based lookups. Items with the same key share the same value instance, making it ideal
-	 * for UI lists keyed by IDs or when you need to preserve identity across reorders.
-	 *
-	 * @param keyFn - Function that extracts the key from each item
-	 * @param initial - Optional initial items to populate the register
-	 * @returns A reactive Register instance
-	 *
-	 * @example
-	 * ```typescript
-	 * const users = register(
-	 *   (user: User) => user.id,
-	 *   [{ id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }]
-	 * )
-	 *
-	 * users.push({ id: 3, name: 'Charlie' })
-	 * const bob = users.get(2) // Get by key
-	 * ```
-	 */
-	function register(keyFn, initial) {
-	    return new RegisterClass(keyFn, initial);
+	        }));
+	    });
 	}
+	//#endregion
 
 	/**
 	 * Converts an iterator to a generator that yields reactive values
@@ -6382,6 +5859,7 @@
 	    let _classSuper = Array;
 	    let _instanceExtraInitializers = [];
 	    let _fill_decorators;
+	    let _copyWithin_decorators;
 	    let _pop_decorators;
 	    let _push_decorators;
 	    let _reverse_decorators;
@@ -6406,6 +5884,9 @@
 	            fill(value, start, end) {
 	                return super.fill(unwrap(value), start, end);
 	            }
+	            copyWithin(target, start, end) {
+	                return super.copyWithin(target, start, end);
+	            }
 	            filter(predicate, thisArg) {
 	                return reactive(super.filter((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg));
 	            }
@@ -6507,7 +5988,7 @@
 	                dependant(this, keysOf);
 	                return makeReactiveIterator(super.values());
 	            }
-	            [(_fill_decorators = [atomic], _pop_decorators = [atomic], _push_decorators = [atomic], _reverse_decorators = [atomic], _shift_decorators = [atomic], _sort_decorators = [atomic], _splice_decorators = [atomic], _unshift_decorators = [atomic], Symbol.iterator)]() {
+	            [(_fill_decorators = [atomic], _copyWithin_decorators = [atomic], _pop_decorators = [atomic], _push_decorators = [atomic], _reverse_decorators = [atomic], _shift_decorators = [atomic], _sort_decorators = [atomic], _splice_decorators = [atomic], _unshift_decorators = [atomic], Symbol.iterator)]() {
 	                dependant(this, keysOf);
 	                return makeReactiveIterator(super[Symbol.iterator]());
 	            }
@@ -6520,7 +6001,6 @@
 	                    : undefined;
 	                return reactive(super.toSorted(wrappedCompare));
 	            }
-	            // biome-ignore lint/complexity/noArguments: Needed to distinguish fn() from fn(undefined)
 	            toSpliced(start, deleteCount, ...items) {
 	                if (arguments.length > 2)
 	                    return reactive(super.toSpliced(start, deleteCount, ...items.map(unwrap)));
@@ -6541,6 +6021,7 @@
 	        (() => {
 	            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
 	            __esDecorate(_a, null, _fill_decorators, { kind: "method", name: "fill", static: false, private: false, access: { has: obj => "fill" in obj, get: obj => obj.fill }, metadata: _metadata }, null, _instanceExtraInitializers);
+	            __esDecorate(_a, null, _copyWithin_decorators, { kind: "method", name: "copyWithin", static: false, private: false, access: { has: obj => "copyWithin" in obj, get: obj => obj.copyWithin }, metadata: _metadata }, null, _instanceExtraInitializers);
 	            __esDecorate(_a, null, _pop_decorators, { kind: "method", name: "pop", static: false, private: false, access: { has: obj => "pop" in obj, get: obj => obj.pop }, metadata: _metadata }, null, _instanceExtraInitializers);
 	            __esDecorate(_a, null, _push_decorators, { kind: "method", name: "push", static: false, private: false, access: { has: obj => "push" in obj, get: obj => obj.push }, metadata: _metadata }, null, _instanceExtraInitializers);
 	            __esDecorate(_a, null, _reverse_decorators, { kind: "method", name: "reverse", static: false, private: false, access: { has: obj => "reverse" in obj, get: obj => obj.reverse }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -6561,18 +6042,18 @@
 	    // Implement WeakMap interface methods with reactivity
 	    delete(key) {
 	        const hadKey = this.has(key);
-	        const result = this.delete(key);
+	        const result = super.delete(key);
 	        if (hadKey)
 	            touched1(contentRef(this), { type: 'del', prop: key }, key);
 	        return result;
 	    }
 	    get(key) {
 	        dependant(contentRef(this), key);
-	        return reactive(this.get(key));
+	        return reactive(super.get(key));
 	    }
 	    has(key) {
 	        dependant(contentRef(this), key);
-	        return this.has(key);
+	        return super.has(key);
 	    }
 	    set(key, value) {
 	        const hadKey = this.has(key);
@@ -6593,16 +6074,18 @@
 	    // Implement Map interface methods with reactivity
 	    get size() {
 	        dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
-	        return this.size;
+	        return super.size;
 	    }
 	    clear() {
 	        const hadEntries = this.size > 0;
-	        this.clear();
+	        super.clear();
 	        if (hadEntries) {
 	            const evolution = { type: 'bunch', method: 'clear' };
 	            // Clear triggers all effects since all keys are affected
-	            touched1(this, evolution, 'size');
-	            touched(contentRef(this), evolution);
+	            batch(() => {
+	                touched1(this, evolution, 'size');
+	                touched(contentRef(this), evolution);
+	            });
 	        }
 	    }
 	    entries() {
@@ -6637,32 +6120,36 @@
 	    // Implement Map methods with reactivity
 	    delete(key) {
 	        const hadKey = this.has(key);
-	        const result = this.delete(key);
+	        const result = super.delete(key);
 	        if (hadKey) {
 	            const evolution = { type: 'del', prop: key };
-	            touched1(contentRef(this), evolution, key);
-	            touched1(this, evolution, 'size');
+	            batch(() => {
+	                touched1(contentRef(this), evolution, key);
+	                touched1(this, evolution, 'size');
+	            });
 	        }
 	        return result;
 	    }
 	    get(key) {
 	        dependant(contentRef(this), key);
-	        return reactive(this.get(key));
+	        return reactive(super.get(key));
 	    }
 	    has(key) {
 	        dependant(contentRef(this), key);
-	        return this.has(key);
+	        return super.has(key);
 	    }
 	    set(key, value) {
 	        const hadKey = this.has(key);
 	        const oldValue = this.get(key);
 	        const reactiveValue = reactive(value);
-	        this.set(key, reactiveValue);
+	        super.set(key, reactiveValue);
 	        if (!hadKey || oldValue !== reactiveValue) {
-	            notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey);
-	            // Also notify size change for Map (WeakMap doesn't track size)
-	            const evolution = { type: hadKey ? 'set' : 'add', prop: key };
-	            touched1(this, evolution, 'size');
+	            batch(() => {
+	                notifyPropertyChange(contentRef(this), key, oldValue, reactiveValue, hadKey);
+	                // Also notify size change for Map (WeakMap doesn't track size)
+	                const evolution = { type: hadKey ? 'set' : 'add', prop: key };
+	                touched1(this, evolution, 'size');
+	            });
 	        }
 	        return this;
 	    }
@@ -6675,7 +6162,7 @@
 	class ReactiveWeakSet extends WeakSet {
 	    add(value) {
 	        const had = this.has(value);
-	        this.add(value);
+	        super.add(value);
 	        if (!had) {
 	            // touch the specific value and the collection view
 	            touched1(contentRef(this), { type: 'add', prop: value }, value);
@@ -6685,14 +6172,14 @@
 	    }
 	    delete(value) {
 	        const had = this.has(value);
-	        const res = this.delete(value);
+	        const res = super.delete(value);
 	        if (had)
 	            touched1(contentRef(this), { type: 'del', prop: value }, value);
 	        return res;
 	    }
 	    has(value) {
 	        dependant(contentRef(this), value);
-	        return this.has(value);
+	        return super.has(value);
 	    }
 	}
 	/**
@@ -6708,31 +6195,37 @@
 	    add(value) {
 	        const had = this.has(value);
 	        const reactiveValue = reactive(value);
-	        this.add(reactiveValue);
+	        super.add(reactiveValue);
 	        if (!had) {
 	            const evolution = { type: 'add', prop: reactiveValue };
 	            // touch for value-specific and aggregate dependencies
-	            touched1(contentRef(this), evolution, reactiveValue);
-	            touched1(this, evolution, 'size');
+	            batch(() => {
+	                touched1(contentRef(this), evolution, reactiveValue);
+	                touched1(this, evolution, 'size');
+	            });
 	        }
 	        return this;
 	    }
 	    clear() {
 	        const hadEntries = this.size > 0;
-	        this.clear();
+	        super.clear();
 	        if (hadEntries) {
 	            const evolution = { type: 'bunch', method: 'clear' };
-	            touched1(this, evolution, 'size');
-	            touched(contentRef(this), evolution);
+	            batch(() => {
+	                touched1(this, evolution, 'size');
+	                touched(contentRef(this), evolution);
+	            });
 	        }
 	    }
 	    delete(value) {
 	        const had = this.has(value);
-	        const res = this.delete(value);
+	        const res = super.delete(value);
 	        if (had) {
 	            const evolution = { type: 'del', prop: value };
-	            touched1(contentRef(this), evolution, value);
-	            touched1(this, evolution, 'size');
+	            batch(() => {
+	                touched1(contentRef(this), evolution, value);
+	                touched1(this, evolution, 'size');
+	            });
 	        }
 	        return res;
 	    }
@@ -6771,14 +6264,12 @@
 	}
 
 	// Register native collection types to use specialized reactive wrappers
-	console.time('mutts-reactive-init');
 	metaProtos.set(Array, ReactiveArray.prototype);
 	metaProtos.set(Set, ReactiveSet.prototype);
 	metaProtos.set(WeakSet, ReactiveWeakSet.prototype);
 	metaProtos.set(Map, ReactiveMap.prototype);
 	metaProtos.set(WeakMap, ReactiveWeakMap.prototype);
 	wrapProtos.set(Array, ReactiveArrayWrapper.prototype);
-	console.timeEnd('mutts-reactive-init');
 	/**
 	 * Object containing internal reactive system state for debugging and profiling
 	 */
@@ -6791,7 +6282,6 @@
 	    objectsWithDeepWatchers,
 	    deepWatchers,
 	    effectToDeepWatchedObjects,
-	    nonReactiveObjects,
 	};
 
 	// In order to avoid async re-entrance, we could use zone.js or something like that.
@@ -6957,8 +6447,7 @@
 	    },
 	}), {
 	    warn: (target, propertyKey, message) => {
-	        // biome-ignore lint/suspicious/noConsole: To be overridden
-	        console.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
+	        options.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
 	    },
 	});
 	/**
@@ -7021,12 +6510,11 @@
 	    });
 	}
 
-	var version$1 = "1.0.10";
+	var version$1 = "1.0.12";
 	var pkg = {
 		version: version$1};
 
 	const { version } = pkg;
-	// Singleton verification
 	const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
 	const globalScope = (typeof globalThis !== 'undefined'
 	    ? globalThis
@@ -7036,28 +6524,16 @@
 	            ? global
 	            : false);
 	if (globalScope) {
-	    // Detect the source of this instance safely across different environments
 	    let source = 'mutts/index';
-	    // biome-ignore lint/security/noGlobalEval: Intentional eval for cross-env import.meta detection
-	    const viteEval = eval;
 	    try {
 	        if (typeof __filename !== 'undefined')
 	            source = __filename;
-	        else {
-	            // Using eval to avoid SyntaxError in CJS environments where import.meta is not allowed
-	            const meta = viteEval('import.meta');
-	            if (meta && meta.url)
-	                source = meta.url;
+	        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));
 	        }
 	    }
-	    catch (e) {
-	        // Fallback for environments where neither is available or accessible
-	    }
-	    const currentSourceInfo = {
-	        version,
-	        source,
-	        timestamp: Date.now(),
-	    };
+	    catch (_e) { }
+	    const currentSourceInfo = { version, source, timestamp: Date.now() };
 	    if (globalScope[GLOBAL_MUTTS_KEY]) {
 	        const existing = globalScope[GLOBAL_MUTTS_KEY];
 	        throw new Error(`[Mutts] Multiple instances detected!\n` +
@@ -7081,15 +6557,16 @@
 	exports.IterableWeakSet = IterableWeakSet;
 	exports.ReactiveBase = ReactiveBase;
 	exports.ReactiveError = ReactiveError;
-	exports.Register = Register;
 	exports.Zone = Zone;
 	exports.ZoneAggregator = ZoneAggregator;
 	exports.ZoneHistory = ZoneHistory;
 	exports.addBatchCleanup = addBatchCleanup;
+	exports.addUnreactiveProps = addUnreactiveProps;
 	exports.allocated = allocated;
 	exports.allocatedValues = allocatedValues;
 	exports.arrayDiff = arrayDiff;
 	exports.arrayEquals = arrayEquals;
+	exports.assertUntracked = assertUntracked;
 	exports.asyncHook = asyncHook;
 	exports.asyncHooks = asyncHooks;
 	exports.asyncZone = asyncZone;
@@ -7100,12 +6577,12 @@
 	exports.cache = cache;
 	exports.cached = cached;
 	exports.callOnGC = callOnGC;
+	exports.captured = captured;
 	exports.caught = caught;
 	exports.chainPromise = chainPromise;
-	exports.cleanedBy = cleanedBy;
-	exports.cleanup = cleanup;
 	exports.createFlavor = createFlavor;
 	exports.debounce = debounce;
+	exports.debugPreset = debugPreset;
 	exports.decorator = decorator;
 	exports.deepCompare = deepCompare;
 	exports.deepWatch = deepWatch;
@@ -7113,6 +6590,7 @@
 	exports.deprecated = deprecated;
 	exports.descriptor = descriptor;
 	exports.destructor = destructor;
+	exports.devPreset = devPreset;
 	exports.effect = effect;
 	exports.effectAggregator = effectAggregator;
 	exports.flavorOptions = flavorOptions;
@@ -7124,14 +6602,17 @@
 	exports.getAt = getAt;
 	exports.getState = getState;
 	exports.hooks = hooks$1;
-	exports.immutables = immutables;
 	exports.isCached = isCached;
 	exports.isConstructor = isConstructor;
+	exports.isDev = isDev;
 	exports.isNonReactive = isNonReactive;
 	exports.isObject = isObject;
+	exports.isProd = isProd;
 	exports.isReactive = isReactive;
+	exports.isTest = isTest;
 	exports.legacyDecorator = legacyDecorator;
 	exports.lift = lift;
+	exports.link = link;
 	exports.memoize = memoize;
 	exports.mixin = mixin;
 	exports.modernDecorator = modernDecorator;
@@ -7141,22 +6622,21 @@
 	exports.onEffectThrow = onEffectThrow;
 	exports.organize = organize;
 	exports.organized = organized;
+	exports.prodPreset = prodPreset;
 	exports.profileInfo = profileInfo;
 	exports.project = morph;
 	exports.proxyToObject = proxyToObject;
 	exports.reactive = reactive;
 	exports.reactiveOptions = options;
-	exports.register = register;
 	exports.reset = reset;
 	exports.resource = resource;
 	exports.root = root;
-	exports.scan = scan;
 	exports.setAt = setAt;
-	exports.stopped = stopped;
 	exports.tag = tag;
 	exports.throttle = throttle;
 	exports.touched = touched;
 	exports.touched1 = touched1;
+	exports.unlink = unlink;
 	exports.unreactive = unreactive;
 	exports.untracked = untracked;
 	exports.unwrap = unwrap;