mutts 1.0.11 → 1.0.13

package/dist/node.cjs

@@ -1,49 +1,47 @@
 'use strict';
 
-require('./chunks/async-node-3PrbVAbB.cjs');
-var browser = require('./browser.cjs');
-var proxy = require('./chunks/proxy-Cc79Lrzj.cjs');
-var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
+require('./chunks/node-DrrphEPf.cjs');
+var index = require('./chunks/index-CAdnMJev.cjs');
+var proxy = require('./chunks/proxy-DBHj3kGK.cjs');
 require('node:async_hooks');
-require('./chunks/async-browser-Dgr5CreQ.cjs');
 
 
 
-exports.ArrayReadForward = browser.ArrayReadForward;
-exports.Destroyable = browser.Destroyable;
-exports.DestructionError = browser.DestructionError;
-exports.Eventful = browser.Eventful;
-exports.Indexable = browser.Indexable;
-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.resource = browser.resource;
-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.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.CompareSymbol = proxy.CompareSymbol;
 exports.DecoratorError = proxy.DecoratorError;
 exports.IterableWeakMap = proxy.IterableWeakMap;
 exports.IterableWeakSet = proxy.IterableWeakSet;
@@ -60,10 +58,13 @@ 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;
@@ -74,12 +75,15 @@ 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;
@@ -106,8 +110,6 @@ 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.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, 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';
+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';

package/dist/node.dev.cjs

@@ -1,50 +1,48 @@
 'use strict';
 
 require('./debug.cjs');
-require('./chunks/async-node-3PrbVAbB.cjs');
-var browser = require('./browser.cjs');
-var proxy = require('./chunks/proxy-Cc79Lrzj.cjs');
-var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
+require('./chunks/node-DrrphEPf.cjs');
+var index = require('./chunks/index-CAdnMJev.cjs');
+var proxy = require('./chunks/proxy-DBHj3kGK.cjs');
 require('node:async_hooks');
-require('./chunks/async-browser-Dgr5CreQ.cjs');
 
 
 
-exports.ArrayReadForward = browser.ArrayReadForward;
-exports.Destroyable = browser.Destroyable;
-exports.DestructionError = browser.DestructionError;
-exports.Eventful = browser.Eventful;
-exports.Indexable = browser.Indexable;
-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.resource = browser.resource;
-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.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.CompareSymbol = proxy.CompareSymbol;
 exports.DecoratorError = proxy.DecoratorError;
 exports.IterableWeakMap = proxy.IterableWeakMap;
 exports.IterableWeakSet = proxy.IterableWeakSet;
@@ -61,10 +59,13 @@ 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;
@@ -75,12 +76,15 @@ 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;
@@ -107,8 +111,6 @@ 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.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, 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';
+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';

package/dist/node.dev.esm.js

@@ -1,6 +1,6 @@
 import './debug.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 './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 'node:async_hooks';
 //# sourceMappingURL=node.dev.esm.js.map

package/dist/node.esm.js

@@ -1,5 +1,5 @@
-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 './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 'node:async_hooks';
 //# sourceMappingURL=node.esm.js.map

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

