mutts 1.0.13 → 1.0.14

package/dist/node.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-require('./chunks/node-DrrphEPf.cjs');
-var index = require('./chunks/index-CAdnMJev.cjs');
-var proxy = require('./chunks/proxy-DBHj3kGK.cjs');
+require('./chunks/node-Df_5r_WA.cjs');
+var index = require('./chunks/index-BnTNC9eC.cjs');
+var proxy = require('./chunks/proxy-HA_QQnd5.cjs');
 require('node:async_hooks');
 
 
@@ -83,6 +83,7 @@ exports.getActivationLog = proxy.getActivationLog;
 exports.getActiveEffect = proxy.getActiveEffect;
 exports.getState = proxy.getState;
 exports.hooks = proxy.hooks;
+exports.inert = proxy.inert;
 exports.inheritCaption = proxy.inheritCaption;
 exports.isConstructor = proxy.isConstructor;
 exports.isDev = proxy.isDev;
@@ -90,26 +91,35 @@ exports.isNonReactive = proxy.isNonReactive;
 exports.isObject = proxy.isObject;
 exports.isProd = proxy.isProd;
 exports.isReactive = proxy.isReactive;
+exports.isReactiveBroken = proxy.isReactiveBroken;
 exports.isTest = proxy.isTest;
 exports.legacyDecorator = proxy.legacyDecorator;
 exports.link = proxy.link;
+exports.markRaw = proxy.markRaw;
+exports.markRawProps = proxy.markRawProps;
 exports.mixin = proxy.mixin;
 exports.modernDecorator = proxy.modernDecorator;
 exports.named = proxy.named;
 exports.objectToProxy = proxy.objectToProxy;
 exports.onEffectThrow = proxy.onEffectThrow;
+exports.onReactiveBroken = proxy.onReactiveBroken;
+exports.onReactiveReset = proxy.onReactiveReset;
 exports.prodPreset = proxy.prodPreset;
 exports.proxyToObject = proxy.proxyToObject;
 exports.reactive = proxy.reactive;
 exports.reactiveOptions = proxy.options;
+exports.readonlyReactive = proxy.readonlyReactive;
 exports.reset = proxy.reset;
 exports.root = proxy.root;
+exports.shallowReactive = proxy.shallowReactive;
 exports.tag = proxy.tag;
+exports.toRaw = proxy.toRaw;
 exports.touched = proxy.touched;
 exports.touched1 = proxy.touched1;
 exports.unlink = proxy.unlink;
 exports.untracked = proxy.untracked;
 exports.unwrap = proxy.unwrap;
 exports.withEffectContext = proxy.withEffectContext;
+exports.wrapInert = proxy.wrapInert;
 exports.zip = proxy.zip;
 //# sourceMappingURL=node.cjs.map

package/dist/node.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"node.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"node.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/node.d.ts

@@ -1,2 +1,2 @@
-export { ArrayDiffResult, ArrayReadForward, Captioned, CompareSymbol, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, EffectContext, Eventful, EventsBase, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactiveBase, Resource, Restorer, addBatchCleanup, addUnreactiveProps, allocated, allocatedValues, arrayDiff, arrayEquals, assertUntracked, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, captioned, captured, caught, chainPromise, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, effectContext, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, inheritCaption, isCached, isConstructor, isDev, isNonReactive, isObject, isProd, isTest, legacyDecorator, lift, link, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, reactive, reset, resource, root, setAt, tag, throttle, touched, touched1, unlink, unreactive, untracked, watch, when, withEffectContext, zip } from './browser.js';
-export { A as AZone, C as CleanupReason, c as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, G as GetterWrapper, H as HistoryValue, P as PropTrigger, R as ReactiveError, h as ReactiveErrorCode, S as ScopedCallback, i as Zone, Z as ZoneAggregator, j as ZoneHistory, k as asyncZone, l as debugPreset, m as devPreset, n as formatCleanupReason, o as isReactive, p as objectToProxy, q as prodPreset, r as proxyToObject, s as reactiveOptions, u as unwrap } from './types.js';
+export { ArrayDiffResult, ArrayReadForward, Captioned, CompareSymbol, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, EffectContext, Eventful, EventsBase, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, MorphPosition, PromiseChain, ReactiveBase, Resource, Restorer, addBatchCleanup, addUnreactiveProps, allocated, allocatedValues, arrayDiff, arrayEquals, assertUntracked, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, captioned, captured, caught, chainPromise, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, effectContext, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, inert, inheritCaption, isCached, isConstructor, isDev, isNonReactive, isObject, isProd, isReactiveBroken, isTest, legacyDecorator, lift, link, markRaw, markRawProps, memoize, mixin, modernDecorator, morph, named, onEffectThrow, onReactiveBroken, onReactiveReset, organize, organized, profileInfo, reactive, readonlyReactive, reset, resource, root, setAt, shallowReactive, tag, throttle, touched, touched1, unlink, unreactive, untracked, watch, when, withEffectContext, wrapInert, zip } from './browser.js';
+export { A as AZone, C as CleanupReason, h as CycleHandlingMode, D as DeprecatedCycleHandlingMode, c as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, G as GetterWrapper, H as HistoryValue, P as PropTrigger, R as ReactiveError, i as ReactiveErrorCode, j as SchedulerMode, S as ScopedCallback, k as Zone, Z as ZoneAggregator, l as ZoneHistory, m as asyncZone, n as debugPreset, o as devPreset, p as formatCleanupReason, q as isReactive, r as objectToProxy, s as prodPreset, t as proxyToObject, u as reactiveOptions, v as toRaw, w as unwrap } from './types.js';

