mutts 1.0.10 → 1.0.12

package/dist/node.cjs

@@ -1,51 +1,46 @@
 'use strict';
 
-require('./chunks/async-node-3PrbVAbB.cjs');
-var browser = require('./browser.cjs');
-var proxy = require('./chunks/proxy-Dtg-bJ3T.cjs');
-var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
+require('./chunks/node-Dd0esp5F.cjs');
+var index = require('./chunks/index-yK0HVxHv.cjs');
+var proxy = require('./chunks/proxy-BvM4yewA.cjs');
 require('node:async_hooks');
-require('./chunks/async-browser-BU_IfxYD.cjs');
 
 
 
-exports.ArrayReadForward = browser.ArrayReadForward;
-exports.Destroyable = browser.Destroyable;
-exports.DestructionError = browser.DestructionError;
-exports.Eventful = browser.Eventful;
-exports.Indexable = browser.Indexable;
-exports.Register = browser.Register;
-exports.allocated = browser.allocated;
-exports.allocatedValues = browser.allocatedValues;
-exports.arrayDiff = browser.arrayDiff;
-exports.attend = browser.attend;
-exports.cache = browser.cache;
-exports.cached = browser.cached;
-exports.callOnGC = browser.callOnGC;
-exports.chainPromise = browser.chainPromise;
-exports.debounce = browser.debounce;
-exports.deepWatch = browser.deepWatch;
-exports.deprecated = browser.deprecated;
-exports.descriptor = browser.descriptor;
-exports.destructor = browser.destructor;
-exports.forwardArray = browser.forwardArray;
-exports.getAt = browser.getAt;
-exports.isCached = browser.isCached;
-exports.lift = browser.lift;
-exports.memoize = browser.memoize;
-exports.morph = browser.morph;
-exports.organize = browser.organize;
-exports.organized = browser.organized;
-exports.profileInfo = browser.profileInfo;
-exports.project = browser.morph;
-exports.register = browser.register;
-exports.resource = browser.resource;
-exports.scan = browser.scan;
-exports.setAt = browser.setAt;
-exports.throttle = browser.throttle;
-exports.unreactive = browser.unreactive;
-exports.watch = browser.watch;
-exports.when = browser.when;
+exports.ArrayReadForward = index.ArrayReadForward;
+exports.Destroyable = index.Destroyable;
+exports.DestructionError = index.DestructionError;
+exports.Eventful = index.Eventful;
+exports.Indexable = index.Indexable;
+exports.allocated = index.allocated;
+exports.allocatedValues = index.allocatedValues;
+exports.arrayDiff = index.arrayDiff;
+exports.attend = index.attend;
+exports.cache = index.cache;
+exports.cached = index.cached;
+exports.callOnGC = index.callOnGC;
+exports.chainPromise = index.chainPromise;
+exports.debounce = index.debounce;
+exports.deepWatch = index.deepWatch;
+exports.deprecated = index.deprecated;
+exports.descriptor = index.descriptor;
+exports.destructor = index.destructor;
+exports.forwardArray = index.forwardArray;
+exports.getAt = index.getAt;
+exports.isCached = index.isCached;
+exports.lift = index.lift;
+exports.memoize = index.memoize;
+exports.morph = index.morph;
+exports.organize = index.organize;
+exports.organized = index.organized;
+exports.profileInfo = index.profileInfo;
+exports.project = index.morph;
+exports.resource = index.resource;
+exports.setAt = index.setAt;
+exports.throttle = index.throttle;
+exports.unreactive = index.unreactive;
+exports.watch = index.watch;
+exports.when = index.when;
 exports.AZone = proxy.AZone;
 exports.DecoratorError = proxy.DecoratorError;
 exports.IterableWeakMap = proxy.IterableWeakMap;
@@ -60,18 +55,23 @@ 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.captured = proxy.captured;
 exports.caught = proxy.caught;
-exports.cleanedBy = proxy.cleanedBy;
-exports.cleanup = proxy.cleanup;
 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.flavorOptions = proxy.flavorOptions;
@@ -80,30 +80,32 @@ exports.formatCleanupReason = proxy.formatCleanupReason;
 exports.getActivationLog = proxy.getActivationLog;
 exports.getActiveEffect = proxy.getActiveEffect;
 exports.getState = proxy.getState;
