mutts 1.0.10 → 1.0.11

package/dist/chunks/{proxy-Dtg-bJ3T.cjs → proxy-Cc79Lrzj.cjs}

@@ -2,6 +2,7 @@
 
 var asyncCore = require('./async-core-CRLKP3l-.cjs');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 /**
  * Yields tuples containing elements from each input array, stopping at the longest array length
  * @param args - Arrays to zip together
@@ -99,16 +100,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);
     },
 };
@@ -132,15 +133,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))
@@ -152,39 +146,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) {
@@ -193,18 +169,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;
@@ -214,16 +186,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;
@@ -231,29 +198,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;
 }
@@ -301,6 +250,12 @@ function named(name, fn) {
     });
     return fn;
 }
+const _mode = (typeof process !== 'undefined' && process.env?.NODE_ENV) ||
+    (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunks/proxy-Cc79Lrzj.cjs', document.baseURI).href)) }) !== 'undefined' && undefined?.MODE) ||
+    'production';
+const isDev = _mode === 'development';
+const isProd = _mode === 'production';
+const isTest = _mode === 'test';
 
 // biome-ignore-all lint/suspicious/noConfusingVoidType: We *love* voids
 // Standardized decorator system that works with both Legacy and Modern decorators
@@ -528,9 +483,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)
@@ -871,6 +824,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.
 
@@ -922,41 +889,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;
@@ -1084,13 +1027,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());
 asyncCore.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;
         };
     };
@@ -1160,6 +1117,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',
@@ -1222,6 +1248,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
  */
@@ -1231,14 +1262,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
  */
@@ -1312,6 +1335,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
@@ -1438,34 +1467,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];
@@ -1479,6 +1480,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();
@@ -1498,54 +1529,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)
@@ -1558,14 +1563,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 = exports.watchers.get(obj);
     if (!objectWatchers) {
@@ -1702,6 +1710,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
@@ -2355,6 +2364,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) {
@@ -2508,6 +2518,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.
@@ -2530,19 +2556,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
@@ -2566,6 +2586,7 @@ fn, effectOptions = {}) {
         if (runningPromise) {
             if (asyncMode === 'cancel' && cancelPrevious) {
                 // Cancel previous execution
+                abort();
                 cancelPrevious();
                 cancelPrevious = null;
                 runningPromise = null;
@@ -2589,11 +2610,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;
@@ -2643,12 +2686,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
@@ -2659,13 +2704,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)
                             exports.watchers.delete(reactiveObj);
-                        }
                     }
                 }
                 exports.effectToReactiveObjects.delete(runEffect);
@@ -2683,33 +2726,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);
     };
@@ -2728,26 +2744,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;
@@ -2756,6 +2771,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;
@@ -2765,6 +2786,7 @@ fn, effectOptions = {}) {
         effectStopped = true;
         node.stopped = true;
         // Cancel any running async work
+        abort();
         if (cancelPrevious) {
             cancelPrevious();
             cancelPrevious = null;
@@ -2783,7 +2805,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);
@@ -2797,16 +2819,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' });
@@ -2837,9 +2859,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
@@ -2910,16 +2934,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'
@@ -2932,7 +2956,7 @@ function bubbleUpChange(changedObject, evolution) {
                         obj: parent,
                         evolution,
                         dependency: dependencyStack,
-                        touch: touchStack,
+                        touch: touchLineage,
                     });
                 }
             }
@@ -2985,6 +3009,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) {
@@ -3035,9 +3061,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);
@@ -3047,7 +3073,7 @@ function touched(obj, evolution, props) {
                     obj,
                     evolution,
                     dependency: dependencyStack,
-                    touch: touchStack,
+                    touch: touchLineage,
                 });
             }
         }
@@ -3086,10 +3112,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);
@@ -3100,7 +3126,7 @@ function touchedOpaque(obj, evolution, prop) {
                     obj,
                     evolution,
                     dependency: dependencyStack,
-                    touch: touchStack,
+                    touch: touchLineage,
                 });
             }
             recordActivation(effect, obj, evolution, prop);
@@ -3129,59 +3155,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);
 }
 
@@ -3203,10 +3230,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 = exports.watchers.get(oldRef);
+    if (!oldMap)
+        return;
+    // Move the entire watcher map
+    exports.watchers.set(newRef, oldMap);
+    exports.watchers.delete(oldRef);
+    // Update the reverse map (effect → objects it watches)
+    for (const deps of oldMap.values()) {
+        for (const effect of deps) {
+            const objects = exports.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
@@ -3224,7 +3274,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);
     }
