mutts 1.0.12 → 1.0.14

package/dist/chunks/{proxy-BvM4yewA.cjs → proxy-HA_QQnd5.cjs}

@@ -1,29 +1,6 @@
 'use strict';
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-// 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
@@ -139,13 +116,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)
@@ -153,6 +127,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;
@@ -271,8 +252,9 @@ 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-BvM4yewA.cjs', document.baseURI).href)) }) !== 'undefined' && undefined?.MODE) ||
+const runtimeGlobals = globalThis;
+const _mode = runtimeGlobals.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-HA_QQnd5.cjs', document.baseURI).href)) }) !== 'undefined' && undefined?.MODE) ||
     'production';
 const isDev = _mode === 'development';
 const isProd = _mode === 'production';
@@ -447,6 +429,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.
  */
@@ -479,7 +548,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.
@@ -512,7 +581,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" />
@@ -693,7 +762,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();
@@ -765,100 +840,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.
 
@@ -921,6 +902,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;
@@ -1106,6 +1110,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();
@@ -1120,8 +1125,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
@@ -1141,11 +1146,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);
@@ -1153,6 +1177,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,
@@ -1180,7 +1233,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)
@@ -1207,6 +1260,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',
@@ -1246,18 +1378,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++) {
@@ -1265,6 +1440,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;
         }
     }
@@ -1311,6 +1489,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
@@ -1401,22 +1590,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
@@ -1465,6 +1674,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.
      *
@@ -1504,14 +1715,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,
@@ -1523,7 +1734,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,
@@ -1546,6 +1757,7 @@ function unwrap(obj) {
         return obj;
     return proxyToObject.get(obj) || obj;
 }
+const toRaw = unwrap;
 function isReactive(obj) {
     return proxyToObject.has(obj);
 }
@@ -1593,7 +1805,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 = exports.watchers.get(obj);
@@ -1616,25 +1829,25 @@ function dependant(obj, prop = allProps) {
         exports.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
+exports.inertDepth = 0;
 /**
  * Finds a cycle in a sequence of functions by looking for the first repetition
  */
@@ -1660,6 +1873,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;
@@ -1733,6 +1949,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
  */
@@ -1751,7 +2001,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);
@@ -1866,7 +2116,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)
@@ -1975,7 +2225,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;
@@ -1983,6 +2233,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) {
@@ -2002,17 +2262,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
@@ -2102,6 +2371,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) {
@@ -2143,15 +2420,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;
         }
@@ -2160,7 +2437,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
@@ -2182,6 +2459,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
@@ -2278,7 +2558,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) {
@@ -2368,9 +2648,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: exports.ReactiveErrorCode.BrokenEffects });
     }
@@ -2385,15 +2663,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(),
@@ -2401,9 +2702,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++) {
@@ -2420,16 +2723,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);
         }
@@ -2483,9 +2792,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) {
@@ -2501,6 +2819,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;
@@ -2511,6 +2830,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.
@@ -2527,7 +2848,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) {
@@ -2535,7 +2856,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 });
         };
     },
 });