package/dist/node.dev.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
 require('./debug.cjs');
-require('./chunks/node-DrrphEPf.cjs');
-var index = require('./chunks/index-CAdnMJev.cjs');
-var proxy = require('./chunks/proxy-DBHj3kGK.cjs');
+require('./chunks/node-Df_5r_WA.cjs');
+var index = require('./chunks/index-BnTNC9eC.cjs');
+var proxy = require('./chunks/proxy-HA_QQnd5.cjs');
 require('node:async_hooks');
 
 
@@ -84,6 +84,7 @@ exports.getActivationLog = proxy.getActivationLog;
 exports.getActiveEffect = proxy.getActiveEffect;
 exports.getState = proxy.getState;
 exports.hooks = proxy.hooks;
+exports.inert = proxy.inert;
 exports.inheritCaption = proxy.inheritCaption;
 exports.isConstructor = proxy.isConstructor;
 exports.isDev = proxy.isDev;
@@ -91,26 +92,35 @@ exports.isNonReactive = proxy.isNonReactive;
 exports.isObject = proxy.isObject;
 exports.isProd = proxy.isProd;
 exports.isReactive = proxy.isReactive;
+exports.isReactiveBroken = proxy.isReactiveBroken;
 exports.isTest = proxy.isTest;
 exports.legacyDecorator = proxy.legacyDecorator;
 exports.link = proxy.link;
+exports.markRaw = proxy.markRaw;
+exports.markRawProps = proxy.markRawProps;
 exports.mixin = proxy.mixin;
 exports.modernDecorator = proxy.modernDecorator;
 exports.named = proxy.named;
 exports.objectToProxy = proxy.objectToProxy;
 exports.onEffectThrow = proxy.onEffectThrow;
+exports.onReactiveBroken = proxy.onReactiveBroken;
+exports.onReactiveReset = proxy.onReactiveReset;
 exports.prodPreset = proxy.prodPreset;
 exports.proxyToObject = proxy.proxyToObject;
 exports.reactive = proxy.reactive;
 exports.reactiveOptions = proxy.options;
+exports.readonlyReactive = proxy.readonlyReactive;
 exports.reset = proxy.reset;
 exports.root = proxy.root;
+exports.shallowReactive = proxy.shallowReactive;
 exports.tag = proxy.tag;
+exports.toRaw = proxy.toRaw;
 exports.touched = proxy.touched;
 exports.touched1 = proxy.touched1;
 exports.unlink = proxy.unlink;
 exports.untracked = proxy.untracked;
 exports.unwrap = proxy.unwrap;
 exports.withEffectContext = proxy.withEffectContext;
+exports.wrapInert = proxy.wrapInert;
 exports.zip = proxy.zip;
 //# sourceMappingURL=node.dev.cjs.map

package/dist/node.dev.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"node.dev.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"node.dev.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/node.dev.d.ts

