mutts 1.0.5 → 1.0.6

package/dist/chunks/{index-qiWwozOc.esm.js → index-DiP0RXoZ.esm.js}

@@ -1,6 +1,6 @@
-import { i as isConstructor, R as ReflectGet, d as decorator, b as ReflectSet, c as isOwnAccessor, r as renamed } from './decorator-DqiszP7i.esm.js';
+import { i as isConstructor, a as ReflectGet, g as rootFunction, o as options, h as allProps, R as ReactiveError, j as ReactiveErrorCode, k as cleanup$1, s as stopped, d as decorator, n as nonReactiveMark, p as nativeReactive, q as prototypeForwarding, u as unreactiveProperties, b as ReflectSet, f as isOwnAccessor, r as renamed, e as deepCompare, t as projectionInfo } from './decorator-BGILvPtN.esm.js';
 import { Indexable, setAt, getAt, ArrayReadForward, forwardArray } from '../indexable.esm.js';
-import { a as __setFunctionName, b as __esDecorate, c as __runInitializers, d as __classPrivateFieldSet, _ as __classPrivateFieldGet } from './_tslib-Mzh1rNsX.esm.js';
+import { _ as __setFunctionName, a as __esDecorate, b as __runInitializers, c as __classPrivateFieldSet, d as __classPrivateFieldGet } from './_tslib-MCKDzsSq.esm.js';
 
 /// <reference lib="esnext.collection" />
 var _a, _b;
