mutts 1.0.10 → 1.0.11

package/dist/chunks/{proxy-r7lARftl.esm.js → proxy-D2C49sXH.esm.js}

@@ -118,16 +118,16 @@ const FoolProof = {
         if (hasNode && obj instanceof Node) {
             obj[prop] = value;
             return true;
-        }
-        if (!(obj instanceof Object) && !Reflect.has(obj, prop)) {
+        } /*
+        if (!(obj instanceof Object) && !Object.hasOwn(obj, prop)) {
             Object.defineProperty(obj, prop, {
                 value,
                 configurable: true,
                 writable: true,
                 enumerable: true,
-            });
-            return true;
-        }
+            })
+            return true
+        }*/
         return Reflect.set(obj, prop, value, receiver);
     },
 };
@@ -151,15 +151,8 @@ function deepCompare(a, b, cache = new Map()) {
         return a === b;
     }
     // Prototype check
-    const protoA = Object.getPrototypeOf(a);
-    const protoB = Object.getPrototypeOf(b);
-    if (protoA !== protoB) {
-        console.warn(`[deepCompare] prototype mismatch:`, {
-            nameA: a?.constructor?.name,
-            nameB: b?.constructor?.name,
-        });
+    if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
         return false;
-    }
     // Circular reference protection
     let compared = cache.get(a);
     if (compared?.has(b))
@@ -171,39 +164,21 @@ function deepCompare(a, b, cache = new Map()) {
     compared.add(b);
     // Handle specific object types
     if (Array.isArray(a)) {
-        if (!Array.isArray(b)) {
-            console.warn(`[deepCompare] B is not an array`);
-            return false;
-        }
-        if (a.length !== b.length) {
-            console.warn(`[deepCompare] array length mismatch:`, { lenA: a.length, lenB: b.length });
+        if (!Array.isArray(b) || a.length !== b.length)
             return false;
-        }
         for (let i = 0; i < a.length; i++) {
-            if (!deepCompare(a[i], b[i], cache)) {
-                console.warn(`[deepCompare] array element mismatch at index ${i}`);
+            if (!deepCompare(a[i], b[i], cache))
                 return false;
-            }
         }
         return true;
     }
-    if (a instanceof Date) {
-        const match = b instanceof Date && a.getTime() === b.getTime();
-        if (!match)
-            console.warn(`[deepCompare] Date mismatch`);
-        return match;
-    }
-    if (a instanceof RegExp) {
-        const match = b instanceof RegExp && a.toString() === b.toString();
-        if (!match)
-            console.warn(`[deepCompare] RegExp mismatch`);
-        return match;
-    }
+    if (a instanceof Date)
+        return b instanceof Date && a.getTime() === b.getTime();
+    if (a instanceof RegExp)
+        return b instanceof RegExp && a.toString() === b.toString();
     if (a instanceof Set) {
-        if (!(b instanceof Set) || a.size !== b.size) {
-            console.warn(`[deepCompare] Set size mismatch`);
+        if (!(b instanceof Set) || a.size !== b.size)
             return false;
-        }
         for (const val of a) {
             let found = false;
             for (const bVal of b) {
@@ -212,18 +187,14 @@ function deepCompare(a, b, cache = new Map()) {
                     break;
                 }
             }
-            if (!found) {
-                console.warn(`[deepCompare] missing Set element`);
+            if (!found)
                 return false;
-            }
         }
         return true;
     }
     if (a instanceof Map) {
-        if (!(b instanceof Map) || a.size !== b.size) {
-            console.warn(`[deepCompare] Map size mismatch`);
+        if (!(b instanceof Map) || a.size !== b.size)
             return false;
-        }
         for (const [key, val] of a) {
             if (!b.has(key)) {
                 let foundMatch = false;
@@ -233,16 +204,11 @@ function deepCompare(a, b, cache = new Map()) {
                         break;
                     }
                 }
-                if (!foundMatch) {
-                    console.warn(`[deepCompare] missing Map key`);
+                if (!foundMatch)
                     return false;
-                }
             }
-            else {
-                if (!deepCompare(val, b.get(key), cache)) {
-                    console.warn(`[deepCompare] Map value mismatch for key`);
-                    return false;
-                }
+            else if (!deepCompare(val, b.get(key), cache)) {
+                return false;
             }
         }
         return true;
@@ -250,29 +216,11 @@ function deepCompare(a, b, cache = new Map()) {
     // Compare own properties
     const keysA = Object.keys(a);
     const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) {
-        console.warn(`[deepCompare] keys length mismatch:`, {
-            lenA: keysA.length,
-            lenB: keysB.length,
-            keysA,
-            keysB,
-            a,
-            b,
-        });
+    if (keysA.length !== keysB.length)
         return false;
-    }
     for (const key of keysA) {
-        if (!Object.hasOwn(b, key)) {
-            console.warn(`[deepCompare] missing key ${String(key)} in B`);
+        if (!Object.hasOwn(b, key) || !deepCompare(a[key], b[key], cache))
             return false;
-        }
-        if (!deepCompare(a[key], b[key], cache)) {
-            console.warn(`[deepCompare] value mismatch for key ${String(key)}:`, {
-                valA: a[key],
-                valB: b[key],
-            });
-            return false;
-        }
     }
     return true;
 }
@@ -320,6 +268,12 @@ function named(name, fn) {
     });
     return fn;
 }
+const _mode = (typeof process !== 'undefined' && process.env?.NODE_ENV) ||
+    (typeof import.meta !== 'undefined' && import.meta.env?.MODE) ||
+    'production';
+const isDev = _mode === 'development';
+const isProd = _mode === 'production';
+const isTest = _mode === 'test';
 
 // biome-ignore-all lint/suspicious/noConfusingVoidType: We *love* voids
 // Standardized decorator system that works with both Legacy and Modern decorators
@@ -547,9 +501,7 @@ function flavorOptions(fn, defaultOptions, opts = {}) {
         const isObject = currentOptions !== null &&
             typeof currentOptions === 'object' &&
             !Array.isArray(currentOptions);
-        newArgs[targetIndex] = isObject
-            ? { ...defaultOptions, ...currentOptions }
-            : defaultOptions;
+        newArgs[targetIndex] = isObject ? { ...defaultOptions, ...currentOptions } : defaultOptions;
         return fn.apply(this, newArgs);
     };
     if (opts.name)
@@ -890,6 +842,20 @@ function mixin(mixinFunction, unwrapFunction) {
     });
 }
 
