mutts 1.0.12 → 1.0.13

package/dist/node.cjs

@@ -1,8 +1,8 @@
 'use strict';
 
-require('./chunks/node-Dd0esp5F.cjs');
-var index = require('./chunks/index-yK0HVxHv.cjs');
-var proxy = require('./chunks/proxy-BvM4yewA.cjs');
+require('./chunks/node-DrrphEPf.cjs');
+var index = require('./chunks/index-CAdnMJev.cjs');
+var proxy = require('./chunks/proxy-DBHj3kGK.cjs');
 require('node:async_hooks');
 
 
@@ -34,7 +34,6 @@ 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;
@@ -42,6 +41,7 @@ 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;
@@ -64,6 +64,7 @@ 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,6 +75,7 @@ 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;
@@ -81,6 +83,7 @@ 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,5 +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;
 //# 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,9 +1,9 @@
 'use strict';
 
 require('./debug.cjs');
-require('./chunks/node-Dd0esp5F.cjs');
-var index = require('./chunks/index-yK0HVxHv.cjs');
-var proxy = require('./chunks/proxy-BvM4yewA.cjs');
+require('./chunks/node-DrrphEPf.cjs');
+var index = require('./chunks/index-CAdnMJev.cjs');
+var proxy = require('./chunks/proxy-DBHj3kGK.cjs');
 require('node:async_hooks');
 
 
@@ -35,7 +35,6 @@ 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;
@@ -43,6 +42,7 @@ 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;
@@ -65,6 +65,7 @@ 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,6 +76,7 @@ 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;
@@ -82,6 +84,7 @@ 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;
@@ -108,5 +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;
 //# 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-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 './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-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 './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 {

package/docs/ai/manual.md

@@ -13,7 +13,7 @@ Proxy-based **fine-grained reactivity** — changes propagate synchronously thro
 | State | `reactive(obj)` — proxy wraps, tracks reads/writes |
 | Reactions | `effect(() => {})` — auto-tracks deps, re-runs on change |
 | Computed | `memoize(fn)` — cached, invalidates on tracked deps |
-| Collections | `project(arr, fn)` — per-entry effects, not `.map()` |
+| Collections | `morph(arr, fn)` — per-entry reactive transform |
 | Async context | `Zone` + `asyncZone` — propagates across await |
 | Batching | `atomic(() => {})` wraps, `atom(() => {})` runs immediately — fire effects once after all mutations |
 | Cleanup | Return fn from effect — runs before re-run/disposal |
@@ -22,11 +22,11 @@ Proxy-based **fine-grained reactivity** — changes propagate synchronously thro
 
 ```ts
 import { reactive, effect, memoize, morph, attend, lift, cleanup,
-  atom, atomic, defer, untracked, unreactive, watch, when, biDi, caught, why,
-  cleanedBy, organized,
+  atom, atomic, defer, untracked, unreactive, watch, when, biDi, caught,
+  organized, organize, resource, root,
   Zone, asyncZone, ZoneHistory, ZoneAggregator,
   decorator, mixin, Eventful, Destroyable, flavored, Indexable, chainPromise,
-  reactiveOptions, isReactive, unwrap, getState
+  reactiveOptions, isReactive, unwrap, getState, ReactiveBase
 } from 'mutts'
 ```
 
@@ -107,14 +107,14 @@ array.splice(0)   // also works — explicit clear
 ```
 
 ### TRAP 6: Using .map() for reactive transforms
-`.map()` is static — full rebuild on any change. Use `project()` for per-entry reactivity.
+`.map()` is static — full rebuild on any change. Use `morph()` for per-entry reactivity.
 
 ```ts
 // BAD — full rebuild
 const doubled = items.map(x => x.value * 2)
 
 // GOOD — per-entry effects
-const doubled = project(items, ({ get }) => get().value * 2)
+const doubled = morph(items, (value) => value * 2)
 ```
 
 ### TRAP 7: Deep watch overhead
@@ -164,7 +164,11 @@ state.count++ // triggers
 stop()        // disposes
 ```
 
-- **Access object**: `{ reaction, tracked(fn), ascend(fn) }` — `reaction` = false on first run, true after. `tracked` restores context in async. `ascend` tracks in parent effect.
+- **Access object**: `{ reaction, tracked(fn), ascend(fn), signal }`
+- `reaction` is `false` on first run, then `true` or a `CleanupReason` on re-runs.
+- `tracked` restores effect tracking in async or escaped callbacks.
+- `ascend` records dependencies on the parent effect context.
+- `signal` aborts when the effect is cleaned up or invalidated.
 - **Parent-child**: effects inside effects are children — parent disposal cascades.
 - **GC**: unreferenced top-level effects may GC — store `stop` to keep alive.
 - **Modifiers**: `effect.opaque(() => {})` (identity-only), `effect.named('x')(() => {})` (debug label). Chainable.
@@ -231,16 +235,15 @@ input.addEventListener('input', () => provide(input.value))
 ```ts
 watch(() => state.count, (newVal, oldVal) => {}) // specific derivation
 watch(state, () => {}) // any property
-watch(state, () => {}, { deep: true }) // deep (expensive)
+watch.deep(state, () => {}) // deep (expensive)
+watch.immediate(() => state.count, (newVal, oldVal) => {}) // immediate first call
 ```
 
-### 3.10 cleanedBy() — Attach cleanup to objects
+`watch` has 3 useful shapes:
 