@@ -1,2 +1,2 @@
-export { A as AZone, C as CleanupReason, c as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, G as GetterWrapper, H as HistoryValue, P as PropTrigger, R as ReactiveError, h as ReactiveErrorCode, S as ScopedCallback, i as Zone, Z as ZoneAggregator, j as ZoneHistory, k as asyncZone, l as debugPreset, m as devPreset, n as formatCleanupReason, o as isReactive, p as objectToProxy, q as prodPreset, r as proxyToObject, s as reactiveOptions, u as unwrap } from './types.js';
-export { ArrayDiffResult, ArrayReadForward, Captioned, CompareSymbol, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, EffectContext, Eventful, EventsBase, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactiveBase, Resource, Restorer, addBatchCleanup, addUnreactiveProps, allocated, allocatedValues, arrayDiff, arrayEquals, assertUntracked, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, captioned, captured, caught, chainPromise, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, effectContext, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, inheritCaption, isCached, isConstructor, isDev, isNonReactive, isObject, isProd, isTest, legacyDecorator, lift, link, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, reactive, reset, resource, root, setAt, tag, throttle, touched, touched1, unlink, unreactive, untracked, watch, when, withEffectContext, zip } from './browser.js';
+export { A as AZone, C as CleanupReason, h as CycleHandlingMode, D as DeprecatedCycleHandlingMode, c as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, G as GetterWrapper, H as HistoryValue, P as PropTrigger, R as ReactiveError, i as ReactiveErrorCode, j as SchedulerMode, S as ScopedCallback, k as Zone, Z as ZoneAggregator, l as ZoneHistory, m as asyncZone, n as debugPreset, o as devPreset, p as formatCleanupReason, q as isReactive, r as objectToProxy, s as prodPreset, t as proxyToObject, u as reactiveOptions, v as toRaw, w as unwrap } from './types.js';
+export { ArrayDiffResult, ArrayReadForward, Captioned, CompareSymbol, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, EffectContext, Eventful, EventsBase, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, MorphPosition, PromiseChain, ReactiveBase, Resource, Restorer, addBatchCleanup, addUnreactiveProps, allocated, allocatedValues, arrayDiff, arrayEquals, assertUntracked, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, captioned, captured, caught, chainPromise, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, effectContext, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, inert, inheritCaption, isCached, isConstructor, isDev, isNonReactive, isObject, isProd, isReactiveBroken, isTest, legacyDecorator, lift, link, markRaw, markRawProps, memoize, mixin, modernDecorator, morph, named, onEffectThrow, onReactiveBroken, onReactiveReset, organize, organized, profileInfo, reactive, readonlyReactive, reset, resource, root, setAt, shallowReactive, tag, throttle, touched, touched1, unlink, unreactive, untracked, watch, when, withEffectContext, wrapInert, zip } from './browser.js';

package/dist/node.dev.esm.js

@@ -1,6 +1,6 @@
 import './debug.esm.js';
-import './chunks/node-NEZvVo4M.esm.js';
-export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, b as allocated, c as allocatedValues, d as arrayDiff, e as attend, f as cache, g as cached, h as callOnGC, i as chainPromise, j as debounce, k as deepWatch, l as deprecated, m as descriptor, n as destructor, o as forwardArray, p as getAt, q as isCached, r as lift, s as memoize, t as morph, u as organize, v as organized, w as profileInfo, x as resource, y as setAt, z as throttle, B as unreactive, C as watch, F as when } from './chunks/index-XsYTUhHx.esm.js';
-export { A as AZone, C as CompareSymbol, D as DecoratorError, I as IterableWeakMap, a as IterableWeakSet, R as ReactiveBase, b as ReactiveError, c as ReactiveErrorCode, Z as Zone, d as ZoneAggregator, e as ZoneHistory, f as addBatchCleanup, g as addUnreactiveProps, h as arrayEquals, i as assertUntracked, j as asyncHook, k as asyncHooks, l as asyncZone, m as atom, n as atomic, o as biDi, p as captioned, q as captured, r as caught, s as createFlavor, t as debugPreset, u as decorator, v as deepCompare, w as defer, x as devPreset, y as effect, z as effectAggregator, B as effectContext, E as flavorOptions, F as flavored, G as formatCleanupReason, H as getActivationLog, J as getActiveEffect, K as getState, L as hooks, M as inheritCaption, N as isConstructor, O as isDev, P as isNonReactive, Q as isObject, S as isProd, T as isReactive, U as isTest, V as legacyDecorator, W as link, X as mixin, Y as modernDecorator, _ as named, $ as objectToProxy, a0 as onEffectThrow, a1 as prodPreset, a2 as proxyToObject, a3 as reactive, a4 as reactiveOptions, a5 as reset, a6 as root, a7 as tag, a8 as touched, a9 as touched1, aa as unlink, ab as untracked, ac as unwrap, ad as withEffectContext, ae as zip } from './chunks/proxy-BtmPFjSr.esm.js';
+import './chunks/node-DuIduHw3.esm.js';
+export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, b as allocated, c as allocatedValues, d as arrayDiff, e as attend, f as cache, g as cached, h as callOnGC, i as chainPromise, j as debounce, k as deepWatch, l as deprecated, m as descriptor, n as destructor, o as forwardArray, p as getAt, q as isCached, r as lift, s as memoize, t as morph, u as organize, v as organized, w as profileInfo, x as resource, y as setAt, z as throttle, B as unreactive, C as watch, F as when } from './chunks/index-CAWVZL7P.esm.js';
+export { A as AZone, C as CompareSymbol, D as DecoratorError, I as IterableWeakMap, a as IterableWeakSet, R as ReactiveBase, b as ReactiveError, c as ReactiveErrorCode, Z as Zone, d as ZoneAggregator, e as ZoneHistory, f as addBatchCleanup, g as addUnreactiveProps, h as arrayEquals, i as assertUntracked, j as asyncHook, k as asyncHooks, l as asyncZone, m as atom, n as atomic, o as biDi, p as captioned, q as captured, r as caught, s as createFlavor, t as debugPreset, u as decorator, v as deepCompare, w as defer, x as devPreset, y as effect, z as effectAggregator, B as effectContext, E as flavorOptions, F as flavored, G as formatCleanupReason, H as getActivationLog, J as getActiveEffect, K as getState, L as hooks, M as inert, N as inheritCaption, O as isConstructor, P as isDev, Q as isNonReactive, S as isObject, T as isProd, U as isReactive, V as isReactiveBroken, W as isTest, X as legacyDecorator, Y as link, _ as markRaw, $ as markRawProps, a0 as mixin, a1 as modernDecorator, a2 as named, a3 as objectToProxy, a4 as onEffectThrow, a5 as onReactiveBroken, a6 as onReactiveReset, a7 as prodPreset, a8 as proxyToObject, a9 as reactive, aa as reactiveOptions, ab as readonlyReactive, ac as reset, ad as root, ae as shallowReactive, af as tag, ag as toRaw, ah as touched, ai as touched1, aj as unlink, ak as untracked, al as unwrap, am as withEffectContext, an as wrapInert, ao as zip } from './chunks/proxy-C2lnvvbx.esm.js';
 import 'node:async_hooks';
 //# sourceMappingURL=node.dev.esm.js.map

