mutts 1.0.12 → 1.0.14

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

@@ -1,26 +1,3 @@
-// Queue for hooks registered before the environment is ready (circular dependency fix)
-const hooks = new Set();
-const asyncHooks = {
-    addHook(hook) {
-        hooks.add(hook);
-        return () => hooks.delete(hook);
-    },
-    /**
-     * [Hack] Sanitize a promise (or value) to prevent context leaks.
-     * Default: Identity function.
-     * Browser: Uses Macrotask wrapping to break microtask chains.
-     */
-    sanitizePromise(p) {
-        return p;
-    },
-};
-/**
- * Register a hook that will be called whenever an asynchronous operation is initiated.
- * The hook should return a restorer function which will be called just before the async callback runs.
- * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
- */
-const asyncHook = (hook) => asyncHooks.addHook(hook);
-
 /**
  * Yields tuples containing elements from each input array, stopping at the longest array length
  * @param args - Arrays to zip together
@@ -136,13 +113,10 @@ function isOwnAccessor(obj, prop) {
     return !!(opd?.get || opd?.set);
 }
 /**
- * Deeply compares two values.
- * For objects, compares prototypes with === and then own properties recursively.
- * Uses a cache to handle circular references.
- * @param a - First value
- * @param b - Second value
- * @param cache - Map for circular reference protection (internal use)
- * @returns True if values are deeply equal
+ * Symbol used to provide custom comparison logic for an object.
+ */
+const CompareSymbol = Symbol.for('mutts.compare');
+/**
  */
 function deepCompare(a, b, cache = new Map()) {
     if (a === b)
@@ -150,6 +124,13 @@ function deepCompare(a, b, cache = new Map()) {
     if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
         return a === b;
     }
+    // Custom comparison support
+    if (typeof a[CompareSymbol] === 'function') {
+        return a[CompareSymbol](b, (x, y) => deepCompare(x, y, cache));
+    }
+    if (typeof b[CompareSymbol] === 'function') {
+        return b[CompareSymbol](a, (x, y) => deepCompare(x, y, cache));
+    }
     // Prototype check
     if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
         return false;
@@ -268,7 +249,8 @@ function named(name, fn) {
     });
     return fn;
 }
-const _mode = (typeof process !== 'undefined' && process.env?.NODE_ENV) ||
+const runtimeGlobals = globalThis;
+const _mode = runtimeGlobals.process?.env?.NODE_ENV ||
     (typeof import.meta !== 'undefined' && import.meta.env?.MODE) ||
     'production';
 const isDev = _mode === 'development';
@@ -444,6 +426,93 @@ const decorator = (description) => {
  * flavoredGreet.loud('World') // "HELLO, WORLD!"
  * ```
  */
+const captionedOptionsSymbol = Symbol('mutts.captioned.options');
+function isTemplateStringsArray(value) {
+    return (Array.isArray(value) &&
+        Object.hasOwn(value, 'raw') &&
+        Array.isArray(value.raw));
+}
+function renderTemplate(strings, values) {
+    let result = strings[0] ?? '';
+    for (let i = 0; i < values.length; i++)
+        result += String(values[i]) + (strings[i + 1] ?? '');
+    return result;
+}
+function renameCallback(caption, callback) {
+    Object.defineProperty(callback, 'name', {
+        value: caption,
+        writable: false,
+        configurable: true,
+    });
+    return callback;
+}
+function isAnonymousCallback(callback) {
+    return !callback.name || callback.name === 'anonymous';
+}
+/**
+ * Wraps a callback-first function so it also accepts a tagged-template call form.
+ *
+ * The template caption is applied to one callback argument before the base
+ * function runs. By default, `captioned` targets the first argument, but
+ * `callbackIndex` can point to any callback position.
+ *
+ * This is intended for APIs such as `effect`, `lift`, or `watch` where naming
+ * is useful but should remain separate from the flavor system.
+ *
+ * Plain calls still work:
+ * `run(callback)`
+ *
+ * Captioned calls add a runtime name to the first callback:
+ * `` run`task:${id}`(callback) ``
+ *
+ * Anonymous uncaptioned callbacks may trigger a warning depending on
+ * `shouldWarnAnonymous`.
+ */
+function captioned(fn, options = {}) {
+    const settings = {
+        callbackIndex: options.callbackIndex ?? 0,
+        name: options.name ?? (fn.name || 'callback'),
+        rename: options.rename ?? ((caption, callback) => renameCallback(caption, callback)),
+        // biome-ignore lint/suspicious/noConsole: This is the whole point here
+        warn: options.warn ?? ((message) => console.warn(message)),
+        shouldWarnAnonymous: options.shouldWarnAnonymous,
+    };
+    fn[captionedOptionsSymbol] = settings;
+    return new Proxy(fn, {
+        get(target, prop, receiver) {
+            if (prop === captionedOptionsSymbol)
+                return settings;
+            return Reflect.get(target, prop, receiver);
+        },
+        apply(target, thisArg, args) {
+            if (isTemplateStringsArray(args[0])) {
+                const caption = renderTemplate(args[0], args.slice(1));
+                return function captionedCall(...callArgs) {
+                    const callback = callArgs[settings.callbackIndex];
+                    if (typeof callback !== 'function')
+                        throw new TypeError(`${settings.name} template calls require a callback at argument index ${settings.callbackIndex}`);
+                    const nextArgs = [...callArgs];
+                    nextArgs[settings.callbackIndex] = settings.rename(caption, callback);
+                    return Reflect.apply(target, this, nextArgs);
+                };
+            }
+            const callback = args[settings.callbackIndex];
+            if (typeof callback === 'function' && isAnonymousCallback(callback)) {
+                const shouldWarn = settings.shouldWarnAnonymous?.(callback, args) ?? true;
+                if (shouldWarn)
+                    settings.warn(`${settings.name}: anonymous callback detected. Use template syntax for automatic naming:\n` +
+                        `  Current: ${settings.name}(() => { ... })\n` +
+                        `  Fix:     ${settings.name}\`descriptive-name\`(() => { ... })\n` +
+                        `The captioned system uses the template literal as the effect name for better debugging.`);
+            }
+            return Reflect.apply(target, thisArg, args);
+        },
+    });
+}
+function inheritCaption(source, target) {
+    const settings = source[captionedOptionsSymbol];
+    return settings ? captioned(target, settings) : target;
+}
 /**
  * Creates a flavored (extensible) version of a function with chainable property modifiers.
  */
@@ -476,7 +545,7 @@ function createFlavor(fn, transform, name) {
     };
     if (name)
         named(name, fct);
-    return flavored(fct, fn.flavors || {});
+    return flavored(inheritCaption(fn, fct), fn.flavors || {});
 }
 /**
  * Creates a new flavored function that merges options objects at a specific index.
@@ -509,7 +578,7 @@ function flavorOptions(fn, defaultOptions, opts = {}) {
     // Preserve arity and options track
     Object.defineProperty(fct, 'length', { value: fn.length });
     fct.optionsIndex = targetIndex;
-    return flavored(fct, fn.flavors || {});
+    return flavored(inheritCaption(fn, fct), fn.flavors || {});
 }
 
 /// <reference lib="esnext.collection" />
@@ -690,7 +759,13 @@ class IterableWeakSet {
     [Symbol.iterator]() {
         return this.keys();
     }
-    union(other) {
+    union(other, ...sets) {
+        if (sets.length > 0) {
+            for (const set of [other, ...sets])
+                for (const value of set)
+                    this.add(value);
+            return this;
+        }
         const others = {
             [Symbol.iterator]() {
                 return other.keys();
@@ -762,100 +837,6 @@ class IterableWeakSet {
 }
 _b = Symbol.toStringTag;
 
-/**
- * Creates a mixin that can be used both as a class (extends) and as a function (mixin)
- *
- * This function supports:
- * - Using mixins as base classes: `class MyClass extends MyMixin`
- * - Using mixins as functions: `class MyClass extends MyMixin(SomeBase)`
- * - Composing mixins: `const Composed = MixinA(MixinB)`
- * - Type-safe property inference for all patterns
- *
- * @param mixinFunction - The function that creates the mixin
- * @param unwrapFunction - Optional function to unwrap reactive objects for method calls
- * @returns A mixin that can be used both as a class and as a function
- */
-function mixin(mixinFunction, unwrapFunction) {
-    /**
-     * Cache for mixin results to ensure the same base class always returns the same mixed class
-     */
-    const mixinCache = new WeakMap();
-    // Apply the mixin to Object as the base class
-    const MixedBase = mixinFunction(Object);
-    mixinCache.set(Object, MixedBase);
-    // Create the proxy that handles both constructor and function calls
-    return new Proxy(MixedBase, {
-        // Handle `MixinClass(SomeBase)` - use as mixin function
-        apply(_target, _thisArg, args) {
-            if (args.length === 0) {
-                throw new Error('Mixin requires a base class');
-            }
-            const baseClass = args[0];
-            if (typeof baseClass !== 'function') {
-                throw new Error('Mixin requires a constructor function');
-            }
-            // Check if it's a valid constructor or a mixin
-            if (!isConstructor(baseClass) &&
-                !(baseClass && typeof baseClass === 'function' && baseClass.prototype)) {
-                throw new Error('Mixin requires a valid constructor');
-            }
-            // Check cache first
-            const cached = mixinCache.get(baseClass);
-            if (cached) {
-                return cached;
-            }
-            let usedBase = baseClass;
-            if (unwrapFunction) {
-                // Create a proxied base class that handles method unwrapping
-                const ProxiedBaseClass = class extends baseClass {
-                };
-                // Proxy the prototype methods to handle unwrapping
-                const originalPrototype = baseClass.prototype;
-                const proxiedPrototype = new Proxy(originalPrototype, {
-                    get(target, prop, receiver) {
-                        const value = FoolProof.get(target, prop, receiver);
-                        // Only wrap methods that are likely to access private fields
-                        // Skip symbols and special properties that the reactive system needs
-                        if (typeof value === 'function' &&
-                            typeof prop === 'string' &&
-                            !['constructor', 'toString', 'valueOf'].includes(prop)) {
-                            // Return a wrapped version that uses unwrapped context
-                            return function (...args) {
-                                // Use the unwrapping function if provided, otherwise use this
-                                const context = unwrapFunction(this);
-                                return value.apply(context, args);
-                            };
-                        }
-                        return value;
-                    },
-                });
-                // Set the proxied prototype
-                Object.setPrototypeOf(ProxiedBaseClass.prototype, proxiedPrototype);
-                usedBase = ProxiedBaseClass;
-            }
-            // Create the mixed class using the proxied base class
-            const mixedClass = mixinFunction(usedBase);
-            // Cache the result
-            mixinCache.set(baseClass, mixedClass);
-            return mixedClass;
-        },
-    });
-}
-
-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.
 