@@ -2574,7 +2895,7 @@ function captured(prev, fn) {
  * ```
  */
 function atom(fn) {
-    return batch(fn, 'immediate');
+    return batch(fn, { immediate: true });
 }
 const fr = new FinalizationRegistry((f) => f());
 /**
@@ -2583,7 +2904,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
@@ -2596,7 +2917,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
@@ -2629,6 +2953,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);
@@ -2691,7 +3018,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) {
@@ -2699,6 +3027,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 {
@@ -2709,7 +3041,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) => {
@@ -2740,8 +3078,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;
@@ -2754,7 +3095,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;
         }
     }
@@ -2798,7 +3139,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) => {
@@ -2814,7 +3155,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
@@ -2857,30 +3198,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 = exports.inertDepth;
+    exports.inertDepth = originalDepth + 1;
+    try {
+        return fn();
+    }
+    finally {
+        exports.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();
@@ -2895,6 +3278,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
@@ -3024,14 +3487,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) {
@@ -3039,7 +3503,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);
                     }
@@ -3072,16 +3536,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();
@@ -3098,7 +3564,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)) {
@@ -3122,6 +3588,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)
@@ -3133,10 +3600,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);
@@ -3172,7 +3638,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 });
     }
 }
 
@@ -3194,9 +3660,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
@@ -3218,6 +3685,8 @@ function nonReactive(...obj) {
     }
     return obj[0];
 }
+const markRaw = nonReactive;
+const markRawProps = addUnreactiveProps;
 function nonReactiveClass(...cls) {
     for (const c of cls)
         if (c)
@@ -3295,7 +3764,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) {
@@ -3435,7 +3904,7 @@ function dispatchNotifications(notifications) {
         const originWatchers = exports.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)
@@ -3454,7 +3923,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) {
@@ -3516,11 +3985,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 (exports.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) {
@@ -3548,32 +4100,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 (exports.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) &&
@@ -3586,16 +4135,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);
@@ -3668,6 +4209,11 @@ const reactiveHandlers = {
                 cycle: [], // We don't have the full cycle here, but we know it involves obj
             });
         hasReentry.add(obj);
+        if (exports.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);
@@ -3676,7 +4222,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) {
@@ -3691,6 +4237,9 @@ const reactiveHandlers = {
         return true;
     },
     ownKeys(obj) {
+        if (exports.inertDepth > 0) {
+            return subsRegister.get(obj)?.ownKeys?.(obj) || Reflect.ownKeys(obj);
+        }
         dependant(obj, keysOf);
         return subsRegister.get(obj)?.ownKeys?.(obj) || Reflect.ownKeys(obj);
     },
@@ -3699,6 +4248,98 @@ const reactiveHandlers = {
             Reflect.getOwnPropertyDescriptor(obj, prop));
     },
 };
+function readonlyError(prop) {
+    return new ReactiveError(`[reactive] Cannot mutate readonly reactive property '${String(prop)}'`, {
+        code: exports.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
 /**
@@ -3740,6 +4381,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
@@ -3770,8 +4439,11 @@ const reactive = decorator({
     },
     default: reactiveObject,
 });
+const shallowReactive = shallowReactiveObject;
+const readonlyReactive = readonlyReactiveObject;
 
 exports.AZone = AZone;
+exports.CompareSymbol = CompareSymbol;
 exports.DecoratorError = DecoratorError;
 exports.FoolProof = FoolProof;
 exports.IterableWeakMap = IterableWeakMap;
@@ -3793,10 +4465,11 @@ exports.asyncHooks = asyncHooks;
 exports.asyncZone = asyncZone;
 exports.atom = atom;
 exports.atomic = atomic;
-exports.batch = batch;
 exports.biDi = biDi;
+exports.captioned = captioned;
 exports.captured = captured;
 exports.caught = caught;
+exports.chainExternalReason = chainExternalReason;
 exports.contentRef = contentRef;
 exports.createFlavor = createFlavor;
 exports.debugPreset = debugPreset;
@@ -3808,6 +4481,7 @@ exports.dependant = dependant;
 exports.devPreset = devPreset;
 exports.effect = effect;
 exports.effectAggregator = effectAggregator;
+exports.effectContext = effectContext;
 exports.effectHistory = effectHistory;
 exports.effectMarker = effectMarker;
 exports.effectToDeepWatchedObjects = effectToDeepWatchedObjects;
@@ -3820,16 +4494,21 @@ exports.getEffectNode = getEffectNode;
 exports.getRoot = getRoot;
 exports.getState = getState;
 exports.hooks = hooks;
+exports.inert = inert;
+exports.inheritCaption = inheritCaption;
 exports.isConstructor = isConstructor;
 exports.isDev = isDev;
 exports.isNonReactive = isNonReactive;
 exports.isObject = isObject;
 exports.isProd = isProd;
 exports.isReactive = isReactive;
+exports.isReactiveBroken = isReactiveBroken;
 exports.isTest = isTest;
 exports.keysOf = keysOf;
 exports.legacyDecorator = legacyDecorator;
 exports.link = link;
+exports.markRaw = markRaw;
+exports.markRawProps = markRawProps;
 exports.markWithRoot = markWithRoot;
 exports.metaProtos = metaProtos;
 exports.mixin = mixin;
@@ -3840,23 +4519,30 @@ exports.objectParents = objectParents;
 exports.objectToProxy = objectToProxy;
 exports.objectsWithDeepWatchers = objectsWithDeepWatchers;
 exports.onEffectThrow = onEffectThrow;
+exports.onReactiveBroken = onReactiveBroken;
+exports.onReactiveReset = onReactiveReset;
 exports.optionCall = optionCall;
 exports.options = options;
 exports.prodPreset = prodPreset;
 exports.proxyToObject = proxyToObject;
 exports.reactive = reactive;
+exports.readonlyReactive = readonlyReactive;
 exports.registerDeepWatcher = registerDeepWatcher;
 exports.reset = reset;
 exports.root = root;
 exports.rootFunctionSymbol = rootFunctionSymbol;
 exports.setDebugHooks = setDebugHooks;
+exports.shallowReactive = shallowReactive;
 exports.tag = tag;
+exports.toRaw = toRaw;
 exports.touched = touched;
 exports.touched1 = touched1;
 exports.unlink = unlink;
 exports.unreactiveProperties = unreactiveProperties;
 exports.untracked = untracked;
 exports.unwrap = unwrap;
+exports.withEffectContext = withEffectContext;
+exports.wrapInert = wrapInert;
 exports.wrapProtos = wrapProtos;
 exports.zip = zip;
-//# sourceMappingURL=proxy-BvM4yewA.cjs.map
+//# sourceMappingURL=proxy-HA_QQnd5.cjs.map