-exports.immutables = proxy.immutables;
+exports.hooks = proxy.hooks;
 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.stopped = proxy.stopped;
 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.zip = proxy.zip;
-exports.asyncHook = asyncCore.asyncHook;
-exports.asyncHooks = asyncCore.asyncHooks;
-exports.hooks = asyncCore.hooks;
 //# 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, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, Eventful, EventsBase, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactiveBase, Register, Resource, Restorer, ScanResult, addBatchCleanup, allocated, allocatedValues, arrayDiff, arrayEquals, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, caught, chainPromise, cleanedBy, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, immutables, isCached, isConstructor, isNonReactive, isObject, legacyDecorator, lift, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, morph as project, reactive, register, reset, resource, root, scan, setAt, tag, throttle, touched, touched1, unreactive, untracked, watch, when, zip } from './index.js';
-export { A as AZone, h as CleanupReason, e as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, F as FunctionWrapper, P as PropTrigger, R as ReactiveError, i as ReactiveErrorCode, S as ScopedCallback, j as Zone, Z as ZoneAggregator, k as ZoneHistory, l as asyncZone, c as cleanup, m as formatCleanupReason, n as isReactive, o as objectToProxy, p as proxyToObject, q as reactiveOptions, s as stopped, u as unwrap } from './types-W5vD6m2n.js';
+export { ArrayDiffResult, ArrayReadForward, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, 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, captured, caught, chainPromise, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, isCached, isConstructor, isDev, isNonReactive, isObject, isProd, isTest, legacyDecorator, lift, link, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, morph as project, reactive, reset, resource, root, setAt, tag, throttle, touched, touched1, unlink, unreactive, untracked, watch, when, zip } from './index.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-Bx2PhORg.js';

package/dist/node.dev.cjs

@@ -1,52 +1,47 @@
 'use strict';
 
 require('./debug.cjs');
-require('./chunks/async-node-3PrbVAbB.cjs');
-var browser = require('./browser.cjs');
-var proxy = require('./chunks/proxy-Dtg-bJ3T.cjs');
-var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
+require('./chunks/node-Dd0esp5F.cjs');
+var index = require('./chunks/index-yK0HVxHv.cjs');
+var proxy = require('./chunks/proxy-BvM4yewA.cjs');
 require('node:async_hooks');
-require('./chunks/async-browser-BU_IfxYD.cjs');
 
 
 
-exports.ArrayReadForward = browser.ArrayReadForward;
-exports.Destroyable = browser.Destroyable;
-exports.DestructionError = browser.DestructionError;
-exports.Eventful = browser.Eventful;
-exports.Indexable = browser.Indexable;
-exports.Register = browser.Register;
-exports.allocated = browser.allocated;
-exports.allocatedValues = browser.allocatedValues;
-exports.arrayDiff = browser.arrayDiff;
-exports.attend = browser.attend;
-exports.cache = browser.cache;
-exports.cached = browser.cached;
-exports.callOnGC = browser.callOnGC;
-exports.chainPromise = browser.chainPromise;
-exports.debounce = browser.debounce;
-exports.deepWatch = browser.deepWatch;
-exports.deprecated = browser.deprecated;
-exports.descriptor = browser.descriptor;
-exports.destructor = browser.destructor;
-exports.forwardArray = browser.forwardArray;
-exports.getAt = browser.getAt;
-exports.isCached = browser.isCached;
-exports.lift = browser.lift;
-exports.memoize = browser.memoize;
-exports.morph = browser.morph;
-exports.organize = browser.organize;
-exports.organized = browser.organized;
-exports.profileInfo = browser.profileInfo;
-exports.project = browser.morph;
-exports.register = browser.register;
-exports.resource = browser.resource;
-exports.scan = browser.scan;
-exports.setAt = browser.setAt;
-exports.throttle = browser.throttle;
-exports.unreactive = browser.unreactive;
-exports.watch = browser.watch;
-exports.when = browser.when;
+exports.ArrayReadForward = index.ArrayReadForward;
+exports.Destroyable = index.Destroyable;
+exports.DestructionError = index.DestructionError;
+exports.Eventful = index.Eventful;
+exports.Indexable = index.Indexable;
+exports.allocated = index.allocated;
+exports.allocatedValues = index.allocatedValues;
+exports.arrayDiff = index.arrayDiff;
+exports.attend = index.attend;
+exports.cache = index.cache;
+exports.cached = index.cached;
+exports.callOnGC = index.callOnGC;
+exports.chainPromise = index.chainPromise;
+exports.debounce = index.debounce;
+exports.deepWatch = index.deepWatch;
+exports.deprecated = index.deprecated;
+exports.descriptor = index.descriptor;
+exports.destructor = index.destructor;
+exports.forwardArray = index.forwardArray;
+exports.getAt = index.getAt;
+exports.isCached = index.isCached;
+exports.lift = index.lift;
+exports.memoize = index.memoize;
+exports.morph = index.morph;
+exports.organize = index.organize;
+exports.organized = index.organized;
+exports.profileInfo = index.profileInfo;
+exports.project = index.morph;
+exports.resource = index.resource;
+exports.setAt = index.setAt;
+exports.throttle = index.throttle;
+exports.unreactive = index.unreactive;
+exports.watch = index.watch;
+exports.when = index.when;
 exports.AZone = proxy.AZone;
 exports.DecoratorError = proxy.DecoratorError;
 exports.IterableWeakMap = proxy.IterableWeakMap;
