mutts 1.0.12 → 1.0.14

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-Df_5r_WA.cjs');
+var index = require('./chunks/index-BnTNC9eC.cjs');
+var proxy = require('./chunks/proxy-HA_QQnd5.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,31 +83,43 @@ exports.getActivationLog = proxy.getActivationLog;
 exports.getActiveEffect = proxy.getActiveEffect;
 exports.getState = proxy.getState;
 exports.hooks = proxy.hooks;
+exports.inert = proxy.inert;
+exports.inheritCaption = proxy.inheritCaption;
 exports.isConstructor = proxy.isConstructor;
 exports.isDev = proxy.isDev;
 exports.isNonReactive = proxy.isNonReactive;
 exports.isObject = proxy.isObject;
 exports.isProd = proxy.isProd;
 exports.isReactive = proxy.isReactive;
+exports.isReactiveBroken = proxy.isReactiveBroken;
 exports.isTest = proxy.isTest;
 exports.legacyDecorator = proxy.legacyDecorator;
 exports.link = proxy.link;
+exports.markRaw = proxy.markRaw;
+exports.markRawProps = proxy.markRawProps;
 exports.mixin = proxy.mixin;
 exports.modernDecorator = proxy.modernDecorator;
 exports.named = proxy.named;
 exports.objectToProxy = proxy.objectToProxy;
 exports.onEffectThrow = proxy.onEffectThrow;
+exports.onReactiveBroken = proxy.onReactiveBroken;
+exports.onReactiveReset = proxy.onReactiveReset;
 exports.prodPreset = proxy.prodPreset;
 exports.proxyToObject = proxy.proxyToObject;
 exports.reactive = proxy.reactive;
 exports.reactiveOptions = proxy.options;
+exports.readonlyReactive = proxy.readonlyReactive;
 exports.reset = proxy.reset;
 exports.root = proxy.root;
+exports.shallowReactive = proxy.shallowReactive;
 exports.tag = proxy.tag;
+exports.toRaw = proxy.toRaw;
 exports.touched = proxy.touched;
 exports.touched1 = proxy.touched1;
 exports.unlink = proxy.unlink;
 exports.untracked = proxy.untracked;
 exports.unwrap = proxy.unwrap;
+exports.withEffectContext = proxy.withEffectContext;
+exports.wrapInert = proxy.wrapInert;
 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, MorphPosition, PromiseChain, ReactiveBase, Resource, Restorer, addBatchCleanup, addUnreactiveProps, allocated, allocatedValues, arrayDiff, arrayEquals, assertUntracked, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, captioned, captured, caught, chainPromise, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, effectContext, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, inert, inheritCaption, isCached, isConstructor, isDev, isNonReactive, isObject, isProd, isReactiveBroken, isTest, legacyDecorator, lift, link, markRaw, markRawProps, memoize, mixin, modernDecorator, morph, named, onEffectThrow, onReactiveBroken, onReactiveReset, organize, organized, profileInfo, reactive, readonlyReactive, reset, resource, root, setAt, shallowReactive, tag, throttle, touched, touched1, unlink, unreactive, untracked, watch, when, withEffectContext, wrapInert, zip } from './browser.js';
+export { A as AZone, C as CleanupReason, h as CycleHandlingMode, D as DeprecatedCycleHandlingMode, c as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, G as GetterWrapper, H as HistoryValue, P as PropTrigger, R as ReactiveError, i as ReactiveErrorCode, j as SchedulerMode, S as ScopedCallback, k as Zone, Z as ZoneAggregator, l as ZoneHistory, m as asyncZone, n as debugPreset, o as devPreset, p as formatCleanupReason, q as isReactive, r as objectToProxy, s as prodPreset, t as proxyToObject, u as reactiveOptions, v as toRaw, w as unwrap } from './types.js';

package/dist/node.dev.cjs

@@ -1,9 +1,9 @@
 'use strict';
 
 require('./debug.cjs');
