mutts 1.0.13 → 1.0.14

package/dist/chunks/{proxy-DBHj3kGK.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
@@ -277,7 +254,7 @@ function named(name, fn) {
 }
 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-DBHj3kGK.cjs', document.baseURI).href)) }) !== 'undefined' && undefined?.MODE) ||
+    (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';
@@ -785,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();
@@ -857,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.
 
@@ -1013,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;
@@ -1348,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',
@@ -1498,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
@@ -1588,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
@@ -1693,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,
@@ -1712,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,
@@ -1735,6 +1757,7 @@ function unwrap(obj) {
         return obj;
     return proxyToObject.get(obj) || obj;
 }
+const toRaw = unwrap;
 function isReactive(obj) {
     return proxyToObject.has(obj);
 }
@@ -1782,8 +1805,9 @@ function dependant(obj, prop = allProps) {
     if (!currentActiveEffect || (typeof prop === 'symbol' && prop !== allProps && prop !== keysOf))
         return;
     const node = getEffectNode(currentActiveEffect);
-    if ('dependencyHook' in node) {
-        node.dependencyHook?.(obj, prop);
+    const hasDependencyHook = node.dependencyHook !== undefined;
+    if (hasDependencyHook) {
+        node.dependencyHook(obj, prop);
     }
     let objectWatchers = exports.watchers.get(obj);
     if (!objectWatchers) {
@@ -1805,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
  */
@@ -1925,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
  */
@@ -1943,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);
@@ -2058,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)
@@ -2167,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;
@@ -2175,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) {
@@ -2194,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
@@ -2343,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;
         }
@@ -2360,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
@@ -2382,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
@@ -2478,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) {
@@ -2568,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, caller) {
+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 });
     }
@@ -2585,16 +2663,38 @@ function batch(effect, immediate, caller) {
             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 activeCaller = getActiveEffect();
-    const callerToUse = caller || activeCaller;
+    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], 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(),
@@ -2602,9 +2702,11 @@ function batch(effect, immediate, caller) {
     };
     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++) {
@@ -2621,11 +2723,17 @@ function batch(effect, immediate, caller) {
                     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
@@ -2685,13 +2793,17 @@ function batch(effect, immediate, caller) {
         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) {
@@ -2707,6 +2819,7 @@ function batch(effect, immediate, caller) {
  * All existing effects become orphaned and must be recreated.
  */
 function reset() {
+    const wasBroken = broken;
     broken = false;
     activationRegistry = undefined;
     batchStack.length = 0;
@@ -2717,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.
@@ -2733,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) {
@@ -2741,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 });
         };
     },
 });
@@ -2780,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());
 /**
@@ -3024,7 +3139,7 @@ const effect = captioned(named(effectMarker.leave, flavored(function effect(fn,
             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) => {
@@ -3094,16 +3209,53 @@ const untracked = captioned(function untracked(fn) {
         ? 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 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
+ */
+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
  */
 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(fn))
-        : effectHistory.root(fn);
+        ? externalReason.with(external, () => effectHistory.root(runner))
+        : effectHistory.root(runner);
 });
 function biDi(received, get, set) {
     if (typeof get !== 'function') {
@@ -3126,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
@@ -3255,7 +3487,7 @@ 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) {
@@ -3271,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);
                     }
@@ -3304,17 +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();
@@ -3331,7 +3564,7 @@ function touched(obj, evolution, props) {
                 });
             }
         }
-        batch(triggers, undefined, sourceEffect);
+        batch(triggers, { caller: sourceEffect });
     }
     // Bubble up changes if this object has deep watchers
     if (objectsWithDeepWatchers.has(obj)) {
@@ -3355,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)
@@ -3366,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);
@@ -3405,7 +3638,7 @@ function touchedOpaque(obj, evolution, prop) {
     }
     if (effects.size > 0) {
         optionCall('touched', obj, evolution, [prop], Array.from(effects));
-        batch(Array.from(effects), undefined, sourceEffect);
+        batch(Array.from(effects), { caller: sourceEffect });
     }
 }
 
@@ -3452,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)
@@ -3669,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)
@@ -3688,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) {
@@ -3750,12 +3985,34 @@ 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
@@ -3766,6 +4023,56 @@ function wrapReactiveValue(obj, prop, value) {
     }
     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) {
@@ -3793,36 +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);
-        if (!getActiveEffect()) {
-            const value = (subsRegister.get(obj)?.get || FoolProof.get)(obj, prop, receiver);
+        const subProxy = subsRegister.get(obj);
+        if (exports.inertDepth > 0) {
+            const value = (subProxy?.get || FoolProof.get)(obj, prop, receiver);
             return wrapReactiveValue(obj, prop, value);
         }
-        // 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 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) &&
@@ -3835,7 +4135,7 @@ 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);
+        const value = (subProxy?.get || FoolProof.get)(obj, prop, receiver);
         return wrapReactiveValue(obj, prop, value);
     },
     set(obj, prop, value, receiver) {
@@ -3909,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);
@@ -3917,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) {
@@ -3932,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);
     },
@@ -3940,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
 /**
@@ -3981,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
@@ -4011,6 +4439,8 @@ const reactive = decorator({
     },
     default: reactiveObject,
 });
+const shallowReactive = shallowReactiveObject;
+const readonlyReactive = readonlyReactiveObject;
 
 exports.AZone = AZone;
 exports.CompareSymbol = CompareSymbol;
@@ -4035,7 +4465,6 @@ exports.asyncHooks = asyncHooks;
 exports.asyncZone = asyncZone;
 exports.atom = atom;
 exports.atomic = atomic;
-exports.batch = batch;
 exports.biDi = biDi;
 exports.captioned = captioned;
 exports.captured = captured;
@@ -4065,6 +4494,7 @@ exports.getEffectNode = getEffectNode;
 exports.getRoot = getRoot;
 exports.getState = getState;
 exports.hooks = hooks;
+exports.inert = inert;
 exports.inheritCaption = inheritCaption;
 exports.isConstructor = isConstructor;
 exports.isDev = isDev;
@@ -4072,10 +4502,13 @@ 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;
@@ -4086,17 +4519,22 @@ 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;
@@ -4104,6 +4542,7 @@ exports.unreactiveProperties = unreactiveProperties;
 exports.untracked = untracked;
 exports.unwrap = unwrap;
 exports.withEffectContext = withEffectContext;
+exports.wrapInert = wrapInert;
 exports.wrapProtos = wrapProtos;
 exports.zip = zip;
-//# sourceMappingURL=proxy-DBHj3kGK.cjs.map
+//# sourceMappingURL=proxy-HA_QQnd5.cjs.map