+const debugHooks = {
+    isDevtoolsEnabled: () => false,
+    registerEffect: () => { },
+    getTriggerChain: () => [],
+    captureStack: () => [],
+    captureLineage: () => new Error().stack,
+    formatStack: (stack) => [stack],
+    recordTriggerLink: () => { },
+    decorateError: () => { },
+};
+function setDebugHooks(hooks) {
+    Object.assign(debugHooks, hooks);
+}
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -941,41 +907,17 @@ function __runInitializers(thisArg, initializers, value) {
     }
     return useValue ? value : void 0;
 }
-function __setFunctionName(f, name, prefix) {
-    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-}
 function __classPrivateFieldGet(receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 }
 
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
 typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-const debugHooks = {
-    isDevtoolsEnabled: () => false,
-    registerEffect: () => { },
-    getTriggerChain: () => [],
-    captureStack: () => [],
-    captureLineage: () => new Error().stack,
-    formatStack: (stack) => [stack],
-    recordTriggerLink: () => { },
-};
-function setDebugHooks(hooks) {
-    Object.assign(debugHooks, hooks);
-}
-
 var _ZoneAggregator_zones;
 function isu(z) {
     return z;
@@ -1103,13 +1045,27 @@ class ZoneAggregator extends AZone {
     }
 }
 _ZoneAggregator_zones = new WeakMap();