@@ -61,18 +56,23 @@ 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.captured = proxy.captured;
 exports.caught = proxy.caught;
-exports.cleanedBy = proxy.cleanedBy;
-exports.cleanup = proxy.cleanup;
 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.flavorOptions = proxy.flavorOptions;
@@ -81,30 +81,32 @@ exports.formatCleanupReason = proxy.formatCleanupReason;
 exports.getActivationLog = proxy.getActivationLog;
 exports.getActiveEffect = proxy.getActiveEffect;
 exports.getState = proxy.getState;
-exports.immutables = proxy.immutables;
+exports.hooks = proxy.hooks;
 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.stopped = proxy.stopped;
 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.zip = proxy.zip;
-exports.asyncHook = asyncCore.asyncHook;
-exports.asyncHooks = asyncCore.asyncHooks;
-exports.hooks = asyncCore.hooks;
 //# 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, h as CleanupReason, e as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, F as FunctionWrapper, P as PropTrigger, R as ReactiveError, i as ReactiveErrorCode, S as ScopedCallback, j as Zone, Z as ZoneAggregator, k as ZoneHistory, l as asyncZone, c as cleanup, m as formatCleanupReason, n as isReactive, o as objectToProxy, p as proxyToObject, q as reactiveOptions, s as stopped, u as unwrap } from './types-W5vD6m2n.js';
-export { ArrayDiffResult, ArrayReadForward, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, Eventful, EventsBase, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactiveBase, Register, Resource, Restorer, ScanResult, addBatchCleanup, allocated, allocatedValues, arrayDiff, arrayEquals, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, caught, chainPromise, cleanedBy, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, immutables, isCached, isConstructor, isNonReactive, isObject, legacyDecorator, lift, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, morph as project, reactive, register, reset, resource, root, scan, setAt, tag, throttle, touched, touched1, unreactive, untracked, watch, when, zip } from './index.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-Bx2PhORg.js';
+export { ArrayDiffResult, ArrayReadForward, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, 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, captured, caught, chainPromise, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, isCached, isConstructor, isDev, isNonReactive, isObject, isProd, isTest, legacyDecorator, lift, link, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, morph as project, reactive, reset, resource, root, setAt, tag, throttle, touched, touched1, unlink, unreactive, untracked, watch, when, zip } from './index.js';

package/dist/node.dev.esm.js

@@ -1,6 +1,6 @@
 import './debug.esm.js';
