mutts 1.0.13 → 1.0.14

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

@@ -1,26 +1,3 @@
-// Queue for hooks registered before the environment is ready (circular dependency fix)
-const hooks = new Set();
-const asyncHooks = {
-    addHook(hook) {
-        hooks.add(hook);
-        return () => hooks.delete(hook);
-    },
-    /**
-     * [Hack] Sanitize a promise (or value) to prevent context leaks.
-     * Default: Identity function.
-     * Browser: Uses Macrotask wrapping to break microtask chains.
-     */
-    sanitizePromise(p) {
-        return p;
-    },
-};
-/**
- * Register a hook that will be called whenever an asynchronous operation is initiated.
- * The hook should return a restorer function which will be called just before the async callback runs.
- * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
- */
-const asyncHook = (hook) => asyncHooks.addHook(hook);
-
 /**
  * Yields tuples containing elements from each input array, stopping at the longest array length
  * @param args - Arrays to zip together
@@ -782,7 +759,13 @@ class IterableWeakSet {
     [Symbol.iterator]() {
         return this.keys();
     }
-    union(other) {
+    union(other, ...sets) {
+        if (sets.length > 0) {
+            for (const set of [other, ...sets])
+                for (const value of set)
+                    this.add(value);
+            return this;
+        }
         const others = {
             [Symbol.iterator]() {
                 return other.keys();
@@ -854,100 +837,6 @@ class IterableWeakSet {
 }
 _b = Symbol.toStringTag;
 
-/**
- * Creates a mixin that can be used both as a class (extends) and as a function (mixin)
- *
- * This function supports:
- * - Using mixins as base classes: `class MyClass extends MyMixin`
- * - Using mixins as functions: `class MyClass extends MyMixin(SomeBase)`
- * - Composing mixins: `const Composed = MixinA(MixinB)`
- * - Type-safe property inference for all patterns
- *
- * @param mixinFunction - The function that creates the mixin
- * @param unwrapFunction - Optional function to unwrap reactive objects for method calls
- * @returns A mixin that can be used both as a class and as a function
- */
-function mixin(mixinFunction, unwrapFunction) {
-    /**
-     * Cache for mixin results to ensure the same base class always returns the same mixed class
-     */
-    const mixinCache = new WeakMap();
-    // Apply the mixin to Object as the base class
-    const MixedBase = mixinFunction(Object);
-    mixinCache.set(Object, MixedBase);
-    // Create the proxy that handles both constructor and function calls
-    return new Proxy(MixedBase, {
-        // Handle `MixinClass(SomeBase)` - use as mixin function
-        apply(_target, _thisArg, args) {
-            if (args.length === 0) {
-                throw new Error('Mixin requires a base class');
-            }
-            const baseClass = args[0];
-            if (typeof baseClass !== 'function') {
-                throw new Error('Mixin requires a constructor function');
-            }
-            // Check if it's a valid constructor or a mixin
-            if (!isConstructor(baseClass) &&
-                !(baseClass && typeof baseClass === 'function' && baseClass.prototype)) {
-                throw new Error('Mixin requires a valid constructor');
-            }
-            // Check cache first
-            const cached = mixinCache.get(baseClass);
-            if (cached) {
-                return cached;
-            }
-            let usedBase = baseClass;
-            if (unwrapFunction) {
-                // Create a proxied base class that handles method unwrapping
-                const ProxiedBaseClass = class extends baseClass {
-                };
-                // Proxy the prototype methods to handle unwrapping
-                const originalPrototype = baseClass.prototype;
-                const proxiedPrototype = new Proxy(originalPrototype, {
-                    get(target, prop, receiver) {
-                        const value = FoolProof.get(target, prop, receiver);
-                        // Only wrap methods that are likely to access private fields
-                        // Skip symbols and special properties that the reactive system needs
-                        if (typeof value === 'function' &&
-                            typeof prop === 'string' &&
-                            !['constructor', 'toString', 'valueOf'].includes(prop)) {
-                            // Return a wrapped version that uses unwrapped context
-                            return function (...args) {
-                                // Use the unwrapping function if provided, otherwise use this
-                                const context = unwrapFunction(this);
-                                return value.apply(context, args);
-                            };
-                        }
-                        return value;
-                    },
-                });
-                // Set the proxied prototype
-                Object.setPrototypeOf(ProxiedBaseClass.prototype, proxiedPrototype);
-                usedBase = ProxiedBaseClass;
-            }
-            // Create the mixed class using the proxied base class
-            const mixedClass = mixinFunction(usedBase);
-            // Cache the result
-            mixinCache.set(baseClass, mixedClass);
-            return mixedClass;
-        },
-    });
-}
-
-const debugHooks = {
-    isDevtoolsEnabled: () => false,
-    registerEffect: () => { },
-    getTriggerChain: () => [],
-    captureStack: () => [],
-    captureLineage: () => new Error().stack,
-    formatStack: (stack) => [stack],
-    recordTriggerLink: () => { },
-    decorateError: () => { },
-};
-function setDebugHooks(hooks) {
-    Object.assign(debugHooks, hooks);
-}
-
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -1010,6 +899,29 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+// Queue for hooks registered before the environment is ready (circular dependency fix)
+const hooks = new Set();
+const asyncHooks = {
+    addHook(hook) {
+        hooks.add(hook);
+        return () => hooks.delete(hook);
+    },
+    /**
+     * [Hack] Sanitize a promise (or value) to prevent context leaks.
+     * Default: Identity function.
+     * Browser: Uses Macrotask wrapping to break microtask chains.
+     */
+    sanitizePromise(p) {
+        return p;
+    },
+};
+/**
+ * Register a hook that will be called whenever an asynchronous operation is initiated.
+ * The hook should return a restorer function which will be called just before the async callback runs.
+ * That restorer should in turn return an undoer function which will be called just after the async callback finishes.
+ */
+const asyncHook = (hook) => asyncHooks.addHook(hook);
+
 var _ZoneAggregator_zones;
 function isu(z) {
     return z;
@@ -1345,6 +1257,85 @@ function unlink(obj, reason) {
     }
 }
 
