mutts 1.0.10 → 1.0.11

package/dist/node.cjs

@@ -2,10 +2,10 @@
 
 require('./chunks/async-node-3PrbVAbB.cjs');
 var browser = require('./browser.cjs');
-var proxy = require('./chunks/proxy-Dtg-bJ3T.cjs');
+var proxy = require('./chunks/proxy-Cc79Lrzj.cjs');
 var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
 require('node:async_hooks');
-require('./chunks/async-browser-BU_IfxYD.cjs');
+require('./chunks/async-browser-Dgr5CreQ.cjs');
 
 
 
@@ -14,7 +14,6 @@ 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;
@@ -38,9 +37,7 @@ 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;
@@ -60,18 +57,21 @@ 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.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,26 +80,30 @@ exports.formatCleanupReason = proxy.formatCleanupReason;
 exports.getActivationLog = proxy.getActivationLog;
 exports.getActiveEffect = proxy.getActiveEffect;
 exports.getState = proxy.getState;
-exports.immutables = proxy.immutables;
 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;

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

@@ -3,10 +3,10 @@
 require('./debug.cjs');
 require('./chunks/async-node-3PrbVAbB.cjs');
 var browser = require('./browser.cjs');
-var proxy = require('./chunks/proxy-Dtg-bJ3T.cjs');
+var proxy = require('./chunks/proxy-Cc79Lrzj.cjs');
 var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
 require('node:async_hooks');
-require('./chunks/async-browser-BU_IfxYD.cjs');
+require('./chunks/async-browser-Dgr5CreQ.cjs');
 
 
 
@@ -15,7 +15,6 @@ 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;
@@ -39,9 +38,7 @@ 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;
@@ -61,18 +58,21 @@ 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.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,26 +81,30 @@ exports.formatCleanupReason = proxy.formatCleanupReason;
 exports.getActivationLog = proxy.getActivationLog;
 exports.getActiveEffect = proxy.getActiveEffect;
 exports.getState = proxy.getState;
-exports.immutables = proxy.immutables;
 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;

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-Sf74wXTV.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-Sf74wXTV.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

package/docs/reactive/advanced.md

@@ -5,7 +5,7 @@
 The `atomic` function wraps a function to batch all reactive effects triggered within it, ensuring effects run only once after the function completes. It can be used both as a function wrapper and as a decorator.
 
 ```typescript
-import { atomic, reactive, effect } from 'mutts/reactive'
+import { atomic, reactive, effect } from 'mutts'
 
 const state = reactive({ a: 0, b: 0 })
 
@@ -48,7 +48,7 @@ The wrapped function preserves its signature (parameters and return value), and
 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.
 
 ```typescript
-import { atom, reactive, effect } from 'mutts/reactive'
+import { atom, reactive, effect } from 'mutts'
 
 const state = reactive({ a: 0, b: 0 })
 
@@ -85,9 +85,9 @@ update(1, 2)  // runs when called
 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.
 
 ```typescript
-import { addBatchCleanup, effect, reactive } from 'mutts/reactive'
+import { addBatchCleanup, effect, reactive } from 'mutts'
 // or use the semantic alias:
-// import { defer } from 'mutts/reactive'
+// import { defer } from 'mutts'
 
 const state = reactive({ 
   items: [],
@@ -298,7 +298,7 @@ effect(() => {
 Creates a bidirectional binding between a reactive value and a non-reactive external value (like DOM elements), automatically preventing infinite loops.
 
 ```typescript
-import { biDi, reactive } from 'mutts/reactive'
+import { biDi, reactive } from 'mutts'
 
 const model = reactive({ value: '' })
 
@@ -1142,15 +1142,14 @@ Mutts provides several ways to derive values from reactive state. They differ in
 | `lift(() => ({...}))` | Eager | Reactive object proxy | Yes (per-prop) | **Yes** | `result[cleanup]()` | Derived objects, computed shapes |
 | `morph(source, fn)` | **Lazy** | Reactive proxy | Yes (per-key) | **Yes** | `cleanedBy` | Lazy per-element map with identity tracking |
 | `morph.pure(source, fn)` | **Lazy** | Reactive proxy | Yes (per-key) | **Yes** | `cleanedBy` | Same, but skips per-item dependency tracking |
