mutts 1.0.4 → 1.0.6

package/dist/chunks/{index-GRBSx0mB.js → index-CDCOjzTy.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var decorator = require('./decorator-DLvrD0UF.js');
+var decorator = require('./decorator-BQ2eBTCj.js');
 var indexable = require('../indexable.js');
 var _tslib = require('./_tslib-BgjropY9.js');
 
@@ -334,313 +334,6 @@ function mixin(mixinFunction, unwrapFunction) {
     });
 }
 
-// biome-ignore-all lint/suspicious/noConfusingVoidType: Type 'void' is not assignable to type 'ScopedCallback | undefined'.
-// Argument of type '() => void' is not assignable to parameter of type '(dep: DependencyFunction) => ScopedCallback | undefined'.
-// Track native reactivity
-const nativeReactive = Symbol('native-reactive');
-/**
- * Symbol to mark individual objects as non-reactive
- */
-const nonReactiveMark = Symbol('non-reactive');
-/**
- * Symbol to mark class properties as non-reactive
- */
-const unreactiveProperties = Symbol('unreactive-properties');
-/**
- * Symbol for prototype forwarding in reactive objects
- */
-const prototypeForwarding = Symbol('prototype-forwarding');
-/**
- * Symbol representing all properties in reactive tracking
- */
-const allProps = Symbol('all-props');
-// Symbol to mark functions with their root function
-const rootFunction = Symbol('root-function');
-/**
- * Structured error codes for machine-readable diagnosis
- */
-var ReactiveErrorCode;
-(function (ReactiveErrorCode) {
-    ReactiveErrorCode["CycleDetected"] = "CYCLE_DETECTED";
-    ReactiveErrorCode["MaxDepthExceeded"] = "MAX_DEPTH_EXCEEDED";
-    ReactiveErrorCode["MaxReactionExceeded"] = "MAX_REACTION_EXCEEDED";
-    ReactiveErrorCode["WriteInComputed"] = "WRITE_IN_COMPUTED";
-    ReactiveErrorCode["TrackingError"] = "TRACKING_ERROR";
-})(ReactiveErrorCode || (ReactiveErrorCode = {}));
-/**
- * Error class for reactive system errors
- */
-class ReactiveError extends Error {
-    constructor(message, debugInfo) {
-        super(message);
-        this.debugInfo = debugInfo;
-        this.name = 'ReactiveError';
-    }
-}
-// biome-ignore-start lint/correctness/noUnusedFunctionParameters: Interface declaration with empty defaults
-/**
- * Global options for the reactive system
- */
-const options = {
-    /**
-     * Debug purpose: called when an effect is entered
-     * @param effect - The effect that is entered
-     */
-    enter: (_effect) => { },
-    /**
-     * Debug purpose: called when an effect is left
-     * @param effect - The effect that is left
-     */
-    leave: (_effect) => { },
-    /**
-     * Debug purpose: called when an effect is chained
-     * @param target - The effect that is being triggered
-     * @param caller - The effect that is calling the target
-     */
-    chain: (_targets, _caller) => { },
-    /**
-     * Debug purpose: called when an effect chain is started
-     * @param target - The effect that is being triggered
-     */
-    beginChain: (_targets) => { },
-    /**
-     * Debug purpose: called when an effect chain is ended
-     */
-    endChain: () => { },
-    garbageCollected: (_fn) => { },
-    /**
-     * Debug purpose: called when an object is touched
-     * @param obj - The object that is touched
-     * @param evolution - The type of change
-     * @param props - The properties that changed
-     * @param deps - The dependencies that changed
-     */
-    touched: (_obj, _evolution, _props, _deps) => { },
-    /**
-     * Debug purpose: called when an effect is skipped because it's already running
-     * @param effect - The effect that is already running
-     * @param runningChain - The array of effects from the detected one to the currently running one
-     */
-    skipRunningEffect: (_effect, _runningChain) => { },
-    /**
-     * Debug purpose: maximum effect chain (like call stack max depth)
-     * Used to prevent infinite loops
-     * @default 100
-     */
-    maxEffectChain: 100,
-    /**
-     * Debug purpose: maximum effect reaction (like call stack max depth)
-     * Used to prevent infinite loops
-     * @default 'throw'
-     */
-    maxEffectReaction: 'throw',
-    /**
-     * How to handle cycles detected in effect batches
-     * - 'throw': Throw an error with cycle information (default, recommended for development)
-     * - 'warn': Log a warning and break the cycle by executing one effect
-     * - 'break': Silently break the cycle by executing one effect (recommended for production)
-     * - 'strict': Prevent cycle creation by checking graph before execution (throws error)
-     * @default 'throw'
-     */
-    cycleHandling: 'throw',
-    /**
-     * Maximum depth for deep watching traversal
-     * Used to prevent infinite recursion in circular references
-     * @default 100
-     */
-    maxDeepWatchDepth: 100,
-    /**
-     * Only react on instance members modification (not inherited properties)
-     * For instance, do not track class methods
-     * @default true
-     */
-    instanceMembers: true,
-    /**
-     * Ignore accessors (getters and setters) and only track direct properties
-     * @default true
-     */
-    ignoreAccessors: true,
-    /**
-     * Enable recursive touching when objects with the same prototype are replaced
-     * When enabled, replacing an object with another of the same prototype triggers
-     * recursive diffing instead of notifying parent effects
-     * @default true
-     */
-    recursiveTouching: true,
-    /**
-     * Default async execution mode for effects that return Promises
-     * - 'cancel': Cancel previous async execution when dependencies change (default, enables async zone)
-     * - 'queue': Queue next execution to run after current completes (enables async zone)
-     * - 'ignore': Ignore new executions while async work is running (enables async zone)
-     * - false: Disable async zone and async mode handling (effects run concurrently)
-     *
-     * **When truthy:** Enables async zone (Promise.prototype wrapping) for automatic context
-     * preservation in Promise callbacks. Warning: This modifies Promise.prototype globally.
-     * Only enable if no other library modifies Promise.prototype.
-     *
-     * **When false:** Async zone is disabled. Use `tracked()` manually in Promise callbacks.
-     *
-     * Can be overridden per-effect via EffectOptions
-     * @default 'cancel'
-     */
-    asyncMode: 'cancel',
-    // biome-ignore lint/suspicious/noConsole: This is the whole point here
-    warn: (...args) => console.warn(...args),
-    /**
-     * Configuration for the introspection system
-     */
-    introspection: {
-        /**
-         * Whether to keep a history of mutations for debugging
-         * @default false
-         */
-        enableHistory: false,
-        /**
-         * Number of mutations to keep in history
-         * @default 50
-         */
-        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)
-     */
-    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,
-    },
-};
-
-/**
- * Effect context stack for nested tracking (front = active, next = parent)
- */
-const stack = [];
-function captureEffectStack() {
-    return stack.slice();
-}
-function isRunning(effect) {
-    const rootEffect = getRoot(effect);
-    // Check if the effect is directly in the stack
-    const rootIndex = stack.indexOf(rootEffect);
-    if (rootIndex !== -1) {
-        return stack.slice(0, rootIndex + 1).reverse();
-    }
-    // Check if any effect in the stack is a descendant of this effect
-    // (i.e., walk up the parent chain from each stack effect to see if we reach this effect)
-    for (let i = 0; i < stack.length; i++) {
-        const stackEffect = stack[i];
-        let current = stackEffect;
-        const visited = new WeakSet();
-        const ancestorChain = [];
-        // TODO: That's perhaps a lot of computations for an `assert`
-        // Walk up the parent chain to find if this effect is an ancestor
-        while (current && !visited.has(current)) {
-            visited.add(current);
-            const currentRoot = getRoot(current);
-            ancestorChain.push(currentRoot);
-            if (currentRoot === rootEffect) {
-                // Found a descendant - build the full chain from ancestor to active
-                // The ancestorChain contains [descendant, parent, ..., ancestor] (walking up)
-                // We need [ancestor (effect), ..., parent, descendant, ...stack from descendant to active]
-                const chainFromAncestor = ancestorChain.reverse(); // [ancestor, ..., descendant]
-                // Prepend the actual effect we're checking (in case current is a wrapper)
-                if (chainFromAncestor[0] !== rootEffect) {
-                    chainFromAncestor.unshift(rootEffect);
-                }
-                // Append the rest of the stack from the descendant to the active effect
-                const stackFromDescendant = stack.slice(0, i + 1).reverse(); // [descendant, ..., active]
-                // Remove duplicate descendant (it's both at end of chainFromAncestor and start of stackFromDescendant)
-                if (chainFromAncestor.length > 0 && stackFromDescendant.length > 0) {
-                    stackFromDescendant.shift(); // Remove duplicate descendant
-                }
-                return [...chainFromAncestor, ...stackFromDescendant];
-            }
-            current = effectParent.get(current);
-        }
-    }
-    return false;
-}
-function withEffectStack(snapshot, fn) {
-    const previousStack = stack.slice();
-    assignStack(snapshot);
-    try {
-        return fn();
-    }
-    finally {
-        assignStack(previousStack);
-    }
-}
-function getActiveEffect() {
-    return stack[0];
-}
-/**
- * Executes a function with a specific effect context
- * @param effect - The effect to use as context
- * @param fn - The function to execute
- * @param keepParent - Whether to keep the parent effect context
- * @returns The result of the function
- */
-function withEffect(effect, fn) {
-    // console.log('[Mutts] withEffect', effect ? 'Active' : 'NULL');
-    if (getRoot(effect) === getRoot(getActiveEffect()))
-        return fn();
-    stack.unshift(effect);
-    try {
-        return fn();
-    }
-    finally {
-        const recoveredEffect = stack.shift();
-        if (recoveredEffect !== effect)
-            throw new ReactiveError('[reactive] Effect stack mismatch');
-    }
-}
-function assignStack(values) {
-    stack.length = 0;
-    stack.push(...values);
-}
-
-const objectToProxy = new WeakMap();
-const proxyToObject = new WeakMap();
-function storeProxyRelationship(target, proxy) {
-    objectToProxy.set(target, proxy);
-    proxyToObject.set(proxy, target);
-}
-function getExistingProxy(target) {
-    return objectToProxy.get(target);
-}
-function trackProxyObject(proxy, target) {
-    proxyToObject.set(proxy, target);
-}
-function unwrap(obj) {
-    let current = obj;
-    while (current && typeof current === 'object' && current !== null && proxyToObject.has(current)) {
-        current = proxyToObject.get(current);
-    }
-    return current;
-}
-function isReactive(obj) {
-    return proxyToObject.has(obj);
-}
-
 // Track which effects are watching which reactive objects for cleanup
 const effectToReactiveObjects = new WeakMap();
 // Track effects per reactive object and property