package/dist/node.esm.js

@@ -1,5 +1,5 @@
-import './chunks/node-NEZvVo4M.esm.js';
-export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, b as allocated, c as allocatedValues, d as arrayDiff, e as attend, f as cache, g as cached, h as callOnGC, i as chainPromise, j as debounce, k as deepWatch, l as deprecated, m as descriptor, n as destructor, o as forwardArray, p as getAt, q as isCached, r as lift, s as memoize, t as morph, u as organize, v as organized, w as profileInfo, x as resource, y as setAt, z as throttle, B as unreactive, C as watch, F as when } from './chunks/index-XsYTUhHx.esm.js';
-export { A as AZone, C as CompareSymbol, D as DecoratorError, I as IterableWeakMap, a as IterableWeakSet, R as ReactiveBase, b as ReactiveError, c as ReactiveErrorCode, Z as Zone, d as ZoneAggregator, e as ZoneHistory, f as addBatchCleanup, g as addUnreactiveProps, h as arrayEquals, i as assertUntracked, j as asyncHook, k as asyncHooks, l as asyncZone, m as atom, n as atomic, o as biDi, p as captioned, q as captured, r as caught, s as createFlavor, t as debugPreset, u as decorator, v as deepCompare, w as defer, x as devPreset, y as effect, z as effectAggregator, B as effectContext, E as flavorOptions, F as flavored, G as formatCleanupReason, H as getActivationLog, J as getActiveEffect, K as getState, L as hooks, M as inheritCaption, N as isConstructor, O as isDev, P as isNonReactive, Q as isObject, S as isProd, T as isReactive, U as isTest, V as legacyDecorator, W as link, X as mixin, Y as modernDecorator, _ as named, $ as objectToProxy, a0 as onEffectThrow, a1 as prodPreset, a2 as proxyToObject, a3 as reactive, a4 as reactiveOptions, a5 as reset, a6 as root, a7 as tag, a8 as touched, a9 as touched1, aa as unlink, ab as untracked, ac as unwrap, ad as withEffectContext, ae as zip } from './chunks/proxy-BtmPFjSr.esm.js';
+import './chunks/node-DuIduHw3.esm.js';
+export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, b as allocated, c as allocatedValues, d as arrayDiff, e as attend, f as cache, g as cached, h as callOnGC, i as chainPromise, j as debounce, k as deepWatch, l as deprecated, m as descriptor, n as destructor, o as forwardArray, p as getAt, q as isCached, r as lift, s as memoize, t as morph, u as organize, v as organized, w as profileInfo, x as resource, y as setAt, z as throttle, B as unreactive, C as watch, F as when } from './chunks/index-CAWVZL7P.esm.js';
+export { A as AZone, C as CompareSymbol, D as DecoratorError, I as IterableWeakMap, a as IterableWeakSet, R as ReactiveBase, b as ReactiveError, c as ReactiveErrorCode, Z as Zone, d as ZoneAggregator, e as ZoneHistory, f as addBatchCleanup, g as addUnreactiveProps, h as arrayEquals, i as assertUntracked, j as asyncHook, k as asyncHooks, l as asyncZone, m as atom, n as atomic, o as biDi, p as captioned, q as captured, r as caught, s as createFlavor, t as debugPreset, u as decorator, v as deepCompare, w as defer, x as devPreset, y as effect, z as effectAggregator, B as effectContext, E as flavorOptions, F as flavored, G as formatCleanupReason, H as getActivationLog, J as getActiveEffect, K as getState, L as hooks, M as inert, N as inheritCaption, O as isConstructor, P as isDev, Q as isNonReactive, S as isObject, T as isProd, U as isReactive, V as isReactiveBroken, W as isTest, X as legacyDecorator, Y as link, _ as markRaw, $ as markRawProps, a0 as mixin, a1 as modernDecorator, a2 as named, a3 as objectToProxy, a4 as onEffectThrow, a5 as onReactiveBroken, a6 as onReactiveReset, a7 as prodPreset, a8 as proxyToObject, a9 as reactive, aa as reactiveOptions, ab as readonlyReactive, ac as reset, ad as root, ae as shallowReactive, af as tag, ag as toRaw, ah as touched, ai as touched1, aj as unlink, ak as untracked, al as unwrap, am as withEffectContext, an as wrapInert, ao as zip } from './chunks/proxy-C2lnvvbx.esm.js';
 import 'node:async_hooks';
 //# sourceMappingURL=node.esm.js.map