+function extractRawStack(error = new Error()) {
+    if (typeof error === 'string')
+        return error;
+    if (error && typeof error === 'object' && 'stack' in error) {
+        const stack = error.stack;
+        return typeof stack === 'string' ? stack : undefined;
+    }
+    return undefined;
+}
+function trimStack(stack) {
+    const raw = extractRawStack(stack);
+    if (!raw)
+        return [];
+    const lines = raw
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines[0]?.startsWith('Error'))
+        lines.shift();
+    while (lines[0] &&
+        (lines[0].includes('captureLineage') ||
+            lines[0].includes('captureDeferredLineage') ||
+            lines[0].includes('debug-hooks.ts')))
+        lines.shift();
+    return lines;
+}
+function digestDeferredLineage(lineage) {
+    if (lineage.segments)
+        return lineage.segments;
+    const segments = [];
+    let effect = lineage.effect;
+    let stack = trimStack(lineage.stack);
+    if (!effect) {
+        lineage.segments = [{ effectName: 'root', stack }];
+        return lineage.segments;
+    }
+    while (effect) {
+        const root = getRoot(effect);
+        segments.push({
+            effectName: root.name || 'anonymous',
+            stack,
+        });
+        const node = getEffectNode(effect);
+        effect = node.parent;
+        stack = trimStack(node.creationStack);
+    }
+    if (stack.length)
+        segments.push({ effectName: 'root', stack });
+    lineage.segments = segments;
+    return segments;
+}
+function formatDeferredLineage(lineage) {
+    return digestDeferredLineage(lineage)
+        .map((segment) => [`${segment.effectName}:`, ...segment.stack.map((line) => `  ${line}`)].join('\n'))
+        .join('\n');
+}
+function captureDeferredLineage(effect = getActiveEffect(), stack = new Error()) {
+    return {
+        effect,
+        stack,
+        toString() {
+            return formatDeferredLineage(this);
+        },
+    };
+}
+const debugHooks = {
+    isDevtoolsEnabled: () => false,
+    registerEffect: () => { },
+    getTriggerChain: () => [],
+    captureStack: (error) => extractRawStack(error ?? new Error()),
+    captureLineage: captureDeferredLineage,
+    formatStack: (stack) => [stack],
+    recordTriggerLink: () => { },
+    decorateError: () => { },
+};
+function setDebugHooks(hooks) {
+    Object.assign(debugHooks, hooks);
+}
+
 const effectMarker = {
     enter: 'effect:enter',
     leave: 'effect:leave',
@@ -1495,6 +1486,17 @@ class ReactiveError extends Error {
         return this.debugInfo?.cause;
     }
 }
+function normalizeSchedulerMode(mode) {
+    switch (mode) {
+        case 'production':
+            return 'raw';
+        case 'development':
+            return 'ordered';
+        default:
+            return mode;
+    }
+}
+let schedulerMode = 'ordered';
 // biome-ignore-start lint/correctness/noUnusedFunctionParameters: Interface declaration with empty defaults
 /**
  * Global options for the reactive system
@@ -1585,22 +1587,42 @@ const options = {
      */
     onMemoizationDiscrepancy: undefined,
     /**
-     * How to handle cycles detected in effect batches.
+     * Effect scheduler mode.
      *
-     * - `'production'` (Default): High-performance mode. Disables dependency graph maintenance and
-     *   Topological Sorting in favor of a simple FIFO queue. Use this for trustworthy, acyclic UI code.
-     *   Cycle detection is heuristic (uses maxEffectChain execution counts).
+     * - `'ordered'` (Default): maintains the causal effect graph so effects that are already
+     *   queued together can run in dependency order. It also preserves parent/child effect
+     *   lifecycle ordering and catches cycles eagerly when edges are created.
      *
-     * - `'development'`: Maintains direct dependency graph for early cycle detection during edge creation.
-     *   Catches cycles before effects execute via DFS check when adding edges. Throws immediately with
-     *   basic path information. Good balance of debugging help with moderate overhead.
+     * - `'raw'`: fastest FIFO scheduler. It does not maintain the effect graph.
+     *   Cycle detection is heuristic, using maxEffectChain execution counts.
      *
-     * - `'debug'`: Full diagnostic mode with transitive closures and topological sorting.
-     *   Provides detailed cycle path reporting. Highest overhead but most informative for bug hunting.
+     * - `'debug'`: ordered scheduling plus the most detailed graph diagnostics. Highest overhead,
+     *   best for investigation.
      *
-     * @default 'production'
+     * @default 'ordered'
      */