@@ -649,15 +342,31 @@ const watchers = new WeakMap();
 const effectChildren = new WeakMap();
 // Track parent effect relationships for hierarchy traversal (used in deep touch filtering)
 const effectParent = new WeakMap();
+// Track reverse mapping to ensure unicity: One Root -> One Function
+const reverseRoots = new WeakMap();
 /**
  * Marks a function with its root function for effect tracking
+ * Enforces strict unicity: A root function can only identify ONE function.
  * @param fn - The function to mark
  * @param root - The root function
  * @returns The marked function
  */
 function markWithRoot(fn, root) {
+    // Check for collision
+    const existingRef = reverseRoots.get(root);
+    const existing = existingRef?.deref();
+    if (existing && existing !== fn) {
+        const rootName = root.name || 'anonymous';
+        const existingName = existing.name || 'anonymous';
+        const fnName = fn.name || 'anonymous';
+        throw new Error(`[reactive] Abusive Shared Root detected: Root '${rootName}' is already identifying function '${existingName}'. ` +
+            `Cannot reuse it for '${fnName}'. Shared roots cause lost updates and broken identity logic.`);
+    }
+    // Always update the map so subsequent checks find this one
+    // (Last writer wins for the check)
+    reverseRoots.set(root, new WeakRef(fn));
     // Mark fn with the new root
-    return Object.defineProperty(fn, rootFunction, {
+    return Object.defineProperty(fn, decorator.rootFunction, {
         value: getRoot(root),
         writable: false,
     });
@@ -668,64 +377,15 @@ function markWithRoot(fn, root) {
  * @returns The root function
  */
 function getRoot(fn) {
-    return fn?.[rootFunction] || fn;
+    while (fn && decorator.rootFunction in fn)
+        fn = fn[decorator.rootFunction];
+    return fn;
 }
 // Flag to disable dependency tracking for the current active effect (not globally)
 const trackingDisabledEffects = new WeakSet();
 let globalTrackingDisabled = false;
-function getTrackingDisabled() {
-    const active = getActiveEffect();
-    if (!active)
-        return globalTrackingDisabled;
-    return trackingDisabledEffects.has(getRoot(active));
-}
-function setTrackingDisabled(value) {
-    const active = getActiveEffect();
-    if (!active) {
-        globalTrackingDisabled = value;
-        return;
-    }
-    const root = getRoot(active);
-    if (value)
-        trackingDisabledEffects.add(root);
-    else
-        trackingDisabledEffects.delete(root);
-}
-/**
- * Marks a property as a dependency of the current effect
- * @param obj - The object containing the property
- * @param prop - The property name (defaults to allProps)
- */
-function dependant(obj, prop = allProps) {
-    obj = unwrap(obj);
-    const currentActiveEffect = getActiveEffect();
-    // Early return if no active effect, tracking disabled, or invalid prop
-    if (!currentActiveEffect ||
-        getTrackingDisabled() ||
-        (typeof prop === 'symbol' && prop !== allProps))
-        return;
-    registerDependency(obj, prop, currentActiveEffect);
-}
-function registerDependency(obj, prop, currentActiveEffect) {
-    let objectWatchers = watchers.get(obj);
-    if (!objectWatchers) {
-        objectWatchers = new Map();
-        watchers.set(obj, objectWatchers);
-    }
-    let deps = objectWatchers.get(prop);
-    if (!deps) {
-        deps = new Set();
-        objectWatchers.set(prop, deps);
-    }
-    deps.add(currentActiveEffect);
-    // Track which reactive objects this effect is watching
-    const effectObjects = effectToReactiveObjects.get(currentActiveEffect);
-    if (effectObjects) {
-        effectObjects.add(obj);
-    }
-    else {
-        effectToReactiveObjects.set(currentActiveEffect, new Set([obj]));
-    }
+function setGlobalTrackingDisabled(value) {
+    globalTrackingDisabled = value;
 }
 
 /**
@@ -766,7 +426,7 @@ function ensureObjectName(obj) {
 }
 function describeProp(obj, prop) {
     const objectName = ensureObjectName(obj);
-    if (prop === allProps)
+    if (prop === decorator.allProps)
         return `${objectName}.*`;
     if (typeof prop === 'symbol')
         return `${objectName}.${prop.description ?? prop.toString()}`;
@@ -863,7 +523,7 @@ function registerObjectForDebug(obj) {
  * @param evolution - The type of change (set/add/del/bunch)
  */
 function recordTriggerLink(source, target, obj, prop, evolution) {
-    if (options.introspection.enableHistory) {
+    if (decorator.options.introspection.enableHistory) {
         addToMutationHistory(source, target, obj, prop, evolution);
     }
     if (!devtoolsEnabled)
@@ -1075,11 +735,176 @@ function addToMutationHistory(source, target, obj, prop, evolution) {
         type: evolution.type,
     };
     mutationHistory.push(record);
-    if (mutationHistory.length > options.introspection.historySize) {
+    if (mutationHistory.length > decorator.options.introspection.historySize) {
         mutationHistory.shift();
     }
 }
 
+/**
+ * Effect context stack for nested tracking (front = active, next = parent)
+ */
+const stack = [];
+function captureEffectStack() {
+    return stack.slice();
+}
+function isRunning(effect) {
+    const rootEffect = getRoot(effect);
+    // Check if the effect is directly in the stack
+    const rootIndex = stack.indexOf(rootEffect);
+    if (rootIndex !== -1) {
+        return stack.slice(0, rootIndex + 1).reverse();
+    }
+    // Check if any effect in the stack is a descendant of this effect
+    // (i.e., walk up the parent chain from each stack effect to see if we reach this effect)
+    for (let i = 0; i < stack.length; i++) {
+        const stackEffect = stack[i];
+        let current = stackEffect;
+        const visited = new WeakSet();
+        const ancestorChain = [];
+        // TODO: That's perhaps a lot of computations for an `assert`
+        // Walk up the parent chain to find if this effect is an ancestor
+        while (current && !visited.has(current)) {
+            visited.add(current);
+            const currentRoot = getRoot(current);
+            ancestorChain.push(currentRoot);
+            if (currentRoot === rootEffect) {
+                // Found a descendant - build the full chain from ancestor to active
+                // The ancestorChain contains [descendant, parent, ..., ancestor] (walking up)
+                // We need [ancestor (effect), ..., parent, descendant, ...stack from descendant to active]
+                const chainFromAncestor = ancestorChain.reverse(); // [ancestor, ..., descendant]
+                // Prepend the actual effect we're checking (in case current is a wrapper)
+                if (chainFromAncestor[0] !== rootEffect) {
+                    chainFromAncestor.unshift(rootEffect);
+                }
+                // Append the rest of the stack from the descendant to the active effect
+                const stackFromDescendant = stack.slice(0, i + 1).reverse(); // [descendant, ..., active]
+                // Remove duplicate descendant (it's both at end of chainFromAncestor and start of stackFromDescendant)
+                if (chainFromAncestor.length > 0 && stackFromDescendant.length > 0) {
+                    stackFromDescendant.shift(); // Remove duplicate descendant
+                }
+                return [...chainFromAncestor, ...stackFromDescendant];
+            }
+            current = effectParent.get(current);
+        }
+    }
+    return false;
+}
+function withEffectStack(snapshot, fn) {
+    const previousStack = stack.slice();
+    assignStack(snapshot);
+    try {
+        return fn();
+    }
+    finally {
+        assignStack(previousStack);
+    }
+}
+function getActiveEffect() {
+    return stack[0];
+}
+/**
+ * Executes a function with a specific effect context
+ * @param effect - The effect to use as context
+ * @param fn - The function to execute
+ * @param keepParent - Whether to keep the parent effect context
+ * @returns The result of the function
+ */
+function withEffect(effect, fn) {
+    if (getRoot(effect) === getRoot(getActiveEffect()))
+        return fn();
+    stack.unshift(effect);
+    try {
+        return fn();
+    }
+    finally {
+        const recoveredEffect = stack.shift();
+        if (recoveredEffect !== effect)
+            throw new decorator.ReactiveError('[reactive] Effect stack mismatch');
+    }
+}
+function assignStack(values) {
+    stack.length = 0;
+    stack.push(...values);
+}
+
+const objectToProxy = new WeakMap();
+const proxyToObject = new WeakMap();
+function storeProxyRelationship(target, proxy) {
+    objectToProxy.set(target, proxy);
+    proxyToObject.set(proxy, target);
+}
+function getExistingProxy(target) {
+    return objectToProxy.get(target);
+}
+function trackProxyObject(proxy, target) {
+    proxyToObject.set(proxy, target);
+}
+function unwrap(obj) {
+    let current = obj;
+    while (current && typeof current === 'object' && current !== null && proxyToObject.has(current)) {
+        current = proxyToObject.get(current);
+    }
+    return current;
+}
+function isReactive(obj) {
+    return proxyToObject.has(obj);
+}
+
+function getTrackingDisabled() {
+    const active = getActiveEffect();
+    if (!active)
+        return globalTrackingDisabled;
+    return trackingDisabledEffects.has(getRoot(active));
+}
+function setTrackingDisabled(value) {
+    const active = getActiveEffect();
+    if (!active) {
+        setGlobalTrackingDisabled(value);
+        return;
+    }
+    const root = getRoot(active);
+    if (value)
+        trackingDisabledEffects.add(root);
+    else
+        trackingDisabledEffects.delete(root);
+}
+/**
+ * Marks a property as a dependency of the current effect
+ * @param obj - The object containing the property
+ * @param prop - The property name (defaults to allProps)
+ */
+function dependant(obj, prop = decorator.allProps) {
+    obj = unwrap(obj);
+    const currentActiveEffect = getActiveEffect();
+    // Early return if no active effect, tracking disabled, or invalid prop
+    if (!currentActiveEffect ||
+        getTrackingDisabled() ||
+        (typeof prop === 'symbol' && prop !== decorator.allProps))
+        return;
+    registerDependency(obj, prop, currentActiveEffect);
+}
+function registerDependency(obj, prop, currentActiveEffect) {
+    let objectWatchers = watchers.get(obj);
+    if (!objectWatchers) {
+        objectWatchers = new Map();
+        watchers.set(obj, objectWatchers);
+    }
+    let deps = objectWatchers.get(prop);
+    if (!deps) {
+        deps = new Set();
+        objectWatchers.set(prop, deps);
+    }
+    deps.add(currentActiveEffect);
+    // Track which reactive objects this effect is watching
+    const effectObjects = effectToReactiveObjects.get(currentActiveEffect);
+    if (effectObjects) {
+        effectObjects.add(obj);
+    }
+    else {
+        effectToReactiveObjects.set(currentActiveEffect, new Set([obj]));
+    }
+}
+
 /**
  * Zone-like async context preservation for reactive effects
  *
@@ -1120,7 +945,7 @@ let batchFn;
 function ensureZoneHooked(batch) {
     if (batch)
         batchFn = batch;
-    if (zoneHooked || !options.asyncMode)
+    if (zoneHooked || !decorator.options.asyncMode)
         return;
     hookZone();
     zoneHooked = true;
@@ -1144,7 +969,7 @@ function hookZone() {
     };
     // Hook setTimeout - preserve original function properties for Node.js compatibility
     const wrappedSetTimeout = ((callback, delay, ...args) => {
-        const capturedStack = options.zones.setTimeout ? captureEffectStack() : undefined;
+        const capturedStack = decorator.options.zones.setTimeout ? captureEffectStack() : undefined;
         return originalSetTimeout.apply(globalThis, [
             wrapCallback(callback, capturedStack),
             delay,
@@ -1155,7 +980,7 @@ function hookZone() {
     globalThis.setTimeout = wrappedSetTimeout;
     // Hook setInterval - preserve original function properties for Node.js compatibility
     const wrappedSetInterval = ((callback, delay, ...args) => {
-        const capturedStack = options.zones.setInterval ? captureEffectStack() : undefined;
+        const capturedStack = decorator.options.zones.setInterval ? captureEffectStack() : undefined;
         return originalSetInterval.apply(globalThis, [
             wrapCallback(callback, capturedStack),
             delay,
@@ -1167,14 +992,14 @@ function hookZone() {
     // Hook requestAnimationFrame if available
     if (originalRequestAnimationFrame) {
         globalThis.requestAnimationFrame = ((callback) => {
-            const capturedStack = options.zones.requestAnimationFrame ? captureEffectStack() : undefined;
+            const capturedStack = decorator.options.zones.requestAnimationFrame ? captureEffectStack() : undefined;
             return originalRequestAnimationFrame.call(globalThis, wrapCallback(callback, capturedStack));
         });
     }
     // Hook queueMicrotask if available
     if (originalQueueMicrotask) {
         globalThis.queueMicrotask = ((callback) => {
-            const capturedStack = options.zones.queueMicrotask ? captureEffectStack() : undefined;
+            const capturedStack = decorator.options.zones.queueMicrotask ? captureEffectStack() : undefined;
             originalQueueMicrotask.call(globalThis, wrapCallback(callback, capturedStack));
         });
     }
@@ -1260,6 +1085,50 @@ function formatRoots(roots, limit = 20) {
     const end = names.slice(-10);
     return `${start.join(' → ')} ... (${names.length - 15} more) ... ${end.join(' → ')}`;
 }
+// Nested map structure for efficient counting and batch cleanup
+// batchId -> effect root -> obj -> prop -> count
+let activationRegistry;
+const activationLog = new Array(100);
+function getActivationLog() {
+    return activationLog;
+}
+function recordActivation(effect, obj, evolution, prop) {
+    const root = getRoot(effect);
+    if (!activationRegistry)
+        return;
+    let effectData = activationRegistry.get(root);
+    if (!effectData) {
+        effectData = new Map();
+        activationRegistry.set(root, effectData);
+    }
+    let objData = effectData.get(obj);
+    if (!objData) {
+        objData = new Map();
+        effectData.set(obj, objData);
+    }
+    const count = (objData.get(prop) ?? 0) + 1;
+    objData.set(prop, count);
+    // Keep a limited history for diagnostics
+    activationLog.unshift({
+        effect,
+        obj,
+        evolution,
+        prop,
+    });
+    activationLog.pop();
+    if (count >= decorator.options.maxTriggerPerBatch) {
+        const effectName = root?.name || 'anonymous';
+        const message = `Aggressive trigger detected: effect "${effectName}" triggered ${count} times in the batch by the same cause.`;
+        if (decorator.options.maxEffectReaction === 'throw') {
+            throw new decorator.ReactiveError(message, {
+                code: decorator.ReactiveErrorCode.MaxReactionExceeded,
+                count,
+                effect: effectName,
+            });
+        }
+        decorator.options.warn(`[reactive] ${message}`);
+    }
+}
 /**
  * Registers a debug callback that is called when the current effect is triggered by a dependency change
  *
@@ -1421,6 +1290,7 @@ function addGraphEdge(callerRoot, targetRoot) {
  * @param end - Target node
  * @param exclude - Node to exclude from the path
  * @returns true if a path exists without going through the excluded node
+ * @todo Can be REALLY costly - optimise or make optional or ...
  */
 function hasPathExcluding(start, end, exclude) {
     if (start === end)
@@ -1549,6 +1419,9 @@ function cleanupEffectFromGraph(effect) {
 // Track currently executing effects to prevent re-execution
 // These are all the effects triggered under `activeEffect`
 let batchQueue;
+function hasBatched(effect) {
+    return batchQueue?.all.has(getRoot(effect));
+}
 const batchCleanups = new Set();
 /**
  * Computes and caches in-degrees for all effects in the batch
@@ -1705,6 +1578,12 @@ function wouldCreateCycle(callerRoot, targetRoot) {
  * @param immediate - If true, don't create edges in the dependency graph
  */
 function addToBatch(effect, caller, immediate) {
+    const cleanupFn = effect[decorator.cleanup];
+    if (cleanupFn)
+        cleanupFn();
+    // If the effect was stopped during cleanup (e.g. lazy memoization), don't add it to the batch
+    if (effect[decorator.stopped])
+        return;
     if (!batchQueue)
         return;
     const root = getRoot(effect);
@@ -1723,14 +1602,14 @@ function addToBatch(effect, caller, immediate) {
             const cycleMessage = cyclePath.length > 0
                 ? `Cycle detected: ${cyclePath.map((r) => r.name || r.toString()).join(' → ')}`
                 : `Cycle detected: ${callerRoot.name || callerRoot.toString()} → ${root.name || root.toString()} (and back)`;
-            const cycleHandling = options.cycleHandling;
+            const cycleHandling = decorator.options.cycleHandling;
             // In strict mode, we throw immediately on detection
             if (cycleHandling === 'strict') {
                 batchQueue.all.delete(root);
                 const causalChain = getTriggerChain(effect);
                 const creationStack = effectCreationStacks.get(root);
-                throw new ReactiveError(`[reactive] Strict Cycle Prevention: ${cycleMessage}`, {
-                    code: ReactiveErrorCode.CycleDetected,
+                throw new decorator.ReactiveError(`[reactive] Strict Cycle Prevention: ${cycleMessage}`, {
+                    code: decorator.ReactiveErrorCode.CycleDetected,
                     cycle: cyclePath.map((r) => r.name || r.toString()),
                     details: cycleMessage,
                     causalChain,
@@ -1743,8 +1622,8 @@ function addToBatch(effect, caller, immediate) {
                     batchQueue.all.delete(root);
                     const causalChain = getTriggerChain(effect);
                     const creationStack = effectCreationStacks.get(root);
-                    throw new ReactiveError(`[reactive] ${cycleMessage}`, {
-                        code: ReactiveErrorCode.CycleDetected,
+                    throw new decorator.ReactiveError(`[reactive] ${cycleMessage}`, {
+                        code: decorator.ReactiveErrorCode.CycleDetected,
                         cycle: cyclePath.map((r) => r.name || r.toString()),
                         details: cycleMessage,
                         causalChain,
@@ -1752,7 +1631,7 @@ function addToBatch(effect, caller, immediate) {
                     });
                 }
                 case 'warn':
-                    options.warn(`[reactive] ${cycleMessage}`);
+                    decorator.options.warn(`[reactive] ${cycleMessage}`);
                     // Don't add the edge, break the cycle
                     batchQueue.all.delete(root);
                     return;
@@ -1901,12 +1780,12 @@ function executeNext(effectuatedRoots) {
             const cycleMessage = cycle.length > 0
                 ? `Cycle detected: ${cycle.map((r) => r.name || '<anonymous>').join(' → ')}`
                 : 'Cycle detected in effect batch - all effects have dependencies that prevent execution';
-            const cycleHandling = options.cycleHandling;
+            const cycleHandling = decorator.options.cycleHandling;
             switch (cycleHandling) {
                 case 'throw':
-                    throw new ReactiveError(`[reactive] ${cycleMessage}`);
+                    throw new decorator.ReactiveError(`[reactive] ${cycleMessage}`);
                 case 'warn': {
-                    options.warn(`[reactive] ${cycleMessage}`);
+                    decorator.options.warn(`[reactive] ${cycleMessage}`);
                     // Break the cycle by executing one effect anyway
                     const firstEffect = batchQueue.all.values().next().value;
                     if (firstEffect) {
@@ -1949,7 +1828,7 @@ function batch(effect, immediate) {
     const roots = effect.map(getRoot);
     if (batchQueue) {
         // Nested batch - add to existing
-        options?.chain(roots, getRoot(getActiveEffect()));
+        decorator.options?.chain(roots, getRoot(getActiveEffect()));
         const caller = getActiveEffect();
         for (let i = 0; i < effect.length; i++) {
             addToBatch(effect[i], caller, immediate === 'immediate');
@@ -1974,7 +1853,11 @@ function batch(effect, immediate) {
     }
     else {
         // New batch - initialize
-        options.beginChain(roots);
+        if (!activationRegistry)
+            activationRegistry = new Map();
+        else
+            throw new Error('Batch already in progress');
+        decorator.options.beginChain(roots);
         batchQueue = {
             all: new Map(),
             inDegrees: new Map(),
@@ -2004,7 +1887,7 @@ function batch(effect, immediate) {
                 // After immediate execution, execute any effects that were triggered during execution
                 // This is important for @atomic decorator - effects triggered inside should still run
                 while (batchQueue.all.size > 0) {
-                    if (effectuatedRoots.length > options.maxEffectChain) {
+                    if (effectuatedRoots.length > decorator.options.maxEffectChain) {
                         const cycle = findCycleInChain(effectuatedRoots);
                         const trace = formatRoots(effectuatedRoots);
                         const message = cycle
@@ -2013,11 +1896,11 @@ function batch(effect, immediate) {
                         const queuedRoots = batchQueue ? Array.from(batchQueue.all.keys()) : [];
                         const queued = queuedRoots.map((r) => r.name || '<anonymous>');
                         const debugInfo = {
-                            code: ReactiveErrorCode.MaxDepthExceeded,
+                            code: decorator.ReactiveErrorCode.MaxDepthExceeded,
                             effectuatedRoots,
                             cycle,
                             trace,
-                            maxEffectChain: options.maxEffectChain,
+                            maxEffectChain: decorator.options.maxEffectChain,
                             queued: queued.slice(0, 50),
                             queuedCount: queued.length,
                             // Try to get causation for the last effect
@@ -2025,15 +1908,15 @@ function batch(effect, immediate) {
                                 ? getTriggerChain(batchQueue.all.get(effectuatedRoots[effectuatedRoots.length - 1]))
                                 : [],
                         };
-                        switch (options.maxEffectReaction) {
+                        switch (decorator.options.maxEffectReaction) {
                             case 'throw':
-                                throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                                throw new decorator.ReactiveError(`[reactive] ${message}`, debugInfo);
                             case 'debug':
                                 // biome-ignore lint/suspicious/noDebugger: This is the whole point here
                                 debugger;
-                                throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                                throw new decorator.ReactiveError(`[reactive] ${message}`, debugInfo);
                             case 'warn':
-                                options.warn(`[reactive] ${message} (queued: ${queued.slice(0, 10).join(', ')}${queued.length > 10 ? ', …' : ''})`);
+                                decorator.options.warn(`[reactive] ${message} (queued: ${queued.slice(0, 10).join(', ')}${queued.length > 10 ? ', …' : ''})`);
                                 break;
                         }
                     }
@@ -2052,8 +1935,9 @@ function batch(effect, immediate) {
                 return firstReturn.value;
             }
             finally {
+                activationRegistry = undefined;
                 batchQueue = undefined;
-                options.endChain();
+                decorator.options.endChain();
             }
         }
         else {
@@ -2065,7 +1949,7 @@ function batch(effect, immediate) {
                 while (batchQueue.all.size > 0 || batchCleanups.size > 0) {
                     // Inner loop: execute all pending effects
                     while (batchQueue.all.size > 0) {
-                        if (effectuatedRoots.length > options.maxEffectChain) {
+                        if (effectuatedRoots.length > decorator.options.maxEffectChain) {
                             const cycle = findCycleInChain(effectuatedRoots);
                             const trace = formatRoots(effectuatedRoots);
                             const message = cycle
@@ -2074,11 +1958,11 @@ function batch(effect, immediate) {
                             const queuedRoots = batchQueue ? Array.from(batchQueue.all.keys()) : [];
                             const queued = queuedRoots.map((r) => r.name || '<anonymous>');
                             const debugInfo = {
-                                code: ReactiveErrorCode.MaxDepthExceeded,
+                                code: decorator.ReactiveErrorCode.MaxDepthExceeded,
                                 effectuatedRoots,
                                 cycle,
                                 trace,
-                                maxEffectChain: options.maxEffectChain,
+                                maxEffectChain: decorator.options.maxEffectChain,
                                 queued: queued.slice(0, 50),
                                 queuedCount: queued.length,
                                 // Try to get causation for the last effect
@@ -2086,15 +1970,15 @@ function batch(effect, immediate) {
                                     ? getTriggerChain(batchQueue.all.get(effectuatedRoots[effectuatedRoots.length - 1]))
                                     : [],
                             };
-                            switch (options.maxEffectReaction) {
+                            switch (decorator.options.maxEffectReaction) {
                                 case 'throw':
-                                    throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                                    throw new decorator.ReactiveError(`[reactive] ${message}`, debugInfo);
                                 case 'debug':
                                     // biome-ignore lint/suspicious/noDebugger: This is the whole point here
                                     debugger;
-                                    throw new ReactiveError(`[reactive] ${message}`, debugInfo);
+                                    throw new decorator.ReactiveError(`[reactive] ${message}`, debugInfo);
                                 case 'warn':
-                                    options.warn(`[reactive] ${message} (queued: ${queued.slice(0, 10).join(', ')}${queued.length > 10 ? ', …' : ''})`);
+                                    decorator.options.warn(`[reactive] ${message} (queued: ${queued.slice(0, 10).join(', ')}${queued.length > 10 ? ', …' : ''})`);
                                     break;
                             }
                         }
@@ -2122,8 +2006,9 @@ function batch(effect, immediate) {
                 return firstReturn.value;
             }
             finally {
+                activationRegistry = undefined;
                 batchQueue = undefined;
-                options.endChain();
+                decorator.options.endChain();
             }
         }
     }
@@ -2134,12 +2019,18 @@ function batch(effect, immediate) {
 const atomic = decorator.decorator({
     method(original) {
         return function (...args) {
-            return batch(markWithRoot(() => original.apply(this, args), original), 'immediate');
+            const atomicEffect = () => original.apply(this, args);
+            // Debug: helpful to have a name
+            Object.defineProperty(atomicEffect, 'name', { value: `atomic(${original.name})` });
+            return batch(atomicEffect, 'immediate');
         };
     },
     default(original) {
         return function (...args) {
-            return batch(markWithRoot(() => original.apply(this, args), original), 'immediate');
+            const atomicEffect = () => original.apply(this, args);
+            // Debug: helpful to have a name
+            Object.defineProperty(atomicEffect, 'name', { value: `atomic(${original.name})` });
+            return batch(atomicEffect, 'immediate');
         };
     },
 });
@@ -2161,8 +2052,8 @@ fn, effectOptions) {
     // Inject batch function to allow atomic game loops in requestAnimationFrame
     ensureZoneHooked(batch);
     // Use per-effect asyncMode or fall back to global option
-    const asyncMode = effectOptions?.asyncMode ?? options.asyncMode ?? 'cancel';
-    if (options.introspection.enableHistory) {
+    const asyncMode = effectOptions?.asyncMode ?? decorator.options.asyncMode ?? 'cancel';
+    if (decorator.options.introspection.enableHistory) {
         const stack = new Error().stack;
         if (stack) {
             // Clean up the stack trace to remove internal frames
@@ -2173,7 +2064,7 @@ fn, effectOptions) {
     let cleanup = null;
     // capture the parent effect at creation time for ascend
     const parentsForAscend = captureEffectStack();
-    const tracked = markWithRoot((cb) => withEffect(runEffect, cb), fn);
+    const tracked = (cb) => withEffect(runEffect, cb);
     const ascend = (cb) => withEffectStack(parentsForAscend, cb);
     let effectStopped = false;
     let hasReacted = false;
@@ -2203,7 +2094,7 @@ fn, effectOptions) {
         // The effect has been stopped after having been planned
         if (effectStopped)
             return;
-        options.enter(getRoot(fn));
+        decorator.options.enter(getRoot(fn));
         let reactionCleanup;
         let result;
         try {
@@ -2211,7 +2102,7 @@ fn, effectOptions) {
             if (result &&
                 typeof result !== 'function' &&
                 (typeof result !== 'object' || !('then' in result)))
-                throw new ReactiveError(`[reactive] Effect returned a non-function value: ${result}`);
+                throw new decorator.ReactiveError(`[reactive] Effect returned a non-function value: ${result}`);
             // Check if result is a Promise (async effect)
             if (result && typeof result === 'object' && typeof result.then === 'function') {
                 const originalPromise = result;
@@ -2220,7 +2111,7 @@ fn, effectOptions) {
                 const cancelPromise = new Promise((_, reject) => {
                     cancelReject = reject;
                 });
-                const cancelError = new ReactiveError('[reactive] Effect canceled due to dependency change');
+                const cancelError = new decorator.ReactiveError('[reactive] Effect canceled due to dependency change');
                 // Race between the actual promise and cancellation
                 // If canceled, the race rejects, which will propagate through any promise chain
                 runningPromise = Promise.race([originalPromise, cancelPromise]);
@@ -2242,7 +2133,7 @@ fn, effectOptions) {
         }
         finally {
             hasReacted = true;
-            options.leave(fn);
+            decorator.options.leave(fn);
         }
         // Create cleanup function for next run
         cleanup = () => {
@@ -2306,11 +2197,28 @@ fn, effectOptions) {
         cleanupEffectFromGraph(runEffect);
         fr.unregister(stopEffect);
     };
+    function augmentedRv(rv) {
+        Object.defineProperty(rv, decorator.stopped, {
+            get() {
+                return effectStopped;
+            },
+        });
+        Object.defineProperty(rv, decorator.cleanup, {
+            value: () => {
+                if (cleanup) {
+                    const prevCleanup = cleanup;
+                    cleanup = null;
+                    withEffect(undefined, () => prevCleanup());
+                }
+            },
+        });
+        return rv;
+    }
     if (isRootEffect) {
-        const callIfCollected = () => stopEffect();
+        const callIfCollected = augmentedRv(() => stopEffect());
         fr.register(callIfCollected, () => {
             stopEffect();
-            options.garbageCollected(fn);
+            decorator.options.garbageCollected(fn);
         }, stopEffect);
         return callIfCollected;
     }
@@ -2320,14 +2228,14 @@ fn, effectOptions) {
         children = new Set();
         effectChildren.set(parent, children);
     }
-    const subEffectCleanup = () => {
+    const subEffectCleanup = augmentedRv(() => {
         children.delete(subEffectCleanup);
         if (children.size === 0) {
             effectChildren.delete(parent);
         }
         // Execute this child effect cleanup (which triggers its own mainCleanup)
         stopEffect();
-    };
+    });
     children.add(subEffectCleanup);
     return subEffectCleanup;
 }
@@ -2488,10 +2396,14 @@ function collectEffects(obj, evolution, effects, objectWatchers, ...keyChains) {
                 for (const effect of deps) {
                     const runningChain = isRunning(effect);
                     if (runningChain) {
-                        options.skipRunningEffect(effect, runningChain);
+                        decorator.options.skipRunningEffect(effect, runningChain);
                         continue;
                     }
-                    effects.add(effect);
+                    if (!effects.has(effect)) {
+                        effects.add(effect);
+                        if (!hasBatched(effect))
+                            recordActivation(effect, obj, evolution, key);
+                    }
                     const trackers = effectTrackers.get(effect);
                     recordTriggerLink(sourceEffect, effect, obj, key, evolution);
                     if (trackers) {
@@ -2525,10 +2437,10 @@ function touched(obj, evolution, props) {
         // Note: we have to collect effects to remove duplicates in the specific case when no batch is running
         const effects = new Set();
         if (props)
-            collectEffects(obj, evolution, effects, objectWatchers, [allProps], props);
+            collectEffects(obj, evolution, effects, objectWatchers, [decorator.allProps], props);
         else
             collectEffects(obj, evolution, effects, objectWatchers, objectWatchers.keys());
-        options.touched(obj, evolution, props, effects);
+        decorator.options.touched(obj, evolution, props, effects);
         batch(Array.from(effects));
     }
     // Bubble up changes if this object has deep watchers
@@ -2555,10 +2467,11 @@ function touchedOpaque(obj, evolution, prop) {
             continue;
         const runningChain = isRunning(effect);
         if (runningChain) {
-            options.skipRunningEffect(effect, runningChain);
+            decorator.options.skipRunningEffect(effect, runningChain);
             continue;
         }
         effects.add(effect);
+        recordActivation(effect, obj, evolution, prop);
         const trackers = effectTrackers.get(effect);
         recordTriggerLink(sourceEffect, effect, obj, prop, evolution);
         if (trackers) {
@@ -2568,7 +2481,7 @@ function touchedOpaque(obj, evolution, prop) {
         }
     }
     if (effects.size > 0) {
-        options.touched(obj, evolution, [prop], effects);
+        decorator.options.touched(obj, evolution, [prop], effects);
         batch(Array.from(effects));
     }
 }
@@ -2579,7 +2492,7 @@ const absent = Symbol('absent');
 function markNonReactive(...obj) {
     for (const o of obj) {
         try {
-            Object.defineProperty(o, nonReactiveMark, {
+            Object.defineProperty(o, decorator.nonReactiveMark, {
                 value: true,
                 writable: false,
                 enumerable: false,
@@ -2587,7 +2500,7 @@ function markNonReactive(...obj) {
             });
         }
         catch { }
-        if (!(nonReactiveMark in o))
+        if (!(decorator.nonReactiveMark in o))
             nonReactiveObjects.add(o);
     }
     return obj[0];
@@ -2595,7 +2508,7 @@ function markNonReactive(...obj) {
 function nonReactiveClass(...cls) {
     for (const c of cls)
         if (c)
-            c.prototype[nonReactiveMark] = true;
+            c.prototype[decorator.nonReactiveMark] = true;
     return cls[0];
 }
 function isNonReactive(obj) {
@@ -2603,7 +2516,7 @@ function isNonReactive(obj) {
         return true;
     if (nonReactiveObjects.has(obj))
         return true;
-    if (obj[nonReactiveMark])
+    if (obj[decorator.nonReactiveMark])
         return true;
     for (const fn of immutables)
         if (fn(obj))
@@ -2611,7 +2524,7 @@ function isNonReactive(obj) {
     return false;
 }
 function registerNativeReactivity(originalClass, reactiveClass) {
-    originalClass.prototype[nativeReactive] = reactiveClass;
+    originalClass.prototype[decorator.nativeReactive] = reactiveClass;
     nonReactiveClass(reactiveClass);
 }
 nonReactiveClass(Date, RegExp, Error, Promise, Function);
@@ -2657,7 +2570,7 @@ function shouldRecurseTouch(oldValue, newValue) {
  */
 function notifyPropertyChange(targetObj, prop, oldValue, newValue, hadProperty) {
     const evolution = { type: hadProperty ? 'set' : 'add', prop };
-    if (options.recursiveTouching &&
+    if (decorator.options.recursiveTouching &&
         oldValue !== undefined &&
         shouldRecurseTouch(oldValue, newValue)) {
         const unwrappedObj = unwrap(targetObj);
@@ -2794,7 +2707,7 @@ function dispatchNotifications(notifications) {
         const originWatchers = watchers.get(origin.obj);
         if (originWatchers) {
             const originEffects = new Set();
-            collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, [allProps], [origin.prop]);
+            collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, [decorator.allProps], [origin.prop]);
             for (const effect of originEffects)
                 allowedEffects.add(effect);
         }
@@ -2812,7 +2725,7 @@ function dispatchNotifications(notifications) {
         const propsArray = [prop];
         if (objectWatchers) {
             currentEffects = new Set();
-            collectEffects(obj, evolution, currentEffects, objectWatchers, [allProps], propsArray);
+            collectEffects(obj, evolution, currentEffects, objectWatchers, [decorator.allProps], propsArray);
             // Filter effects by ancestor chain if origin exists
             // Include effects that either directly depend on origin or have an ancestor that does
             if (origin && allowedEffects) {
@@ -2828,7 +2741,7 @@ function dispatchNotifications(notifications) {
             for (const effect of currentEffects)
                 combinedEffects.add(effect);
         }
-        options.touched(obj, evolution, propsArray, currentEffects);
+        decorator.options.touched(obj, evolution, propsArray, currentEffects);
         if (objectsWithDeepWatchers.has(obj))
             bubbleUpChange(obj);
     }
@@ -2840,18 +2753,18 @@ const hasReentry = [];
 const reactiveHandlers = {
     [Symbol.toStringTag]: 'MutTs Reactive',
     get(obj, prop, receiver) {
-        if (prop === nonReactiveMark)
+        if (prop === decorator.nonReactiveMark)
             return false;
         const unwrappedObj = unwrap(obj);
         // Check if this property is marked as unreactive
-        if (unwrappedObj[unreactiveProperties]?.has(prop) || typeof prop === 'symbol')
+        if (unwrappedObj[decorator.unreactiveProperties]?.has(prop) || typeof prop === 'symbol')
             return decorator.ReflectGet(obj, prop, receiver);
         // Special-case: array wrappers use prototype forwarding + numeric accessors.
         // With options.instanceMembers=true, inherited reads are normally not tracked, which breaks
         // reactivity for array indices/length (they appear inherited on the proxy).
-        const isArrayCase = prototypeForwarding in obj &&
+        const isArrayCase = decorator.prototypeForwarding in obj &&
             // biome-ignore lint/suspicious/useIsArray: This is the whole point here
-            obj[prototypeForwarding] instanceof Array &&
+            obj[decorator.prototypeForwarding] instanceof Array &&
             typeof prop === 'string' &&
             (prop === 'length' || !Number.isNaN(Number(prop)));
         if (isArrayCase) {
@@ -2863,16 +2776,16 @@ const reactiveHandlers = {
         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
-        const shouldIgnoreAccessor = options.ignoreAccessors &&
+        const shouldIgnoreAccessor = decorator.options.ignoreAccessors &&
             isOwnProp &&
             (decorator.isOwnAccessor(receiver, prop) || decorator.isOwnAccessor(unwrappedObj, prop));
         // Depend if...
         if (!hasProp ||
-            (!(options.instanceMembers && isInheritedAccess && obj instanceof Object) &&
+            (!(decorator.options.instanceMembers && isInheritedAccess && obj instanceof Object) &&
                 !shouldIgnoreAccessor))
             dependant(obj, prop);
         // Watch the whole prototype chain when requested or for null-proto objects
-        if (isInheritedAccess && (!options.instanceMembers || !(obj instanceof Object))) {
+        if (isInheritedAccess && (!decorator.options.instanceMembers || !(obj instanceof Object))) {
             let current = reactiveObject(Object.getPrototypeOf(obj));
             while (current && current !== Object.prototype) {
                 dependant(current, prop);
@@ -2901,12 +2814,12 @@ const reactiveHandlers = {
         const unwrappedObj = unwrap(obj);
         const unwrappedReceiver = unwrap(receiver);
         // Check if this property is marked as unreactive
-        if (unwrappedObj[unreactiveProperties]?.has(prop) || unwrappedObj !== unwrappedReceiver)
+        if (unwrappedObj[decorator.unreactiveProperties]?.has(prop) || unwrappedObj !== unwrappedReceiver)
             return decorator.ReflectSet(obj, prop, value, receiver);
         // Really specific case for when Array is forwarder, in order to let it manage the reactivity
-        const isArrayCase = prototypeForwarding in obj &&
+        const isArrayCase = decorator.prototypeForwarding in obj &&
             // biome-ignore lint/suspicious/useIsArray: This is the whole point here
-            obj[prototypeForwarding] instanceof Array &&
+            obj[decorator.prototypeForwarding] instanceof Array &&
             (!Number.isNaN(Number(prop)) || prop === 'length');
         const newValue = unwrap(value);
         if (isArrayCase) {
@@ -2921,13 +2834,13 @@ const reactiveHandlers = {
             const receiverDesc = Object.getOwnPropertyDescriptor(unwrappedReceiver, prop);
             const targetDesc = Object.getOwnPropertyDescriptor(unwrappedObj, prop);
             const desc = receiverDesc || targetDesc;
-            // If it's a getter-only accessor (has getter but no setter), read without tracking
-            // to avoid breaking memoization invalidation when the getter calls memoized functions
+            // We *need* to use `receiver` and not `unwrappedObj` here, otherwise we break
+            // the dependency tracking for memoized getters
             if (desc?.get && !desc?.set) {
-                oldVal = withEffect(undefined, () => Reflect.get(unwrappedObj, prop, unwrappedReceiver));
+                oldVal = withEffect(undefined, () => Reflect.get(unwrappedObj, prop, receiver));
             }
             else {
-                oldVal = Reflect.get(unwrappedObj, prop, unwrappedReceiver);
+                oldVal = withEffect(undefined, () => Reflect.get(unwrappedObj, prop, receiver));
             }
         }
         if (objectsWithDeepWatchers.has(obj)) {
@@ -2950,8 +2863,8 @@ const reactiveHandlers = {
     },
     has(obj, prop) {
         if (hasReentry.includes(obj))
-            throw new ReactiveError(`[reactive] Circular dependency detected in 'has' check for property '${String(prop)}'`, {
-                code: ReactiveErrorCode.CycleDetected,
+            throw new decorator.ReactiveError(`[reactive] Circular dependency detected in 'has' check for property '${String(prop)}'`, {
+                code: decorator.ReactiveErrorCode.CycleDetected,
                 cycle: [], // We don't have the full cycle here, but we know it involves obj
             });
         hasReentry.push(obj);
@@ -2977,18 +2890,18 @@ const reactiveHandlers = {
         return true;
     },
     getPrototypeOf(obj) {
-        if (prototypeForwarding in obj)
-            return obj[prototypeForwarding];
+        if (decorator.prototypeForwarding in obj)
+            return obj[decorator.prototypeForwarding];
         return Object.getPrototypeOf(obj);
     },
     setPrototypeOf(obj, proto) {
-        if (prototypeForwarding in obj)
+        if (decorator.prototypeForwarding in obj)
             return false;
         Object.setPrototypeOf(obj, proto);
         return true;
     },
     ownKeys(obj) {
-        dependant(obj, allProps);
+        dependant(obj, decorator.allProps);
         return Reflect.ownKeys(obj);
     },
 };
@@ -3024,8 +2937,8 @@ function reactiveObject(anyTarget) {
     const existing = getExistingProxy(target);
     if (existing !== undefined)
         return existing;
-    const proxied = nativeReactive in target && !(target instanceof target[nativeReactive])
-        ? new target[nativeReactive](target)
+    const proxied = decorator.nativeReactive in target && !(target instanceof target[decorator.nativeReactive])
+        ? new target[decorator.nativeReactive](target)
         : target;
     if (proxied !== target)
         trackProxyObject(proxied, target);
@@ -3048,7 +2961,7 @@ const reactive = decorator.decorator({
             constructor(...args) {
                 super(...args);
                 if (new.target !== Reactive && !reactiveClasses.has(new.target))
-                    options.warn(`${original.name} has been inherited by ${this.constructor.name} that is not reactive.
+                    decorator.options.warn(`${original.name} has been inherited by ${this.constructor.name} that is not reactive.
 @reactive decorator must be applied to the leaf class OR classes have to extend ReactiveBase.`);
                 // biome-ignore lint/correctness/noConstructorReturn: This is the whole point here
                 return reactive(this);
@@ -3105,7 +3018,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
         const visited = new WeakSet();
         function traverseAndTrack(obj, depth = 0) {
             // Prevent infinite recursion and excessive depth
-            if (!obj || visited.has(obj) || !isObject(obj) || depth > options.maxDeepWatchDepth)
+            if (!obj || visited.has(obj) || !isObject(obj) || depth > decorator.options.maxDeepWatchDepth)
                 return;
             // Do not traverse into unreactive objects
             if (isNonReactive(obj))
@@ -3217,12 +3130,12 @@ function watchObject(value, changed, { immediate = false, deep = false } = {}) {
     const myParentEffect = getActiveEffect();
     if (deep)
         return deepWatch(value, changed, { immediate });
-    return effect(markWithRoot(function watchObjectEffect() {
+    return effect(function watchObjectEffect() {
         dependant(value);
         if (immediate)
             withEffect(myParentEffect, () => changed(value));
         immediate = true;
-    }, changed));
+    });
 }
 function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
     const myParentEffect = getActiveEffect();
@@ -3231,7 +3144,7 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
     const cbCleanup = effect(markWithRoot(function watchCallBackEffect(access) {
         const newValue = value(access);
         if (oldValue !== newValue)
-            withEffect(myParentEffect, markWithRoot(() => {
+            withEffect(myParentEffect, () => {
                 if (oldValue === unsetYet) {
                     if (immediate)
                         changed(newValue);
@@ -3242,9 +3155,9 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
                 if (deep) {
                     if (deepCleanup)
                         deepCleanup();
-                    deepCleanup = deepWatch(newValue, markWithRoot((value) => changed(value, value), changed));
+                    deepCleanup = deepWatch(newValue, (value) => changed(value, value));
                 }
-            }, changed));
+            });
     }, value));
     return () => {
         cbCleanup();
@@ -3263,7 +3176,7 @@ function deepNonReactive(obj) {
     if (isNonReactive(obj))
         return obj;
     try {
-        Object.defineProperty(obj, nonReactiveMark, {
+        Object.defineProperty(obj, decorator.nonReactiveMark, {
             value: true,
             writable: false,
             enumerable: false,
@@ -3271,7 +3184,7 @@ function deepNonReactive(obj) {
         });
     }
     catch { }
-    if (!(nonReactiveMark in obj))
+    if (!(decorator.nonReactiveMark in obj))
         nonReactiveObjects.add(obj);
     //for (const key in obj) deepNonReactive(obj[key])
     return obj;
@@ -3281,11 +3194,11 @@ function unreactiveApplication(arg1, ...args) {
         ? deepNonReactive(arg1)
         : ((original) => {
             // Copy the parent's unreactive properties if they exist
-            original.prototype[unreactiveProperties] = new Set(original.prototype[unreactiveProperties] || []);
+            original.prototype[decorator.unreactiveProperties] = new Set(original.prototype[decorator.unreactiveProperties] || []);
             // Add all arguments (including the first one)
-            original.prototype[unreactiveProperties].add(arg1);
+            original.prototype[decorator.unreactiveProperties].add(arg1);
             for (const arg of args)
-                original.prototype[unreactiveProperties].add(arg);
+                original.prototype[decorator.unreactiveProperties].add(arg);
             return original; // Return the class
         });
 }
@@ -3317,9 +3230,9 @@ function cleanedBy(obj, cleanupFn) {
  */
 function derived(compute) {
     const rv = { value: undefined };
-    return cleanedBy(rv, untracked(() => effect(markWithRoot(function derivedEffect(access) {
+    return cleanedBy(rv, untracked(() => effect(function derivedEffect(access) {
         rv.value = compute(access);
-    }, compute))));
+    })));
 }
 
 /**
@@ -3347,11 +3260,10 @@ function* makeReactiveEntriesIterator(iterator) {
 const native$2 = Symbol('native');
 const isArray = Array.isArray;
 Array.isArray = ((value) => isArray(value) ||
-    // biome-ignore lint/suspicious/useIsArray: We are defining it
     (value &&
         typeof value === 'object' &&
-        prototypeForwarding in value &&
-        Array.isArray(value[prototypeForwarding])));
+        decorator.prototypeForwarding in value &&
+        Array.isArray(value[decorator.prototypeForwarding])));
 class ReactiveBaseArray {
     // Safe array access with negative indices
     at(index) {
@@ -3564,7 +3476,7 @@ class ReactiveArray extends indexable.Indexable(ReactiveBaseArray, {
         Object.defineProperties(this, {
             // We have to make it double, as [native] must be `unique symbol` - impossible through import
             [native$2]: { value: original },
-            [prototypeForwarding]: { value: original },
+            [decorator.prototypeForwarding]: { value: original },
         });
     }
     push(...items) {
@@ -3695,7 +3607,7 @@ class ReactiveReadOnlyArrayClass extends indexable.Indexable(ReactiveBaseArray,
         Object.defineProperties(this, {
             // We have to make it double, as [native] must be `unique symbol` - impossible through import
             [native$2]: { value: original },
-            [prototypeForwarding]: { value: original },
+            [decorator.prototypeForwarding]: { value: original },
         });
     }
     push(..._items) {
@@ -3776,6 +3688,7 @@ function reduced(inputs, compute) {
 }
 
 const memoizedRegistry = new WeakMap();
+const wrapperRegistry = new WeakMap();
 function getBranch(tree, key) {
     tree.branches ?? (tree.branches = new WeakMap());
     let branch = tree.branches.get(key);
@@ -3796,15 +3709,30 @@ function memoizeFunction(fn) {
         if (localArgs.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg))))
             throw new Error('memoize expects non-null object arguments');
         let node = cacheRoot;
+        // Note: decorators add `this` as first argument
         for (const arg of localArgs) {
             node = getBranch(node, arg);
         }
         dependant(node, 'memoize');
-        if ('result' in node)
+        if ('result' in node) {
+            if (decorator.options.onMemoizationDiscrepancy) {
+                const wasVerification = decorator.options.isVerificationRun;
+                decorator.options.isVerificationRun = true;
+                try {
+                    const fresh = untracked(() => fn(...localArgs));
+                    if (!decorator.deepCompare(node.result, fresh)) {
+                        decorator.options.onMemoizationDiscrepancy(node.result, fresh, fn, localArgs, 'calculation');
+                    }
+                }
+                finally {
+                    decorator.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(markWithRoot(() => {
+        node.cleanup = root(() => effect(() => {
             // Execute the function and track its dependencies
             // The function execution will automatically track dependencies on reactive objects
             node.result = fn(...localArgs);
@@ -3812,8 +3740,27 @@ function memoizeFunction(fn) {
                 // When dependencies change, clear the cache and notify consumers
                 delete node.result;
                 touched1(node, { type: 'invalidate', prop: localArgs }, '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();
+                    node.cleanup = undefined;
+                }
             };
-        }, fnRoot), { opaque: true }));
+        }, { opaque: true }));
+        if (decorator.options.onMemoizationDiscrepancy) {
+            const wasVerification = decorator.options.isVerificationRun;
+            decorator.options.isVerificationRun = true;
+            try {
+                const fresh = untracked(() => fn(...localArgs));
+                if (!decorator.deepCompare(node.result, fresh)) {
+                    decorator.options.onMemoizationDiscrepancy(node.result, fresh, fn, localArgs, 'comparison');
+                }
+            }
+            finally {
+                decorator.options.isVerificationRun = wasVerification;
+            }
+        }
         return node.result;
     }, fn);
     memoizedRegistry.set(fnRoot, memoized);
@@ -3821,19 +3768,37 @@ function memoizeFunction(fn) {
     return memoized;
 }
 const memoize = decorator.decorator({
-    getter(original, propertyKey) {
-        const memoized = memoizeFunction(markWithRoot(decorator.renamed((that) => {
-            return original.call(that);
-        }, `${String(this.constructor.name)}.${String(propertyKey)}`), original));
+    getter(original, target, propertyKey) {
         return function () {
+            let wrapper = wrapperRegistry.get(original);
+            if (!wrapper) {
+                wrapper = markWithRoot(decorator.renamed((that) => {
+                    return original.call(that);
+                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`), {
+                    method: original,
+                    propertyKey,
+                    ...(original[decorator.rootFunction] ? { [decorator.rootFunction]: original[decorator.rootFunction] } : {}),
+                });
+                wrapperRegistry.set(original, wrapper);
+            }
+            const memoized = memoizeFunction(wrapper);
             return memoized(this);
         };
     },
-    method(original, name) {
-        const memoized = memoizeFunction(markWithRoot(decorator.renamed((that, ...args) => {
-            return original.call(that, ...args);
-        }, `${String(this.constructor.name)}.${String(name)}`), original));
+    method(original, target, name) {
         return function (...args) {
+            let wrapper = wrapperRegistry.get(original);
+            if (!wrapper) {
+                wrapper = markWithRoot(decorator.renamed((that, ...args) => {
+                    return original.call(that, ...args);
+                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`), {
+                    method: original,
+                    propertyKey: name,
+                    ...(original[decorator.rootFunction] ? { [decorator.rootFunction]: original[decorator.rootFunction] } : {}),
+                });
+                wrapperRegistry.set(original, wrapper);
+            }
+            const memoized = memoizeFunction(wrapper);
             return memoized(this, ...args);
         };
     },
@@ -3895,7 +3860,7 @@ let RegisterClass = (() => {
             _tslib.__classPrivateFieldSet(this, _RegisterClass_keys, reactive([]), "f");
             _tslib.__classPrivateFieldSet(this, _RegisterClass_values, reactive(new Map()), "f");
             Object.defineProperties(this, {
-                [prototypeForwarding]: { value: _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f") },
+                [decorator.prototypeForwarding]: { value: _tslib.__classPrivateFieldGet(this, _RegisterClass_keys, "f") },
             });
             if (initial)
                 this.push(...initial);
@@ -4243,6 +4208,17 @@ function register(keyFn, initial) {
     return new RegisterClass(keyFn, initial);
 }
 
+/**
+ * Maps projection effects (item effects) to their projection context
+ */
+const effectProjectionMetadata = new WeakMap();
+/**
+ * Returns the projection context of the currently running effect, if any.
+ */
+function getActiveProjection() {
+    const active = getActiveEffect();
+    return active ? effectProjectionMetadata.get(active) : undefined;
+}
 function defineAccessValue(access) {
     Object.defineProperty(access, 'value', {
         get: access.get,
@@ -4251,7 +4227,15 @@ function defineAccessValue(access) {
         enumerable: true,
     });
 }
-function makeCleanup(target, effectMap, onDispose) {
+function makeCleanup(target, effectMap, onDispose, metadata) {
+    if (metadata) {
+        Object.defineProperty(target, decorator.projectionInfo, {
+            value: metadata,
+            writable: false,
+            enumerable: false,
+            configurable: true,
+        });
+    }
     return cleanedBy(target, () => {
         onDispose();
         for (const stop of effectMap.values())
@@ -4274,6 +4258,8 @@ function projectArray(source, apply) {
             Reflect.deleteProperty(target, index);
         }
     }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
     const cleanupLength = effect(function projectArrayLengthEffect({ ascend }) {
         const length = observedSource.length;
         normalizeTargetLength(length);
@@ -4296,6 +4282,14 @@ function projectArray(source, apply) {
                     const produced = apply(accessBase, target);
                     target[index] = produced;
                 });
+                setEffectName(stop, `project[${depth}]:${index}`);
+                effectProjectionMetadata.set(stop, {
+                    source: observedSource,
+                    key: index,
+                    target,
+                    depth,
+                    parent,
+                });
                 indexEffects.set(i, stop);
             });
         }
@@ -4303,7 +4297,13 @@ function projectArray(source, apply) {
             if (index >= length)
                 disposeIndex(index);
     });
-    return makeCleanup(target, indexEffects, () => cleanupLength());
+    return makeCleanup(target, indexEffects, () => cleanupLength(), {
+        source: observedSource,
+        target,
+        apply,
+        depth,
+        parent,
+    });
 }
 function projectRegister(source, apply) {
     const observedSource = reactive(source);
@@ -4318,6 +4318,8 @@ function projectRegister(source, apply) {
             target.delete(key);
         }
     }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
     const cleanupKeys = effect(function projectRegisterEffect({ ascend }) {
         const keys = new Set();
         for (const key of observedSource.mapKeys())
@@ -4342,6 +4344,14 @@ function projectRegister(source, apply) {
                     const produced = apply(accessBase, target);
                     target.set(key, produced);
                 });
+                setEffectName(stop, `project[${depth}]:${String(key)}`);
+                effectProjectionMetadata.set(stop, {
+                    source: observedSource,
+                    key,
+                    target,
+                    depth,
+                    parent,
+                });
                 keyEffects.set(key, stop);
             });
         }
@@ -4349,7 +4359,13 @@ function projectRegister(source, apply) {
             if (!keys.has(key))
                 disposeKey(key);
     });
-    return makeCleanup(target, keyEffects, () => cleanupKeys());
+    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+        source: observedSource,
+        target,
+        apply,
+        depth,
+        parent,
+    });
 }
 function projectRecord(source, apply) {
     const observedSource = reactive(source);
@@ -4363,6 +4379,8 @@ function projectRecord(source, apply) {
             Reflect.deleteProperty(target, key);
         }
     }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
     const cleanupKeys = effect(function projectRecordEffect({ ascend }) {
         const keys = new Set();
         for (const key in observedSource)
@@ -4388,6 +4406,14 @@ function projectRecord(source, apply) {
                     const produced = apply(accessBase, target);
                     target[sourceKey] = produced;
                 });
+                setEffectName(stop, `project[${depth}]:${String(key)}`);
+                effectProjectionMetadata.set(stop, {
+                    source: observedSource,
+                    key,
+                    target,
+                    depth,
+                    parent,
+                });
                 keyEffects.set(key, stop);
             });
         }
@@ -4395,7 +4421,13 @@ function projectRecord(source, apply) {
             if (!keys.has(key))
                 disposeKey(key);
     });
-    return makeCleanup(target, keyEffects, () => cleanupKeys());
+    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+        source: observedSource,
+        target,
+        apply,
+        depth,
+        parent,
+    });
 }
 function projectMap(source, apply) {
     const observedSource = reactive(source);
@@ -4410,6 +4442,8 @@ function projectMap(source, apply) {
             target.delete(key);
         }
     }
+    const parent = getActiveProjection();
+    const depth = parent ? parent.depth + 1 : 0;
     const cleanupKeys = effect(function projectMapEffect({ ascend }) {
         const keys = new Set();
         for (const key of observedSource.keys())
@@ -4434,6 +4468,14 @@ function projectMap(source, apply) {
                     const produced = apply(accessBase, target);
                     target.set(key, produced);
                 });
+                setEffectName(stop, `project[${depth}]:${String(key)}`);
+                effectProjectionMetadata.set(stop, {
+                    source: observedSource,
+                    key,
+                    target,
+                    depth,
+                    parent,
+                });
                 keyEffects.set(key, stop);
             });
         }
@@ -4441,7 +4483,13 @@ function projectMap(source, apply) {
             if (!keys.has(key))
                 disposeKey(key);
     });
-    return makeCleanup(target, keyEffects, () => cleanupKeys());
+    return makeCleanup(target, keyEffects, () => cleanupKeys(), {
+        source: observedSource,
+        target,
+        apply,
+        depth,
+        parent,
+    });
 }
 function projectCore(source, apply) {
     if (Array.isArray(source))
@@ -4588,8 +4636,8 @@ class ReactiveWeakMap {
     constructor(original) {
         Object.defineProperties(this, {
             [native$1]: { value: original },
-            [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
+            [decorator.prototypeForwarding]: { value: original },
+            content: { value: Symbol('WeakMapContent') },
             [Symbol.toStringTag]: { value: 'ReactiveWeakMap' },
         });
     }
@@ -4628,8 +4676,8 @@ class ReactiveMap {
     constructor(original) {
         Object.defineProperties(this, {
             [native$1]: { value: original },
-            [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
+            [decorator.prototypeForwarding]: { value: original },
+            content: { value: Symbol('MapContent') },
             [Symbol.toStringTag]: { value: 'ReactiveMap' },
         });
     }
@@ -4723,8 +4771,8 @@ class ReactiveWeakSet {
     constructor(original) {
         Object.defineProperties(this, {
             [native]: { value: original },
-            [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
+            [decorator.prototypeForwarding]: { value: original },
+            content: { value: Symbol('WeakSetContent') },
             [Symbol.toStringTag]: { value: 'ReactiveWeakSet' },
         });
     }
@@ -4758,8 +4806,8 @@ class ReactiveSet {
     constructor(original) {
         Object.defineProperties(this, {
             [native]: { value: original },
-            [prototypeForwarding]: { value: original },
-            content: { value: Symbol('content') },
+            [decorator.prototypeForwarding]: { value: original },
+            content: { value: Symbol('SetContent') },
             [Symbol.toStringTag]: { value: 'ReactiveSet' },
         });
     }
@@ -4858,7 +4906,6 @@ const profileInfo = {
 exports.IterableWeakMap = IterableWeakMap;
 exports.IterableWeakSet = IterableWeakSet;
 exports.ReactiveBase = ReactiveBase;
-exports.ReactiveError = ReactiveError;
 exports.ReadOnlyError = ReadOnlyError;
 exports.Register = Register;
 exports.addBatchCleanup = addBatchCleanup;
@@ -4873,7 +4920,9 @@ exports.defer = defer;
 exports.derived = derived;
 exports.effect = effect;
 exports.enableDevTools = enableDevTools;
+exports.getActivationLog = getActivationLog;
 exports.getActiveEffect = getActiveEffect;
+exports.getActiveProjection = getActiveProjection;
 exports.getState = getState;
 exports.immutables = immutables;
 exports.isDevtoolsEnabled = isDevtoolsEnabled;
@@ -4883,7 +4932,6 @@ exports.isZoneEnabled = isZoneEnabled;
 exports.mapped = mapped;
 exports.memoize = memoize;
 exports.mixin = mixin;
-exports.options = options;
 exports.organize = organize;
 exports.organized = organized;
 exports.profileInfo = profileInfo;
@@ -4905,4 +4953,4 @@ exports.unreactive = unreactive;
 exports.untracked = untracked;
 exports.unwrap = unwrap;
 exports.watch = watch;
-//# sourceMappingURL=index-GRBSx0mB.js.map
+//# sourceMappingURL=index-CDCOjzTy.js.map