@@ -332,323 +332,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 for accessing projection information on reactive objects
- */
-const projectionInfo = Symbol('projection-info');
-// 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,
-    /**
-     * Maximum number of times an effect can be triggered by the same cause in a single batch
-     * Used to detect aggressive re-computation or infinite loops
-     * @default 10
-     */
-    maxTriggerPerBatch: 10,
-    /**
-     * 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
@@ -657,13 +340,29 @@ 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, {
         value: getRoot(root),
@@ -676,64 +375,15 @@ function markWithRoot(fn, root) {
  * @returns The root function
  */
 function getRoot(fn) {
-    return fn?.[rootFunction] || fn;
+    while (fn && rootFunction in fn)
+        fn = fn[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;
 }
 
 /**
@@ -1088,6 +738,171 @@ function addToMutationHistory(source, target, obj, prop, evolution) {
     }
 }
 
+/**
+ * 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 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 = 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]));
+    }
+}
+
 /**
  * Zone-like async context preservation for reactive effects
  *
@@ -1473,6 +1288,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)
@@ -1760,6 +1576,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[cleanup$1];
+    if (cleanupFn)
+        cleanupFn();
+    // If the effect was stopped during cleanup (e.g. lazy memoization), don't add it to the batch
+    if (effect[stopped])
+        return;
     if (!batchQueue)
         return;
     const root = getRoot(effect);
@@ -2195,12 +2017,18 @@ function batch(effect, immediate) {
 const atomic = 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');
         };
     },
 });
@@ -2234,7 +2062,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;
@@ -2367,8 +2195,25 @@ fn, effectOptions) {
         cleanupEffectFromGraph(runEffect);
         fr.unregister(stopEffect);
     };
+    function augmentedRv(rv) {
+        Object.defineProperty(rv, stopped, {
+            get() {
+                return effectStopped;
+            },
+        });
+        Object.defineProperty(rv, cleanup$1, {
+            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);
@@ -2381,14 +2226,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;
 }
@@ -2987,13 +2832,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)) {
@@ -3283,12 +3128,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();
@@ -3297,7 +3142,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);
@@ -3308,9 +3153,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();
@@ -3383,9 +3228,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))));
+    })));
 }
 
 /**
@@ -3841,6 +3686,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);
@@ -3861,15 +3707,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 (options.onMemoizationDiscrepancy) {
+                const wasVerification = options.isVerificationRun;
+                options.isVerificationRun = true;
+                try {
+                    const fresh = untracked(() => fn(...localArgs));
+                    if (!deepCompare(node.result, fresh)) {
+                        options.onMemoizationDiscrepancy(node.result, fresh, fn, localArgs, '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(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);
@@ -3877,8 +3738,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 (options.onMemoizationDiscrepancy) {
+            const wasVerification = options.isVerificationRun;
+            options.isVerificationRun = true;
+            try {
+                const fresh = untracked(() => fn(...localArgs));
+                if (!deepCompare(node.result, fresh)) {
+                    options.onMemoizationDiscrepancy(node.result, fresh, fn, localArgs, 'comparison');
+                }
+            }
+            finally {
+                options.isVerificationRun = wasVerification;
+            }
+        }
         return node.result;
     }, fn);
     memoizedRegistry.set(fnRoot, memoized);
@@ -3886,19 +3766,37 @@ function memoizeFunction(fn) {
     return memoized;
 }
 const memoize = decorator({
-    getter(original, propertyKey) {
-        const memoized = memoizeFunction(markWithRoot(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(renamed((that) => {
+                    return original.call(that);
+                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`), {
+                    method: original,
+                    propertyKey,
+                    ...(original[rootFunction] ? { [rootFunction]: original[rootFunction] } : {}),
+                });
+                wrapperRegistry.set(original, wrapper);
+            }
+            const memoized = memoizeFunction(wrapper);
             return memoized(this);
         };
     },
-    method(original, name) {
-        const memoized = memoizeFunction(markWithRoot(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(renamed((that, ...args) => {
+                    return original.call(that, ...args);
+                }, `${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`), {
+                    method: original,
+                    propertyKey: name,
+                    ...(original[rootFunction] ? { [rootFunction]: original[rootFunction] } : {}),
+                });
+                wrapperRegistry.set(original, wrapper);
+            }
+            const memoized = memoizeFunction(wrapper);
             return memoized(this, ...args);
         };
     },
@@ -5003,5 +4901,5 @@ const profileInfo = {
     nonReactiveObjects,
 };
 
-export { cleanup as A, derived as B, unreactive as C, watch as D, mapped as E, reduced as F, memoize as G, immutables as H, IterableWeakMap as I, isNonReactive as J, registerNativeReactivity as K, getActiveProjection as L, project as M, isReactive as N, ReactiveBase as O, reactive as P, unwrap as Q, ReadOnlyError as R, organize as S, organized as T, Register as U, register as V, options as W, ReactiveError as X, isZoneEnabled as Y, setZoneEnabled as Z, IterableWeakSet as a, touched1 as b, buildReactivityGraph as c, registerObjectForDebug as d, enableDevTools as e, setObjectName as f, getState as g, deepWatch as h, isDevtoolsEnabled as i, addBatchCleanup as j, atomic as k, batch as l, mixin as m, biDi as n, defer as o, profileInfo as p, effect as q, registerEffectForDebug as r, setEffectName as s, touched as t, getActivationLog as u, getActiveEffect as v, root as w, trackEffect as x, untracked as y, cleanedBy as z };
-//# sourceMappingURL=index-qiWwozOc.esm.js.map
+export { mixin as A, organize as B, organized as C, profileInfo as D, project as E, reactive as F, reduced as G, register as H, IterableWeakMap as I, registerEffectForDebug as J, registerNativeReactivity as K, registerObjectForDebug as L, root as M, setEffectName as N, setObjectName as O, setZoneEnabled as P, touched as Q, ReactiveBase as R, touched1 as S, trackEffect as T, unreactive as U, untracked as V, unwrap as W, watch as X, IterableWeakSet as a, ReadOnlyError as b, Register as c, addBatchCleanup as d, atomic as e, batch as f, biDi as g, buildReactivityGraph as h, cleanedBy as i, cleanup as j, deepWatch as k, defer as l, derived as m, effect as n, enableDevTools as o, getActivationLog as p, getActiveEffect as q, getActiveProjection as r, getState as s, immutables as t, isDevtoolsEnabled as u, isNonReactive as v, isReactive as w, isZoneEnabled as x, mapped as y, memoize as z };
+//# sourceMappingURL=index-DiP0RXoZ.esm.js.map