+/**
+ * Aggregator of zones that should be preserved across async boundaries.
+ * If you add a zone here, it will be preserved across async boundaries.
+ *
+ * @example
+ * ```ts
+ * import { Zone, asyncZone } from 'mutts'
+ * const userZone = new Zone<User>()
+ * asyncZone.add(userZone)
+ * ```
+ */
 const asyncZone = tag('async', new ZoneAggregator());
 asyncHooks.addHook(() => {
+    // capture state before async boundary
     const zone = asyncZone.active;
     return () => {
+        // restore state after async boundary, temporarily
         const prev = asyncZone.active;
         asyncZone.active = zone;
         return () => {
+            // restore previous state from before our restore
             asyncZone.active = prev;
         };
     };
@@ -1179,6 +1135,75 @@ function getRoot(fn) {
     return fn;
 }
 
+const effectHistory = tag('effectHistory', new ZoneHistory());
+tag('effectHistory.present', effectHistory.present);
+asyncZone.add(effectHistory);
+/**
+ * Aggregator for zones that need to be tracked along effects.
+ * ie. in each effect, the active zone of the given zoning will be the one active at effect's definition
+ */
+const effectAggregator = tag('effectAggregator', new ZoneAggregator(effectHistory.present));
+function isRunning(effect) {
+    const root = getRoot(effect);
+    return effectHistory.some((e) => getRoot(e) === root);
+}
+function getActiveEffect() {
+    return effectHistory.present.active;
+}
+const cleanups = new WeakMap();
+/**
+ * Attach cleanup dependencies to an object. When `unlink(obj)` is called,
+ * each dependency is disposed: functions are invoked with the cleanup reason,
+ * objects are recursively `unlink`ed. This forms a cleanup tree.
+ *
+ * @param obj - The owner object
+ * @param cleanupFns - Cleanup callbacks and/or child objects to unlink recursively
+ * @returns The owner object (for chaining)
+ *
+ * @example
+ * ```ts
+ * // Functions are called with CleanupReason
+ * link(parent, () => console.log('disposed'))
+ *
+ * // Objects are recursively unlinked
+ * link(parent, childA, childB)
+ *
+ * // Mixed
+ * link(parent, childObj, () => timer.clear())
+ *
+ * unlink(parent) // disposes childA, childB, calls the function
+ * ```
+ */
+function link(obj, ...cleanupFns) {
+    const set = cleanups.get(obj);
+    if (!set)
+        cleanups.set(obj, new Set(cleanupFns.filter(Boolean)));
+    else
+        for (const fn of cleanupFns)
+            if (fn)
+                set.add(fn);
+    return obj;
+}
+/**
+ * Dispose an object's cleanup dependencies. Functions are called with the
+ * reason; linked objects are recursively unlinked. The cleanup set is removed
+ * so calling `unlink` twice is safe (second call is a no-op).
+ *
+ * @param obj - The object to dispose
+ * @param reason - Optional cleanup reason propagated to callbacks
+ */
+function unlink(obj, reason) {
+    const set = cleanups.get(obj);
+    if (set) {
+        cleanups.delete(obj);
+        for (const fn of set)
+            if (typeof fn === 'function')
+                fn(reason);
+            else
+                unlink(fn, reason);
+    }
+}
+
 const effectMarker = {
     enter: 'effect:enter',
     leave: 'effect:leave',
@@ -1241,6 +1266,11 @@ function formatCleanupReason(reason, depth = 0) {
         }
     }
 }
+// Track native reactivity
+/**
+ * Symbol to mark class properties as non-reactive
+ */
+const unreactiveProperties = Symbol('unreactive-properties');
 /**
  * Symbol representing all properties in reactive tracking
  */
@@ -1250,14 +1280,6 @@ const allProps = Symbol('all-props');
  * Used by ownKeys proxy trap — Object.keys(), for..in, Map.keys() depend on this.
  */
 const keysOf = Symbol('keys-of');
-/**
- * Symbol to check if an effect is stopped
- */
-const stopped = Symbol('stopped');
-/**
- * Symbol to access effect cleanup function
- */
-const cleanup = Symbol('cleanup');
 /**
  * Structured error codes for machine-readable diagnosis
  */
@@ -1331,6 +1353,12 @@ const options = {
      * @param runningChain - The array of effects from the detected one to the currently running one
      */
     skipRunningEffect: (_effect) => { },
+    /**
+     * Debug purpose: called when an effect starts executing.
+     * @param effect - The effect being executed (root function)
+     * @param reaction - false for initial creation, true/CleanupReason for subsequent runs
+     */
+    effectRun: (_effect, _reaction) => { },
     /**
      * Debug purpose: maximum effect chain (like call stack max depth)
      * Used to prevent infinite loops
@@ -1457,34 +1485,6 @@ const options = {
         enableHistory: true,
         historySize: 50,
     },
-    /**
-     * Configuration for zone hooks - control which async APIs are hooked
-     * Each option controls whether the corresponding async API is wrapped to preserve effect context
-     * Only applies when asyncMode is enabled (truthy)
-     * @deprecated Should take all when we made sure PIXI.create, Game.create, ... are -> .root()
-     */
-    zones: {
-        /**
-         * Hook setTimeout to preserve effect context
-         * @default true
-         */
-        setTimeout: true,
-        /**
-         * Hook setInterval to preserve effect context
-         * @default true
-         */
-        setInterval: true,
-        /**
-         * Hook requestAnimationFrame (runs in untracked context when hooked)
-         * @default true
-         */
-        requestAnimationFrame: true,
-        /**
-         * Hook queueMicrotask to preserve effect context
-         * @default true
-         */
-        queueMicrotask: true,
-    },
 };
 function optionCall(name, ...args) {
     const fn = options[name];
@@ -1498,6 +1498,36 @@ function optionCall(name, ...args) {
         options.warn(`options.${name} threw`, error);
     }
 }
+/** Production preset: no introspection, heuristic cycle detection, minimal overhead */
+const prodPreset = {
+    maxEffectReaction: 'throw',
+    cycleHandling: 'production',
+    introspection: null,
+    onMemoizationDiscrepancy: undefined,
+};
+/** Development preset (default): introspection on, early cycle detection, warnings */
+const devPreset = {
+    maxEffectReaction: 'warn',
+    cycleHandling: 'development',
+    introspection: {
+        gatherReasons: { lineages: 'touch' },
+        logErrors: true,
+        enableHistory: true,
+        historySize: 50,
+    },
+    onMemoizationDiscrepancy: undefined,
+};
+/** Debug preset: full diagnostics, throws on violations, rich lineage capture */
+const debugPreset = {
+    maxEffectReaction: 'debug',
+    cycleHandling: 'debug',
+    introspection: {
+        gatherReasons: { lineages: 'both' },
+        logErrors: true,
+        enableHistory: true,
+        historySize: 200,
+    },
+};
 // --- Proxy State (Merged from proxy-state.ts) ---
 const objectToProxy = new WeakMap();
 const proxyToObject = new WeakMap();
@@ -1517,54 +1547,28 @@ function isReactive(obj) {
     return proxyToObject.has(obj);
 }
 
-const effectHistory = tag('effectHistory', new ZoneHistory());
-tag('effectHistory.present', effectHistory.present);
-asyncZone.add(effectHistory);
-/**
- * Aggregator for zones that need to be tracked along effects.
- * ie. in each effect, the active zone of the given zoning will be the one active at effect's definition
- */
-const effectAggregator = tag('effectAggregator', new ZoneAggregator(effectHistory.present));
-function isRunning(effect) {
-    const root = getRoot(effect);
-    return effectHistory.some((e) => getRoot(e) === root);
-}
-function getActiveEffect() {
-    return effectHistory.present.active;
-}
-/**
- * ADD a cleanup function to an object using the cleanup symbol.
- * The cleanup function will be called when the object needs to be disposed.
- *
- * Note: most of the time, you don't need to use this function directly.
- * The main use if for the cleanup function to be stored with the object, as GC calls the cleanup function when the *function* is garbage collected.
- *
- * @param obj - The object to attach the cleanup function to
- * @param cleanupFn - The cleanup function to attach
- * @returns The object with the cleanup function attached
- */
-function cleanedBy(obj, cleanupFn) {
-    const oldCleanup = obj[cleanup];
-    return Object.defineProperty(obj, cleanup, {
-        value: oldCleanup
-            ? Object.defineProperties((reason) => {
-                oldCleanup(reason);
-                cleanupFn(reason);
-            }, {
-                [stopped]: { get: () => oldCleanup[stopped] || cleanupFn[stopped] },
-            })
-            : cleanupFn,
-        writable: false,
-        enumerable: false,
-        configurable: true,
-    });
-}
-
 // Track dependency stacks per (obj, prop, effect)
 let dependencyStacks = new WeakMap();
+let assertUntrackedFlag = false;
 function resetTracking() {
     dependencyStacks = new WeakMap();
 }
+/**
+ * Executes a function and throws if any reactive dependencies are tracked during execution.
+ * Used to assert that code runs in an untracked context.
+ */
+function assertUntracked(fn) {
+    if (assertUntrackedFlag) {
+        throw new Error('assertUntracked: nested calls are not supported');
+    }
+    assertUntrackedFlag = true;
+    try {
+        return fn();
+    }
+    finally {
+        assertUntrackedFlag = false;
+    }
+}
 function getDependencyStack(effect, obj, prop) {
     const objStacks = dependencyStacks.get(obj);
     if (!objStacks)
@@ -1577,14 +1581,17 @@ function getDependencyStack(effect, obj, prop) {
  * @param prop - The property name (defaults to allProps)
  */
 function dependant(obj, prop = allProps) {
+    if (assertUntrackedFlag) {
+        throw new Error(`Reactive dependency tracking detected in assertUntracked context: ${String(prop)} on ${obj}`);
+    }
     obj = unwrap(obj);
     const currentActiveEffect = getActiveEffect();
     // Early return if no active effect, tracking disabled, or invalid prop
     if (!currentActiveEffect || (typeof prop === 'symbol' && prop !== allProps && prop !== keysOf))
         return;
-    if ('dependencyHook' in currentActiveEffect) {
-        // @ts-expect-error We declared it nowhere - it's okay as it's really internal and for edge-case debug purpose only
-        currentActiveEffect.dependencyHook(obj, prop);
+    const node = getEffectNode(currentActiveEffect);
+    if ('dependencyHook' in node) {
+        node.dependencyHook(obj, prop);
     }
     let objectWatchers = watchers.get(obj);
     if (!objectWatchers) {
@@ -1721,6 +1728,7 @@ let effectTriggeredBy = new WeakMap();
 // consequencesClosure: for each effect, all effects that it triggers (directly or indirectly)
 let causesClosure = new WeakMap();
 let consequencesClosure = new WeakMap();
+// Batch re-entrance depth and broken state
 let broken = false;
 /**
  * Gets or creates an IterableWeakSet for a closure map
@@ -2374,6 +2382,7 @@ function batch(effect, immediate) {
             throw new Error('Activation registry already exists');
         optionCall('beginChain', roots);
     }
+    // TODO: Consider this has been produced but was useless - it might be more correct ?const caller = executingStack.length > 0 ? getActiveEffect() : undefined
     const caller = getActiveEffect();
     // Optimization: If nested and NOT immediate, just join the existing batch
     if (!isNewBatch && !immediate) {
@@ -2527,6 +2536,22 @@ const atomic = decorator({
         };
     },
 });
+/**
+ * Wraps `fn` so it runs within `effect`'s zone context when invoked later.
+ *
+ * Useful for deferred callbacks (event listeners, `DOMContentLoaded`, etc.)
+ * that need sub-effects parented to the original effect.
+ *
+ * @param prev - The effect whose context should be restored, or `undefined` for root context
+ * @param fn - The function to wrap
+ * @returns A function with the same signature that restores the effect context before calling `fn`
+ */
+function captured(prev, fn) {
+    prev ?? (prev = effectHistory.active);
+    return named(effectMarker.leave, (...args) => {
+        return effectHistory.with(prev, () => fn(...args));
+    });
+}
 /**
  * Runs `fn` atomically and **always immediately**, batching all reactive effects
  * triggered inside it so they fire only once after `fn` completes.
@@ -2549,19 +2574,13 @@ function atom(fn) {
     return batch(fn, 'immediate');
 }
 const fr = new FinalizationRegistry((f) => f());
-/**
- * @param fn - The effect function to run - provides the cleaner
- * @returns The cleanup function
- */
 /**
  * Creates a reactive effect that automatically re-runs when dependencies change
  * @param fn - The effect function that provides dependencies and may return a cleanup function or Promise
  * @param options - Options for effect execution
  * @returns A cleanup function to stop the effect
  */
-const effect = named(effectMarker.leave, flavored(function effect(
-// biome-ignore lint/suspicious/noConfusingVoidType: Effect callbacks commonly return void
-fn, effectOptions = {}) {
+const effect = named(effectMarker.leave, flavored(function effect(fn, effectOptions = {}) {
     if (effectOptions?.name)
         Object.defineProperty(fn, 'name', { value: effectOptions.name });
     // Use per-effect asyncMode or fall back to global option
@@ -2585,6 +2604,7 @@ fn, effectOptions = {}) {
         if (runningPromise) {
             if (asyncMode === 'cancel' && cancelPrevious) {
                 // Cancel previous execution
+                abort();
                 cancelPrevious();
                 cancelPrevious = null;
                 runningPromise = null;
@@ -2608,11 +2628,33 @@ fn, effectOptions = {}) {
         access.reaction = node.nextReason || access.reaction;
         node.nextReason = undefined;
         optionCall('enter', getRoot(fn));
+        optionCall('effectRun', getRoot(fn), access.reaction);
         let result;
         let caught = 0;
-        // Default thrower (self)
-        let thrower = (error) => {
-            throw error;
+        // Define bubbling thrower
+        const thrower = (error) => {
+            const catches = node.catchers;
+            const reason = { type: 'error', error };
+            if (catches)
+                while (caught < catches.length) {
+                    cleanupReaction(reason);
+                    try {
+                        reactionCleanup = catches[caught](error);
+                        return;
+                    }
+                    catch (_e) {
+                        caught++;
+                    }
+                }
+            if (parent) {
+                const parentNode = getEffectNode(parent);
+                if (parentNode.forwardThrow)
+                    parentNode.forwardThrow(error);
+                else
+                    throw error;
+            }
+            else
+                throw error;
         };
         node.forwardThrow = thrower;
         let errorToThrow;
@@ -2662,12 +2704,14 @@ fn, effectOptions = {}) {
             }
         }
         catch (error) {
+            debugHooks.decorateError(error, runEffect);
             // catcher:self`
             errorToThrow = error;
         }
         // Create cleanup function for next run
         node.cleanup = (reason) => {
             node.cleanup = undefined;
+            abort();
             cleanupReaction(reason);
             delete node.catchers;
             // Remove this effect from all reactive objects it's watching
@@ -2678,13 +2722,11 @@ fn, effectOptions = {}) {
                     if (objectWatchers) {
                         for (const [prop, deps] of objectWatchers.entries()) {
                             deps.delete(runEffect);
-                            if (deps.size === 0) {
+                            if (deps.size === 0)
                                 objectWatchers.delete(prop);
-                            }
                         }
-                        if (objectWatchers.size === 0) {
+                        if (objectWatchers.size === 0)
                             watchers.delete(reactiveObj);
-                        }
                     }
                 }
                 effectToReactiveObjects.delete(runEffect);
@@ -2702,33 +2744,6 @@ fn, effectOptions = {}) {
                 delete node.children;
             }
         };
-        // Define bubbling thrower
-        thrower = (error) => {
-            const catches = node.catchers;
-            const reason = { type: 'error', error };
-            if (catches)
-                while (caught < catches.length) {
-                    cleanupReaction(reason);
-                    try {
-                        reactionCleanup = catches[caught](error);
-                        return;
-                    }
-                    catch (e) {
-                        caught++;
-                    }
-                }
-            if (parent) {
-                const parentNode = getEffectNode(parent);
-                if (parentNode.forwardThrow)
-                    parentNode.forwardThrow(error);
-                else
-                    throw error;
-            }
-            else
-                throw error;
-        };
-        // Update the node's forwardThrow to the bubbling one
-        node.forwardThrow = thrower;
         if (errorToThrow)
             thrower(errorToThrow);
     };
@@ -2747,26 +2762,25 @@ fn, effectOptions = {}) {
     node.parent = parent;
     // let thrower: CatchFunction | undefined // Moved inside runEffect
     let effectStopped = false;
+    let abortController;
     const access = {
         tracked,
         ascend: named(effectMarker.leave, (fn) => ascended(named(effectMarker.enter, () => fn.call(null)))),
         //named(effectMarker.enter, (fn) => ascended(fn)),
         reaction: false,
+        get signal() {
+            if (!abortController) {
+                abortController = new AbortController();
+            }
+            return abortController.signal;
+        },
     };
     let runningPromise = null;
     let cancelPrevious = null;
-    if (effectOptions?.dependencyHook) {
+    if (effectOptions?.dependencyHook)
         node.dependencyHook = effectOptions.dependencyHook;
-    }
     // Mark the runEffect callback with the original function as its root
     markWithRoot(runEffect, fn);
-    function augmentedRv(rv) {
-        return Object.defineProperties(rv, {
-            [stopped]: {
-                get: () => effectStopped,
-            },
-        });
-    }
     // Register strict mode if enabled
     if (effectOptions?.opaque) {
         node.isOpaque = true;
@@ -2775,6 +2789,12 @@ fn, effectOptions = {}) {
         debugHooks.registerEffect(runEffect);
     }
     // Store parent relationship for hierarchy traversal - ALREADY DONE ABOVE via getEffectNode
+    const abort = () => {
+        if (abortController) {
+            abortController.abort(new ReactiveError('[reactive] Effect aborted due to dependency change or stop'));
+            abortController = undefined;
+        }
+    };
     batch(runEffect, 'immediate');
     // Only ROOT effects are registered for GC cleanup and zone tracking
     const isRootEffect = !parent;
@@ -2784,6 +2804,7 @@ fn, effectOptions = {}) {
         effectStopped = true;
         node.stopped = true;
         // Cancel any running async work
+        abort();
         if (cancelPrevious) {
             cancelPrevious();
             cancelPrevious = null;
@@ -2802,7 +2823,7 @@ fn, effectOptions = {}) {
         fr.unregister(stopEffect);
     };
     if (isRootEffect) {
-        const callIfCollected = augmentedRv((reason) => stopEffect(reason));
+        const callIfCollected = (reason) => stopEffect(reason);
         fr.register(callIfCollected, () => {
             stopEffect({ type: 'gc' });
             optionCall('garbageCollected', fn);
@@ -2816,16 +2837,16 @@ fn, effectOptions = {}) {
             parentNode.children = new Set();
         }
         const children = parentNode.children;
-        const subEffectCleanup = augmentedRv((reason) => {
+        const subEffectCleanup = (reason) => {
             children.delete(subEffectCleanup);
             // Execute this child effect cleanup (which triggers its own mainCleanup)
             stopEffect(reason);
-        });
+        };
         children.add(subEffectCleanup);
         return subEffectCleanup;
     }
     // Should not be reachable given isRootEffect check, but for type safety
-    return augmentedRv((reason) => stopEffect(reason));
+    return (reason) => stopEffect(reason);
 }, {
     get opaque() {
         return flavorOptions(this, { opaque: true }, { name: 'opaque' });
@@ -2856,9 +2877,11 @@ function biDi(received, get, set) {
         get = get.get;
     }
     let programmaticallySetValue = Symbol();
-    effect(markWithRoot(() => {
+    effect.named('biDi')(markWithRoot(() => {
         const newValue = get();
-        if (unwrap(newValue) !== programmaticallySetValue)
+        const pValue = programmaticallySetValue;
+        programmaticallySetValue = Symbol();
+        if (unwrap(newValue) !== pValue)
             received(newValue);
     }, received));
     return set
@@ -2929,16 +2952,16 @@ function bubbleUpChange(changedObject, evolution) {
     const parents = objectParents.get(changedObject);
     if (!parents)
         return;
-    for (const { parent, prop } of parents) {
+    for (const { parent } of parents) {
         // Trigger deep watchers on parent
         const parentDeepWatchers = deepWatchers.get(parent);
         if (parentDeepWatchers) {
             if (options.introspection?.gatherReasons) {
                 const gatherReasons = options.introspection.gatherReasons;
                 const lineageConfig = gatherReasons.lineages;
-                let touchStack;
+                let touchLineage;
                 if (lineageConfig === 'touch' || lineageConfig === 'both') {
-                    touchStack = debugHooks.captureLineage();
+                    touchLineage = debugHooks.captureLineage();
                 }
                 for (const watcher of parentDeepWatchers) {
                     const dependencyStack = lineageConfig === 'dependency' || lineageConfig === 'both'
@@ -2951,7 +2974,7 @@ function bubbleUpChange(changedObject, evolution) {
                         obj: parent,
                         evolution,
                         dependency: dependencyStack,
-                        touch: touchStack,
+                        touch: touchLineage,
                     });
                 }
             }
@@ -3004,6 +3027,8 @@ function collectEffects(obj, evolution, effects, objectWatchers, ...keyChains) {
         for (const key of keys) {
             const deps = objectWatchers.get(key);
             if (deps) {
+                // Make sure `some.prop++` does not keep a dependency to `some.props`
+                deps.delete(sourceEffect);
                 for (const effect of deps) {
                     const runningChain = isRunning(effect);
                     if (runningChain) {
@@ -3054,9 +3079,9 @@ function touched(obj, evolution, props) {
         if (options.introspection?.gatherReasons) {
             const gatherReasons = options.introspection.gatherReasons;
             const lineageConfig = gatherReasons.lineages;
-            let touchStack;
+            let touchLineage;
             if (lineageConfig === 'touch' || lineageConfig === 'both') {
-                touchStack = debugHooks.captureLineage();
+                touchLineage = debugHooks.captureLineage();
             }
             for (const [effect, dependencyStack] of effects) {
                 const node = getEffectNode(effect);
@@ -3066,7 +3091,7 @@ function touched(obj, evolution, props) {
                     obj,
                     evolution,
                     dependency: dependencyStack,
-                    touch: touchStack,
+                    touch: touchLineage,
                 });
             }
         }
@@ -3105,10 +3130,10 @@ function touchedOpaque(obj, evolution, prop) {
             }
             effects.add(effect);
             if (gather) {
-                let touchStack;
+                let touchLineage;
                 let dependencyStack;
                 if (lineageConfig === 'touch' || lineageConfig === 'both') {
-                    touchStack = debugHooks.captureLineage();
+                    touchLineage = debugHooks.captureLineage();
                 }
                 if (lineageConfig === 'dependency' || lineageConfig === 'both') {
                     dependencyStack = getDependencyStack(effect, obj, prop);
@@ -3119,7 +3144,7 @@ function touchedOpaque(obj, evolution, prop) {
                     obj,
                     evolution,
                     dependency: dependencyStack,
-                    touch: touchStack,
+                    touch: touchLineage,
                 });
             }
             recordActivation(effect, obj, evolution, prop);
@@ -3148,59 +3173,60 @@ function touchedOpaque(obj, evolution, prop) {
     }
 }
 
-const nonReactiveObjects = new WeakSet();
-const nonReactiveClasses = new WeakSet();
-const unreactiveProps = new WeakMap();
-let unreactivePropsCount = 0;
+const absent = Symbol('absent');
+/**
+ * Add unreactive properties to a prototype.
+ * If no set is provided, marks the entire object/prototype as non-reactive (sets [unreactiveProperties] = true).
+ * If a set is provided, merges with existing unreactive properties (never overrides true).
+ */
 function addUnreactiveProps(proto, set) {
-    unreactiveProps.set(proto, set);
-    unreactivePropsCount++;
+    if (unreactiveProperties in proto) {
+        const existing = proto[unreactiveProperties];
+        // If already fully unreactive, don't change
+        if (existing === true)
+            return proto;
+        // If no set provided, upgrade to fully unreactive
+        if (!set) {
+            proto[unreactiveProperties] = true;
+            return proto;
+        }
+        // Merge sets
+        set = proto[unreactiveProperties] = new Set(proto[unreactiveProperties]);
+        for (const p of set)
+            existing.add(p);
+    }
+    // If no set, mark as fully unreactive, otherwise create set
+    else
+        proto[unreactiveProperties] = set ? new Set(set) : true;
+    return proto;
 }
 /** Check if a property is marked unreactive on obj or any of its prototypes (trap-free) */
 function isUnreactiveProp(obj, prop) {
-    if (!unreactivePropsCount)
-        return false;
-    let target = obj;
-    while (target) {
-        if (unreactiveProps.get(target)?.has(prop))
-            return true;
-        target = Object.getPrototypeOf(target);
-    }
-    return false;
+    if (typeof prop === 'symbol' || prop === 'constructor')
+        return true;
+    const marker = obj[unreactiveProperties];
+    return (marker === true || // Fully unreactive
+        marker?.has?.(prop) || // Property is unreactive
+        false);
 }
-const immutables = new Set();
-const absent = Symbol('absent');
-function markNonReactive(...obj) {
-    for (const o of obj)
-        nonReactiveObjects.add(o);
+function nonReactive(...obj) {
+    for (const o of obj) {
+        o[unreactiveProperties] = true;
+    }
     return obj[0];
 }
 function nonReactiveClass(...cls) {
     for (const c of cls)
         if (c)
-            nonReactiveClasses.add(c.prototype);
+            c.prototype[unreactiveProperties] = true;
     return cls[0];
 }
 function isNonReactive(obj) {
-    if (obj === null || typeof obj !== 'object')
-        return true;
-    if (nonReactiveObjects.has(obj))
-        return true;
-    // Walk the prototype chain on the raw object to check for non-reactive classes
-    let proto = Object.getPrototypeOf(obj);
-    while (proto) {
-        if (nonReactiveClasses.has(proto))
-            return true;
-        proto = Object.getPrototypeOf(proto);
-    }
-    for (const fn of immutables)
-        if (fn(obj))
-            return true;
-    return false;
+    return !obj || obj[unreactiveProperties] === true;
 }
 nonReactiveClass(Date, RegExp, Error, Promise, Function);
 if (typeof window !== 'undefined') {
-    markNonReactive(window, document);
+    nonReactive(window, document);
     nonReactiveClass(Node, Element, HTMLElement, EventTarget, HTMLCollection, NodeList);
 }
 
@@ -3222,10 +3248,33 @@ function shouldRecurseTouch(oldValue, newValue) {
     if ((typeof oldValue !== 'object' && !Array.isArray(oldValue)) ||
         (typeof newValue !== 'object' && !Array.isArray(newValue)))
         return false;
-    if (isNonReactive(oldValue) || isNonReactive(newValue))
+    if (isNonReactive(oldValue) /*|| isNonReactive(newValue)*/)
         return false;
     return getPrototypeToken(oldValue) === getPrototypeToken(newValue);
 }
+/**
+ * Migrate all watcher registrations from oldRef to newRef.
+ * Called when deep touch replaces an object identity without any child value differences,
+ * to prevent watcher orphaning (effects still pointing at the discarded old object).
+ */
+function migrateWatchers(oldRef, newRef) {
+    const oldMap = watchers.get(oldRef);
+    if (!oldMap)
+        return;
+    // Move the entire watcher map
+    watchers.set(newRef, oldMap);
+    watchers.delete(oldRef);
+    // Update the reverse map (effect → objects it watches)
+    for (const deps of oldMap.values()) {
+        for (const effect of deps) {
+            const objects = effectToReactiveObjects.get(effect);
+            if (objects) {
+                objects.delete(oldRef);
+                objects.add(newRef);
+            }
+        }
+    }
+}
 /**
  * Centralized function to handle property change notifications with optional recursive touch
  * @param targetObj - The object whose property changed
@@ -3243,7 +3292,15 @@ function notifyPropertyChange(targetObj, prop, oldValue, newValue, hadProperty)
         const origin = { obj: unwrappedObj, prop };
         // Deep touch: only notify nested property changes with origin filtering
         // Don't notify direct property change - the whole point is to avoid parent effects re-running
-        dispatchNotifications(untracked(() => recursiveTouch(oldValue, newValue, new WeakMap(), [], origin)));
+        const changes = untracked(() => recursiveTouch(oldValue, newValue, new WeakMap(), [], origin));
+        // When deep touch found no child differences, the object identity still changed.
+        // Migrate watchers from old → new so the dependency chain is preserved.
+        if (changes.length === 0) {
+            migrateWatchers(unwrap(oldValue), unwrap(newValue));
+        }
+        else {
+            dispatchNotifications(changes);
+        }
         // Notify opaque listeners (like memoize) that always want to know about identity changes
         touchedOpaque(targetObj, evolution, prop);
     }
@@ -3330,12 +3387,11 @@ function diffObjectProperties(oldObj, newObj, visited, notifications, origin) {
     for (const key of oldKeys)
         if (!newKeys.has(key))
             local.push({ target: oldObj, evolution: { type: 'del', prop: key }, prop: key, origin });
-    for (const key of newKeys)
-        if (!oldKeys.has(key))
-            local.push({ target: oldObj, evolution: { type: 'add', prop: key }, prop: key, origin });
     for (const key of newKeys) {
-        if (!oldKeys.has(key))
+        if (!oldKeys.has(key)) {
+            local.push({ target: oldObj, evolution: { type: 'add', prop: key }, prop: key, origin });
             continue;
+        }
         const oldEntry = unwrap(oldObj[key]);
         const newEntry = unwrap(newObj[key]);
         if (shouldRecurseTouch(oldEntry, newEntry)) {
@@ -3377,11 +3433,10 @@ function dispatchNotifications(notifications) {
         if (originWatchers) {
             const originEffects = new Map();
             collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, [allProps], [origin.prop]);
-            for (const effect of originEffects.keys())
-                allowedEffects.add(effect);
+            allowedEffects = new Set(originEffects.keys());
         }
         // If no allowed effects, skip all notifications (no one should be notified)
-        if (allowedEffects.size === 0)
+        if (!allowedEffects?.size)
             return;
     }
     for (const notification of notifications) {
@@ -3394,7 +3449,6 @@ function dispatchNotifications(notifications) {
         let currentEffects;
         const propsArray = [prop];
         if (objectWatchers) {
-            // console.log(`[DEBUG] dispatchNotifications: processing ${obj.constructor.name} (has watchers)`)
             currentEffects = new Map();
             const broad = evolution.type !== 'set' ? [allProps, keysOf] : [allProps];
             collectEffects(obj, evolution, currentEffects, objectWatchers, broad, propsArray);
@@ -3430,9 +3484,9 @@ function dispatchNotifications(notifications) {
         if (options.introspection?.gatherReasons) {
             const gatherReasons = options.introspection.gatherReasons;
             const lineageConfig = gatherReasons.lineages;
-            let touchStack;
+            let touchLineage;
             if (lineageConfig === 'touch' || lineageConfig === 'both') {
-                touchStack = debugHooks.captureLineage();
+                touchLineage = debugHooks.captureLineage();
             }
             for (const effect of combinedEffects) {
                 const node = getEffectNode(effect);
@@ -3446,7 +3500,7 @@ function dispatchNotifications(notifications) {
                         obj: unwrap(target),
                         evolution,
                         dependency: dependencyStack,
-                        touch: touchStack,
+                        touch: touchLineage,
                     });
                 }
             }
@@ -3459,11 +3513,16 @@ const metaProtos = new WeakMap();
 const wrapProtos = new WeakMap();
 const arrayLengths = new WeakMap();
 const hasReentry = new Set();
-const subsRegister = new WeakMap();
 // Sub-proxy registration for custom reactive behaviors
+const subsRegister = new WeakMap();
+// Internal untracked flag for setter/getter operations - only used when testing oldValue while setting a value
+// TODO: `touched` trigger also compares to old value and should use the internalUntracked flag
+let internalUntracked = false;
 const reactiveHandlers = {
     [Symbol.toStringTag]: 'MutTs Reactive',
     get(obj, prop, receiver) {
+        if (internalUntracked)
+            return FoolProof.get(obj, prop, receiver);
         if (obj && typeof obj === 'object' && prop !== Symbol.toStringTag) {
             const metaProto = metaProtos.get(obj.constructor);
             if (metaProto && Object.hasOwn(metaProto, prop)) {
@@ -3483,15 +3542,21 @@ const reactiveHandlers = {
             if (wrapProto && Object.hasOwn(wrapProto, prop))
                 return wrapProto[prop];
         }
-        // Symbols: fast-path — no reactivity tracking, no unreactive check needed
-        if (typeof prop === 'symbol')
-            return FoolProof.get(obj, prop, receiver);
-        // Check if this property is marked as unreactive (WeakMap lookup — no proxy traps)
-        if (isUnreactiveProp(obj, prop))
+        // Symbols: fast-path — no reactivity tracking
+        if (typeof prop === 'symbol' || prop === 'constructor' || isUnreactiveProp(obj, prop))
             return FoolProof.get(obj, prop, receiver);
         // Check if property exists using a trap-free walk to avoid triggering
         // the has-trap cascade on prototype chains of reactive proxies.
         const isOwnProp = Object.hasOwn(obj, prop);
+        // For accessor properties, check the unwrapped object to see if it's an accessor
+        // This ensures ignoreAccessors works correctly even after operations like Object.setPrototypeOf
+        // Skip for null-proto objects (pounce scopes) — they never have accessors
+        const shouldIgnoreAccessor = options.ignoreAccessors &&
+            isOwnProp &&
+            Object.getPrototypeOf(obj) !== null &&
+            (isOwnAccessor(receiver, prop) || isOwnAccessor(obj, prop));
+        // Check if property exists using a trap-free walk to avoid triggering
+        // the has-trap cascade on prototype chains of reactive proxies.
         let hasProp = isOwnProp;
         let owner = isOwnProp ? obj : undefined;
         if (!isOwnProp) {
@@ -3506,29 +3571,20 @@ 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
-        // Skip for null-proto objects (pounce scopes) — they never have accessors
-        const shouldIgnoreAccessor = options.ignoreAccessors &&
-            isOwnProp &&
-            Object.getPrototypeOf(obj) !== null &&
-            (isOwnAccessor(receiver, prop) || isOwnAccessor(obj, prop));
         // Depend if...
         if (!hasProp ||
             (!(options.instanceMembers && isInheritedAccess && obj instanceof Object) &&
                 !shouldIgnoreAccessor))
             dependant(obj, prop);
-        // Two-Point Tracking: for inherited access on null-proto chains, only track
-        // the owning ancestor — not every intermediate level.  This relies on the
-        // "structural stability" contract: key presence in the chain is fixed at
-        // creation time, so intermediate levels never gain/lose shadowing properties.
+        // Two-Point Tracking: for inherited access on null-proto chains, also track
+        // the owning ancestor so that writing directly to it triggers dependent effects.
         if (isInheritedAccess && owner && (!options.instanceMembers || !(obj instanceof Object))) {
             dependant(owner, prop);
         }
         // For arrays, use FoolProof.get (Indexer path) for numeric index reactivity.
         // For all other objects, inline Reflect.get directly (skips 3 function calls).
         const value = (subsRegister.get(obj)?.get || FoolProof.get)(obj, prop, receiver);
-        if (typeof value === 'object' && value !== null) {
+        if (!isReactive(value) && typeof value === 'object' && value !== null) {
             const reactiveValue = reactiveObject(value);
             // Only create back-references if this object needs them
             if (needsBackReferences(obj)) {
@@ -3539,9 +3595,19 @@ const reactiveHandlers = {
         return value;
     },
     set(obj, prop, value, receiver) {
-        const unwrappedReceiver = unwrap(receiver);
+        const unwrapped = unwrap(receiver);
+        if (obj !== unwrapped)
+            return Object.defineProperty(unwrapped, prop, {
+                value,
+                configurable: true,
+                writable: true,
+                enumerable: true,
+            });
+        if (internalUntracked)
+            throw new Error('Internal untracked: setting a value in an getter in a set operation');
+        //return FoolProof.set(obj, prop, value, receiver)
         // Check if this property is marked as unreactive
-        if (isUnreactiveProp(obj, prop) || obj !== unwrappedReceiver)
+        if (isUnreactiveProp(obj, prop))
             return FoolProof.set(obj, prop, value, receiver);
         const newValue = unwrap(value);
         // metaProto setter dispatch (e.g., reactive array length)
@@ -3558,16 +3624,19 @@ const reactiveHandlers = {
         // Read old value, using withEffect(undefined, ...) for getter-only accessors to avoid
         // breaking memoization dependency tracking during SET operations
         let oldVal = absent;
-        // TODO: Pffft... Find a way to "generalize" this case?
         const isArrayLength = prop === 'length' && Array.isArray(obj);
-        if (Reflect.has(unwrappedReceiver, prop)) {
-            // We *need* to use `receiver` and not `obj` here, otherwise we break
-            // the dependency tracking for memoized getters
-            oldVal = isArrayLength
-                ? arrayLengths.get(obj) === newValue
-                    ? newValue
-                    : absent
-                : untracked(() => Reflect.get(obj, prop, receiver));
+        internalUntracked = true;
+        try {
+            if (Reflect.has(obj, prop)) {
+                oldVal = isArrayLength
+                    ? arrayLengths.get(obj) === newValue
+                        ? newValue
+                        : absent
+                    : Reflect.get(obj, prop, receiver);
+            }
+        }
+        finally {
+            internalUntracked = false;
         }
         if (objectsWithDeepWatchers.has(obj)) {
             if (typeof oldVal === 'object' && oldVal !== null) {
@@ -3596,7 +3665,8 @@ const reactiveHandlers = {
                 cycle: [], // We don't have the full cycle here, but we know it involves obj
             });
         hasReentry.add(obj);
-        dependant(obj, prop);
+        if (!internalUntracked && !isUnreactiveProp(obj, prop))
+            dependant(obj, prop);
         const rv = (subsRegister.get(obj)?.has || Reflect.has)(obj, prop);
         hasReentry.delete(obj);
         return rv;
@@ -3622,7 +3692,8 @@ const reactiveHandlers = {
         return subsRegister.get(obj)?.ownKeys?.(obj) || Reflect.ownKeys(obj);
     },
     getOwnPropertyDescriptor(obj, prop) {
-        return subsRegister.get(obj)?.getOwnPropertyDescriptor?.(obj, prop) || Reflect.getOwnPropertyDescriptor(obj, prop);
+        return (subsRegister.get(obj)?.getOwnPropertyDescriptor?.(obj, prop) ||
+            Reflect.getOwnPropertyDescriptor(obj, prop));
     },
 };
 const reactiveClasses = new WeakSet();
@@ -3697,5 +3768,5 @@ const reactive = decorator({
     default: reactiveObject,
 });
 
-export { touched1 as $, AZone as A, getActiveEffect as B, getState as C, DecoratorError as D, hooks as E, immutables as F, isConstructor as G, isNonReactive as H, IterableWeakMap as I, isObject as J, isReactive as K, legacyDecorator as L, mixin as M, modernDecorator as N, named as O, objectToProxy as P, onEffectThrow as Q, ReactiveBase as R, proxyToObject as S, reactive as T, options as U, reset as V, root as W, stopped as X, tag as Y, Zone as Z, touched as _, IterableWeakSet as a, untracked as a0, unwrap as a1, zip as a2, markWithRoot as a3, rootFunctionSymbol as a4, getRoot as a5, dependant as a6, optionCall as a7, keysOf as a8, __runInitializers as a9, __esDecorate as aa, FoolProof as ab, objectsWithDeepWatchers as ac, effectToDeepWatchedObjects as ad, deepWatchers as ae, registerDeepWatcher as af, nonReactiveClass as ag, unreactiveProps as ah, addUnreactiveProps as ai, nonReactiveObjects as aj, __setFunctionName as ak, __classPrivateFieldGet as al, __classPrivateFieldSet as am, contentRef as an, notifyPropertyChange as ao, metaProtos as ap, wrapProtos as aq, objectParents as ar, watchers as as, effectToReactiveObjects as at, effectMarker as au, getEffectNode as av, setDebugHooks as aw, allProps as ax, ReactiveError as b, ReactiveErrorCode as c, ZoneAggregator as d, ZoneHistory as e, addBatchCleanup as f, arrayEquals as g, asyncHook as h, asyncHooks as i, asyncZone as j, atom as k, atomic as l, biDi as m, caught as n, cleanedBy as o, cleanup as p, createFlavor as q, decorator as r, deepCompare as s, defer as t, effect as u, effectAggregator as v, flavorOptions as w, flavored as x, formatCleanupReason as y, getActivationLog as z };
-//# sourceMappingURL=proxy-r7lARftl.esm.js.map
+export { reactive as $, AZone as A, flavored as B, formatCleanupReason as C, DecoratorError as D, getActivationLog as E, getActiveEffect as F, getState as G, hooks as H, IterableWeakMap as I, isConstructor as J, isDev as K, isNonReactive as L, isObject as M, isProd as N, isReactive as O, isTest as P, legacyDecorator as Q, ReactiveBase as R, link as S, mixin as T, modernDecorator as U, named as V, objectToProxy as W, onEffectThrow as X, prodPreset as Y, Zone as Z, proxyToObject as _, IterableWeakSet as a, options as a0, reset as a1, root as a2, tag as a3, touched as a4, touched1 as a5, unlink as a6, untracked as a7, unwrap as a8, zip as a9, allProps as aA, dependant as aa, keysOf as ab, markWithRoot as ac, objectsWithDeepWatchers as ad, effectToDeepWatchedObjects as ae, deepWatchers as af, registerDeepWatcher as ag, rootFunctionSymbol as ah, getRoot as ai, optionCall as aj, FoolProof as ak, effectHistory as al, unreactiveProperties as am, __runInitializers as an, __esDecorate as ao, batch as ap, contentRef as aq, notifyPropertyChange as ar, metaProtos as as, wrapProtos as at, objectParents as au, watchers as av, effectToReactiveObjects as aw, effectMarker as ax, getEffectNode as ay, setDebugHooks as az, ReactiveError as b, ReactiveErrorCode as c, ZoneAggregator as d, ZoneHistory as e, addBatchCleanup as f, addUnreactiveProps as g, arrayEquals as h, assertUntracked as i, asyncHook as j, asyncHooks as k, asyncZone as l, atom as m, atomic as n, biDi as o, captured as p, caught as q, createFlavor as r, debugPreset as s, decorator as t, deepCompare as u, defer as v, devPreset as w, effect as x, effectAggregator as y, flavorOptions as z };
+//# sourceMappingURL=proxy-D2C49sXH.esm.js.map