@@ -124,23 +124,34 @@ type PropTrigger = {
 type CleanupReason = {
     type: 'propChange';
     triggers: PropTrigger[];
+    chain?: CleanupReason;
 } | {
     type: 'invalidate';
     cause: CleanupReason;
+    chain?: CleanupReason;
+} | {
+    type: 'external';
+    detail: string;
+    chain?: CleanupReason;
 } | {
     type: 'stopped';
     detail?: string;
+    chain?: CleanupReason;
 } | {
     type: 'gc';
+    chain?: CleanupReason;
 } | {
     type: 'lineage';
     parent: CleanupReason;
+    chain?: CleanupReason;
 } | {
     type: 'error';
     error: unknown;
+    chain?: CleanupReason;
 } | {
     type: 'multiple';
     reasons: CleanupReason[];
+    chain?: CleanupReason;
 };
 /**
  * Console-friendly description of a `CleanupReason`.
@@ -419,6 +430,7 @@ declare const options: {
      */
     asyncMode: AsyncExecutionMode | false;
     warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
     /**
      * Introspection and debug aids. Set to `null` to disable all debug overhead in production.
      *

package/docs/ai/api-reference.md

@@ -24,22 +24,72 @@ export declare const Reactive: unique symbol;
  * Symbol to map back from a reactive proxy to its original target
  */
 export declare const Raw: unique symbol;
-export type ScopedCallback = (() => void | (() => void)) & {
-    [cleanup]?: () => void;
+export type PropTrigger = {
+    obj: object;
+    evolution: Evolution;
+    dependency?: unknown;
+    touch?: unknown;
 };
-export type DependencyFunction = <T>(fn: () => T) => T;
-export type DependencyAccess = {
-    tracked: DependencyFunction;
-    ascend: DependencyFunction;
-    reaction: boolean;
+export type CleanupReason = {
+    type: 'propChange';
+    triggers: PropTrigger[];
+} | {
+    type: 'invalidate';
+    cause: CleanupReason;
+} | {
+    type: 'stopped';
+    detail?: string;
+} | {
+    type: 'gc';
+} | {
+    type: 'lineage';
+    parent: CleanupReason;
+} | {
+    type: 'error';
+    error: unknown;
+} | {
+    type: 'multiple';
+    reasons: CleanupReason[];
+};
+export type ScopedCallback = (reason?: CleanupReason) => void;
+export type EffectCleanup = ScopedCallback;
+export type EffectCloser = (reason?: CleanupReason) => void;
+export type EffectAccess = {
+    tracked: <T>(fn: () => T) => T;
+    ascend: <T>(fn: () => T) => T;
+    reaction: boolean | CleanupReason;
+    signal: AbortSignal;
+};
+export type EffectOptions = {
+    asyncMode?: 'cancel' | 'queue' | 'ignore';
+    opaque?: boolean;
+    dependencyHook?: (obj: any, prop: any) => void;
+    name?: string;
+};
+export type Evolution = {
+    type: 'set' | 'del' | 'add' | 'invalidate';
+    prop: any;
+} | {
+    type: 'bunch';
+    method: string;
 };
 
+export declare const effect: {
+    (fn: (access: EffectAccess) => EffectCloser | undefined | void | Promise<any>, effectOptions?: EffectOptions): EffectCleanup;
+    readonly opaque: typeof effect;
+    named(name: string): typeof effect;
+};
 export declare function reactive<T extends object>(target: T): T;
-export declare function effect(fn: (access: DependencyAccess, ...args: any[]) => (ScopedCallback | undefined | void), ...args: any[]): ScopedCallback;
 export declare function unwrap<T>(obj: T): T;
 export declare function isReactive(obj: any): boolean;
+export declare class ReactiveBase {}
 export declare function isNonReactive(obj: any): boolean;
 export declare function untracked<T>(fn: () => T): T;
+export declare function root<T>(fn: () => T): T;
+export declare function assertUntracked<T>(fn: () => T): T;
+export declare function getState(obj: any): {};
+export declare function touched(obj: any, evolution: Evolution, props?: any[]): void;
+export declare function touched1(obj: any, evolution: Evolution, prop: any): void;
 
 // --------------------------------------------------------------------------------
 // REACTIVE HELPERS
@@ -48,15 +98,55 @@ export declare function untracked<T>(fn: () => T): T;
 export declare function atomic<T extends (...args: any[]) => any>(fn: T): T;
 export declare function atom<T>(fn: () => T): T;
 export declare function memoize<Result, Args extends any[]>(fn: (...args: Args) => Result, maxArgs?: number): (...args: Args) => Result;
-export declare function deepWatch(source: any, callback: (path: string[], value: any) => void): () => void;
-export declare function biDi<T>(target: (val: T) => void, source: { get: () => T, set: (v: T) => void }): (val: T) => void;
+export declare function deepWatch<T extends object>(target: T, callback: (value: T) => void, options?: { immediate?: boolean }): EffectCleanup | undefined;
+export declare function biDi<T>(received: (value: T) => void, value: { get: () => T, set: (value: T) => void }): (value: T) => void;
+export declare function biDi<T>(received: (value: T) => void, get: () => T, set: (value: T) => void): (value: T) => void;
+export declare function addBatchCleanup(cleanup: () => void): void;
+export declare const defer: typeof addBatchCleanup;
+export declare function caught(onThrow: (error: unknown) => EffectCloser | undefined | void): void;
+export declare const onEffectThrow: typeof caught;
+export declare function getActiveEffect(): ScopedCallback;
+export declare const effectAggregator: unknown;
+export declare function link(owner: object, ...deps: (ScopedCallback | object)[]): void;
+export declare function unlink(owner: object, reason?: CleanupReason): void;
 
 // --------------------------------------------------------------------------------
 // COLLECTIONS
 // --------------------------------------------------------------------------------
 
-export declare function project<S, R>(source: S, apply: (access: any, target: any) => any): R;
+export declare function attend<T>(source: readonly T[], callback: (index: number, access: EffectAccess) => EffectCloser | void): ScopedCallback;
+export declare function attend<K, V>(source: Map<K, V>, callback: (key: K, access: EffectAccess) => EffectCloser | void): ScopedCallback;
+export declare function attend<T>(source: Set<T>, callback: (value: T, access: EffectAccess) => EffectCloser | void): ScopedCallback;
+export declare function attend<S extends object>(source: S, callback: (key: keyof S & string, access: EffectAccess) => EffectCloser | void): ScopedCallback;
+export declare function attend<Key>(enumerate: () => Iterable<Key>, callback: (key: Key, access: EffectAccess) => EffectCloser | void): ScopedCallback;
+export declare function lift<Output extends any[]>(cb: (access: EffectAccess) => Output): Output;
+export declare function lift<Output extends object>(cb: (access: EffectAccess) => Output): Output;
+export declare const morph: {
+    <I, O>(source: readonly I[] | (() => readonly I[]), fn: (arg: I, access?: EffectAccess) => O, options?: { pure?: boolean | ((i: I) => boolean) }): readonly O[];
+    <K, V, O>(source: Map<K, V>, fn: (arg: V, key: K, access?: EffectAccess) => O, options?: { pure?: boolean | ((i: V) => boolean) }): Map<K, O>;
+    <S extends Record<PropertyKey, any>, O>(source: S, fn: (arg: S[keyof S], key: keyof S, access?: EffectAccess) => O, options?: { pure?: boolean | ((i: S[keyof S]) => boolean) }): { [K in keyof S]: O };
+    pure: typeof morph;
+};
 export declare function organized<S, T>(source: S, apply: (access: any, target: T) => any, baseTarget?: T): T;
+export declare function organize<T>(target: object, property: PropertyKey, access: { get?(): T, set?(value: T): boolean }): () => boolean;
+export declare const watch: {
+    <T>(value: (dep: EffectAccess) => T, changed: (value: T, oldValue?: T) => void, options?: { immediate?: boolean, deep?: false }): EffectCleanup;
+    <T extends object | any[]>(value: (dep: EffectAccess) => T, changed: (value: T, oldValue?: T) => void, options?: { immediate?: boolean, deep: true }): EffectCleanup;
+    <T extends object | any[]>(value: T, changed: (value: T) => void, options?: { immediate?: boolean, deep?: boolean }): EffectCleanup;
+    readonly deep: typeof watch;
+    readonly immediate: typeof watch;
+};
+export declare function when<T>(predicate: (dep: EffectAccess) => T, timeout?: number): Promise<T>;
+export interface Resource<T> {
+    value: T | undefined;
+    loading: boolean;
+    error: any;
+    latest: T | undefined;
+    reload(): void;
+    promise: Promise<void>;
+}
+export declare function resource<T>(fetcher: (access: EffectAccess) => Promise<T> | T, options?: { initialValue?: T }): Resource<T>;
+export declare function unreactive<T extends object>(obj: T): T;
 
 // --------------------------------------------------------------------------------
 // DESTROYABLE
@@ -96,7 +186,7 @@ export declare function deprecated(message?: string): Function;
 
 export declare const reactiveOptions: {
     cycleHandling: 'production' | 'development' | 'debug';
-    introspection: { enableHistory: boolean; historySize: number; logErrors: boolean };
+    introspection: unknown;
 };
 
 export enum ReactiveErrorCode {