-import './chunks/node-nKJBk8iJ.esm.js';
-export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, R as Register, 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, t as project, x as register, y as resource, z as scan, B as setAt, C as throttle, F as unreactive, G as watch, H as when } from './chunks/index-CaaQQlPJ.esm.js';
-export { A as AZone, 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 arrayEquals, h as asyncHook, i as asyncHooks, j as asyncZone, k as atom, l as atomic, m as biDi, n as caught, o as cleanedBy, p as cleanup, q as createFlavor, r as decorator, s as deepCompare, t as defer, u as effect, v as effectAggregator, w as flavorOptions, x as flavored, y as formatCleanupReason, z as getActivationLog, B as getActiveEffect, C as getState, E as hooks, F as immutables, G as isConstructor, H as isNonReactive, J as isObject, K as isReactive, L as legacyDecorator, M as mixin, N as modernDecorator, O as named, P as objectToProxy, Q as onEffectThrow, S as proxyToObject, T as reactive, U as reactiveOptions, V as reset, W as root, X as stopped, Y as tag, _ as touched, $ as touched1, a0 as untracked, a1 as unwrap, a2 as zip } from './chunks/proxy-r7lARftl.esm.js';
+import './chunks/node-Bo7WU5S2.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, t as project, x as resource, y as setAt, z as throttle, B as unreactive, C as watch, F as when } from './chunks/index-BUop6B2U.esm.js';
+export { A as AZone, 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 captured, q as caught, r as createFlavor, s as debugPreset, t as decorator, u as deepCompare, v as defer, w as devPreset, x as effect, y as effectAggregator, z as flavorOptions, B as flavored, C as formatCleanupReason, E as getActivationLog, F as getActiveEffect, G as getState, H as hooks, J as isConstructor, K as isDev, L as isNonReactive, M as isObject, N as isProd, O as isReactive, P as isTest, Q as legacyDecorator, S as link, T as mixin, U as modernDecorator, V as named, W as objectToProxy, X as onEffectThrow, Y as prodPreset, _ as proxyToObject, $ as reactive, a0 as reactiveOptions, a1 as reset, a2 as root, a3 as tag, a4 as touched, a5 as touched1, a6 as unlink, a7 as untracked, a8 as unwrap, a9 as zip } from './chunks/proxy-D2C49sXH.esm.js';
 import 'node:async_hooks';
 //# sourceMappingURL=node.dev.esm.js.map

package/dist/node.esm.js

@@ -1,5 +1,5 @@
-import './chunks/node-nKJBk8iJ.esm.js';
-export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, R as Register, 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, t as project, x as register, y as resource, z as scan, B as setAt, C as throttle, F as unreactive, G as watch, H as when } from './chunks/index-CaaQQlPJ.esm.js';
-export { A as AZone, 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 arrayEquals, h as asyncHook, i as asyncHooks, j as asyncZone, k as atom, l as atomic, m as biDi, n as caught, o as cleanedBy, p as cleanup, q as createFlavor, r as decorator, s as deepCompare, t as defer, u as effect, v as effectAggregator, w as flavorOptions, x as flavored, y as formatCleanupReason, z as getActivationLog, B as getActiveEffect, C as getState, E as hooks, F as immutables, G as isConstructor, H as isNonReactive, J as isObject, K as isReactive, L as legacyDecorator, M as mixin, N as modernDecorator, O as named, P as objectToProxy, Q as onEffectThrow, S as proxyToObject, T as reactive, U as reactiveOptions, V as reset, W as root, X as stopped, Y as tag, _ as touched, $ as touched1, a0 as untracked, a1 as unwrap, a2 as zip } from './chunks/proxy-r7lARftl.esm.js';
+import './chunks/node-Bo7WU5S2.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, t as project, x as resource, y as setAt, z as throttle, B as unreactive, C as watch, F as when } from './chunks/index-BUop6B2U.esm.js';
+export { A as AZone, 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 captured, q as caught, r as createFlavor, s as debugPreset, t as decorator, u as deepCompare, v as defer, w as devPreset, x as effect, y as effectAggregator, z as flavorOptions, B as flavored, C as formatCleanupReason, E as getActivationLog, F as getActiveEffect, G as getState, H as hooks, J as isConstructor, K as isDev, L as isNonReactive, M as isObject, N as isProd, O as isReactive, P as isTest, Q as legacyDecorator, S as link, T as mixin, U as modernDecorator, V as named, W as objectToProxy, X as onEffectThrow, Y as prodPreset, _ as proxyToObject, $ as reactive, a0 as reactiveOptions, a1 as reset, a2 as root, a3 as tag, a4 as touched, a5 as touched1, a6 as unlink, a7 as untracked, a8 as unwrap, a9 as zip } from './chunks/proxy-D2C49sXH.esm.js';
 import 'node:async_hooks';
 //# sourceMappingURL=node.esm.js.map

package/dist/{types-W5vD6m2n.d.ts → types-Bx2PhORg.d.ts}

@@ -4,9 +4,9 @@ declare abstract class AZone<T> {
     protected leave(entered: unknown): void;
     with<R>(value: T | undefined, fn: () => R): R;
     root<R>(fn: () => R): R;
-    get zoned(): FunctionWrapper;
+    get zoned(): GetterWrapper;
 }