-```ts
-const obj = cleanedBy({ data: [] }, () => console.log('cleaned up'))
-obj[cleanup]() // triggers cleanup
-// Chains: if obj already has a cleanup, both run
-```
+- `watch(() => value, callback)`
+- `watch.deep(() => object, callback)`
+- `watch(object, callback)`
 
 ### 3.11 Lazy computed values
 
@@ -258,9 +261,25 @@ effect(() => console.log(d.value)) // recomputes immediately, .value is reactive
 
 ```ts
 await when(() => state.loaded)        // resolves when truthy
-await when(() => state.ready, { timeout: 5000 }) // rejects after 5s
+await when(() => state.ready, 5000)   // rejects after 5s
 ```
 
+### 3.13 resource() — Async reactive state
+
+```ts
+const user = resource(async () => fetchUser(state.userId), { initialValue: null })
+
+effect(() => {
+  if (user.loading) return
+  console.log(user.value)
+})
+
+user.reload()
+await user.promise
+```
+
+`resource()` returns `{ value, loading, error, latest, reload(), promise }`.
+
 ---
 
 ## 4. COLLECTIONS
@@ -280,15 +299,22 @@ Array methods (`push`, `splice`, `sort`, etc.) all trigger reactivity.
 
 All transforms return reactive results. Cleanup via `result[cleanup]()`.
 
-### 5.1 project() — Per-entry reactive map
+### 5.1 morph() — Per-entry reactive map
 
 ```ts
-const names = project(users, ({ get }) => get().name.toUpperCase())
+const names = morph(users, (user) => user.name.toUpperCase())
 // names[0] recomputes ONLY when users[0] changes
-// Variants: project.record(), project.map() — auto-dispatches by source type
+// Use morph.pure(...) when the callback has no reactive reads
 ```
 
-**Access object**: `{ get(), set(v), key, source, old, value }`
+For arrays the callback is `(value, access?) => mapped`.
+For Maps and records it also receives the key.
+
+The mapper can also be captioned, even though it is the second argument:
+
+```ts
+const names = morph`user:names`(users, (user) => user.name.toUpperCase())
+```
 
 ### 5.2 attend() — Per-key lifecycle
 
@@ -297,9 +323,17 @@ attend(reactiveRecord, (key) => {
   console.log(`${key} = ${reactiveRecord[key]}`)
   return () => console.log(`cleanup: ${key}`) // disposed when key disappears
 })
-// Works with: arrays, Maps, Sets, or raw () => Iterable<Key>
 ```
 
+`attend` also supports callback captions on its second argument:
+
+```ts
+attend`record:entries`(reactiveRecord, (key) => {
+  console.log(`${key} = ${reactiveRecord[key]}`)
+})
+```
+Works with: arrays, Maps, Sets, or raw `() => Iterable<Key>`.
+
 ### 5.3 organized() — Per-key record transform
 
 ```ts
@@ -309,7 +343,7 @@ const doubled = organized(source, (access, target) => {
 })
 ```
 
-### 5.6 lift() — Sync a computed array/object
+### 5.4 lift() — Sync a computed array/object
 
 ```ts
 const filtered = lift(() => items.filter(x => x.active))
@@ -318,7 +352,7 @@ const filtered = lift(() => items.filter(x => x.active))
 
 **lift vs deep touching**: Deep touching handles `state.items = newArray` (replacement diffs). `lift` is for **derived collections** (filter/map/reshape) where there's no single assignment — the output is recomputed from scratch.
 
-**lift vs memoize**: `memoize` is lazy (invalidate → recompute on next read), returns raw values, keyed by args. `lift` is eager (recompute immediately), returns a **stable reactive proxy** with per-element diffing. Use `lift` for derived collections consumed by `project()`/effects; use `memoize` for parameterized caching or lazy evaluation.
+**lift vs memoize**: `memoize` is lazy (invalidate → recompute on next read), returns raw values, keyed by args. `lift` is eager (recompute immediately), returns a **stable reactive proxy** with per-element diffing. Use `lift` for derived collections consumed by effects; use `memoize` for parameterized caching or lazy evaluation.
 
 ---
 
@@ -387,6 +421,8 @@ const graph = buildReactivityGraph()
 
 **ReactiveError.debugInfo**: `causalChain`, `creationStack`, `cycle` (for CYCLE_DETECTED).
 
+`onEffectThrow` is still exported as a deprecated alias of `caught`.
+
 ---
 
 ## 9. ZONES (Async Context)
@@ -484,7 +520,7 @@ const theme = await chainPromise(api.getUser('123')).getProfile().getSettings().
 ## 11. PHILOSOPHY
 
 - **Affirmative state**: Declare `Y = f(X)`. Don't say "when X changes, update Y".
-- **Events are legacy**: Use reactive derivations (`effect`, `memoize`, `project`) for internal logic. Events only for DOM/external APIs.
+- **Events are legacy**: Use reactive derivations (`effect`, `memoize`, `morph`) for internal logic. Events only for DOM/external APIs.
 - **Cleanup ≠ undo**: Cleanup releases subscriptions, does NOT undo side effects.
 
 ---
@@ -504,5 +540,5 @@ const theme = await chainPromise(api.getUser('123')).getProfile().getSettings().
 | `isReactive(obj)` to check | `obj._mutts_isReactive` |
 | Store `stop = effect(...)` | letting effect GC unintentionally |
 | `import { x } from 'mutts'` | `import { x } from 'mutts/reactive'` (no subpaths) |
-| `cleanedBy(obj, fn)` for cleanup | manual `obj[cleanup] = fn` |
+| `caught(handler)` for effect-local error handling | ad-hoc try/catch around reactive graph edges |
 | `memoize(() => a + b)` for computed | `effect` + manual state sync |