mutts 1.0.13 → 1.0.15

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-CKuro-Uk.cjs');
+var index = require('./chunks/index-Dtj2qZ0d.cjs');
+var effects = require('./chunks/effects-oUauWxxl.cjs');
 require('node:async_hooks');
 
 
@@ -40,76 +40,86 @@ exports.throttle = index.throttle;
 exports.unreactive = index.unreactive;
 exports.watch = index.watch;
 exports.when = index.when;
-exports.AZone = proxy.AZone;
-exports.CompareSymbol = proxy.CompareSymbol;
-exports.DecoratorError = proxy.DecoratorError;
-exports.IterableWeakMap = proxy.IterableWeakMap;
-exports.IterableWeakSet = proxy.IterableWeakSet;
-exports.ReactiveBase = proxy.ReactiveBase;
-exports.ReactiveError = proxy.ReactiveError;
+exports.AZone = effects.AZone;
+exports.CompareSymbol = effects.CompareSymbol;
+exports.DecoratorError = effects.DecoratorError;
+exports.IterableWeakMap = effects.IterableWeakMap;
+exports.IterableWeakSet = effects.IterableWeakSet;
+exports.ReactiveBase = effects.ReactiveBase;
+exports.ReactiveError = effects.ReactiveError;
 Object.defineProperty(exports, "ReactiveErrorCode", {
 	enumerable: true,
-	get: function () { return proxy.ReactiveErrorCode; }
+	get: function () { return effects.ReactiveErrorCode; }
 });
-exports.Zone = proxy.Zone;
-exports.ZoneAggregator = proxy.ZoneAggregator;
-exports.ZoneHistory = proxy.ZoneHistory;
-exports.addBatchCleanup = proxy.addBatchCleanup;
-exports.addUnreactiveProps = proxy.addUnreactiveProps;
-exports.arrayEquals = proxy.arrayEquals;
-exports.assertUntracked = proxy.assertUntracked;
-exports.asyncHook = proxy.asyncHook;
-exports.asyncHooks = proxy.asyncHooks;
-exports.asyncZone = proxy.asyncZone;
-exports.atom = proxy.atom;
-exports.atomic = proxy.atomic;
-exports.biDi = proxy.biDi;
-exports.captioned = proxy.captioned;
-exports.captured = proxy.captured;
-exports.caught = proxy.caught;
-exports.createFlavor = proxy.createFlavor;
-exports.debugPreset = proxy.debugPreset;
-exports.decorator = proxy.decorator;
-exports.deepCompare = proxy.deepCompare;
-exports.defer = proxy.defer;
-exports.devPreset = proxy.devPreset;
-exports.effect = proxy.effect;
-exports.effectAggregator = proxy.effectAggregator;
-exports.effectContext = proxy.effectContext;
-exports.flavorOptions = proxy.flavorOptions;
-exports.flavored = proxy.flavored;
-exports.formatCleanupReason = proxy.formatCleanupReason;
-exports.getActivationLog = proxy.getActivationLog;
-exports.getActiveEffect = proxy.getActiveEffect;
-exports.getState = proxy.getState;
-exports.hooks = proxy.hooks;
-exports.inheritCaption = proxy.inheritCaption;
-exports.isConstructor = proxy.isConstructor;
-exports.isDev = proxy.isDev;
-exports.isNonReactive = proxy.isNonReactive;
-exports.isObject = proxy.isObject;
-exports.isProd = proxy.isProd;
-exports.isReactive = proxy.isReactive;
-exports.isTest = proxy.isTest;
-exports.legacyDecorator = proxy.legacyDecorator;
-exports.link = proxy.link;
-exports.mixin = proxy.mixin;
-exports.modernDecorator = proxy.modernDecorator;
-exports.named = proxy.named;
-exports.objectToProxy = proxy.objectToProxy;
-exports.onEffectThrow = proxy.onEffectThrow;
-exports.prodPreset = proxy.prodPreset;
-exports.proxyToObject = proxy.proxyToObject;
-exports.reactive = proxy.reactive;
-exports.reactiveOptions = proxy.options;
-exports.reset = proxy.reset;
-exports.root = proxy.root;
-exports.tag = proxy.tag;
-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.zip = proxy.zip;
+exports.Zone = effects.Zone;
+exports.ZoneAggregator = effects.ZoneAggregator;
+exports.ZoneHistory = effects.ZoneHistory;
+exports.addBatchCleanup = effects.addBatchCleanup;
+exports.addUnreactiveProps = effects.addUnreactiveProps;
+exports.arrayEquals = effects.arrayEquals;
+exports.assertUntracked = effects.assertUntracked;
+exports.asyncHook = effects.asyncHook;
+exports.asyncHooks = effects.asyncHooks;
+exports.asyncZone = effects.asyncZone;
+exports.atom = effects.atom;
+exports.atomic = effects.atomic;
+exports.biDi = effects.biDi;
+exports.captioned = effects.captioned;
+exports.captured = effects.captured;
+exports.caught = effects.caught;
+exports.createFlavor = effects.createFlavor;
+exports.debugPreset = effects.debugPreset;
+exports.decorator = effects.decorator;
+exports.deepCompare = effects.deepCompare;
+exports.defer = effects.defer;
+exports.devPreset = effects.devPreset;
+exports.effect = effects.effect;
+exports.effectAggregator = effects.effectAggregator;
+exports.effectContext = effects.effectContext;
+exports.flavorOptions = effects.flavorOptions;
+exports.flavored = effects.flavored;
+exports.formatCleanupReason = effects.formatCleanupReason;
+exports.getActivationLog = effects.getActivationLog;
+exports.getActiveEffect = effects.getActiveEffect;
+exports.getState = effects.getState;
+exports.hooks = effects.hooks;
+exports.inert = effects.inert;
+exports.inheritCaption = effects.inheritCaption;
+exports.isConstructor = effects.isConstructor;
+exports.isDev = effects.isDev;
+exports.isNonReactive = effects.isNonReactive;
+exports.isObject = effects.isObject;
+exports.isProd = effects.isProd;
+exports.isReactive = effects.isReactive;
+exports.isReactiveBroken = effects.isReactiveBroken;
+exports.isTest = effects.isTest;
+exports.legacyDecorator = effects.legacyDecorator;
+exports.link = effects.link;
+exports.markRaw = effects.markRaw;
+exports.markRawProps = effects.markRawProps;
+exports.mixin = effects.mixin;
+exports.modernDecorator = effects.modernDecorator;
+exports.named = effects.named;
+exports.objectToProxy = effects.objectToProxy;
+exports.onEffectThrow = effects.onEffectThrow;
+exports.onReactiveBroken = effects.onReactiveBroken;
+exports.onReactiveReset = effects.onReactiveReset;
+exports.prodPreset = effects.prodPreset;
+exports.proxyToObject = effects.proxyToObject;
+exports.reactive = effects.reactive;
+exports.reactiveOptions = effects.options;
+exports.readonlyReactive = effects.readonlyReactive;
+exports.reset = effects.reset;
+exports.root = effects.root;
+exports.shallowReactive = effects.shallowReactive;
+exports.tag = effects.tag;
+exports.toRaw = effects.toRaw;
+exports.touched = effects.touched;
+exports.touched1 = effects.touched1;
+exports.unlink = effects.unlink;
+exports.untracked = effects.untracked;
+exports.unwrap = effects.unwrap;
+exports.withEffectContext = effects.withEffectContext;
+exports.wrapInert = effects.wrapInert;
+exports.zip = effects.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-CKuro-Uk.cjs');
+var index = require('./chunks/index-Dtj2qZ0d.cjs');
+var effects = require('./chunks/effects-oUauWxxl.cjs');
 require('node:async_hooks');
 
 