@@ -918,6 +899,29 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+// Queue for hooks registered before the environment is ready (circular dependency fix)
+const hooks = new Set();
+const asyncHooks = {
+    addHook(hook) {
+        hooks.add(hook);
+        return () => hooks.delete(hook);
+    },
+    /**
+     * [Hack] Sanitize a promise (or value) to prevent context leaks.
+     * Default: Identity function.
+     * Browser: Uses Macrotask wrapping to break microtask chains.
+     */
+    sanitizePromise(p) {
+        return p;
+    },
+};
+/**
+ * Register a hook that will be called whenever an asynchronous operation is initiated.
+ * The hook should return a restorer function which will be called just before the async callback runs.
+ * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
+ */
+const asyncHook = (hook) => asyncHooks.addHook(hook);
+
 var _ZoneAggregator_zones;
 function isu(z) {
     return z;
@@ -1103,6 +1107,7 @@ function resetRegistry() {
  * @returns The marked function
  */
 function markWithRoot(fn, root) {
+    const marked = fn;
     // Check for collision
     const existingRef = reverseRoots.get(root);
     const existing = existingRef?.deref();
@@ -1117,8 +1122,8 @@ function markWithRoot(fn, root) {
     // (Last writer wins for the check)
     reverseRoots.set(root, new WeakRef(fn));
     // Store root mapping as symbol property on the function
-    fn[rootFunctionSymbol] = getRoot(root);
-    return fn;
+    marked[rootFunctionSymbol] = getRoot(root);
+    return marked;
 }
 /**
  * Gets the root function of a function for effect tracking
@@ -1138,11 +1143,30 @@ function getRoot(fn) {
 const effectHistory = tag('effectHistory', new ZoneHistory());
 tag('effectHistory.present', effectHistory.present);
 asyncZone.add(effectHistory);
+const externalReason = tag('externalReason', new Zone());
+asyncZone.add(externalReason);
 /**
  * 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));
+effectAggregator.add(externalReason);
+function chainExternalReason(reason) {
+    const external = externalReason.active;
+    if (!external)
+        return reason;
+    if (!reason)
+        return external;
+    let current = reason;
+    while (current) {
+        if (current.type === 'external' &&
+            external.type === 'external' &&
+            current.detail === external.detail)
+            return reason;
+        current = current.chain;
+    }
+    return { ...reason, chain: chainExternalReason(reason.chain) };
+}
 function isRunning(effect) {
     const root = getRoot(effect);
     return effectHistory.some((e) => getRoot(e) === root);
@@ -1150,6 +1174,35 @@ function isRunning(effect) {
 function getActiveEffect() {
     return effectHistory.present.active;
 }
+/**
+ * Captures the current effect context so that deferred code can later
+ * create child effects parented to this point in the effect tree.
+ *
+ * @returns An opaque token to pass to `withEffectContext()`
+ *
+ * @example
+ * ```ts
+ * const ctx = effectContext() // inside an effect or root()
+ * // later, in a deferred callback:
+ * withEffectContext(ctx, () => {
+ *   effect(() => { /* child of the captured context *​/ })
+ * })
+ * ```
+ */
+function effectContext() {
+    return effectHistory.active;
+}
+/**
+ * Runs `fn` within a previously captured effect context.
+ * Any effects created inside `fn` become children of the captured parent.
+ *
+ * @param ctx - The context token from `effectContext()`, or `undefined` for root context
+ * @param fn - The function to execute within the restored context
+ * @returns The return value of `fn`
+ */
+function withEffectContext(ctx, fn) {
+    return effectHistory.with(ctx, fn);
+}
 const cleanups = new WeakMap();
 /**
  * Attach cleanup dependencies to an object. When `unlink(obj)` is called,
@@ -1177,7 +1230,7 @@ const cleanups = new WeakMap();
 function link(obj, ...cleanupFns) {
     const set = cleanups.get(obj);
     if (!set)
-        cleanups.set(obj, new Set(cleanupFns.filter(Boolean)));
+        cleanups.set(obj, new Set(cleanupFns.filter((fn) => fn !== undefined)));
     else
         for (const fn of cleanupFns)
             if (fn)
@@ -1204,6 +1257,85 @@ function unlink(obj, reason) {
     }
 }
 
+function extractRawStack(error = new Error()) {
+    if (typeof error === 'string')
+        return error;
+    if (error && typeof error === 'object' && 'stack' in error) {
+        const stack = error.stack;
+        return typeof stack === 'string' ? stack : undefined;
+    }
+    return undefined;
+}
+function trimStack(stack) {
+    const raw = extractRawStack(stack);
+    if (!raw)
+        return [];
+    const lines = raw
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines[0]?.startsWith('Error'))
+        lines.shift();
+    while (lines[0] &&
+        (lines[0].includes('captureLineage') ||
+            lines[0].includes('captureDeferredLineage') ||
+            lines[0].includes('debug-hooks.ts')))
+        lines.shift();
+    return lines;
+}
+function digestDeferredLineage(lineage) {
+    if (lineage.segments)
+        return lineage.segments;
+    const segments = [];
+    let effect = lineage.effect;
+    let stack = trimStack(lineage.stack);
+    if (!effect) {
+        lineage.segments = [{ effectName: 'root', stack }];
+        return lineage.segments;
+    }
+    while (effect) {
+        const root = getRoot(effect);
+        segments.push({
+            effectName: root.name || 'anonymous',
+            stack,
+        });
+        const node = getEffectNode(effect);
+        effect = node.parent;
+        stack = trimStack(node.creationStack);
+    }
+    if (stack.length)
+        segments.push({ effectName: 'root', stack });
+    lineage.segments = segments;
+    return segments;
+}
+function formatDeferredLineage(lineage) {
+    return digestDeferredLineage(lineage)
+        .map((segment) => [`${segment.effectName}:`, ...segment.stack.map((line) => `  ${line}`)].join('\n'))
+        .join('\n');
+}
+function captureDeferredLineage(effect = getActiveEffect(), stack = new Error()) {
+    return {
+        effect,
+        stack,
+        toString() {
+            return formatDeferredLineage(this);
+        },
+    };
+}
+const debugHooks = {
+    isDevtoolsEnabled: () => false,
+    registerEffect: () => { },
+    getTriggerChain: () => [],
+    captureStack: (error) => extractRawStack(error ?? new Error()),
+    captureLineage: captureDeferredLineage,
+    formatStack: (stack) => [stack],
+    recordTriggerLink: () => { },
+    decorateError: () => { },
+};
+function setDebugHooks(hooks) {
+    Object.assign(debugHooks, hooks);
+}
+
 const effectMarker = {
     enter: 'effect:enter',
     leave: 'effect:leave',
@@ -1243,18 +1375,61 @@ function formatCleanupReason(reason, depth = 0) {
                     parts.push(',');
                 parts.push(...formatTrigger(reason.triggers[i]));
             }
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'stopped': {
+            const parts = [`${indent}stopped`];
+            if (reason.detail)
+                parts.push(`(${reason.detail})`);
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'external': {
+            const parts = [`${indent}external:`, reason.detail];
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'gc': {
+            const parts = [`${indent}gc`];
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'error': {
+            const parts = [`${indent}error:`, reason.error];
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'lineage': {
+            const parts = [
+                `${indent}lineage ←\n`,
+                ...formatCleanupReason(reason.parent, depth + 1),
+            ];
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
+            return parts;
+        }
+        case 'invalidate': {
+            const parts = [
+                `${indent}invalidate ←\n`,
+                ...formatCleanupReason(reason.cause, depth + 1),
+            ];
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
             return parts;
         }
-        case 'stopped':
-            return [`${indent}stopped`];
-        case 'gc':
-            return [`${indent}gc`];
-        case 'error':
-            return [`${indent}error:`, reason.error];
-        case 'lineage':
-            return [`${indent}lineage ←\n`, ...formatCleanupReason(reason.parent, depth + 1)];
-        case 'invalidate':
-            return [`${indent}invalidate ←\n`, ...formatCleanupReason(reason.cause, depth + 1)];
         case 'multiple': {
             const parts = [];
             for (let i = 0; i < reason.reasons.length; i++) {
@@ -1262,6 +1437,9 @@ function formatCleanupReason(reason, depth = 0) {
                     parts.push('\n');
                 parts.push(...formatCleanupReason(reason.reasons[i], depth));
             }
+            if (reason.chain) {
+                parts.push('\n', ...formatCleanupReason(reason.chain, depth));
+            }
             return parts;
         }
     }
@@ -1308,6 +1486,17 @@ class ReactiveError extends Error {
         return this.debugInfo?.cause;
     }
 }
+function normalizeSchedulerMode(mode) {
+    switch (mode) {
+        case 'production':
+            return 'raw';
+        case 'development':
+            return 'ordered';
+        default:
+            return mode;
+    }
+}
+let schedulerMode = 'ordered';
 // biome-ignore-start lint/correctness/noUnusedFunctionParameters: Interface declaration with empty defaults
 /**
  * Global options for the reactive system
@@ -1398,22 +1587,42 @@ const options = {
      */
     onMemoizationDiscrepancy: undefined,
     /**
-     * How to handle cycles detected in effect batches.
+     * Effect scheduler mode.
      *
-     * - `'production'` (Default): High-performance mode. Disables dependency graph maintenance and
-     *   Topological Sorting in favor of a simple FIFO queue. Use this for trustworthy, acyclic UI code.
-     *   Cycle detection is heuristic (uses maxEffectChain execution counts).
+     * - `'ordered'` (Default): maintains the causal effect graph so effects that are already
+     *   queued together can run in dependency order. It also preserves parent/child effect
+     *   lifecycle ordering and catches cycles eagerly when edges are created.
      *
-     * - `'development'`: Maintains direct dependency graph for early cycle detection during edge creation.
-     *   Catches cycles before effects execute via DFS check when adding edges. Throws immediately with
-     *   basic path information. Good balance of debugging help with moderate overhead.
+     * - `'raw'`: fastest FIFO scheduler. It does not maintain the effect graph.
+     *   Cycle detection is heuristic, using maxEffectChain execution counts.
      *
-     * - `'debug'`: Full diagnostic mode with transitive closures and topological sorting.
-     *   Provides detailed cycle path reporting. Highest overhead but most informative for bug hunting.
+     * - `'debug'`: ordered scheduling plus the most detailed graph diagnostics. Highest overhead,
+     *   best for investigation.
      *
-     * @default 'production'
+     * @default 'ordered'
      */
-    cycleHandling: 'development',
+    get scheduler() {
+        return schedulerMode;
+    },
+    set scheduler(mode) {
+        schedulerMode = mode;
+    },
+    /**
+     * @deprecated Use `scheduler` instead.
+     *
+     * Backward-compatible alias for older names:
+     * - `'production'` maps to `scheduler = 'raw'`
+     * - `'development'` maps to `scheduler = 'ordered'`
+     * - `'debug'` maps to `scheduler = 'debug'`
+     *
+     * The new names describe scheduler behavior rather than runtime environment.
+     */
+    get cycleHandling() {
+        return schedulerMode;
+    },
+    set cycleHandling(mode) {
+        schedulerMode = normalizeSchedulerMode(mode);
+    },
     /**
      * Internal flag used by memoization discrepancy detector to avoid counting calls in tests
      * @warning Do not modify this flag manually, this flag is given by the engine
@@ -1462,6 +1671,8 @@ const options = {
     asyncMode: 'cancel',
     // biome-ignore lint/suspicious/noConsole: This is the whole point here
     warn: (...args) => console.warn(...args),
+    // biome-ignore lint/suspicious/noConsole: This is the whole point here
+    error: (...args) => console.error(...args),
     /**
      * Introspection and debug aids. Set to `null` to disable all debug overhead in production.
      *
@@ -1501,14 +1712,14 @@ function optionCall(name, ...args) {
 /** Production preset: no introspection, heuristic cycle detection, minimal overhead */
 const prodPreset = {
     maxEffectReaction: 'throw',
-    cycleHandling: 'production',
+    scheduler: 'raw',
     introspection: null,
     onMemoizationDiscrepancy: undefined,
 };
-/** Development preset (default): introspection on, early cycle detection, warnings */
+/** Development preset: introspection on, early cycle detection, warnings */
 const devPreset = {
     maxEffectReaction: 'warn',
-    cycleHandling: 'development',
+    scheduler: 'ordered',
     introspection: {
         gatherReasons: { lineages: 'touch' },
         logErrors: true,
@@ -1520,7 +1731,7 @@ const devPreset = {
 /** Debug preset: full diagnostics, throws on violations, rich lineage capture */
 const debugPreset = {
     maxEffectReaction: 'debug',
-    cycleHandling: 'debug',
+    scheduler: 'debug',
     introspection: {
         gatherReasons: { lineages: 'both' },
         logErrors: true,
@@ -1543,6 +1754,7 @@ function unwrap(obj) {
         return obj;
     return proxyToObject.get(obj) || obj;
 }
+const toRaw = unwrap;
 function isReactive(obj) {
     return proxyToObject.has(obj);
 }
@@ -1590,7 +1802,8 @@ function dependant(obj, prop = allProps) {
     if (!currentActiveEffect || (typeof prop === 'symbol' && prop !== allProps && prop !== keysOf))
         return;
     const node = getEffectNode(currentActiveEffect);
-    if ('dependencyHook' in node) {
+    const hasDependencyHook = node.dependencyHook !== undefined;
+    if (hasDependencyHook) {
         node.dependencyHook(obj, prop);
     }
     let objectWatchers = watchers.get(obj);
@@ -1613,25 +1826,25 @@ function dependant(obj, prop = allProps) {
         effectToReactiveObjects.set(currentActiveEffect, new Set([obj]));
     }
     // Store dependency stack if introspection is enabled
-    const gatherReasons = options.introspection?.gatherReasons;
-    if (gatherReasons) {
-        const lineageConfig = gatherReasons.lineages;
-        if (lineageConfig === 'dependency' || lineageConfig === 'both') {
-            let objStacks = dependencyStacks.get(obj);
-            if (!objStacks) {
-                objStacks = new Map();
-                dependencyStacks.set(obj, objStacks);
-            }
-            let propStacks = objStacks.get(prop);
-            if (!propStacks) {
-                propStacks = new Map();
-                objStacks.set(prop, propStacks);
-            }
-            propStacks.set(currentActiveEffect, debugHooks.captureLineage());
+    const lineageMode = options.introspection?.gatherReasons?.lineages;
+    const shouldGatherDependencyLineage = lineageMode === 'dependency' || lineageMode === 'both';
+    if (shouldGatherDependencyLineage) {
+        let objStacks = dependencyStacks.get(obj);
+        if (!objStacks) {
+            objStacks = new Map();
+            dependencyStacks.set(obj, objStacks);
+        }
+        let propStacks = objStacks.get(prop);
+        if (!propStacks) {
+            propStacks = new Map();
+            objStacks.set(prop, propStacks);
         }
+        propStacks.set(currentActiveEffect, debugHooks.captureLineage());
     }
 }
 
+// Simple module to manage inert state without circular dependencies
+let inertDepth = 0;
 /**
  * Finds a cycle in a sequence of functions by looking for the first repetition
  */
@@ -1657,6 +1870,9 @@ function formatRoots(roots, limit = 20) {
     const end = names.slice(-10);
     return `${start.join(' → ')} ... (${names.length - 15} more) ... ${end.join(' → ')}`;
 }
+function externalReasonFrom(fn) {
+    return fn.name ? { type: 'external', detail: fn.name } : undefined;
+}
 // Nested map structure for efficient counting and batch cleanup
 // batchId -> effect root -> obj -> prop -> count
 let activationRegistry;
@@ -1730,6 +1946,40 @@ let causesClosure = new WeakMap();
 let consequencesClosure = new WeakMap();
 // Batch re-entrance depth and broken state
 let broken = false;
+/** True after an unrecoverable reactive failure until `reset()`. */
+function isReactiveBroken() {
+    return broken;
+}
+const reactiveBrokenHandlers = new Set();
+const reactiveResetHandlers = new Set();
+function onReactiveBroken(handler) {
+    reactiveBrokenHandlers.add(handler);
+    return () => reactiveBrokenHandlers.delete(handler);
+}
+function onReactiveReset(handler) {
+    reactiveResetHandlers.add(handler);
+    return () => reactiveResetHandlers.delete(handler);
+}
+function notifyReactiveBroken(error) {
+    for (const handler of Array.from(reactiveBrokenHandlers)) {
+        try {
+            handler(error);
+        }
+        catch (handlerError) {
+            options.warn('[reactive] onReactiveBroken handler threw', handlerError);
+        }
+    }
+}
+function notifyReactiveReset() {
+    for (const handler of Array.from(reactiveResetHandlers)) {
+        try {
+            handler();
+        }
+        catch (handlerError) {
+            options.warn('[reactive] onReactiveReset handler threw', handlerError);
+        }
+    }
+}
 /**
  * Gets or creates an IterableWeakSet for a closure map
  */
@@ -1748,7 +1998,7 @@ function getOrCreateClosure(closure, root) {
  * @param targetRoot - Root function of the effect being triggered
  */
 function addGraphEdge(callerRoot, targetRoot) {
-    if (options.cycleHandling === 'production')
+    if (options.scheduler === 'raw')
         return;
     // Add to forward graph: callerRoot → targetRoot
     const triggers = effectTriggers.get(callerRoot);
@@ -1863,7 +2113,7 @@ function hasPathExcluding(start, end, exclude) {
  * @param effect - The effect being cleaned up
  */
 function cleanupEffectFromGraph(effect) {
-    if (options.cycleHandling === 'production')
+    if (options.scheduler === 'raw')
         return;
     const root = getRoot(effect);
     // Get closures before removing direct edges (needed for propagation)
@@ -1972,7 +2222,7 @@ const executingStack = [];
  * Called once when batch starts or when new effects are added
  */
 function computeAllInDegrees(batch) {
-    if (options.cycleHandling === 'production')
+    if (options.scheduler === 'raw')
         return;
     const activeEffect = getActiveEffect();
     const activeRoot = activeEffect ? getRoot(activeEffect) : null;
@@ -1980,6 +2230,16 @@ function computeAllInDegrees(batch) {
     batch.inDegrees.clear();
     for (const [root] of batch.all) {
         let inDegree = 0;
+        // Make sure parents are executed before children: if parent is in batch, count it as a dependency
+        const effect = batch.all.get(root);
+        const parent = getEffectNode(effect).parent;
+        const parentRoot = parent ? getRoot(parent) : undefined;
+        if (parentRoot &&
+            batch.all.has(parentRoot) &&
+            parentRoot !== activeRoot &&
+            parentRoot !== root) {
+            inDegree++;
+        }
         const causes = causesClosure.get(root);
         if (causes) {
             for (const causeRoot of causes) {
@@ -1999,17 +2259,26 @@ function computeAllInDegrees(batch) {
 function decrementInDegreesForExecuted(batch, executedRoot) {
     // Get all effects that this executed effect triggers
     const consequences = consequencesClosure.get(executedRoot);
-    if (!consequences)
-        return;
-    for (const consequenceRoot of consequences) {
-        // Only update if it's still in the batch
-        if (batch.all.has(consequenceRoot)) {
-            const currentDegree = batch.inDegrees.get(consequenceRoot) ?? 0;
-            if (currentDegree > 0) {
-                batch.inDegrees.set(consequenceRoot, currentDegree - 1);
+    if (consequences) {
+        for (const consequenceRoot of consequences) {
+            // Only update if it's still in the batch
+            if (batch.all.has(consequenceRoot)) {
+                const currentDegree = batch.inDegrees.get(consequenceRoot) ?? 0;
+                if (currentDegree > 0) {
+                    batch.inDegrees.set(consequenceRoot, currentDegree - 1);
+                }
             }
         }
     }
+    for (const [root, effect] of batch.all) {
+        const parent = getEffectNode(effect).parent;
+        if (!parent || getRoot(parent) !== executedRoot)
+            continue;
+        const currentDegree = batch.inDegrees.get(root) ?? 0;
+        if (currentDegree > 0) {
+            batch.inDegrees.set(root, currentDegree - 1);
+        }
+    }
 }
 /**
  * Finds a path from startRoot to endRoot in the dependency graph
@@ -2099,6 +2368,14 @@ function addToBatch(effect, caller, immediate, reason) {
     // Build reason from pending triggers if not provided
     if (!reason && node.pendingTriggers) {
         reason = { type: 'propChange', triggers: node.pendingTriggers };
+        // Add chain: if this is being triggered from another effect, get its reason
+        if (caller) {
+            const callerNode = getEffectNode(caller);
+            if (callerNode.currentReason) {
+                reason.chain = callerNode.currentReason;
+            }
+        }
+        reason = chainExternalReason(reason);
     }
     node.pendingTriggers = undefined;
     if (reason) {
@@ -2140,15 +2417,15 @@ function addToBatch(effect, caller, immediate, reason) {
         }
     }
     // 1. Add to batch first (needed for cycle detection)
-    // TODO: Check if it's the correct way to do (these different behavior in function of dev/production)
-    if (options.cycleHandling === 'production') {
-        // Production mode: FIFO (delete and re-add to move to end)
+    // TODO: Check if this difference between raw and graph-backed scheduling is the right tradeoff.
+    if (options.scheduler === 'raw') {
+        // Raw mode: FIFO (delete and re-add to move to end)
         if (currentBatch.all.has(root)) {
             currentBatch.all.delete(root);
         }
     }
     else {
-        // Dev mode: skip if already queued — the existing entry will re-run
+        // Graph-backed modes: skip if already queued — the existing entry will re-run
         if (currentBatch.all.has(root)) {
             return;
         }
@@ -2157,7 +2434,7 @@ function addToBatch(effect, caller, immediate, reason) {
     if (node.stopped)
         return;
     currentBatch.all.set(root, effect);
-    if (caller && true && options.cycleHandling !== 'production') {
+    if (caller && true && options.scheduler !== 'raw') {
         const callerRoot = getRoot(caller);
         // const root = getRoot(effect) // Already have root
         // Check for cycle BEFORE adding edge
@@ -2179,6 +2456,9 @@ function addToBatch(effect, caller, immediate, reason) {
         }
         addGraphEdge(callerRoot, root);
     }
+    if (options.scheduler !== 'raw') {
+        computeAllInDegrees(currentBatch);
+    }
 }
 /**
  * Adds a cleanup function to be called when the current batch of effects completes
@@ -2275,7 +2555,7 @@ function executeNext(effectuatedRoots) {
     // Find an effect with in-degree 0 using cached values
     let nextEffect = null;
     let nextRoot = null;
-    if (options.cycleHandling === 'production') {
+    if (options.scheduler === 'raw') {
         // In flat mode, we just take the first effect in the queue (FIFO)
         const first = currentBatch.all.entries().next().value;
         if (first) {
@@ -2365,9 +2645,7 @@ function executeNext(effectuatedRoots) {
     }
     return result;
 }
-// Track which sub-effects have been executed to prevent infinite loops
-// These are all the effects triggered under `activeEffect` and all their sub-effects
-function batch(effect, immediate) {
+function batch(effect, batchOptions) {
     if (broken) {
         throw new ReactiveError('[reactive] Reactive system is broken after an unrecoverable error. Call reset() to recover.', { code: ReactiveErrorCode.BrokenEffects });
     }
@@ -2382,15 +2660,38 @@ 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();
+    const immediate = batchOptions?.immediate === true;
+    const contained = batchOptions?.contained === true;
+    const callerToUse = batchOptions?.caller || getActiveEffect();
     // Optimization: If nested and NOT immediate, just join the existing batch
-    if (!isNewBatch && !immediate) {
+    if (!isNewBatch && !contained && !immediate) {
         for (let i = 0; i < effect.length; i++) {
-            addToBatch(effect[i], caller);
+            addToBatch(effect[i], callerToUse);
         }
         return;
     }
+    if (!isNewBatch && !contained && immediate) {
+        const firstReturn = {};
+        for (let i = 0; i < effect.length; i++) {
+            executingStack.push(effect[i]);
+            try {
+                const node = getEffectNode(effect[i]);
+                const reason = node.nextReason;
+                if (node.cleanup) {
+                    const cleanup = node.cleanup;
+                    node.cleanup = undefined;
+                    cleanup(reason);
+                }
+                const rv = effect[i]();
+                if (rv !== undefined && !('value' in firstReturn))
+                    firstReturn.value = rv;
+            }
+            finally {
+                executingStack.pop();
+            }
+        }
+        return firstReturn.value;
+    }
     const currentBatch = {
         all: new Map(),
         inDegrees: new Map(),
@@ -2398,9 +2699,11 @@ function batch(effect, immediate) {
     };
     batchStack.push(currentBatch);
     let success = false;
+    let failure;
     try {
         const effectuatedRoots = [];
         const firstReturn = {};
+        let initialError;
         if (immediate) {
             // Execute initial effects in providing order
             for (let i = 0; i < effect.length; i++) {
@@ -2417,16 +2720,22 @@ function batch(effect, immediate) {
                     if (rv !== undefined && !('value' in firstReturn))
                         firstReturn.value = rv;
                 }
+                catch (error) {
+                    initialError = error;
+                    break;
+                }
                 finally {
                     executingStack.pop();
                     currentBatch.all.delete(getRoot(effect[i]));
                 }
             }
+            if (initialError)
+                throw initialError;
         }
         else {
             // Add initial effects to batch and compute dependencies
             for (let i = 0; i < effect.length; i++) {
-                addToBatch(effect[i], caller, false);
+                addToBatch(effect[i], callerToUse, false);
             }
             computeAllInDegrees(currentBatch);
         }
@@ -2480,9 +2789,18 @@ function batch(effect, immediate) {
         success = true;
         return firstReturn.value;
     }
+    catch (error) {
+        failure = error;
+        if (batchStack.length === 1)
+            optionCall('error', '[reactive] Root batch failure before broken state:', error);
+        throw error;
+    }
     finally {
         if (!success && batchStack.length === 1) {
+            const wasBroken = broken;
             broken = true;
+            if (!wasBroken)
+                notifyReactiveBroken(failure);
         }
         batchStack.pop();
         if (batchStack.length === 0) {
@@ -2498,6 +2816,7 @@ function batch(effect, immediate) {
  * All existing effects become orphaned and must be recreated.
  */
 function reset() {
+    const wasBroken = broken;
     broken = false;
     activationRegistry = undefined;
     batchStack.length = 0;
@@ -2508,6 +2827,8 @@ function reset() {
     resetRegistry();
     resetTracking();
     effectHistory.present.active = undefined;
+    if (wasBroken)
+        notifyReactiveReset();
 }
 // Inject batch function to allow atomic game loops in requestAnimationFrame/setTimeout/...
 // Note: Automatic batching of async callbacks (setTimeout, Promise.then, etc.) is NOT implemented.
@@ -2524,7 +2845,7 @@ const atomic = decorator({
             const atomicEffect = () => original.apply(this, args);
             // Debug: helpful to have a name
             Object.defineProperty(atomicEffect, 'name', { value: `atomic(${original.name})` });
-            return batch(atomicEffect, 'immediate');
+            return batch(atomicEffect, { immediate: true });
         };
     },
     default(original) {
@@ -2532,7 +2853,7 @@ const atomic = decorator({
             const atomicEffect = () => original.apply(this, args);
             // Debug: helpful to have a name
             Object.defineProperty(atomicEffect, 'name', { value: `atomic(${original.name})` });
-            return batch(atomicEffect, 'immediate');
+            return batch(atomicEffect, { immediate: true });
         };
     },
 });
@@ -2571,7 +2892,7 @@ function captured(prev, fn) {
  * ```
  */
 function atom(fn) {
-    return batch(fn, 'immediate');
+    return batch(fn, { immediate: true });
 }
 const fr = new FinalizationRegistry((f) => f());
 /**
@@ -2580,7 +2901,7 @@ const fr = new FinalizationRegistry((f) => f());
  * @param options - Options for effect execution
  * @returns A cleanup function to stop the effect
  */
-const effect = named(effectMarker.leave, flavored(function effect(fn, effectOptions = {}) {
+const effect = captioned(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
@@ -2593,7 +2914,10 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
             const prevCleanup = node.cleanup;
             node.cleanup = undefined;
             try {
-                untracked(() => prevCleanup(node.nextReason || { type: 'stopped' }));
+                untracked `effect:cleanup`(() => prevCleanup(chainExternalReason(node.nextReason || {
+                    type: 'stopped',
+                    chain: node.currentReason,
+                })));
             }
             catch (error) {
                 // If we want to report them, we could use options.warn or similar
@@ -2626,6 +2950,9 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
         }
         // Set reaction reason for the upcoming run
         access.reaction = node.nextReason || access.reaction;
+        node.currentReason =
+            node.nextReason ||
+                (access.reaction && access.reaction !== true ? access.reaction : undefined);
         node.nextReason = undefined;
         optionCall('enter', getRoot(fn));
         optionCall('effectRun', getRoot(fn), access.reaction);
@@ -2688,7 +3015,8 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
                 // This ensures that when we cancel, the original promise's .catch() handlers are triggered
                 // We do this by rejecting the race promise, which makes the original promise chain see the rejection
                 // through the zone-wrapped .then()/.catch() handlers
-                runningPromise = runningPromise.catch((error) => {
+                runningPromise = runningPromise
+                    .catch((error) => {
                     // Propagate async errors to the effect's error handler
                     // This ensures onEffectThrow handlers are triggered for async errors
                     if (error !== cancelError) {
@@ -2696,6 +3024,10 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
                     }
                     // If thrower didn't throw (handled), we absorb the error.
                     // If thrower threw (unhandled), it propagates as a new unhandled rejection, which is correct.
+                })
+                    .finally(() => {
+                    // Clear currentReason when async effect completes
+                    node.currentReason = undefined;
                 });
             }
             else {
@@ -2706,7 +3038,13 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
         catch (error) {
             debugHooks.decorateError(error, runEffect);
             // catcher:self`
-            errorToThrow = error;
+            errorToThrow = error instanceof Error ? error : new Error(String(error));
+        }
+        finally {
+            // Clear currentReason for synchronous effects
+            if (!runningPromise) {
+                node.currentReason = undefined;
+            }
         }
         // Create cleanup function for next run
         node.cleanup = (reason) => {
@@ -2737,8 +3075,11 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
                 const childReason = reason
                     ? reason.type === 'lineage'
                         ? reason
-                        : { type: 'lineage', parent: reason }
-                    : { type: 'stopped' };
+                        : { type: 'lineage', parent: reason, chain: node.currentReason }
+                    : (chainExternalReason({ type: 'stopped', chain: node.currentReason }) ?? {
+                        type: 'stopped',
+                        chain: node.currentReason,
+                    });
                 for (const childCleanup of children)
                     childCleanup(childReason);
                 delete node.children;
@@ -2751,7 +3092,7 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
     const node = getEffectNode(runEffect);
     if (debugHooks.isDevtoolsEnabled()) {
         const stack = debugHooks.captureStack(); // Robustly skips internal mutts frames
-        if (Array.isArray(stack) && stack.length > 0) {
+        if (stack) {
             node.creationStack = stack;
         }
     }
@@ -2795,7 +3136,7 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
             abortController = undefined;
         }
     };
-    batch(runEffect, 'immediate');
+    batch(runEffect, { immediate: true });
     // Only ROOT effects are registered for GC cleanup and zone tracking
     const isRootEffect = !parent;
     const stopEffect = (reason) => {
@@ -2811,7 +3152,7 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
             runningPromise = null;
         }
         try {
-            node.cleanup?.(reason || { type: 'stopped' });
+            node.cleanup?.(chainExternalReason(reason || { type: 'stopped', chain: node.currentReason }));
         }
         catch (error) {
             // Cleanup errors should basically be ignored or at least not stop the world
@@ -2854,30 +3195,72 @@ const effect = named(effectMarker.leave, flavored(function effect(fn, effectOpti
     named(name) {
         return flavorOptions(this, { name }, { name: 'named' });
     },
-}));
+})), {
+    name: 'effect',
+    warn: (message) => options.warn(`[reactive] ${message}`),
+    shouldWarnAnonymous: (_callback, args) => !(args[1] && typeof args[1] === 'object' && 'name' in args[1]),
+});
+const untracked = captioned(function untracked(fn) {
+    const external = externalReasonFrom(fn);
+    return external
+        ? externalReason.with(external, () => effectHistory.present.root(fn))
+        : effectHistory.present.root(fn);
+});
+function runInert(fn) {
+    // Increment the counter
+    const originalDepth = inertDepth;
+    inertDepth = originalDepth + 1;
+    try {
+        return fn();
+    }
+    finally {
+        inertDepth = originalDepth;
+    }
+}
+function wrapInert(fn) {
+    function inertEffect(...args) {
+        return runInert(() => fn.apply(this, args));
+    }
+    Object.defineProperty(inertEffect, 'name', { value: `inert(${fn.name})` });
+    return inertEffect;
+}
 /**
- * Executes a function without tracking dependencies but maintains parent cleanup relationship
- * Effects created inside will still be cleaned up when the parent effect is destroyed
+ * Executes a function with fast-path reads that bypass proxy overhead and dependency tracking.
+ * Writes remain fully reactive. Uses a counter for safe nesting.
+ * Can also decorate methods so the whole method body runs inertly.
  * @param fn - The function to execute
  */
-function untracked(fn) {
-    return effectHistory.present.root(fn);
-}
+const inert = decorator({
+    method(original) {
+        return wrapInert(original);
+    },
+    default(fn) {
+        if (typeof fn !== 'function')
+            throw new Error('inert() expects a function');
+        return runInert(fn);
+    },
+});
 /**
  * Executes a function from a virgin/root context - no parent effect, no tracking
  * Creates completely independent effects that won't be cleaned up by any parent
  * @param fn - The function to execute
  */
-function root(fn) {
-    return effectHistory.root(fn);
-}
+const root = captioned(function root(fn) {
+    // When broken, `atomic`/`batch` throws immediately. DOM wrappers (e.g. Sursaut
+    // `root\`event:…\``) still need to run listener code for inspection UI; skip batching.
+    const runner = broken ? fn : atomic(fn);
+    const external = externalReasonFrom(fn);
+    return external
+        ? externalReason.with(external, () => effectHistory.root(runner))
+        : effectHistory.root(runner);
+});
 function biDi(received, get, set) {
     if (typeof get !== 'function') {
         set = get.set;
         get = get.get;
     }
     let programmaticallySetValue = Symbol();
-    effect.named('biDi')(markWithRoot(() => {
+    effect `biDi`(markWithRoot(() => {
         const newValue = get();
         const pValue = programmaticallySetValue;
         programmaticallySetValue = Symbol();
@@ -2892,6 +3275,86 @@ function biDi(received, get, set) {
         : () => { };
 }
 
+/**
+ * Creates a mixin that can be used both as a class (extends) and as a function (mixin)
+ *
+ * This function supports:
+ * - Using mixins as base classes: `class MyClass extends MyMixin`
+ * - Using mixins as functions: `class MyClass extends MyMixin(SomeBase)`
+ * - Composing mixins: `const Composed = MixinA(MixinB)`
+ * - Type-safe property inference for all patterns
+ *
+ * @param mixinFunction - The function that creates the mixin
+ * @param unwrapFunction - Optional function to unwrap reactive objects for method calls
+ * @returns A mixin that can be used both as a class and as a function
+ */
+function mixin(mixinFunction, unwrapFunction) {
+    /**
+     * Cache for mixin results to ensure the same base class always returns the same mixed class
+     */
+    const mixinCache = new WeakMap();
+    // Apply the mixin to Object as the base class
+    const MixedBase = mixinFunction(Object);
+    mixinCache.set(Object, MixedBase);
+    // Create the proxy that handles both constructor and function calls
+    return new Proxy(MixedBase, {
+        // Handle `MixinClass(SomeBase)` - use as mixin function
+        apply(_target, _thisArg, args) {
+            if (args.length === 0) {
+                throw new Error('Mixin requires a base class');
+            }
+            const baseClass = args[0];
+            if (typeof baseClass !== 'function') {
+                throw new Error('Mixin requires a constructor function');
+            }
+            // Check if it's a valid constructor or a mixin
+            if (!isConstructor(baseClass) &&
+                !(baseClass && typeof baseClass === 'function' && baseClass.prototype)) {
+                throw new Error('Mixin requires a valid constructor');
+            }
+            // Check cache first
+            const cached = mixinCache.get(baseClass);
+            if (cached) {
+                return cached;
+            }
+            let usedBase = baseClass;
+            if (unwrapFunction) {
+                // Create a proxied base class that handles method unwrapping
+                const ProxiedBaseClass = class extends baseClass {
+                };
+                // Proxy the prototype methods to handle unwrapping
+                const originalPrototype = baseClass.prototype;
+                const proxiedPrototype = new Proxy(originalPrototype, {
+                    get(target, prop, receiver) {
+                        const value = FoolProof.get(target, prop, receiver);
+                        // Only wrap methods that are likely to access private fields
+                        // Skip symbols and special properties that the reactive system needs
+                        if (typeof value === 'function' &&
+                            typeof prop === 'string' &&
+                            !['constructor', 'toString', 'valueOf'].includes(prop)) {
+                            // Return a wrapped version that uses unwrapped context
+                            return function (...args) {
+                                // Use the unwrapping function if provided, otherwise use this
+                                const context = unwrapFunction(this);
+                                return value.apply(context, args);
+                            };
+                        }
+                        return value;
+                    },
+                });
+                // Set the proxied prototype
+                Object.setPrototypeOf(ProxiedBaseClass.prototype, proxiedPrototype);
+                usedBase = ProxiedBaseClass;
+            }
+            // Create the mixed class using the proxied base class
+            const mixedClass = mixinFunction(usedBase);
+            // Cache the result
+            mixinCache.set(baseClass, mixedClass);
+            return mixedClass;
+        },
+    });
+}
+
 // Track which objects contain which other objects (back-references)
 const objectParents = new WeakMap();
 // Track which objects have deep watchers
@@ -3021,14 +3484,15 @@ function getState(obj) {
     }
     return state;
 }
-function collectEffects(obj, evolution, effects, objectWatchers, ...keyChains) {
+function collectEffects(obj, evolution, effects, objectWatchers, collectDependencyStack, ...keyChains) {
     const sourceEffect = getActiveEffect();
     for (const keys of keyChains)
         for (const key of keys) {
             const deps = objectWatchers.get(key);
             if (deps) {
                 // Make sure `some.prop++` does not keep a dependency to `some.props`
-                deps.delete(sourceEffect);
+                if (sourceEffect)
+                    deps.delete(sourceEffect);
                 for (const effect of deps) {
                     const runningChain = isRunning(effect);
                     if (runningChain) {
@@ -3036,7 +3500,7 @@ function collectEffects(obj, evolution, effects, objectWatchers, ...keyChains) {
                         continue;
                     }
                     if (!effects.has(effect)) {
-                        effects.set(effect, getDependencyStack(effect, obj, key));
+                        effects.set(effect, collectDependencyStack ? getDependencyStack(effect, obj, key) : undefined);
                         if (!hasBatched(effect))
                             recordActivation(effect, obj, evolution, key);
                     }
@@ -3069,16 +3533,18 @@ function touched(obj, evolution, props) {
         const effects = new Map();
         const structural = !['set', 'invalidate'].includes(evolution.type);
         const broad = structural ? [allProps, keysOf] : [allProps];
+        const gatherReasons = options.introspection?.gatherReasons;
+        const lineageConfig = gatherReasons?.lineages;
+        const collectDependencyStack = lineageConfig === 'dependency' || lineageConfig === 'both';
         if (props)
-            collectEffects(obj, evolution, effects, objectWatchers, broad, props);
+            collectEffects(obj, evolution, effects, objectWatchers, collectDependencyStack, broad, props);
         else
-            collectEffects(obj, evolution, effects, objectWatchers, objectWatchers.keys());
+            collectEffects(obj, evolution, effects, objectWatchers, collectDependencyStack, objectWatchers.keys());
         const triggers = Array.from(effects.keys());
+        const sourceEffect = getActiveEffect();
         optionCall('touched', obj, evolution, props, triggers);
         // Store pending triggers for CleanupReason before batching
-        if (options.introspection?.gatherReasons) {
-            const gatherReasons = options.introspection.gatherReasons;
-            const lineageConfig = gatherReasons.lineages;
+        if (gatherReasons && effects.size > 0) {
             let touchLineage;
             if (lineageConfig === 'touch' || lineageConfig === 'both') {
                 touchLineage = debugHooks.captureLineage();
@@ -3095,7 +3561,7 @@ function touched(obj, evolution, props) {
                 });
             }
         }
-        batch(triggers);
+        batch(triggers, { caller: sourceEffect });
     }
     // Bubble up changes if this object has deep watchers
     if (objectsWithDeepWatchers.has(obj)) {
@@ -3119,6 +3585,7 @@ function touchedOpaque(obj, evolution, prop) {
     const gather = options.introspection?.gatherReasons;
     if (gather) {
         const lineageConfig = gather.lineages;
+        let touchLineage;
         for (const effect of deps) {
             const node = getEffectNode(effect);
             if (!node.isOpaque)
@@ -3130,10 +3597,9 @@ function touchedOpaque(obj, evolution, prop) {
             }
             effects.add(effect);
             if (gather) {
-                let touchLineage;
                 let dependencyStack;
                 if (lineageConfig === 'touch' || lineageConfig === 'both') {
-                    touchLineage = debugHooks.captureLineage();
+                    touchLineage ?? (touchLineage = debugHooks.captureLineage());
                 }
                 if (lineageConfig === 'dependency' || lineageConfig === 'both') {
                     dependencyStack = getDependencyStack(effect, obj, prop);
@@ -3169,7 +3635,7 @@ function touchedOpaque(obj, evolution, prop) {
     }
     if (effects.size > 0) {
         optionCall('touched', obj, evolution, [prop], Array.from(effects));
-        batch(Array.from(effects));
+        batch(Array.from(effects), { caller: sourceEffect });
     }
 }
 
@@ -3191,9 +3657,10 @@ function addUnreactiveProps(proto, set) {
             return proto;
         }
         // Merge sets
-        set = proto[unreactiveProperties] = new Set(proto[unreactiveProperties]);
+        const merged = new Set(existing);
+        proto[unreactiveProperties] = merged;
         for (const p of set)
-            existing.add(p);
+            merged.add(p);
     }
     // If no set, mark as fully unreactive, otherwise create set
     else
@@ -3215,6 +3682,8 @@ function nonReactive(...obj) {
     }
     return obj[0];
 }
+const markRaw = nonReactive;
+const markRawProps = addUnreactiveProps;
 function nonReactiveClass(...cls) {
     for (const c of cls)
         if (c)
@@ -3292,7 +3761,7 @@ 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
-        const changes = untracked(() => recursiveTouch(oldValue, newValue, new WeakMap(), [], origin));
+        const changes = untracked `deepTouch:recursive`(() => 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) {
@@ -3432,7 +3901,7 @@ function dispatchNotifications(notifications) {
         const originWatchers = watchers.get(origin.obj);
         if (originWatchers) {
             const originEffects = new Map();
-            collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, [allProps], [origin.prop]);
+            collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, false, [allProps], [origin.prop]);
             allowedEffects = new Set(originEffects.keys());
         }
         // If no allowed effects, skip all notifications (no one should be notified)
@@ -3451,7 +3920,7 @@ function dispatchNotifications(notifications) {
         if (objectWatchers) {
             currentEffects = new Map();
             const broad = evolution.type !== 'set' ? [allProps, keysOf] : [allProps];
-            collectEffects(obj, evolution, currentEffects, objectWatchers, broad, propsArray);
+            collectEffects(obj, evolution, currentEffects, objectWatchers, false, broad, propsArray);
             // Filter effects by ancestor chain if origin exists
             // Include effects that either directly depend on origin or have an ancestor that does
             if (origin && allowedEffects) {
@@ -3513,11 +3982,94 @@ const metaProtos = new WeakMap();
 const wrapProtos = new WeakMap();
 const arrayLengths = new WeakMap();
 const hasReentry = new Set();
+const accessAnalysisCache = new WeakMap();
+const readonlyObjectToProxy = new WeakMap();
+const shallowObjectToProxy = new WeakMap();
+const readonlyMutators = new Set([
+    'copyWithin',
+    'fill',
+    'pop',
+    'push',
+    'reverse',
+    'shift',
+    'sort',
+    'splice',
+    'unshift',
+    'add',
+    'clear',
+    'delete',
+    'set',
+]);
 // 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;
+function wrapReactiveValue(obj, prop, value) {
+    // Optional fast-path for inert reads - skips reactive wrapping
+    // Disabled by default for safety, can be enabled for performance-critical read-only contexts
+    if (inertDepth > 0)
+        return value;
+    if (!isReactive(value) && typeof value === 'object' && value !== null) {
+        const reactiveValue = reactiveObject(value);
+        // Only create back-references if this object needs them
+        if (needsBackReferences(obj)) {
+            addBackReference(reactiveValue, obj, prop);
+        }
+        return reactiveValue;
+    }
+    return value;
+}
+function computeAccessAnalysis(obj, prop, receiver) {
+    const proto = Object.getPrototypeOf(obj);
+    const isOwnProp = Object.hasOwn(obj, prop);
+    const shouldIgnoreAccessor = options.ignoreAccessors &&
+        isOwnProp &&
+        proto !== null &&
+        (isOwnAccessor(receiver, prop) || isOwnAccessor(obj, prop));
+    let hasProp = isOwnProp;
+    let owner = isOwnProp ? obj : undefined;
+    if (!isOwnProp) {
+        let raw = proto;
+        while (raw && raw !== Object.prototype) {
+            if (Object.hasOwn(raw, prop)) {
+                hasProp = true;
+                owner = raw;
+                break;
+            }
+            raw = Object.getPrototypeOf(raw);
+        }
+    }
+    return {
+        hasProp,
+        owner,
+        isInheritedAccess: hasProp && !isOwnProp,
+        shouldIgnoreAccessor,
+        ignoreAccessors: options.ignoreAccessors,
+        instanceMembers: options.instanceMembers,
+    };
+}
+function analyzeAccess(obj, prop, receiver) {
+    const proto = Object.getPrototypeOf(obj);
+    if (Object.hasOwn(obj, prop))
+        return computeAccessAnalysis(obj, prop, receiver);
+    if (proto === null || Array.isArray(obj))
+        return computeAccessAnalysis(obj, prop, receiver);
+    let propCache = accessAnalysisCache.get(proto);
+    if (!propCache) {
+        propCache = new Map();
+        accessAnalysisCache.set(proto, propCache);
+    }
+    const cached = propCache.get(prop);
+    if (cached &&
+        cached.ignoreAccessors === options.ignoreAccessors &&
+        cached.instanceMembers === options.instanceMembers)
+        return cached;
+    const analysis = computeAccessAnalysis(obj, prop, receiver);
+    if (analysis.hasProp)
+        propCache.set(prop, analysis);
+    return analysis;
+}
 const reactiveHandlers = {
     [Symbol.toStringTag]: 'MutTs Reactive',
     get(obj, prop, receiver) {
@@ -3545,32 +4097,29 @@ const reactiveHandlers = {
         // 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) {
-            let raw = Object.getPrototypeOf(obj);
-            while (raw && raw !== Object.prototype) {
-                if (Object.hasOwn(raw, prop)) {
-                    hasProp = true;
-                    owner = raw;
-                    break;
+        const subProxy = subsRegister.get(obj);
+        if (inertDepth > 0) {
+            const value = (subProxy?.get || FoolProof.get)(obj, prop, receiver);
+            return wrapReactiveValue(obj, prop, value);
+        }
+        const activeEffect = getActiveEffect();
+        if (!activeEffect) {
+            const value = (subProxy?.get || FoolProof.get)(obj, prop, receiver);
+            return wrapReactiveValue(obj, prop, value);
+        }
+        if (!subProxy && !Array.isArray(obj)) {
+            const proto = Object.getPrototypeOf(obj);
+            if (proto === Object.prototype || proto === null) {
+                const ownDesc = Object.getOwnPropertyDescriptor(obj, prop);
+                if (ownDesc && 'value' in ownDesc) {
+                    dependant(obj, prop);
+                    return wrapReactiveValue(obj, prop, ownDesc.value);
                 }
-                raw = Object.getPrototypeOf(raw);
             }
         }
-        const isInheritedAccess = hasProp && !isOwnProp;
+        // Check if property exists using a trap-free walk to avoid triggering
+        // the has-trap cascade on prototype chains of reactive proxies.
+        const { hasProp, owner, isInheritedAccess, shouldIgnoreAccessor } = analyzeAccess(obj, prop, receiver);
         // Depend if...
         if (!hasProp ||
             (!(options.instanceMembers && isInheritedAccess && obj instanceof Object) &&
@@ -3583,16 +4132,8 @@ const reactiveHandlers = {
         }
         // 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 (!isReactive(value) && typeof value === 'object' && value !== null) {
-            const reactiveValue = reactiveObject(value);
-            // Only create back-references if this object needs them
-            if (needsBackReferences(obj)) {
-                addBackReference(reactiveValue, obj, prop);
-            }
-            return reactiveValue;
-        }
-        return value;
+        const value = (subProxy?.get || FoolProof.get)(obj, prop, receiver);
+        return wrapReactiveValue(obj, prop, value);
     },
     set(obj, prop, value, receiver) {
         const unwrapped = unwrap(receiver);
@@ -3665,6 +4206,11 @@ const reactiveHandlers = {
                 cycle: [], // We don't have the full cycle here, but we know it involves obj
             });
         hasReentry.add(obj);
+        if (inertDepth > 0) {
+            const rv = (subsRegister.get(obj)?.has || Reflect.has)(obj, prop);
+            hasReentry.delete(obj);
+            return rv;
+        }
         if (!internalUntracked && !isUnreactiveProp(obj, prop))
             dependant(obj, prop);
         const rv = (subsRegister.get(obj)?.has || Reflect.has)(obj, prop);
@@ -3673,7 +4219,7 @@ const reactiveHandlers = {
     },
     deleteProperty(obj, prop) {
         if (!Object.hasOwn(obj, prop))
-            return false;
+            return true;
         const oldVal = obj[prop];
         // Remove back-references if this object has deep watchers
         if (objectsWithDeepWatchers.has(obj) && typeof oldVal === 'object' && oldVal !== null) {
@@ -3688,6 +4234,9 @@ const reactiveHandlers = {
         return true;
     },
     ownKeys(obj) {
+        if (inertDepth > 0) {
+            return subsRegister.get(obj)?.ownKeys?.(obj) || Reflect.ownKeys(obj);
+        }
         dependant(obj, keysOf);
         return subsRegister.get(obj)?.ownKeys?.(obj) || Reflect.ownKeys(obj);
     },
@@ -3696,6 +4245,98 @@ const reactiveHandlers = {
             Reflect.getOwnPropertyDescriptor(obj, prop));
     },
 };
+function readonlyError(prop) {
+    return new ReactiveError(`[reactive] Cannot mutate readonly reactive property '${String(prop)}'`, {
+        code: ReactiveErrorCode.WriteInComputed,
+    });
+}
+function readonlyValue(value) {
+    if (!value || typeof value !== 'object')
+        return value;
+    return readonlyReactive(value);
+}
+const shallowReactiveHandlers = {
+    get(obj, prop, receiver) {
+        if (typeof prop === 'symbol' || prop === 'constructor' || isUnreactiveProp(obj, prop))
+            return Reflect.get(obj, prop, receiver);
+        if (getActiveEffect())
+            dependant(obj, prop);
+        return Reflect.get(obj, prop, receiver);
+    },
+    set(obj, prop, value, receiver) {
+        const unwrapped = unwrap(receiver);
+        if (obj !== unwrapped)
+            return Object.defineProperty(unwrapped, prop, {
+                value,
+                configurable: true,
+                writable: true,
+                enumerable: true,
+            });
+        if (isUnreactiveProp(obj, prop))
+            return FoolProof.set(obj, prop, value, receiver);
+        const hadProperty = Reflect.has(obj, prop);
+        const oldVal = hadProperty ? Reflect.get(obj, prop, receiver) : absent;
+        const newValue = unwrap(value);
+        if (oldVal !== newValue && FoolProof.set(obj, prop, newValue, receiver)) {
+            touched1(obj, { type: hadProperty ? 'set' : 'add', prop }, prop);
+        }
+        return true;
+    },
+    has(obj, prop) {
+        return reactiveHandlers.has(obj, prop);
+    },
+    deleteProperty(obj, prop) {
+        if (!Object.hasOwn(obj, prop))
+            return true;
+        delete obj[prop];
+        touched1(obj, { type: 'del', prop }, prop);
+        return true;
+    },
+    ownKeys(obj) {
+        return reactiveHandlers.ownKeys(obj);
+    },
+    getOwnPropertyDescriptor(obj, prop) {
+        return Reflect.getOwnPropertyDescriptor(obj, prop);
+    },
+};
+const readonlyReactiveHandlers = {
+    get(obj, prop, receiver) {
+        if (readonlyMutators.has(prop)) {
+            return () => {
+                throw readonlyError(prop);
+            };
+        }
+        const reactiveTarget = reactiveObject(obj);
+        const value = FoolProof.get(reactiveTarget, prop, receiver);
+        if (typeof value === 'function') {
+            return (...args) => readonlyValue(value.apply(reactiveTarget, args));
+        }
+        return readonlyValue(value);
+    },
+    set(_obj, prop) {
+        throw readonlyError(prop);
+    },
+    deleteProperty(_obj, prop) {
+        throw readonlyError(prop);
+    },
+    defineProperty(_obj, prop) {
+        throw readonlyError(prop);
+    },
+    setPrototypeOf() {
+        throw readonlyError('[[Prototype]]');
+    },
+    has(obj, prop) {
+        const reactiveTarget = reactiveObject(obj);
+        return Reflect.has(reactiveTarget, prop);
+    },
+    ownKeys(obj) {
+        const reactiveTarget = reactiveObject(obj);
+        return Reflect.ownKeys(reactiveTarget);
+    },
+    getOwnPropertyDescriptor(obj, prop) {
+        return Reflect.getOwnPropertyDescriptor(obj, prop);
+    },
+};
 const reactiveClasses = new WeakSet();
 // Create the ReactiveBase mixin
 /**
@@ -3737,6 +4378,34 @@ function reactiveObject(anyTarget, subProxy) {
     storeProxyRelationship(target, proxy);
     return proxy;
 }
+function shallowReactiveObject(anyTarget) {
+    if (!anyTarget || typeof anyTarget !== 'object')
+        return anyTarget;
+    const target = unwrap(anyTarget);
+    if (isNonReactive(target))
+        return target;
+    const existing = shallowObjectToProxy.get(target);
+    if (existing)
+        return existing;
+    const proxy = new Proxy(target, shallowReactiveHandlers);
+    shallowObjectToProxy.set(target, proxy);
+    proxyToObject.set(proxy, target);
+    return proxy;
+}
+function readonlyReactiveObject(anyTarget) {
+    if (!anyTarget || typeof anyTarget !== 'object')
+        return anyTarget;
+    const target = unwrap(anyTarget);
+    if (isNonReactive(target))
+        return target;
+    const existing = readonlyObjectToProxy.get(target);
+    if (existing)
+        return existing;
+    const proxy = new Proxy(target, readonlyReactiveHandlers);
+    readonlyObjectToProxy.set(target, proxy);
+    proxyToObject.set(proxy, target);
+    return proxy;
+}
 /**
  * Main decorator for making classes reactive
  * Automatically makes class instances reactive when created
@@ -3767,6 +4436,8 @@ const reactive = decorator({
     },
     default: reactiveObject,
 });
+const shallowReactive = shallowReactiveObject;
+const readonlyReactive = readonlyReactiveObject;
 
-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
+export { markRawProps as $, AZone as A, effectContext as B, CompareSymbol as C, DecoratorError as D, flavorOptions as E, flavored as F, formatCleanupReason as G, getActivationLog as H, IterableWeakMap as I, getActiveEffect as J, getState as K, hooks as L, inert as M, inheritCaption as N, isConstructor as O, isDev as P, isNonReactive as Q, ReactiveBase as R, isObject as S, isProd as T, isReactive as U, isReactiveBroken as V, isTest as W, legacyDecorator as X, link as Y, Zone as Z, markRaw as _, IterableWeakSet as a, mixin as a0, modernDecorator as a1, named as a2, objectToProxy as a3, onEffectThrow as a4, onReactiveBroken as a5, onReactiveReset as a6, prodPreset as a7, proxyToObject as a8, reactive as a9, inertDepth as aA, optionCall as aB, FoolProof as aC, effectHistory as aD, unreactiveProperties as aE, __runInitializers as aF, __esDecorate as aG, contentRef as aH, notifyPropertyChange as aI, metaProtos as aJ, wrapProtos as aK, objectParents as aL, watchers as aM, effectToReactiveObjects as aN, effectMarker as aO, setDebugHooks as aP, allProps as aQ, options as aa, readonlyReactive as ab, reset as ac, root as ad, shallowReactive as ae, tag as af, toRaw as ag, touched as ah, touched1 as ai, unlink as aj, untracked as ak, unwrap as al, withEffectContext as am, wrapInert as an, zip as ao, markWithRoot as ap, dependant as aq, getEffectNode as ar, chainExternalReason as as, keysOf as at, objectsWithDeepWatchers as au, effectToDeepWatchedObjects as av, deepWatchers as aw, registerDeepWatcher as ax, rootFunctionSymbol as ay, getRoot 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, captioned as p, captured as q, caught as r, createFlavor as s, debugPreset as t, decorator as u, deepCompare as v, defer as w, devPreset as x, effect as y, effectAggregator as z };
+//# sourceMappingURL=proxy-C2lnvvbx.esm.js.map