package/dist/types.d.ts

@@ -278,6 +278,9 @@ declare class ReactiveError extends Error {
     get code(): ReactiveErrorCode | undefined;
     get cause(): any;
 }
+type SchedulerMode = 'raw' | 'ordered' | 'debug';
+type DeprecatedCycleHandlingMode = 'production' | 'development' | 'debug';
+type CycleHandlingMode = SchedulerMode | DeprecatedCycleHandlingMode;
 /**
  * Global options for the reactive system
  */
@@ -367,22 +370,33 @@ declare const options: {
      */
     onMemoizationDiscrepancy: ((cached: any, fresh: any, fn: Function, args: any[], cause: "calculation" | "comparison") => void) | 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: "production" | "development" | "debug";
+    scheduler: SchedulerMode;
+    /**
+     * @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(): SchedulerMode;
+    set cycleHandling(mode: CycleHandlingMode);
     /**
      * 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
@@ -455,18 +469,19 @@ declare const options: {
         logErrors: boolean;
         enableHistory: boolean;
         historySize: number;
-    } | null;
+    } | undefined;
 };
 /** Production preset: no introspection, heuristic cycle detection, minimal overhead */
 declare const prodPreset: Partial<typeof options>;
-/** Development preset (default): introspection on, early cycle detection, warnings */
+/** Development preset: introspection on, early cycle detection, warnings */
 declare const devPreset: Partial<typeof options>;
 /** Debug preset: full diagnostics, throws on violations, rich lineage capture */
 declare const debugPreset: Partial<typeof options>;
 declare const objectToProxy: WeakMap<object, object>;
 declare const proxyToObject: WeakMap<object, object>;
 declare function unwrap<T>(obj: T): T;
+declare const toRaw: typeof unwrap;
 declare function isReactive(obj: any): boolean;
 
-export { AZone as A, ReactiveError as R, ZoneAggregator as Z, ReactiveErrorCode as h, Zone as i, ZoneHistory as j, asyncZone as k, debugPreset as l, devPreset as m, formatCleanupReason as n, isReactive as o, objectToProxy as p, prodPreset as q, proxyToObject as r, options as s, unwrap as u };
-export type { CleanupReason as C, EffectTrigger as E, GetterWrapper as G, HistoryValue as H, PropTrigger as P, ScopedCallback as S, Evolution as a, EffectCleanup as b, EffectAccess as c, EffectCloser as d, State as e, CatchFunction as f, EffectOptions as g };
+export { AZone as A, ReactiveError as R, ZoneAggregator as Z, ReactiveErrorCode as i, Zone as k, ZoneHistory as l, asyncZone as m, debugPreset as n, devPreset as o, formatCleanupReason as p, isReactive as q, objectToProxy as r, prodPreset as s, proxyToObject as t, options as u, toRaw as v, unwrap as w };
+export type { CleanupReason as C, DeprecatedCycleHandlingMode as D, EffectTrigger as E, GetterWrapper as G, HistoryValue as H, PropTrigger as P, ScopedCallback as S, Evolution as a, EffectCleanup as b, EffectAccess as c, EffectCloser as d, State as e, CatchFunction as f, EffectOptions as g, CycleHandlingMode as h, SchedulerMode as j };

package/docs/ai/api-reference.md

@@ -185,7 +185,9 @@ export declare function deprecated(message?: string): Function;
 // buildReactivityGraph, getMutationHistory, getDependents, getDependencies, etc.
 
 export declare const reactiveOptions: {
-    cycleHandling: 'production' | 'development' | 'debug';
+    scheduler: 'raw' | 'ordered' | 'debug';
+    /** @deprecated Use scheduler instead. */
+    cycleHandling: 'raw' | 'ordered' | 'debug' | 'production' | 'development';
     introspection: unknown;
 };
 

package/docs/ai/manual.md

@@ -6,7 +6,7 @@
 
 ## 1. MENTAL MODEL
 
-Proxy-based **fine-grained reactivity** — changes propagate synchronously through dependency-tracked effects. No VDOM, no scheduler, no hooks.
+Proxy-based **fine-grained reactivity** — changes propagate synchronously through dependency-tracked effects. No VDOM, no async render scheduler, no hooks.
 
 | Concept | Mutts |
 |---------|-------|
@@ -202,6 +202,8 @@ const updateBoth = atomic((a, b) => { state.a = a; state.b = b }) // effects fir
 // Decorator: @atomic on methods
 ```
 
+`atomic()` wraps for later invocation but still executes synchronously when called. Internally it behaves like `batch(fn, { immediate: true })`, so nested atomic calls join the active batch by default instead of creating an implicit child batch.
+
 ### 3.7 atom() — Immediate atomic execution
 
 ```ts
@@ -209,6 +211,16 @@ atom(() => { state.a = 1; state.b = 2 }) // runs now, effects fire once
 // Unlike atomic() which wraps for later, atom() executes immediately
 ```
 
+The explicit batching API is now:
+
+```ts
+batch(fnOrEffects, { immediate?: boolean, contained?: boolean, caller?: EffectTrigger })
+```
+
+- `batch(fn)` joins the current batch when nested
+- `batch(fn, { immediate: true })` runs `fn` now and queues its consequences into the active batch
+- `batch(fn, { contained: true })` creates an isolated nested batch that flushes before returning
+
 ### 3.8 defer() — Avoid cycles
 
 ```ts
@@ -396,10 +408,10 @@ effect(() => {
 ```ts
 import { reactiveOptions } from 'mutts'
 
-// Cycle detection
-reactiveOptions.cycleHandling = 'development' // default: graph-based, throws
-reactiveOptions.cycleHandling = 'debug'       // full transitive closure, detailed paths
-reactiveOptions.cycleHandling = 'production'  // heuristic via maxTriggerPerBatch
+// Scheduler / cycle detection
+reactiveOptions.scheduler = 'ordered' // default: causal graph ordering, eager cycles
+reactiveOptions.scheduler = 'raw'     // fastest FIFO mode, heuristic cycles
+reactiveOptions.scheduler = 'debug'   // ordered mode plus heavier diagnostics
 
 // Lifecycle hooks (all wrapped via optionCall for safety)
 reactiveOptions.enter = (effect) => {}    // before effect runs

package/docs/reactive/advanced.md

@@ -45,7 +45,7 @@ The wrapped function preserves its signature (parameters and return value), and
 
 ### `atom()` - Immediate Atomic Execution
 
-While `atomic()` **wraps** a function for later calls, `atom()` **runs** a function immediately and atomically. It always executes right away, even inside a nested batch.
+While `atomic()` **wraps** a function for later calls, `atom()` **runs** a function immediately and atomically. It uses `batch(fn, { immediate: true })`, so it executes right away even inside an existing batch while still contributing its triggered effects to the active transaction.
 
 ```typescript
 import { atom, reactive, effect } from 'mutts'
@@ -80,6 +80,122 @@ const update = atomic((a, b) => { state.a = a; state.b = b })
 update(1, 2)  // runs when called
 ```
 
+### `batch()` - Explicit Batch Control
+
+`batch()` now uses an options object:
+
+```typescript
+batch(effectOrEffects, {
+  immediate?: boolean,
+  contained?: boolean,
+  caller?: EffectTrigger,
+})
+```
+
+The main modes are:
+
+- default nested behavior: if a batch is already active, `batch(fn)` joins that existing batch instead of creating an implicit child batch
+- `immediate: true`: execute the provided function now, but keep all triggered effects inside the current batch
+- `contained: true`: force a fresh local batch that drains before returning, even when called from inside another batch
+- `caller`: advanced internal override for causal chaining; most user code should omit it
+
+```typescript
+import { batch, effect, reactive } from 'mutts'
+
+const state = reactive({ a: 0, b: 0 })
+
+effect(() => {
+  console.log(state.a, state.b)
+})
+
+batch(() => {
+  state.a = 1
+  state.b = 2
+})
+
+batch(() => {
+  state.a = 3
+}, { immediate: true })
+
+batch(() => {
+  state.b = 4
+}, { immediate: true, contained: true })
+```
+
+#### Nested semantics
+
+Nested batching is no longer implicitly contained.
+
+- `batch(fn)` inside another batch joins the parent batch
+- `batch(fn, { immediate: true })` runs `fn` now and queues its consequences into the parent batch
+- `batch(fn, { contained: true })` creates an isolated sub-batch and flushes it before returning
+
+Use `contained: true` only when you explicitly need sub-transaction behavior.
+
+### Effect Ordering with Phase Tokens
+
+Effects are usually ordered by their data dependencies: an effect that reads a reactive property is eligible to re-run after another effect changes that property. Mutts uses those causal links as an execution graph by default. The `reactiveOptions.scheduler` option controls how much of that graph is maintained for scheduling and diagnostics:
+
+- `scheduler: 'ordered'` (default): effects that are already queued together are processed in dependency order when possible, so consequences run after the effects that caused them. Parent effects also run before their queued child effects, which lets parent cleanup stop stale children before they re-run.
+- `scheduler: 'debug'`: ordered scheduling plus heavier diagnostics for investigation.
+- `scheduler: 'raw'`: graph maintenance is disabled for speed, and already-queued effects use FIFO ordering with heuristic cycle protection.
+
+When you need to make a render phase or other side-effect phase explicit, use an ordinary reactive "phase token": one effect advances the token, and later effects read it.
+
+```typescript
+import { effect, reactive } from 'mutts'
+
+const phase = reactive({
+  measured: 0,
+  positioned: 0,
+})
+
+effect`render:measure`(() => {
+  measureDom()
+  phase.measured++
+})
+
+effect`render:position`(() => {
+  phase.measured
+  positionDom()
+  phase.positioned++
+})
+
+effect`render:paint`(() => {
+  phase.positioned
+  paintDom()
+})
+```
+
+This is sometimes called a beacon, barrier, or phase marker in application code, but it does not need a special primitive: the token is just reactive state. The important part is that the dependency is visible. The second effect does not merely rely on incidental registration order; it declares "I am downstream of `phase.measured`."
+
+This phase-token pattern also works in `scheduler: 'raw'` when the token is the downstream effect's actual scheduling dependency: the producer runs, advances the token, and that write queues the consumer afterward. That ordering comes from normal queuing, not from the dependency graph. What raw mode does not do is topologically reorder two effects that were already queued independently by some other write.
+
+If the downstream effect should be scheduled only by the phase token, and not directly by the raw state used by the producer, read the raw payload untracked:
+
+```typescript
+import { effect, reactive, untracked } from 'mutts'
+
+const state = reactive({ input: '' })
+const phase = reactive({ rendered: 0 })
+
+effect`render:first-pass`(() => {
+  state.input
+  renderFirstPass()
+  phase.rendered++
+})
+
+effect`render:second-pass`(() => {
+  phase.rendered
+
+  untracked`render:second-pass:payload`(() => {
+    renderSecondPass(state.input)
+  })
+})
+```
+
+Use `defer()` instead when the desired ordering is "after the whole current batch has settled" rather than "after this producer effect advances this phase."
+
 ### `addBatchCleanup()` / `defer()` - Deferring Work to Avoid Cycles
 
 When an effect needs to perform an action that would modify state the effect depends on, this can create a reactive cycle. The `addBatchCleanup` function (also exported as `defer` for semantic clarity) allows you to defer such work until after the current batch of effects completes.
@@ -238,7 +354,7 @@ addBatchCleanup(() => {
 
 **Nested Batches:**
 
-Callbacks added in nested batches are collected and run when the **outermost batch** completes:
+Callbacks added in inherited nested batches are collected and run when the **outermost batch** completes:
 
 ```typescript
 effect(() => {
@@ -252,7 +368,15 @@ effect(() => {
 // Output:
 // Outer deferred
 // Inner deferred
-// (Both run after outer batch completes)
+// (Both run after outer batch completes because `atomic()` joins the active batch)
+```
+
+If you need deferred callbacks to flush within an isolated nested batch, use an explicitly contained batch:
+
+```typescript
+batch(() => {
+  addBatchCleanup(() => console.log('Contained deferred'))
+}, { contained: true })
 ```
 
 **Error Handling:**
@@ -935,7 +1059,7 @@ When you replace a reactive object with another object that shares the same prot
 
 - Watchers attached to the container are *not* re-fired if the container's prototype did not change (this avoids unnecessary parent effect re-runs).
 - Watchers attached to nested properties are re-evaluated only for keys that actually changed (added, removed, or whose values differ).
-- For arrays, the behaviour stays index-oriented: replacing an element at index `i` fires a touch for that index (and `length` if needed) rather than diffing the element recursively. This preserves reorder detection.
+- For arrays, the behavior stays index-oriented: replacing an element at index `i` fires a touch for that index (and `length` if needed) rather than diffing the element recursively. This preserves reorder detection.
 - Prototype chain properties are compared when both objects have prototype chains, ensuring changes to prototype-level properties are detected.
 
 **Integration with Prototype Chains:**
@@ -981,7 +1105,7 @@ expect(titleWatcher).toHaveBeenCalledTimes(2)
 expect(viewsWatcher).toHaveBeenCalledTimes(2)
 ```
 
-This behaviour keeps container-level watchers stable while still delivering fine-grained updates to nested effects—ideal when you replace data structures with freshly fetched objects that share the same prototype.
+This behavior keeps container-level watchers stable while still delivering fine-grained updates to nested effects—ideal when you replace data structures with freshly fetched objects that share the same prototype.
 
 ### Origin Filtering
 
@@ -1243,17 +1367,36 @@ state.items = fetchedItems // deep touch diffs old vs new per-index — no lift
 ```typescript
 import { morph } from 'mutts'
 
+// Arrays: (item, position, access?) => O
 function morph<I, O>(
   source: readonly I[] | (() => readonly I[]),
-  fn: (arg: I) => O,
+  fn: (arg: I, position: { index: number }, access?: EffectAccess) => O,
   options?: { pure?: boolean | ((i: I) => boolean) }
 ): O[]
+
+// Maps: (value, key, access?) => O  
+function morph<K, V, O>(
+  source: Map<K, V>,
+  fn: (arg: V, key: K, access?: EffectAccess) => O,
+  options?: { pure?: boolean | ((i: V) => boolean) }
+): Map<K, O>
+
+// Records: (value, key, access?) => O
+function morph<S extends Record<PropertyKey, any>, O>(
+  source: S,
+  fn: (arg: S[keyof S], key: keyof S, access?: EffectAccess) => O,
+  options?: { pure?: boolean | ((i: S[keyof S]) => boolean) }
+): { [K in keyof S]: O }
 ```
 
 **Parameters**
 
-- `source`: a reactive array or a function returning one. Array mutations are tracked via `arrayDiff`.
-- `fn`: mapping callback. In the default (non-pure) mode, each element's computation runs inside its own effect, so reactive reads inside `fn` are tracked and will invalidate that element's cache when they change.
+- `source`: a reactive array, Map, or record, or a function returning one. Array mutations are tracked via `arrayDiff`.
+- `fn`: mapping callback. Signature varies by source type:
+  - Arrays: `(item, position, access?) => O` where `position.index` is the current index
+  - Maps: `(value, key, access?) => O` 
+  - Records: `(value, key, access?) => O`
+  In the default (non-pure) mode, each element's computation runs inside its own effect, so reactive reads inside `fn` are tracked and will invalidate that element's cache when they change.
 - `options.pure`: controls per-item effect creation. `true` skips effects for all items (same as `morph.pure`). A **predicate function** `(i: I) => boolean` decides per-item: return `true` to skip the effect (pure), `false` to create one (reactive). The predicate receives the input item and is evaluated once per cache slot on first access.
 
 **Behaviour**
@@ -1261,6 +1404,7 @@ function morph<I, O>(
 - **Lazy**: elements are only computed when accessed (e.g. `result[0]`). Unaccessed indices remain `undefined` in the cache.
 - **Identity stable**: the returned reactive array proxy is the same object across source mutations. Only affected indices are invalidated.
 - **Per-item effects** (default): each accessed element gets its own effect. If `fn` reads reactive values beyond its argument, changes to those values invalidate and recompute only the affected elements.
+- **Reactive position**: For arrays, the `position` object is stable per item and its `index` updates reactively when items move due to shifts/reorders.
 - **Cleanup**: the returned array is `cleanedBy` the internal morph effect. When the parent effect is disposed, the morph effect and all per-item effects are cleaned up.
 
 **Basic usage**
@@ -1281,6 +1425,21 @@ console.log(upper[3]) // "DAVE"
 items.splice(1, 1) // Remove 'bob' — indices shift, cache invalidated for affected positions
 ```
 
+**Using position.index**
+
+```typescript
+const items = reactive(['a', 'b', 'c'])
+const indexed = morph(items, (item, position) => `${item}@${position.index}`)
+
+console.log(indexed[0]) // "a@0"
+console.log(indexed[1]) // "b@1"
+
+items.unshift('x') // Insert at beginning
+console.log(indexed[0]) // "x@0"  
+console.log(indexed[1]) // "a@1" — position.index updated reactively
+console.log(indexed[2]) // "b@2"
+```
+
 **With reactive callback dependencies**
 
 ```typescript
@@ -1491,7 +1650,7 @@ For a full guide on debugging, including cycle detection and memoization discrep
 
 ### Quick Summary
 
-- **Cycle Detection**: Automatically catch circular dependencies via `reactiveOptions.cycleHandling`. Note: Instant mathematical detection requires choosing `'development'` or `'debug'` mode.
-- **Production Mode**: The default `reactiveOptions.cycleHandling` is set to `'production'`, providing maximum performance in high-frequency update scenarios by disabling graph maintenance.
+- **Cycle Detection**: Automatically catch circular dependencies via `reactiveOptions.scheduler`. Note: Instant mathematical detection requires choosing `'ordered'` or `'debug'` mode.
+- **Ordered Mode**: The default `reactiveOptions.scheduler` is set to `'ordered'`, preserving causal ordering and parent/child effect lifecycle ordering.
 - **Memoization Discrepancy**: Detect "missing dependencies" by running computations twice during development using `reactiveOptions.onMemoizationDiscrepancy`.
 - **Global Hooks**: Use `reactiveOptions.touched`, `enter`, and `leave` to observe system activity.