-type FunctionWrapper = <R>(fn: () => R) => R;
+type GetterWrapper = <R>(fn: () => R) => R;
 declare class Zone<T> extends AZone<T> {
     active: T | undefined;
 }
@@ -35,6 +35,17 @@ declare class ZoneAggregator extends AZone<Map<AZone<unknown>, unknown>> {
     delete(z: AZone<unknown>): void;
     clear(): void;
 }
+/**
+ * Aggregator of zones that should be preserved across async boundaries.
+ * If you add a zone here, it will be preserved across async boundaries.
+ *
+ * @example
+ * ```ts
+ * import { Zone, asyncZone } from 'mutts'
+ * const userZone = new Zone<User>()
+ * asyncZone.add(userZone)
+ * ```
+ */
 declare const asyncZone: ZoneAggregator;
 
 /**
@@ -54,7 +65,7 @@ interface EffectAccess {
      * })
      * ```
      */
-    tracked: FunctionWrapper;
+    tracked: GetterWrapper;
     /**
      * Tracks dependencies in the parent effect context
      * Use this when child effects should track dependencies in the parent,
@@ -72,7 +83,7 @@ interface EffectAccess {
      * })
      * ```
      */
-    ascend: FunctionWrapper;
+    ascend: GetterWrapper;
     /**
      * `false` on the first execution, `true` or `CleanupReason` on subsequent runs.
      * `true` means this is a re-run but detailed reason gathering is disabled or unavailable.
@@ -91,6 +102,11 @@ interface EffectAccess {
      * ```
      */
     reaction: boolean | CleanupReason;
+    /**
+     * AbortSignal that is aborted when the effect is cleaned up or re-runs.
+     * Use this to cancel async operations (like fetch) when the effect is no longer valid.
+     */
+    signal: AbortSignal;
 }
 /**
  * Base type for effect callbacks - simple function without additional properties
@@ -113,6 +129,7 @@ type CleanupReason = {
     cause: CleanupReason;
 } | {
     type: 'stopped';
+    detail?: string;
 } | {
     type: 'gc';
 } | {
@@ -139,11 +156,9 @@ type CleanupReason = {
  */
 declare function formatCleanupReason(reason: CleanupReason, depth?: number): unknown[];
 /**
- * Type for effect cleanup functions with stopped state tracking
+ * Type for effect cleanup functions.
  */
-type EffectCleanup = ScopedCallback & {
-    [stopped]: boolean;
-};
+type EffectCleanup = ScopedCallback;
 /**
  * Type for the `runEffect` function of an effect - argument-less function to call to trigger the effect
  */
@@ -198,16 +213,8 @@ type State = {
     evolution: Evolution;
     next: State;
 } | {};
-/**
- * Symbol to check if an effect is stopped
- */
-declare const stopped: unique symbol;
-/**
- * Symbol to access effect cleanup function
- */
-declare const cleanup: unique symbol;
 type EffectCloser = (reason?: CleanupReason) => void;
-type CatchFunction = (error: any) => EffectCloser | undefined | void;
+type CatchFunction = (error: unknown) => EffectCloser | undefined | void;
 /**
  * Structured error codes for machine-readable diagnosis
  */
@@ -304,6 +311,12 @@ declare const options: {
      * @param runningChain - The array of effects from the detected one to the currently running one
      */
     skipRunningEffect: (_effect: EffectTrigger) => void;
+    /**
+     * Debug purpose: called when an effect starts executing.
+     * @param effect - The effect being executed (root function)
+     * @param reaction - false for initial creation, true/CleanupReason for subsequent runs
+     */
+    effectRun: (_effect: Function, _reaction: boolean | CleanupReason) => void;
     /**
      * Debug purpose: maximum effect chain (like call stack max depth)
      * Used to prevent infinite loops
@@ -431,39 +444,17 @@ declare const options: {
         enableHistory: boolean;
         historySize: number;
     } | null;
-    /**
-     * Configuration for zone hooks - control which async APIs are hooked
-     * Each option controls whether the corresponding async API is wrapped to preserve effect context
-     * Only applies when asyncMode is enabled (truthy)
-     * @deprecated Should take all when we made sure PIXI.create, Game.create, ... are -> .root()
-     */
-    zones: {
-        /**
-         * Hook setTimeout to preserve effect context
-         * @default true
-         */
-        setTimeout: boolean;
-        /**
-         * Hook setInterval to preserve effect context
-         * @default true
-         */
-        setInterval: boolean;
-        /**
-         * Hook requestAnimationFrame (runs in untracked context when hooked)
-         * @default true
-         */
-        requestAnimationFrame: boolean;
-        /**
-         * Hook queueMicrotask to preserve effect context
-         * @default true
-         */
-        queueMicrotask: boolean;
-    };
 };