-    cycleHandling: 'development',
+    get scheduler() {
+        return schedulerMode;
+    },
+    set scheduler(mode) {
+        schedulerMode = mode;
+    },
+    /**
+     * @deprecated Use `scheduler` instead.
+     *
+     * Backward-compatible alias for older names:
+     * - `'production'` maps to `scheduler = 'raw'`
+     * - `'development'` maps to `scheduler = 'ordered'`
+     * - `'debug'` maps to `scheduler = 'debug'`
+     *
+     * The new names describe scheduler behavior rather than runtime environment.
+     */
+    get cycleHandling() {
+        return schedulerMode;
+    },
+    set cycleHandling(mode) {
+        schedulerMode = normalizeSchedulerMode(mode);
+    },
     /**
      * Internal flag used by memoization discrepancy detector to avoid counting calls in tests
      * @warning Do not modify this flag manually, this flag is given by the engine
@@ -1690,14 +1712,14 @@ function optionCall(name, ...args) {
 /** Production preset: no introspection, heuristic cycle detection, minimal overhead */
 const prodPreset = {
     maxEffectReaction: 'throw',
-    cycleHandling: 'production',
+    scheduler: 'raw',
     introspection: null,
     onMemoizationDiscrepancy: undefined,
 };
-/** Development preset (default): introspection on, early cycle detection, warnings */
+/** Development preset: introspection on, early cycle detection, warnings */
 const devPreset = {
     maxEffectReaction: 'warn',
-    cycleHandling: 'development',
+    scheduler: 'ordered',
     introspection: {
         gatherReasons: { lineages: 'touch' },
         logErrors: true,
@@ -1709,7 +1731,7 @@ const devPreset = {
 /** Debug preset: full diagnostics, throws on violations, rich lineage capture */
 const debugPreset = {
     maxEffectReaction: 'debug',
-    cycleHandling: 'debug',
+    scheduler: 'debug',
     introspection: {
         gatherReasons: { lineages: 'both' },
         logErrors: true,
@@ -1732,6 +1754,7 @@ function unwrap(obj) {
         return obj;
     return proxyToObject.get(obj) || obj;
 }
+const toRaw = unwrap;
 function isReactive(obj) {
     return proxyToObject.has(obj);
 }
@@ -1779,8 +1802,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 = watchers.get(obj);
     if (!objectWatchers) {
@@ -1802,25 +1826,25 @@ function dependant(obj, prop = allProps) {
         effectToReactiveObjects.set(currentActiveEffect, new Set([obj]));
     }
     // Store dependency stack if introspection is enabled
-    const gatherReasons = options.introspection?.gatherReasons;
-    if (gatherReasons) {
-        const lineageConfig = gatherReasons.lineages;
-        if (lineageConfig === 'dependency' || lineageConfig === 'both') {
-            let objStacks = dependencyStacks.get(obj);
-            if (!objStacks) {
-                objStacks = new Map();
-                dependencyStacks.set(obj, objStacks);
-            }
-            let propStacks = objStacks.get(prop);
-            if (!propStacks) {
-                propStacks = new Map();
-                objStacks.set(prop, propStacks);
-            }
-            propStacks.set(currentActiveEffect, debugHooks.captureLineage());
+    const lineageMode = options.introspection?.gatherReasons?.lineages;
+    const shouldGatherDependencyLineage = lineageMode === 'dependency' || lineageMode === 'both';
+    if (shouldGatherDependencyLineage) {
+        let objStacks = dependencyStacks.get(obj);
+        if (!objStacks) {
+            objStacks = new Map();
+            dependencyStacks.set(obj, objStacks);
+        }
+        let propStacks = objStacks.get(prop);
+        if (!propStacks) {
+            propStacks = new Map();
+            objStacks.set(prop, propStacks);
         }
+        propStacks.set(currentActiveEffect, debugHooks.captureLineage());
     }
 }
 
+// Simple module to manage inert state without circular dependencies
+let inertDepth = 0;
 /**
  * Finds a cycle in a sequence of functions by looking for the first repetition
  */
@@ -1922,6 +1946,40 @@ let causesClosure = new WeakMap();
 let consequencesClosure = new WeakMap();
 // Batch re-entrance depth and broken state
 let broken = false;
+/** True after an unrecoverable reactive failure until `reset()`. */
+function isReactiveBroken() {
+    return broken;
+}
+const reactiveBrokenHandlers = new Set();
+const reactiveResetHandlers = new Set();
+function onReactiveBroken(handler) {
+    reactiveBrokenHandlers.add(handler);
+    return () => reactiveBrokenHandlers.delete(handler);
+}
+function onReactiveReset(handler) {
+    reactiveResetHandlers.add(handler);
+    return () => reactiveResetHandlers.delete(handler);
+}
+function notifyReactiveBroken(error) {
+    for (const handler of Array.from(reactiveBrokenHandlers)) {
+        try {
+            handler(error);
+        }
+        catch (handlerError) {
+            options.warn('[reactive] onReactiveBroken handler threw', handlerError);
+        }
+    }
+}
+function notifyReactiveReset() {
+    for (const handler of Array.from(reactiveResetHandlers)) {
+        try {
+            handler();
+        }
+        catch (handlerError) {
+            options.warn('[reactive] onReactiveReset handler threw', handlerError);
+        }
+    }
+}
 /**
  * Gets or creates an IterableWeakSet for a closure map
  */
@@ -1940,7 +1998,7 @@ function getOrCreateClosure(closure, root) {
  * @param targetRoot - Root function of the effect being triggered
  */
 function addGraphEdge(callerRoot, targetRoot) {
-    if (options.cycleHandling === 'production')
+    if (options.scheduler === 'raw')
         return;
     // Add to forward graph: callerRoot → targetRoot
     const triggers = effectTriggers.get(callerRoot);
@@ -2055,7 +2113,7 @@ function hasPathExcluding(start, end, exclude) {
  * @param effect - The effect being cleaned up
  */
 function cleanupEffectFromGraph(effect) {
-    if (options.cycleHandling === 'production')
+    if (options.scheduler === 'raw')
         return;
     const root = getRoot(effect);
     // Get closures before removing direct edges (needed for propagation)
@@ -2164,7 +2222,7 @@ const executingStack = [];
  * Called once when batch starts or when new effects are added
  */
 function computeAllInDegrees(batch) {
-    if (options.cycleHandling === 'production')
+    if (options.scheduler === 'raw')
         return;
     const activeEffect = getActiveEffect();
     const activeRoot = activeEffect ? getRoot(activeEffect) : null;
@@ -2172,6 +2230,16 @@ function computeAllInDegrees(batch) {
     batch.inDegrees.clear();
     for (const [root] of batch.all) {
         let inDegree = 0;
+        // Make sure parents are executed before children: if parent is in batch, count it as a dependency
+        const effect = batch.all.get(root);
+        const parent = getEffectNode(effect).parent;
+        const parentRoot = parent ? getRoot(parent) : undefined;
+        if (parentRoot &&
+            batch.all.has(parentRoot) &&
+            parentRoot !== activeRoot &&
+            parentRoot !== root) {
+            inDegree++;
+        }
         const causes = causesClosure.get(root);
         if (causes) {
             for (const causeRoot of causes) {
@@ -2191,17 +2259,26 @@ function computeAllInDegrees(batch) {
 function decrementInDegreesForExecuted(batch, executedRoot) {
     // Get all effects that this executed effect triggers
     const consequences = consequencesClosure.get(executedRoot);
-    if (!consequences)
-        return;
-    for (const consequenceRoot of consequences) {
-        // Only update if it's still in the batch
-        if (batch.all.has(consequenceRoot)) {
-            const currentDegree = batch.inDegrees.get(consequenceRoot) ?? 0;
-            if (currentDegree > 0) {
-                batch.inDegrees.set(consequenceRoot, currentDegree - 1);
+    if (consequences) {
+        for (const consequenceRoot of consequences) {
+            // Only update if it's still in the batch
+            if (batch.all.has(consequenceRoot)) {
+                const currentDegree = batch.inDegrees.get(consequenceRoot) ?? 0;
+                if (currentDegree > 0) {
+                    batch.inDegrees.set(consequenceRoot, currentDegree - 1);
+                }
             }
         }
     }
+    for (const [root, effect] of batch.all) {
+        const parent = getEffectNode(effect).parent;
+        if (!parent || getRoot(parent) !== executedRoot)
+            continue;
+        const currentDegree = batch.inDegrees.get(root) ?? 0;
+        if (currentDegree > 0) {
+            batch.inDegrees.set(root, currentDegree - 1);
+        }
+    }
 }
 /**
  * Finds a path from startRoot to endRoot in the dependency graph
@@ -2340,15 +2417,15 @@ function addToBatch(effect, caller, immediate, reason) {
         }
     }
     // 1. Add to batch first (needed for cycle detection)
-    // TODO: Check if it's the correct way to do (these different behavior in function of dev/production)
-    if (options.cycleHandling === 'production') {
-        // Production mode: FIFO (delete and re-add to move to end)
+    // TODO: Check if this difference between raw and graph-backed scheduling is the right tradeoff.
+    if (options.scheduler === 'raw') {
+        // Raw mode: FIFO (delete and re-add to move to end)
         if (currentBatch.all.has(root)) {
             currentBatch.all.delete(root);
         }
     }
     else {
-        // Dev mode: skip if already queued — the existing entry will re-run
+        // Graph-backed modes: skip if already queued — the existing entry will re-run
         if (currentBatch.all.has(root)) {
             return;
         }
@@ -2357,7 +2434,7 @@ function addToBatch(effect, caller, immediate, reason) {
     if (node.stopped)
         return;
     currentBatch.all.set(root, effect);
-    if (caller && true && options.cycleHandling !== 'production') {
+    if (caller && true && options.scheduler !== 'raw') {
         const callerRoot = getRoot(caller);
         // const root = getRoot(effect) // Already have root
         // Check for cycle BEFORE adding edge
@@ -2379,6 +2456,9 @@ function addToBatch(effect, caller, immediate, reason) {
         }
         addGraphEdge(callerRoot, root);
     }
+    if (options.scheduler !== 'raw') {
+        computeAllInDegrees(currentBatch);
+    }
 }
 /**
  * Adds a cleanup function to be called when the current batch of effects completes
@@ -2475,7 +2555,7 @@ function executeNext(effectuatedRoots) {
     // Find an effect with in-degree 0 using cached values
     let nextEffect = null;
     let nextRoot = null;
-    if (options.cycleHandling === 'production') {
+    if (options.scheduler === 'raw') {
         // In flat mode, we just take the first effect in the queue (FIFO)
         const first = currentBatch.all.entries().next().value;
         if (first) {
@@ -2565,9 +2645,7 @@ function executeNext(effectuatedRoots) {
     }
     return result;
 }
-// Track which sub-effects have been executed to prevent infinite loops
-// These are all the effects triggered under `activeEffect` and all their sub-effects
-function batch(effect, immediate, caller) {
+function batch(effect, batchOptions) {
     if (broken) {
         throw new ReactiveError('[reactive] Reactive system is broken after an unrecoverable error. Call reset() to recover.', { code: ReactiveErrorCode.BrokenEffects });
     }
@@ -2582,16 +2660,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(),
@@ -2599,9 +2699,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++) {
@@ -2618,11 +2720,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
@@ -2682,13 +2790,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) {
@@ -2704,6 +2816,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;
@@ -2714,6 +2827,8 @@ function reset() {
     resetRegistry();
     resetTracking();
     effectHistory.present.active = undefined;
+    if (wasBroken)
+        notifyReactiveReset();
 }
 // Inject batch function to allow atomic game loops in requestAnimationFrame/setTimeout/...
 // Note: Automatic batching of async callbacks (setTimeout, Promise.then, etc.) is NOT implemented.
@@ -2730,7 +2845,7 @@ const atomic = decorator({
             const atomicEffect = () => original.apply(this, args);
             // Debug: helpful to have a name
             Object.defineProperty(atomicEffect, 'name', { value: `atomic(${original.name})` });
-            return batch(atomicEffect, 'immediate');
+            return batch(atomicEffect, { immediate: true });
         };
     },
     default(original) {
@@ -2738,7 +2853,7 @@ const atomic = decorator({
             const atomicEffect = () => original.apply(this, args);
             // Debug: helpful to have a name
             Object.defineProperty(atomicEffect, 'name', { value: `atomic(${original.name})` });
-            return batch(atomicEffect, 'immediate');
+            return batch(atomicEffect, { immediate: true });
         };
     },
 });
@@ -2777,7 +2892,7 @@ function captured(prev, fn) {
  * ```
  */
 function atom(fn) {
-    return batch(fn, 'immediate');
+    return batch(fn, { immediate: true });
 }
 const fr = new FinalizationRegistry((f) => f());
 /**
@@ -3021,7 +3136,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) => {
@@ -3091,16 +3206,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 = inertDepth;
+    inertDepth = originalDepth + 1;
+    try {
+        return fn();
+    }
+    finally {
+        inertDepth = originalDepth;
+    }
+}
+function wrapInert(fn) {
+    function inertEffect(...args) {
+        return runInert(() => fn.apply(this, args));
+    }
+    Object.defineProperty(inertEffect, 'name', { value: `inert(${fn.name})` });
+    return inertEffect;
+}
+/**
+ * Executes a function 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') {
@@ -3123,6 +3275,86 @@ function biDi(received, get, set) {
         : () => { };
 }
 
+/**
+ * Creates a mixin that can be used both as a class (extends) and as a function (mixin)
+ *
+ * This function supports:
+ * - Using mixins as base classes: `class MyClass extends MyMixin`
+ * - Using mixins as functions: `class MyClass extends MyMixin(SomeBase)`
+ * - Composing mixins: `const Composed = MixinA(MixinB)`
+ * - Type-safe property inference for all patterns
+ *
+ * @param mixinFunction - The function that creates the mixin
+ * @param unwrapFunction - Optional function to unwrap reactive objects for method calls
+ * @returns A mixin that can be used both as a class and as a function
+ */
+function mixin(mixinFunction, unwrapFunction) {
+    /**
+     * Cache for mixin results to ensure the same base class always returns the same mixed class
+     */
+    const mixinCache = new WeakMap();
+    // Apply the mixin to Object as the base class
+    const MixedBase = mixinFunction(Object);
+    mixinCache.set(Object, MixedBase);
+    // Create the proxy that handles both constructor and function calls
+    return new Proxy(MixedBase, {
+        // Handle `MixinClass(SomeBase)` - use as mixin function
+        apply(_target, _thisArg, args) {
+            if (args.length === 0) {
+                throw new Error('Mixin requires a base class');
+            }
+            const baseClass = args[0];
+            if (typeof baseClass !== 'function') {
+                throw new Error('Mixin requires a constructor function');
+            }
+            // Check if it's a valid constructor or a mixin
+            if (!isConstructor(baseClass) &&
+                !(baseClass && typeof baseClass === 'function' && baseClass.prototype)) {
+                throw new Error('Mixin requires a valid constructor');
+            }
+            // Check cache first
+            const cached = mixinCache.get(baseClass);
+            if (cached) {
+                return cached;
+            }
+            let usedBase = baseClass;
+            if (unwrapFunction) {
+                // Create a proxied base class that handles method unwrapping
+                const ProxiedBaseClass = class extends baseClass {
+                };
+                // Proxy the prototype methods to handle unwrapping
+                const originalPrototype = baseClass.prototype;
+                const proxiedPrototype = new Proxy(originalPrototype, {
+                    get(target, prop, receiver) {
+                        const value = FoolProof.get(target, prop, receiver);
+                        // Only wrap methods that are likely to access private fields
+                        // Skip symbols and special properties that the reactive system needs
+                        if (typeof value === 'function' &&
+                            typeof prop === 'string' &&
+                            !['constructor', 'toString', 'valueOf'].includes(prop)) {
+                            // Return a wrapped version that uses unwrapped context
+                            return function (...args) {
+                                // Use the unwrapping function if provided, otherwise use this
+                                const context = unwrapFunction(this);
+                                return value.apply(context, args);
+                            };
+                        }
+                        return value;
+                    },
+                });
+                // Set the proxied prototype
+                Object.setPrototypeOf(ProxiedBaseClass.prototype, proxiedPrototype);
+                usedBase = ProxiedBaseClass;
+            }
+            // Create the mixed class using the proxied base class
+            const mixedClass = mixinFunction(usedBase);
+            // Cache the result
+            mixinCache.set(baseClass, mixedClass);
+            return mixedClass;
+        },
+    });
+}
+
 // Track which objects contain which other objects (back-references)
 const objectParents = new WeakMap();
 // Track which objects have deep watchers
@@ -3252,7 +3484,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) {
@@ -3268,7 +3500,7 @@ function collectEffects(obj, evolution, effects, objectWatchers, ...keyChains) {
                         continue;
                     }
                     if (!effects.has(effect)) {
-                        effects.set(effect, getDependencyStack(effect, obj, key));
+                        effects.set(effect, collectDependencyStack ? getDependencyStack(effect, obj, key) : undefined);
                         if (!hasBatched(effect))
                             recordActivation(effect, obj, evolution, key);
                     }
@@ -3301,17 +3533,18 @@ function touched(obj, evolution, props) {
         const effects = new Map();
         const structural = !['set', 'invalidate'].includes(evolution.type);
         const broad = structural ? [allProps, keysOf] : [allProps];
+        const gatherReasons = options.introspection?.gatherReasons;
+        const lineageConfig = gatherReasons?.lineages;
+        const collectDependencyStack = lineageConfig === 'dependency' || lineageConfig === 'both';
         if (props)
-            collectEffects(obj, evolution, effects, objectWatchers, broad, props);
+            collectEffects(obj, evolution, effects, objectWatchers, collectDependencyStack, broad, props);
         else
-            collectEffects(obj, evolution, effects, objectWatchers, objectWatchers.keys());
+            collectEffects(obj, evolution, effects, objectWatchers, collectDependencyStack, objectWatchers.keys());
         const triggers = Array.from(effects.keys());
         const sourceEffect = getActiveEffect();
         optionCall('touched', obj, evolution, props, triggers);
         // Store pending triggers for CleanupReason before batching
-        if (options.introspection?.gatherReasons) {
-            const gatherReasons = options.introspection.gatherReasons;
-            const lineageConfig = gatherReasons.lineages;
+        if (gatherReasons && effects.size > 0) {
             let touchLineage;
             if (lineageConfig === 'touch' || lineageConfig === 'both') {
                 touchLineage = debugHooks.captureLineage();
@@ -3328,7 +3561,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)) {
@@ -3352,6 +3585,7 @@ function touchedOpaque(obj, evolution, prop) {
     const gather = options.introspection?.gatherReasons;
     if (gather) {
         const lineageConfig = gather.lineages;
+        let touchLineage;
         for (const effect of deps) {
             const node = getEffectNode(effect);
             if (!node.isOpaque)
@@ -3363,10 +3597,9 @@ function touchedOpaque(obj, evolution, prop) {
             }
             effects.add(effect);
             if (gather) {
-                let touchLineage;
                 let dependencyStack;
                 if (lineageConfig === 'touch' || lineageConfig === 'both') {
-                    touchLineage = debugHooks.captureLineage();
+                    touchLineage ?? (touchLineage = debugHooks.captureLineage());
                 }
                 if (lineageConfig === 'dependency' || lineageConfig === 'both') {
                     dependencyStack = getDependencyStack(effect, obj, prop);
@@ -3402,7 +3635,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 });
     }
 }
 
@@ -3449,6 +3682,8 @@ function nonReactive(...obj) {
     }
     return obj[0];
 }
+const markRaw = nonReactive;
+const markRawProps = addUnreactiveProps;
 function nonReactiveClass(...cls) {
     for (const c of cls)
         if (c)
@@ -3666,7 +3901,7 @@ function dispatchNotifications(notifications) {
         const originWatchers = watchers.get(origin.obj);
         if (originWatchers) {
             const originEffects = new Map();
-            collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, [allProps], [origin.prop]);
+            collectEffects(origin.obj, { type: 'set', prop: origin.prop }, originEffects, originWatchers, false, [allProps], [origin.prop]);
             allowedEffects = new Set(originEffects.keys());
         }
         // If no allowed effects, skip all notifications (no one should be notified)
@@ -3685,7 +3920,7 @@ function dispatchNotifications(notifications) {
         if (objectWatchers) {
             currentEffects = new Map();
             const broad = evolution.type !== 'set' ? [allProps, keysOf] : [allProps];
-            collectEffects(obj, evolution, currentEffects, objectWatchers, broad, propsArray);
+            collectEffects(obj, evolution, currentEffects, objectWatchers, false, broad, propsArray);
             // Filter effects by ancestor chain if origin exists
             // Include effects that either directly depend on origin or have an ancestor that does
             if (origin && allowedEffects) {
@@ -3747,12 +3982,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 (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
@@ -3763,6 +4020,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) {
@@ -3790,36 +4097,29 @@ const reactiveHandlers = {
         // Symbols: fast-path — no reactivity tracking
         if (typeof prop === 'symbol' || prop === 'constructor' || isUnreactiveProp(obj, prop))
             return FoolProof.get(obj, prop, receiver);
-        if (!getActiveEffect()) {
-            const value = (subsRegister.get(obj)?.get || FoolProof.get)(obj, prop, receiver);
+        const subProxy = subsRegister.get(obj);
+        if (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) &&
@@ -3832,7 +4132,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) {
@@ -3906,6 +4206,11 @@ const reactiveHandlers = {
                 cycle: [], // We don't have the full cycle here, but we know it involves obj
             });
         hasReentry.add(obj);
+        if (inertDepth > 0) {
+            const rv = (subsRegister.get(obj)?.has || Reflect.has)(obj, prop);
+            hasReentry.delete(obj);
+            return rv;
+        }
         if (!internalUntracked && !isUnreactiveProp(obj, prop))
             dependant(obj, prop);
         const rv = (subsRegister.get(obj)?.has || Reflect.has)(obj, prop);
@@ -3914,7 +4219,7 @@ const reactiveHandlers = {
     },
     deleteProperty(obj, prop) {
         if (!Object.hasOwn(obj, prop))
-            return false;
+            return true;
         const oldVal = obj[prop];
         // Remove back-references if this object has deep watchers
         if (objectsWithDeepWatchers.has(obj) && typeof oldVal === 'object' && oldVal !== null) {
@@ -3929,6 +4234,9 @@ const reactiveHandlers = {
         return true;
     },
     ownKeys(obj) {
+        if (inertDepth > 0) {
+            return subsRegister.get(obj)?.ownKeys?.(obj) || Reflect.ownKeys(obj);
+        }
         dependant(obj, keysOf);
         return subsRegister.get(obj)?.ownKeys?.(obj) || Reflect.ownKeys(obj);
     },
@@ -3937,6 +4245,98 @@ const reactiveHandlers = {
             Reflect.getOwnPropertyDescriptor(obj, prop));
     },
 };
+function readonlyError(prop) {
+    return new ReactiveError(`[reactive] Cannot mutate readonly reactive property '${String(prop)}'`, {
+        code: ReactiveErrorCode.WriteInComputed,
+    });
+}
+function readonlyValue(value) {
+    if (!value || typeof value !== 'object')
+        return value;
+    return readonlyReactive(value);
+}
+const shallowReactiveHandlers = {
+    get(obj, prop, receiver) {
+        if (typeof prop === 'symbol' || prop === 'constructor' || isUnreactiveProp(obj, prop))
+            return Reflect.get(obj, prop, receiver);
+        if (getActiveEffect())
+            dependant(obj, prop);
+        return Reflect.get(obj, prop, receiver);
+    },
+    set(obj, prop, value, receiver) {
+        const unwrapped = unwrap(receiver);
+        if (obj !== unwrapped)
+            return Object.defineProperty(unwrapped, prop, {
+                value,
+                configurable: true,
+                writable: true,
+                enumerable: true,
+            });
+        if (isUnreactiveProp(obj, prop))
+            return FoolProof.set(obj, prop, value, receiver);
+        const hadProperty = Reflect.has(obj, prop);
+        const oldVal = hadProperty ? Reflect.get(obj, prop, receiver) : absent;
+        const newValue = unwrap(value);
+        if (oldVal !== newValue && FoolProof.set(obj, prop, newValue, receiver)) {
+            touched1(obj, { type: hadProperty ? 'set' : 'add', prop }, prop);
+        }
+        return true;
+    },
+    has(obj, prop) {
+        return reactiveHandlers.has(obj, prop);
+    },
+    deleteProperty(obj, prop) {
+        if (!Object.hasOwn(obj, prop))
+            return true;
+        delete obj[prop];
+        touched1(obj, { type: 'del', prop }, prop);
+        return true;
+    },
+    ownKeys(obj) {
+        return reactiveHandlers.ownKeys(obj);
+    },
+    getOwnPropertyDescriptor(obj, prop) {
+        return Reflect.getOwnPropertyDescriptor(obj, prop);
+    },
+};
+const readonlyReactiveHandlers = {
+    get(obj, prop, receiver) {
+        if (readonlyMutators.has(prop)) {
+            return () => {
+                throw readonlyError(prop);
+            };
+        }
+        const reactiveTarget = reactiveObject(obj);
+        const value = FoolProof.get(reactiveTarget, prop, receiver);
+        if (typeof value === 'function') {
+            return (...args) => readonlyValue(value.apply(reactiveTarget, args));
+        }
+        return readonlyValue(value);
+    },
+    set(_obj, prop) {
+        throw readonlyError(prop);
+    },
+    deleteProperty(_obj, prop) {
+        throw readonlyError(prop);
+    },
+    defineProperty(_obj, prop) {
+        throw readonlyError(prop);
+    },
+    setPrototypeOf() {
+        throw readonlyError('[[Prototype]]');
+    },
+    has(obj, prop) {
+        const reactiveTarget = reactiveObject(obj);
+        return Reflect.has(reactiveTarget, prop);
+    },
+    ownKeys(obj) {
+        const reactiveTarget = reactiveObject(obj);
+        return Reflect.ownKeys(reactiveTarget);
+    },
+    getOwnPropertyDescriptor(obj, prop) {
+        return Reflect.getOwnPropertyDescriptor(obj, prop);
+    },
+};
 const reactiveClasses = new WeakSet();
 // Create the ReactiveBase mixin
 /**
@@ -3978,6 +4378,34 @@ function reactiveObject(anyTarget, subProxy) {
     storeProxyRelationship(target, proxy);
     return proxy;
 }
+function shallowReactiveObject(anyTarget) {
+    if (!anyTarget || typeof anyTarget !== 'object')
+        return anyTarget;
+    const target = unwrap(anyTarget);
+    if (isNonReactive(target))
+        return target;
+    const existing = shallowObjectToProxy.get(target);
+    if (existing)
+        return existing;
+    const proxy = new Proxy(target, shallowReactiveHandlers);
+    shallowObjectToProxy.set(target, proxy);
+    proxyToObject.set(proxy, target);
+    return proxy;
+}
+function readonlyReactiveObject(anyTarget) {
+    if (!anyTarget || typeof anyTarget !== 'object')
+        return anyTarget;
+    const target = unwrap(anyTarget);
+    if (isNonReactive(target))
+        return target;
+    const existing = readonlyObjectToProxy.get(target);
+    if (existing)
+        return existing;
+    const proxy = new Proxy(target, readonlyReactiveHandlers);
+    readonlyObjectToProxy.set(target, proxy);
+    proxyToObject.set(proxy, target);
+    return proxy;
+}
 /**
  * Main decorator for making classes reactive
  * Automatically makes class instances reactive when created
@@ -4008,6 +4436,8 @@ const reactive = decorator({
     },
     default: reactiveObject,
 });
+const shallowReactive = shallowReactiveObject;
+const readonlyReactive = readonlyReactiveObject;
 
-export { objectToProxy as $, AZone as A, effectContext as B, CompareSymbol as C, DecoratorError as D, flavorOptions as E, flavored as F, formatCleanupReason as G, getActivationLog as H, IterableWeakMap as I, getActiveEffect as J, getState as K, hooks as L, inheritCaption as M, isConstructor as N, isDev as O, isNonReactive as P, isObject as Q, ReactiveBase as R, isProd as S, isReactive as T, isTest as U, legacyDecorator as V, link as W, mixin as X, modernDecorator as Y, Zone as Z, named as _, IterableWeakSet as a, onEffectThrow as a0, prodPreset as a1, proxyToObject as a2, reactive as a3, options as a4, reset as a5, root as a6, tag as a7, touched as a8, touched1 as a9, wrapProtos as aA, objectParents as aB, watchers as aC, effectToReactiveObjects as aD, effectMarker as aE, setDebugHooks as aF, allProps as aG, unlink as aa, untracked as ab, unwrap as ac, withEffectContext as ad, zip as ae, markWithRoot as af, dependant as ag, getEffectNode as ah, chainExternalReason as ai, keysOf as aj, objectsWithDeepWatchers as ak, effectToDeepWatchedObjects as al, deepWatchers as am, registerDeepWatcher as an, rootFunctionSymbol as ao, getRoot as ap, optionCall as aq, FoolProof as ar, effectHistory as as, unreactiveProperties as at, __runInitializers as au, __esDecorate as av, batch as aw, contentRef as ax, notifyPropertyChange as ay, metaProtos as az, ReactiveError as b, ReactiveErrorCode as c, ZoneAggregator as d, ZoneHistory as e, addBatchCleanup as f, addUnreactiveProps as g, arrayEquals as h, assertUntracked as i, asyncHook as j, asyncHooks as k, asyncZone as l, atom as m, atomic as n, biDi as o, captioned as p, captured as q, caught as r, createFlavor as s, debugPreset as t, decorator as u, deepCompare as v, defer as w, devPreset as x, effect as y, effectAggregator as z };
-//# sourceMappingURL=proxy-BtmPFjSr.esm.js.map
+export { markRawProps as $, AZone as A, effectContext as B, CompareSymbol as C, DecoratorError as D, flavorOptions as E, flavored as F, formatCleanupReason as G, getActivationLog as H, IterableWeakMap as I, getActiveEffect as J, getState as K, hooks as L, inert as M, inheritCaption as N, isConstructor as O, isDev as P, isNonReactive as Q, ReactiveBase as R, isObject as S, isProd as T, isReactive as U, isReactiveBroken as V, isTest as W, legacyDecorator as X, link as Y, Zone as Z, markRaw as _, IterableWeakSet as a, mixin as a0, modernDecorator as a1, named as a2, objectToProxy as a3, onEffectThrow as a4, onReactiveBroken as a5, onReactiveReset as a6, prodPreset as a7, proxyToObject as a8, reactive as a9, inertDepth as aA, optionCall as aB, FoolProof as aC, effectHistory as aD, unreactiveProperties as aE, __runInitializers as aF, __esDecorate as aG, contentRef as aH, notifyPropertyChange as aI, metaProtos as aJ, wrapProtos as aK, objectParents as aL, watchers as aM, effectToReactiveObjects as aN, effectMarker as aO, setDebugHooks as aP, allProps as aQ, options as aa, readonlyReactive as ab, reset as ac, root as ad, shallowReactive as ae, tag as af, toRaw as ag, touched as ah, touched1 as ai, unlink as aj, untracked as ak, unwrap as al, withEffectContext as am, wrapInert as an, zip as ao, markWithRoot as ap, dependant as aq, getEffectNode as ar, chainExternalReason as as, keysOf as at, objectsWithDeepWatchers as au, effectToDeepWatchedObjects as av, deepWatchers as aw, registerDeepWatcher as ax, rootFunctionSymbol as ay, getRoot as az, ReactiveError as b, ReactiveErrorCode as c, ZoneAggregator as d, ZoneHistory as e, addBatchCleanup as f, addUnreactiveProps as g, arrayEquals as h, assertUntracked as i, asyncHook as j, asyncHooks as k, asyncZone as l, atom as m, atomic as n, biDi as o, captioned as p, captured as q, caught as r, createFlavor as s, debugPreset as t, decorator as u, deepCompare as v, defer as w, devPreset as x, effect as y, effectAggregator as z };
+//# sourceMappingURL=proxy-C2lnvvbx.esm.js.map