-| `scan(source, fn, init)` | Eager | Reactive array | Yes (per-index) | **Yes** | `result[cleanup]()` | Running accumulations (prefix sums) |
 | `when(() => cond)` | Eager | Promise\<T\> | N/A | N/A | Auto (on resolve/timeout) | Awaiting a reactive condition |
 | `watch(source, cb)` | Eager | Callback (old/new) | N/A | N/A | Auto (parent/GC) + Returned cleanup | Observing specific changes |
 
 ### Key distinctions
 
 - **Lazy vs Eager**: `memoize` only recomputes when the result is read. Everything else recomputes immediately when dependencies change — even if nobody is consuming the output.
-- **Trackable**: Can downstream effects depend on the result? `memoize`'s return value is trackable because calling it runs inside an effect context. `lift`/`morph`/`scan` return reactive proxies where each property/index is independently trackable.
-- **Identity stable**: `lift`, `morph`, and `scan` return the **same proxy** across recomputations — only changed slots are updated. This is critical for downstream transformations or DOM reconciliation that relies on reference identity.
+- **Trackable**: Can downstream effects depend on the result? `memoize`'s return value is trackable because calling it runs inside an effect context. `lift`/`morph` return reactive proxies where each property/index is independently trackable.
+- **Identity stable**: `lift` and `morph` return the **same proxy** across recomputations — only changed slots are updated. This is critical for downstream transformations or DOM reconciliation that relies on reference identity.
 
 ### Common patterns
 
@@ -1229,7 +1228,7 @@ state.items = fetchedItems // deep touch diffs old vs new per-index — no lift
 **Signature**
 
 ```typescript
-import { morph } from 'mutts/reactive'
+import { morph } from 'mutts'
 
 function morph<I, O>(
   source: readonly I[] | (() => readonly I[]),
@@ -1254,7 +1253,7 @@ function morph<I, O>(
 **Basic usage**
 
 ```typescript
-import { morph, reactive, effect } from 'mutts/reactive'
+import { morph, reactive, effect } from 'mutts'
 
 const items = reactive(['alice', 'bob', 'charlie'])
 const upper = morph(items, name => name.toUpperCase())
@@ -1355,7 +1354,7 @@ pure[0]     // 10 — stale, no per-item effect to invalidate
 **Signature**
 
 ```typescript
-import { memoize } from 'mutts/reactive'
+import { memoize } from 'mutts'
 
 type Memoizable = object | any[] | symbol
 
@@ -1380,7 +1379,7 @@ function memoize<Result>(
 **Basic usage**
 
 ```typescript
-import { effect, memoize, reactive } from 'mutts/reactive'
+import { effect, memoize, reactive } from 'mutts'
 
 const source = reactive({ value: 1 })
 const args = { node: source }
@@ -1426,7 +1425,7 @@ Use `maxArgs` when the memoized function should only consider the first _n_ argu
 A flavored variant that gracefully handles non-WeakKey arguments (primitives, `null`, `undefined`). Instead of throwing, it falls back to recomputing the function without caching.
 
 ```typescript
-import { memoize } from 'mutts/reactive'
+import { memoize } from 'mutts'
 
 const process = memoize.lenient((value: string | { data: string }) => {
   return typeof value === 'string' ? value.toUpperCase() : value.data
@@ -1447,7 +1446,7 @@ This is useful when a memoized function may receive both objects and primitives,
 Apply `@memoize` (or `@memoize.lenient`) to class getters or methods to share the same cache semantics. Getters cache per instance; methods cache per instance and argument tuple.
 
 ```typescript
-import { memoize, reactive } from 'mutts/reactive'
+import { memoize, reactive } from 'mutts'
 
 class Example {
   state = reactive({ count: 0 })

package/docs/reactive/attend.md

@@ -137,6 +137,5 @@ attend(
 | `attend` | — | Reactive lifecycle per key |
 | `organized` | ✅ | Reactive record mapping with access objects |
 | `project` | ❌ | Reactive collection mapping (manages a target + projection context) |
-| `scan` | ❌ | Reactive accumulation (sequential key dependency) |
 
-`project` and `scan` have additional concerns (target management, sequential dependencies) that go beyond `attend`'s independent-key lifecycle model.
+`project` has additional concerns (target management) that go beyond `attend`'s independent-key lifecycle model.