+/** Production preset: no introspection, heuristic cycle detection, minimal overhead */
+declare const prodPreset: Partial<typeof options>;
+/** Development preset (default): 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 function isReactive(obj: any): boolean;
 
-export { AZone as A, ReactiveError as R, ZoneAggregator as Z, cleanup as c, ReactiveErrorCode as i, Zone as j, ZoneHistory as k, asyncZone as l, formatCleanupReason as m, isReactive as n, objectToProxy as o, proxyToObject as p, options as q, stopped as s, unwrap as u };
-export type { CatchFunction as C, EffectTrigger as E, FunctionWrapper as F, PropTrigger as P, ScopedCallback as S, Evolution as a, EffectCleanup as b, EffectCloser as d, EffectAccess as e, State as f, EffectOptions as g, CleanupReason as h };
+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 };

package/docs/ai/api-reference.md

@@ -55,20 +55,6 @@ export declare function biDi<T>(target: (val: T) => void, source: { get: () => T
 // COLLECTIONS
 // --------------------------------------------------------------------------------
 
-export interface Register<T, K extends PropertyKey = PropertyKey> extends Iterable<T> {
-    length: number;
-    [index: number]: T;
-    get(key: K): T | undefined;
-    set(key: K, value: T): void;
-    hasKey(key: K): boolean;
-    indexOfKey(key: K): number;
-    remove(key: K): void;
-    removeAt(index: number): T | undefined;
-    push(...items: T[]): number;
-    // ... complete array methods are supported
-}
-
-export declare function register<T, K extends PropertyKey = PropertyKey>(keyFn: (item: T) => K, initial?: Iterable<T>): Register<T, K>;
 export declare function project<S, R>(source: S, apply: (access: any, target: any) => any): R;
 export declare function organized<S, T>(source: S, apply: (access: any, target: T) => any, baseTarget?: T): T;
 

package/docs/ai/manual.md

@@ -21,9 +21,9 @@ Proxy-based **fine-grained reactivity** — changes propagate synchronously thro
 **All exports come from `'mutts'`** — no subpath imports like `mutts/reactive` or `mutts/zone`.
 
 ```ts
-import { reactive, effect, memoize, morph, attend, lift, scan, cleanup,
+import { reactive, effect, memoize, morph, attend, lift, cleanup,
   atom, atomic, defer, untracked, unreactive, watch, when, biDi, caught, why,
-  cleanedBy, organized, Register,
+  cleanedBy, organized,
   Zone, asyncZone, ZoneHistory, ZoneAggregator,
   decorator, mixin, Eventful, Destroyable, flavored, Indexable, chainPromise,
   reactiveOptions, isReactive, unwrap, getState
@@ -274,18 +274,6 @@ await when(() => state.ready, { timeout: 5000 }) // rejects after 5s
 
 Array methods (`push`, `splice`, `sort`, etc.) all trigger reactivity.
 
-### 4.1 Register — Keyed ordered collection
-
-```ts
-const list = new Register(item => item.id, [{ id: 1, label: 'A' }])
-list.get(1)            // O(1) lookup by key
-list.set(1, newItem)   // update by key
-list.remove(1)         // remove by key
-list.keep(x => x.active) // filter in-place
-list.upsert(v => list.push(v), ...items) // update or insert
-// Full array surface + CRUD events: on('add'|'delete'|'update'|'rekey', ...)
-```
-
 ---
 
 ## 5. COLLECTION TRANSFORMS
@@ -321,14 +309,6 @@ const doubled = organized(source, (access, target) => {
 })
 ```
 
-### 5.4 scan() — Reactive accumulation
-
-```ts
-const result = scan(source, (acc, item) => acc + item.val, 0)
-// [1, 3, 6] — changing source[1] recomputes from index 1 onward
-// Items must be objects (WeakMap keys). Move-optimized.
-```
-
 ### 5.6 lift() — Sync a computed array/object
 
 ```ts