@@ -41,76 +41,86 @@ exports.throttle = index.throttle;
 exports.unreactive = index.unreactive;
 exports.watch = index.watch;
 exports.when = index.when;
-exports.AZone = proxy.AZone;
-exports.CompareSymbol = proxy.CompareSymbol;
-exports.DecoratorError = proxy.DecoratorError;
-exports.IterableWeakMap = proxy.IterableWeakMap;
-exports.IterableWeakSet = proxy.IterableWeakSet;
-exports.ReactiveBase = proxy.ReactiveBase;
-exports.ReactiveError = proxy.ReactiveError;
+exports.AZone = effects.AZone;
+exports.CompareSymbol = effects.CompareSymbol;
+exports.DecoratorError = effects.DecoratorError;
+exports.IterableWeakMap = effects.IterableWeakMap;
+exports.IterableWeakSet = effects.IterableWeakSet;
+exports.ReactiveBase = effects.ReactiveBase;
+exports.ReactiveError = effects.ReactiveError;
 Object.defineProperty(exports, "ReactiveErrorCode", {
 	enumerable: true,
-	get: function () { return proxy.ReactiveErrorCode; }
+	get: function () { return effects.ReactiveErrorCode; }
 });
-exports.Zone = proxy.Zone;
-exports.ZoneAggregator = proxy.ZoneAggregator;
-exports.ZoneHistory = proxy.ZoneHistory;
-exports.addBatchCleanup = proxy.addBatchCleanup;
-exports.addUnreactiveProps = proxy.addUnreactiveProps;
-exports.arrayEquals = proxy.arrayEquals;
-exports.assertUntracked = proxy.assertUntracked;
-exports.asyncHook = proxy.asyncHook;
-exports.asyncHooks = proxy.asyncHooks;
-exports.asyncZone = proxy.asyncZone;
-exports.atom = proxy.atom;
-exports.atomic = proxy.atomic;
-exports.biDi = proxy.biDi;
-exports.captioned = proxy.captioned;
-exports.captured = proxy.captured;
-exports.caught = proxy.caught;
-exports.createFlavor = proxy.createFlavor;
-exports.debugPreset = proxy.debugPreset;
-exports.decorator = proxy.decorator;
-exports.deepCompare = proxy.deepCompare;
-exports.defer = proxy.defer;
-exports.devPreset = proxy.devPreset;
-exports.effect = proxy.effect;
-exports.effectAggregator = proxy.effectAggregator;
-exports.effectContext = proxy.effectContext;
-exports.flavorOptions = proxy.flavorOptions;
-exports.flavored = proxy.flavored;
-exports.formatCleanupReason = proxy.formatCleanupReason;
-exports.getActivationLog = proxy.getActivationLog;
-exports.getActiveEffect = proxy.getActiveEffect;
-exports.getState = proxy.getState;
-exports.hooks = proxy.hooks;
-exports.inheritCaption = proxy.inheritCaption;
-exports.isConstructor = proxy.isConstructor;
-exports.isDev = proxy.isDev;
-exports.isNonReactive = proxy.isNonReactive;
-exports.isObject = proxy.isObject;
-exports.isProd = proxy.isProd;
-exports.isReactive = proxy.isReactive;
-exports.isTest = proxy.isTest;
-exports.legacyDecorator = proxy.legacyDecorator;
-exports.link = proxy.link;
-exports.mixin = proxy.mixin;
-exports.modernDecorator = proxy.modernDecorator;
-exports.named = proxy.named;
-exports.objectToProxy = proxy.objectToProxy;
-exports.onEffectThrow = proxy.onEffectThrow;
-exports.prodPreset = proxy.prodPreset;
-exports.proxyToObject = proxy.proxyToObject;
-exports.reactive = proxy.reactive;
-exports.reactiveOptions = proxy.options;
-exports.reset = proxy.reset;
-exports.root = proxy.root;
-exports.tag = proxy.tag;
-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.zip = proxy.zip;
+exports.Zone = effects.Zone;
+exports.ZoneAggregator = effects.ZoneAggregator;
+exports.ZoneHistory = effects.ZoneHistory;
+exports.addBatchCleanup = effects.addBatchCleanup;
+exports.addUnreactiveProps = effects.addUnreactiveProps;
+exports.arrayEquals = effects.arrayEquals;
+exports.assertUntracked = effects.assertUntracked;
+exports.asyncHook = effects.asyncHook;
+exports.asyncHooks = effects.asyncHooks;
+exports.asyncZone = effects.asyncZone;
+exports.atom = effects.atom;
+exports.atomic = effects.atomic;
+exports.biDi = effects.biDi;
+exports.captioned = effects.captioned;
+exports.captured = effects.captured;
+exports.caught = effects.caught;
+exports.createFlavor = effects.createFlavor;
+exports.debugPreset = effects.debugPreset;
+exports.decorator = effects.decorator;
+exports.deepCompare = effects.deepCompare;
+exports.defer = effects.defer;
+exports.devPreset = effects.devPreset;
+exports.effect = effects.effect;
+exports.effectAggregator = effects.effectAggregator;
+exports.effectContext = effects.effectContext;
+exports.flavorOptions = effects.flavorOptions;
+exports.flavored = effects.flavored;
+exports.formatCleanupReason = effects.formatCleanupReason;
+exports.getActivationLog = effects.getActivationLog;
+exports.getActiveEffect = effects.getActiveEffect;
+exports.getState = effects.getState;
+exports.hooks = effects.hooks;
+exports.inert = effects.inert;
+exports.inheritCaption = effects.inheritCaption;
+exports.isConstructor = effects.isConstructor;
+exports.isDev = effects.isDev;
+exports.isNonReactive = effects.isNonReactive;
+exports.isObject = effects.isObject;
+exports.isProd = effects.isProd;
+exports.isReactive = effects.isReactive;
+exports.isReactiveBroken = effects.isReactiveBroken;
+exports.isTest = effects.isTest;
+exports.legacyDecorator = effects.legacyDecorator;
+exports.link = effects.link;
+exports.markRaw = effects.markRaw;
+exports.markRawProps = effects.markRawProps;
+exports.mixin = effects.mixin;
+exports.modernDecorator = effects.modernDecorator;
+exports.named = effects.named;
+exports.objectToProxy = effects.objectToProxy;
+exports.onEffectThrow = effects.onEffectThrow;
+exports.onReactiveBroken = effects.onReactiveBroken;
+exports.onReactiveReset = effects.onReactiveReset;
+exports.prodPreset = effects.prodPreset;
+exports.proxyToObject = effects.proxyToObject;
+exports.reactive = effects.reactive;
+exports.reactiveOptions = effects.options;
+exports.readonlyReactive = effects.readonlyReactive;
+exports.reset = effects.reset;
+exports.root = effects.root;
+exports.shallowReactive = effects.shallowReactive;
+exports.tag = effects.tag;
+exports.toRaw = effects.toRaw;
+exports.touched = effects.touched;
+exports.touched1 = effects.touched1;
+exports.unlink = effects.unlink;
+exports.untracked = effects.untracked;
+exports.unwrap = effects.unwrap;
+exports.withEffectContext = effects.withEffectContext;
+exports.wrapInert = effects.wrapInert;
+exports.zip = effects.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-sQtns7M-.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-YGpb1te7.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/effects-CPjf6gNA.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-sQtns7M-.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-YGpb1te7.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/effects-CPjf6gNA.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