-require('./chunks/node-Dd0esp5F.cjs');
-var index = require('./chunks/index-yK0HVxHv.cjs');
-var proxy = require('./chunks/proxy-BvM4yewA.cjs');
+require('./chunks/node-Df_5r_WA.cjs');
+var index = require('./chunks/index-BnTNC9eC.cjs');
+var proxy = require('./chunks/proxy-HA_QQnd5.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,31 +84,43 @@ exports.getActivationLog = proxy.getActivationLog;
 exports.getActiveEffect = proxy.getActiveEffect;
 exports.getState = proxy.getState;
 exports.hooks = proxy.hooks;
+exports.inert = proxy.inert;
+exports.inheritCaption = proxy.inheritCaption;
 exports.isConstructor = proxy.isConstructor;
 exports.isDev = proxy.isDev;
 exports.isNonReactive = proxy.isNonReactive;
 exports.isObject = proxy.isObject;
 exports.isProd = proxy.isProd;
 exports.isReactive = proxy.isReactive;
+exports.isReactiveBroken = proxy.isReactiveBroken;
 exports.isTest = proxy.isTest;
 exports.legacyDecorator = proxy.legacyDecorator;
 exports.link = proxy.link;
+exports.markRaw = proxy.markRaw;
+exports.markRawProps = proxy.markRawProps;
 exports.mixin = proxy.mixin;
 exports.modernDecorator = proxy.modernDecorator;
 exports.named = proxy.named;
 exports.objectToProxy = proxy.objectToProxy;
 exports.onEffectThrow = proxy.onEffectThrow;
+exports.onReactiveBroken = proxy.onReactiveBroken;
+exports.onReactiveReset = proxy.onReactiveReset;
 exports.prodPreset = proxy.prodPreset;
 exports.proxyToObject = proxy.proxyToObject;
 exports.reactive = proxy.reactive;
 exports.reactiveOptions = proxy.options;
+exports.readonlyReactive = proxy.readonlyReactive;
 exports.reset = proxy.reset;
 exports.root = proxy.root;
+exports.shallowReactive = proxy.shallowReactive;
 exports.tag = proxy.tag;
+exports.toRaw = proxy.toRaw;
 exports.touched = proxy.touched;
 exports.touched1 = proxy.touched1;
 exports.unlink = proxy.unlink;
 exports.untracked = proxy.untracked;
 exports.unwrap = proxy.unwrap;
+exports.withEffectContext = proxy.withEffectContext;
+exports.wrapInert = proxy.wrapInert;
 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, h as CycleHandlingMode, D as DeprecatedCycleHandlingMode, c as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, G as GetterWrapper, H as HistoryValue, P as PropTrigger, R as ReactiveError, i as ReactiveErrorCode, j as SchedulerMode, S as ScopedCallback, k as Zone, Z as ZoneAggregator, l as ZoneHistory, m as asyncZone, n as debugPreset, o as devPreset, p as formatCleanupReason, q as isReactive, r as objectToProxy, s as prodPreset, t as proxyToObject, u as reactiveOptions, v as toRaw, w as unwrap } from './types.js';
+export { ArrayDiffResult, ArrayReadForward, Captioned, CompareSymbol, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, EffectContext, Eventful, EventsBase, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, MorphPosition, PromiseChain, ReactiveBase, Resource, Restorer, addBatchCleanup, addUnreactiveProps, allocated, allocatedValues, arrayDiff, arrayEquals, assertUntracked, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, captioned, captured, caught, chainPromise, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, effectContext, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, inert, inheritCaption, isCached, isConstructor, isDev, isNonReactive, isObject, isProd, isReactiveBroken, isTest, legacyDecorator, lift, link, markRaw, markRawProps, memoize, mixin, modernDecorator, morph, named, onEffectThrow, onReactiveBroken, onReactiveReset, organize, organized, profileInfo, reactive, readonlyReactive, reset, resource, root, setAt, shallowReactive, tag, throttle, touched, touched1, unlink, unreactive, untracked, watch, when, withEffectContext, wrapInert, zip } from './browser.js';

package/dist/node.dev.esm.js

@@ -1,6 +1,6 @@
 import './debug.esm.js';