@@ -3311,12 +3369,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)) {
@@ -3358,11 +3415,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) {
@@ -3375,7 +3431,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);
@@ -3411,9 +3466,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);
@@ -3427,7 +3482,7 @@ function dispatchNotifications(notifications) {
                         obj: unwrap(target),
                         evolution,
                         dependency: dependencyStack,
-                        touch: touchStack,
+                        touch: touchLineage,
                     });
                 }
             }
@@ -3440,11 +3495,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)) {
@@ -3464,15 +3524,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) {
@@ -3487,29 +3553,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)) {
@@ -3520,9 +3577,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)
@@ -3539,16 +3606,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) {
@@ -3577,7 +3647,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;
@@ -3603,7 +3674,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();
@@ -3688,31 +3760,32 @@ exports.ReactiveError = ReactiveError;
 exports.Zone = Zone;
 exports.ZoneAggregator = ZoneAggregator;
 exports.ZoneHistory = ZoneHistory;
-exports.__classPrivateFieldGet = __classPrivateFieldGet;
-exports.__classPrivateFieldSet = __classPrivateFieldSet;
 exports.__esDecorate = __esDecorate;
 exports.__runInitializers = __runInitializers;
-exports.__setFunctionName = __setFunctionName;
 exports.addBatchCleanup = addBatchCleanup;
 exports.addUnreactiveProps = addUnreactiveProps;
 exports.allProps = allProps;
 exports.arrayEquals = arrayEquals;
+exports.assertUntracked = assertUntracked;
 exports.asyncZone = asyncZone;
 exports.atom = atom;
 exports.atomic = atomic;
+exports.batch = batch;
 exports.biDi = biDi;
+exports.captured = captured;
 exports.caught = caught;
-exports.cleanedBy = cleanedBy;
-exports.cleanup = cleanup;
 exports.contentRef = contentRef;
 exports.createFlavor = createFlavor;
+exports.debugPreset = debugPreset;
 exports.decorator = decorator;
 exports.deepCompare = deepCompare;
 exports.deepWatchers = deepWatchers;
 exports.defer = defer;
 exports.dependant = dependant;
+exports.devPreset = devPreset;
 exports.effect = effect;
 exports.effectAggregator = effectAggregator;
+exports.effectHistory = effectHistory;
 exports.effectMarker = effectMarker;
 exports.effectToDeepWatchedObjects = effectToDeepWatchedObjects;
 exports.flavorOptions = flavorOptions;
@@ -3723,20 +3796,21 @@ exports.getActiveEffect = getActiveEffect;
 exports.getEffectNode = getEffectNode;
 exports.getRoot = getRoot;
 exports.getState = getState;
-exports.immutables = immutables;
 exports.isConstructor = isConstructor;
+exports.isDev = isDev;
 exports.isNonReactive = isNonReactive;
 exports.isObject = isObject;
+exports.isProd = isProd;
 exports.isReactive = isReactive;
+exports.isTest = isTest;
 exports.keysOf = keysOf;
 exports.legacyDecorator = legacyDecorator;
+exports.link = link;
 exports.markWithRoot = markWithRoot;
 exports.metaProtos = metaProtos;
 exports.mixin = mixin;
 exports.modernDecorator = modernDecorator;
 exports.named = named;
-exports.nonReactiveClass = nonReactiveClass;
-exports.nonReactiveObjects = nonReactiveObjects;
 exports.notifyPropertyChange = notifyPropertyChange;
 exports.objectParents = objectParents;
 exports.objectToProxy = objectToProxy;
@@ -3744,6 +3818,7 @@ exports.objectsWithDeepWatchers = objectsWithDeepWatchers;
 exports.onEffectThrow = onEffectThrow;
 exports.optionCall = optionCall;
 exports.options = options;
+exports.prodPreset = prodPreset;
 exports.proxyToObject = proxyToObject;
 exports.reactive = reactive;
 exports.registerDeepWatcher = registerDeepWatcher;
@@ -3751,13 +3826,13 @@ exports.reset = reset;
 exports.root = root;
 exports.rootFunctionSymbol = rootFunctionSymbol;
 exports.setDebugHooks = setDebugHooks;
-exports.stopped = stopped;
 exports.tag = tag;
 exports.touched = touched;
 exports.touched1 = touched1;
-exports.unreactiveProps = unreactiveProps;
+exports.unlink = unlink;
+exports.unreactiveProperties = unreactiveProperties;
 exports.untracked = untracked;
 exports.unwrap = unwrap;
 exports.wrapProtos = wrapProtos;
 exports.zip = zip;
-//# sourceMappingURL=proxy-Dtg-bJ3T.cjs.map
+//# sourceMappingURL=proxy-Cc79Lrzj.cjs.map