-import './chunks/node-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-DuIduHw3.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-CAWVZL7P.esm.js';
+export { A as AZone, C as CompareSymbol, D as DecoratorError, I as IterableWeakMap, a as IterableWeakSet, R as ReactiveBase, b as ReactiveError, c as ReactiveErrorCode, Z as Zone, d as ZoneAggregator, e as ZoneHistory, f as addBatchCleanup, g as addUnreactiveProps, h as arrayEquals, i as assertUntracked, j as asyncHook, k as asyncHooks, l as asyncZone, m as atom, n as atomic, o as biDi, p as captioned, q as captured, r as caught, s as createFlavor, t as debugPreset, u as decorator, v as deepCompare, w as defer, x as devPreset, y as effect, z as effectAggregator, B as effectContext, E as flavorOptions, F as flavored, G as formatCleanupReason, H as getActivationLog, J as getActiveEffect, K as getState, L as hooks, M as inert, N as inheritCaption, O as isConstructor, P as isDev, Q as isNonReactive, S as isObject, T as isProd, U as isReactive, V as isReactiveBroken, W as isTest, X as legacyDecorator, Y as link, _ as markRaw, $ as markRawProps, a0 as mixin, a1 as modernDecorator, a2 as named, a3 as objectToProxy, a4 as onEffectThrow, a5 as onReactiveBroken, a6 as onReactiveReset, a7 as prodPreset, a8 as proxyToObject, a9 as reactive, aa as reactiveOptions, ab as readonlyReactive, ac as reset, ad as root, ae as shallowReactive, af as tag, ag as toRaw, ah as touched, ai as touched1, aj as unlink, ak as untracked, al as unwrap, am as withEffectContext, an as wrapInert, ao as zip } from './chunks/proxy-C2lnvvbx.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-DuIduHw3.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-CAWVZL7P.esm.js';
+export { A as AZone, C as CompareSymbol, D as DecoratorError, I as IterableWeakMap, a as IterableWeakSet, R as ReactiveBase, b as ReactiveError, c as ReactiveErrorCode, Z as Zone, d as ZoneAggregator, e as ZoneHistory, f as addBatchCleanup, g as addUnreactiveProps, h as arrayEquals, i as assertUntracked, j as asyncHook, k as asyncHooks, l as asyncZone, m as atom, n as atomic, o as biDi, p as captioned, q as captured, r as caught, s as createFlavor, t as debugPreset, u as decorator, v as deepCompare, w as defer, x as devPreset, y as effect, z as effectAggregator, B as effectContext, E as flavorOptions, F as flavored, G as formatCleanupReason, H as getActivationLog, J as getActiveEffect, K as getState, L as hooks, M as inert, N as inheritCaption, O as isConstructor, P as isDev, Q as isNonReactive, S as isObject, T as isProd, U as isReactive, V as isReactiveBroken, W as isTest, X as legacyDecorator, Y as link, _ as markRaw, $ as markRawProps, a0 as mixin, a1 as modernDecorator, a2 as named, a3 as objectToProxy, a4 as onEffectThrow, a5 as onReactiveBroken, a6 as onReactiveReset, a7 as prodPreset, a8 as proxyToObject, a9 as reactive, aa as reactiveOptions, ab as readonlyReactive, ac as reset, ad as root, ae as shallowReactive, af as tag, ag as toRaw, ah as touched, ai as touched1, aj as unlink, ak as untracked, al as unwrap, am as withEffectContext, an as wrapInert, ao as zip } from './chunks/proxy-C2lnvvbx.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`.
@@ -267,6 +278,9 @@ declare class ReactiveError extends Error {
     get code(): ReactiveErrorCode | undefined;
     get cause(): any;
 }
+type SchedulerMode = 'raw' | 'ordered' | 'debug';
+type DeprecatedCycleHandlingMode = 'production' | 'development' | 'debug';
+type CycleHandlingMode = SchedulerMode | DeprecatedCycleHandlingMode;
 /**
  * Global options for the reactive system
  */
@@ -356,22 +370,33 @@ declare const options: {
      */
     onMemoizationDiscrepancy: ((cached: any, fresh: any, fn: Function, args: any[], cause: "calculation" | "comparison") => void) | undefined;
     /**
-     * How to handle cycles detected in effect batches.
+     * Effect scheduler mode.
+     *
+     * - `'ordered'` (Default): maintains the causal effect graph so effects that are already
+     *   queued together can run in dependency order. It also preserves parent/child effect
+     *   lifecycle ordering and catches cycles eagerly when edges are created.
+     *
+     * - `'raw'`: fastest FIFO scheduler. It does not maintain the effect graph.
+     *   Cycle detection is heuristic, using maxEffectChain execution counts.
      *
-     * - `'production'` (Default): High-performance mode. Disables dependency graph maintenance and
-     *   Topological Sorting in favor of a simple FIFO queue. Use this for trustworthy, acyclic UI code.
-     *   Cycle detection is heuristic (uses maxEffectChain execution counts).
+     * - `'debug'`: ordered scheduling plus the most detailed graph diagnostics. Highest overhead,
+     *   best for investigation.
      *
-     * - `'development'`: Maintains direct dependency graph for early cycle detection during edge creation.
-     *   Catches cycles before effects execute via DFS check when adding edges. Throws immediately with
-     *   basic path information. Good balance of debugging help with moderate overhead.
+     * @default 'ordered'
+     */
+    scheduler: SchedulerMode;
+    /**
+     * @deprecated Use `scheduler` instead.
      *
-     * - `'debug'`: Full diagnostic mode with transitive closures and topological sorting.
-     *   Provides detailed cycle path reporting. Highest overhead but most informative for bug hunting.
+     * Backward-compatible alias for older names:
+     * - `'production'` maps to `scheduler = 'raw'`
+     * - `'development'` maps to `scheduler = 'ordered'`
+     * - `'debug'` maps to `scheduler = 'debug'`
      *
-     * @default 'production'
+     * The new names describe scheduler behavior rather than runtime environment.
      */
-    cycleHandling: "production" | "development" | "debug";
+    get cycleHandling(): SchedulerMode;
+    set cycleHandling(mode: CycleHandlingMode);
     /**
      * Internal flag used by memoization discrepancy detector to avoid counting calls in tests
      * @warning Do not modify this flag manually, this flag is given by the engine
@@ -419,6 +444,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.
      *
@@ -443,18 +469,19 @@ declare const options: {
         logErrors: boolean;
         enableHistory: boolean;
         historySize: number;
-    } | null;
+    } | undefined;
 };
 /** Production preset: no introspection, heuristic cycle detection, minimal overhead */
 declare const prodPreset: Partial<typeof options>;
-/** Development preset (default): introspection on, early cycle detection, warnings */
+/** Development preset: introspection on, early cycle detection, warnings */
 declare const devPreset: Partial<typeof options>;
 /** Debug preset: full diagnostics, throws on violations, rich lineage capture */
 declare const debugPreset: Partial<typeof options>;
 declare const objectToProxy: WeakMap<object, object>;
 declare const proxyToObject: WeakMap<object, object>;
 declare function unwrap<T>(obj: T): T;
+declare const toRaw: typeof unwrap;
 declare function isReactive(obj: any): boolean;
 
-export { AZone as A, ReactiveError as R, ZoneAggregator as Z, ReactiveErrorCode as h, Zone as i, ZoneHistory as j, asyncZone as k, debugPreset as l, devPreset as m, formatCleanupReason as n, isReactive as o, objectToProxy as p, prodPreset as q, proxyToObject as r, options as s, unwrap as u };
-export type { CleanupReason as C, EffectTrigger as E, GetterWrapper as G, HistoryValue as H, PropTrigger as P, ScopedCallback as S, Evolution as a, EffectCleanup as b, EffectAccess as c, EffectCloser as d, State as e, CatchFunction as f, EffectOptions as g };
+export { AZone as A, ReactiveError as R, ZoneAggregator as Z, ReactiveErrorCode as i, Zone as k, ZoneHistory as l, asyncZone as m, debugPreset as n, devPreset as o, formatCleanupReason as p, isReactive as q, objectToProxy as r, prodPreset as s, proxyToObject as t, options as u, toRaw as v, unwrap as w };
+export type { CleanupReason as C, DeprecatedCycleHandlingMode as D, EffectTrigger as E, GetterWrapper as G, HistoryValue as H, PropTrigger as P, ScopedCallback as S, Evolution as a, EffectCleanup as b, EffectAccess as c, EffectCloser as d, State as e, CatchFunction as f, EffectOptions as g, CycleHandlingMode as h, SchedulerMode as j };

package/docs/ai/api-reference.md

@@ -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
@@ -95,8 +185,10 @@ export declare function deprecated(message?: string): Function;
 // buildReactivityGraph, getMutationHistory, getDependents, getDependencies, etc.
 
 export declare const reactiveOptions: {
-    cycleHandling: 'production' | 'development' | 'debug';
-    introspection: { enableHistory: boolean; historySize: number; logErrors: boolean };
+    scheduler: 'raw' | 'ordered' | 'debug';
+    /** @deprecated Use scheduler instead. */
+    cycleHandling: 'raw' | 'ordered' | 'debug' | 'production' | 'development';
+    introspection: unknown;
 };
 
 export enum ReactiveErrorCode {