mutts 1.0.9 → 1.0.10

package/dist/node.cjs

@@ -1,11 +1,11 @@
 'use strict';
 
-require('./chunks/async-node-C3DeIb0y.cjs');
+require('./chunks/async-node-3PrbVAbB.cjs');
 var browser = require('./browser.cjs');
-var debug = require('./chunks/index-VTO-b2vR.cjs');
+var proxy = require('./chunks/proxy-Dtg-bJ3T.cjs');
 var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
 require('node:async_hooks');
-require('./chunks/async-browser-lvzLOCgk.cjs');
+require('./chunks/async-browser-BU_IfxYD.cjs');
 
 
 
@@ -17,6 +17,7 @@ exports.Indexable = browser.Indexable;
 exports.Register = browser.Register;
 exports.allocated = browser.allocated;
 exports.allocatedValues = browser.allocatedValues;
+exports.arrayDiff = browser.arrayDiff;
 exports.attend = browser.attend;
 exports.cache = browser.cache;
 exports.cached = browser.cached;
@@ -25,82 +26,83 @@ exports.chainPromise = browser.chainPromise;
 exports.debounce = browser.debounce;
 exports.deepWatch = browser.deepWatch;
 exports.deprecated = browser.deprecated;
-exports.describe = browser.describe;
 exports.descriptor = browser.descriptor;
 exports.destructor = browser.destructor;
 exports.forwardArray = browser.forwardArray;
-exports.getActiveProjection = browser.getActiveProjection;
 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.project;
+exports.project = browser.morph;
 exports.register = browser.register;
+exports.resource = browser.resource;
 exports.scan = browser.scan;
 exports.setAt = browser.setAt;
 exports.throttle = browser.throttle;
 exports.unreactive = browser.unreactive;
 exports.watch = browser.watch;
-exports.AZone = debug.AZone;
-exports.DecoratorError = debug.DecoratorError;
-exports.FoolProof = debug.FoolProof;
-exports.IterableWeakMap = debug.IterableWeakMap;
-exports.IterableWeakSet = debug.IterableWeakSet;
-exports.ReactiveBase = debug.ReactiveBase;
-exports.ReactiveError = debug.ReactiveError;
+exports.when = browser.when;
+exports.AZone = proxy.AZone;
+exports.DecoratorError = proxy.DecoratorError;
+exports.IterableWeakMap = proxy.IterableWeakMap;
+exports.IterableWeakSet = proxy.IterableWeakSet;
+exports.ReactiveBase = proxy.ReactiveBase;
+exports.ReactiveError = proxy.ReactiveError;
 Object.defineProperty(exports, "ReactiveErrorCode", {
 	enumerable: true,
-	get: function () { return debug.ReactiveErrorCode; }
+	get: function () { return proxy.ReactiveErrorCode; }
 });
-exports.Zone = debug.Zone;
-exports.ZoneAggregator = debug.ZoneAggregator;
-exports.ZoneHistory = debug.ZoneHistory;
-exports.addBatchCleanup = debug.addBatchCleanup;
-exports.arrayEquals = debug.arrayEquals;
-exports.asyncZone = debug.asyncZone;
-exports.atomic = debug.atomic;
-exports.biDi = debug.biDi;
-exports.cleanedBy = debug.cleanedBy;
-exports.cleanup = debug.cleanup;
-exports.contentRef = debug.contentRef;
-exports.createFlavor = debug.createFlavor;
-exports.decorator = debug.decorator;
-exports.deepCompare = debug.deepCompare;
-exports.defer = debug.defer;
-exports.derived = debug.derived;
-exports.effect = debug.effect;
-exports.effectAggregator = debug.effectAggregator;
-exports.flavorOptions = debug.flavorOptions;
-exports.flavored = debug.flavored;
-exports.getActivationLog = debug.getActivationLog;
-exports.getActiveEffect = debug.getActiveEffect;
-exports.getState = debug.getState;
-exports.immutables = debug.immutables;
-exports.isConstructor = debug.isConstructor;
-exports.isNonReactive = debug.isNonReactive;
-exports.isOwnAccessor = debug.isOwnAccessor;
-exports.isReactive = debug.isReactive;
-exports.legacyDecorator = debug.legacyDecorator;
-exports.mixin = debug.mixin;
-exports.modernDecorator = debug.modernDecorator;
-exports.named = debug.named;
-exports.onEffectThrow = debug.onEffectThrow;
-exports.onEffectTrigger = debug.onEffectTrigger;
-exports.reactive = debug.reactive;
-exports.reactiveOptions = debug.options;
-exports.registerNativeReactivity = debug.registerNativeReactivity;
-exports.renamed = debug.renamed;
-exports.reset = debug.reset;
-exports.root = debug.root;
-exports.tag = debug.tag;
-exports.touched = debug.touched;
-exports.touched1 = debug.touched1;
-exports.untracked = debug.untracked;
-exports.unwrap = debug.unwrap;
-exports.zip = debug.zip;
+exports.Zone = proxy.Zone;
+exports.ZoneAggregator = proxy.ZoneAggregator;
+exports.ZoneHistory = proxy.ZoneHistory;
+exports.addBatchCleanup = proxy.addBatchCleanup;
+exports.arrayEquals = proxy.arrayEquals;
+exports.asyncZone = proxy.asyncZone;
+exports.atom = proxy.atom;
+exports.atomic = proxy.atomic;
+exports.biDi = proxy.biDi;
+exports.caught = proxy.caught;
+exports.cleanedBy = proxy.cleanedBy;
+exports.cleanup = proxy.cleanup;
+exports.createFlavor = proxy.createFlavor;
+exports.decorator = proxy.decorator;
+exports.deepCompare = proxy.deepCompare;
+exports.defer = proxy.defer;
+exports.effect = proxy.effect;
+exports.effectAggregator = proxy.effectAggregator;
+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.immutables = proxy.immutables;
+exports.isConstructor = proxy.isConstructor;
+exports.isNonReactive = proxy.isNonReactive;
+exports.isObject = proxy.isObject;
+exports.isReactive = proxy.isReactive;
+exports.legacyDecorator = proxy.legacyDecorator;
+exports.mixin = proxy.mixin;
+exports.modernDecorator = proxy.modernDecorator;
+exports.named = proxy.named;
+exports.objectToProxy = proxy.objectToProxy;
+exports.onEffectThrow = proxy.onEffectThrow;
+exports.proxyToObject = proxy.proxyToObject;
+exports.reactive = proxy.reactive;
+exports.reactiveOptions = proxy.options;
+exports.reset = proxy.reset;
+exports.root = proxy.root;
+exports.stopped = proxy.stopped;
+exports.tag = proxy.tag;
+exports.touched = proxy.touched;
+exports.touched1 = proxy.touched1;
+exports.untracked = proxy.untracked;
+exports.unwrap = proxy.unwrap;
+exports.zip = proxy.zip;
 exports.asyncHook = asyncCore.asyncHook;
 exports.asyncHooks = asyncCore.asyncHooks;
 exports.hooks = asyncCore.hooks;

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 { ArrayReadForward, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, Eventful, EventsBase, FoolProof, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactiveBase, Register, Restorer, ScanResult, addBatchCleanup, allocated, allocatedValues, arrayEquals, asyncHook, asyncHooks, atomic, attend, biDi, cache, cached, callOnGC, chainPromise, cleanedBy, contentRef, debounce, decorator, deepCompare, deepWatch, defer, deprecated, derived, describe, descriptor, destructor, effect, effectAggregator, forwardArray, getActivationLog, getActiveEffect, getActiveProjection, getAt, getState, hooks, immutables, isCached, isConstructor, isNonReactive, isOwnAccessor, isReactive, legacyDecorator, lift, memoize, mixin, modernDecorator, named, onEffectThrow, onEffectTrigger, organize, organized, profileInfo, project, reactive, register, registerNativeReactivity, renamed, reset, root, scan, setAt, tag, throttle, touched, touched1, unreactive, untracked, unwrap, watch, zip } from './browser.js';
-export { A as AZone, e as DependencyAccess, b as EffectCleanup, g as EffectOptions, E as EffectTrigger, a as Evolution, F as FunctionWrapper, R as ReactiveError, h as ReactiveErrorCode, S as ScopedCallback, i as Zone, Z as ZoneAggregator, j as ZoneHistory, k as asyncZone, c as cleanup, o as reactiveOptions } from './types-DaHFfhlN.js';
+export { ArrayDiffResult, ArrayReadForward, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, Eventful, EventsBase, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactiveBase, Register, Resource, Restorer, ScanResult, addBatchCleanup, allocated, allocatedValues, arrayDiff, arrayEquals, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, caught, chainPromise, cleanedBy, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, immutables, isCached, isConstructor, isNonReactive, isObject, legacyDecorator, lift, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, morph as project, reactive, register, reset, resource, root, scan, setAt, tag, throttle, touched, touched1, unreactive, untracked, watch, when, zip } from './index.js';
+export { A as AZone, h as CleanupReason, e as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, F as FunctionWrapper, P as PropTrigger, R as ReactiveError, i as ReactiveErrorCode, S as ScopedCallback, j as Zone, Z as ZoneAggregator, k as ZoneHistory, l as asyncZone, c as cleanup, m as formatCleanupReason, n as isReactive, o as objectToProxy, p as proxyToObject, q as reactiveOptions, s as stopped, u as unwrap } from './types-W5vD6m2n.js';

package/dist/node.dev.cjs

@@ -0,0 +1,110 @@
+'use strict';
+
+require('./debug.cjs');
+require('./chunks/async-node-3PrbVAbB.cjs');
+var browser = require('./browser.cjs');
+var proxy = require('./chunks/proxy-Dtg-bJ3T.cjs');
+var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
+require('node:async_hooks');
+require('./chunks/async-browser-BU_IfxYD.cjs');
+
+
+
+exports.ArrayReadForward = browser.ArrayReadForward;
+exports.Destroyable = browser.Destroyable;
+exports.DestructionError = browser.DestructionError;
+exports.Eventful = browser.Eventful;
+exports.Indexable = browser.Indexable;
+exports.Register = browser.Register;
+exports.allocated = browser.allocated;
+exports.allocatedValues = browser.allocatedValues;
+exports.arrayDiff = browser.arrayDiff;
+exports.attend = browser.attend;
+exports.cache = browser.cache;
+exports.cached = browser.cached;
+exports.callOnGC = browser.callOnGC;
+exports.chainPromise = browser.chainPromise;
+exports.debounce = browser.debounce;
+exports.deepWatch = browser.deepWatch;
+exports.deprecated = browser.deprecated;
+exports.descriptor = browser.descriptor;
+exports.destructor = browser.destructor;
+exports.forwardArray = browser.forwardArray;
+exports.getAt = browser.getAt;
+exports.isCached = browser.isCached;
+exports.lift = browser.lift;
+exports.memoize = browser.memoize;
+exports.morph = browser.morph;
+exports.organize = browser.organize;
+exports.organized = browser.organized;
+exports.profileInfo = browser.profileInfo;
+exports.project = browser.morph;
+exports.register = browser.register;
+exports.resource = browser.resource;
+exports.scan = browser.scan;
+exports.setAt = browser.setAt;
+exports.throttle = browser.throttle;
+exports.unreactive = browser.unreactive;
+exports.watch = browser.watch;
+exports.when = browser.when;
+exports.AZone = proxy.AZone;
+exports.DecoratorError = proxy.DecoratorError;
+exports.IterableWeakMap = proxy.IterableWeakMap;
+exports.IterableWeakSet = proxy.IterableWeakSet;
+exports.ReactiveBase = proxy.ReactiveBase;
+exports.ReactiveError = proxy.ReactiveError;
+Object.defineProperty(exports, "ReactiveErrorCode", {
+	enumerable: true,
+	get: function () { return proxy.ReactiveErrorCode; }
+});
+exports.Zone = proxy.Zone;
+exports.ZoneAggregator = proxy.ZoneAggregator;
+exports.ZoneHistory = proxy.ZoneHistory;
+exports.addBatchCleanup = proxy.addBatchCleanup;
+exports.arrayEquals = proxy.arrayEquals;
+exports.asyncZone = proxy.asyncZone;
+exports.atom = proxy.atom;
+exports.atomic = proxy.atomic;
+exports.biDi = proxy.biDi;
+exports.caught = proxy.caught;
+exports.cleanedBy = proxy.cleanedBy;
+exports.cleanup = proxy.cleanup;
+exports.createFlavor = proxy.createFlavor;
+exports.decorator = proxy.decorator;
+exports.deepCompare = proxy.deepCompare;
+exports.defer = proxy.defer;
+exports.effect = proxy.effect;
+exports.effectAggregator = proxy.effectAggregator;
+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.immutables = proxy.immutables;
+exports.isConstructor = proxy.isConstructor;
+exports.isNonReactive = proxy.isNonReactive;
+exports.isObject = proxy.isObject;
+exports.isReactive = proxy.isReactive;
+exports.legacyDecorator = proxy.legacyDecorator;
+exports.mixin = proxy.mixin;
+exports.modernDecorator = proxy.modernDecorator;
+exports.named = proxy.named;
+exports.objectToProxy = proxy.objectToProxy;
+exports.onEffectThrow = proxy.onEffectThrow;
+exports.proxyToObject = proxy.proxyToObject;
+exports.reactive = proxy.reactive;
+exports.reactiveOptions = proxy.options;
+exports.reset = proxy.reset;
+exports.root = proxy.root;
+exports.stopped = proxy.stopped;
+exports.tag = proxy.tag;
+exports.touched = proxy.touched;
+exports.touched1 = proxy.touched1;
+exports.untracked = proxy.untracked;
+exports.unwrap = proxy.unwrap;
+exports.zip = proxy.zip;
+exports.asyncHook = asyncCore.asyncHook;
+exports.asyncHooks = asyncCore.asyncHooks;
+exports.hooks = asyncCore.hooks;
+//# sourceMappingURL=node.dev.cjs.map

package/dist/node.dev.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.dev.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/node.dev.d.ts

@@ -0,0 +1,2 @@
+export { A as AZone, h as CleanupReason, e as EffectAccess, b as EffectCleanup, d as EffectCloser, g as EffectOptions, E as EffectTrigger, a as Evolution, F as FunctionWrapper, P as PropTrigger, R as ReactiveError, i as ReactiveErrorCode, S as ScopedCallback, j as Zone, Z as ZoneAggregator, k as ZoneHistory, l as asyncZone, c as cleanup, m as formatCleanupReason, n as isReactive, o as objectToProxy, p as proxyToObject, q as reactiveOptions, s as stopped, u as unwrap } from './types-W5vD6m2n.js';
+export { ArrayDiffResult, ArrayReadForward, ContextManager, Decorator, DecoratorDescription, DecoratorError, DecoratorFactory, Destroyable, DestructionError, Eventful, EventsBase, GenericClassDecorator, Hook, Indexable, IterableWeakMap, IterableWeakSet, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, ReactiveBase, Register, Resource, Restorer, ScanResult, addBatchCleanup, allocated, allocatedValues, arrayDiff, arrayEquals, asyncHook, asyncHooks, atom, atomic, attend, biDi, cache, cached, callOnGC, caught, chainPromise, cleanedBy, createFlavor, debounce, decorator, deepCompare, deepWatch, defer, deprecated, descriptor, destructor, effect, effectAggregator, flavorOptions, flavored, forwardArray, getActivationLog, getActiveEffect, getAt, getState, hooks, immutables, isCached, isConstructor, isNonReactive, isObject, legacyDecorator, lift, memoize, mixin, modernDecorator, morph, named, onEffectThrow, organize, organized, profileInfo, morph as project, reactive, register, reset, resource, root, scan, setAt, tag, throttle, touched, touched1, unreactive, untracked, watch, when, zip } from './index.js';

package/dist/node.dev.esm.js

@@ -0,0 +1,6 @@
+import './debug.esm.js';
+import './chunks/node-nKJBk8iJ.esm.js';
+export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, R as Register, b as allocated, c as allocatedValues, d as arrayDiff, e as attend, f as cache, g as cached, h as callOnGC, i as chainPromise, j as debounce, k as deepWatch, l as deprecated, m as descriptor, n as destructor, o as forwardArray, p as getAt, q as isCached, r as lift, s as memoize, t as morph, u as organize, v as organized, w as profileInfo, t as project, x as register, y as resource, z as scan, B as setAt, C as throttle, F as unreactive, G as watch, H as when } from './chunks/index-CaaQQlPJ.esm.js';
+export { A as AZone, D as DecoratorError, I as IterableWeakMap, a as IterableWeakSet, R as ReactiveBase, b as ReactiveError, c as ReactiveErrorCode, Z as Zone, d as ZoneAggregator, e as ZoneHistory, f as addBatchCleanup, g as arrayEquals, h as asyncHook, i as asyncHooks, j as asyncZone, k as atom, l as atomic, m as biDi, n as caught, o as cleanedBy, p as cleanup, q as createFlavor, r as decorator, s as deepCompare, t as defer, u as effect, v as effectAggregator, w as flavorOptions, x as flavored, y as formatCleanupReason, z as getActivationLog, B as getActiveEffect, C as getState, E as hooks, F as immutables, G as isConstructor, H as isNonReactive, J as isObject, K as isReactive, L as legacyDecorator, M as mixin, N as modernDecorator, O as named, P as objectToProxy, Q as onEffectThrow, S as proxyToObject, T as reactive, U as reactiveOptions, V as reset, W as root, X as stopped, Y as tag, _ as touched, $ as touched1, a0 as untracked, a1 as unwrap, a2 as zip } from './chunks/proxy-r7lARftl.esm.js';
+import 'node:async_hooks';
+//# sourceMappingURL=node.dev.esm.js.map

package/dist/node.dev.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.dev.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/node.esm.js

@@ -1,98 +1,5 @@
-import { createHook } from 'node:async_hooks';
-import { h as hooks } from './chunks/index-CtA2AWl3.esm.js';
-export { A as AZone, D as DecoratorError, F as FoolProof, I as IterableWeakMap, b as IterableWeakSet, R as ReactiveBase, c as ReactiveError, d as ReactiveErrorCode, Z as Zone, e as ZoneAggregator, f as ZoneHistory, g as addBatchCleanup, i as arrayEquals, j as asyncHook, a as asyncHooks, k as asyncZone, l as atomic, m as biDi, n as cleanedBy, o as cleanup, p as contentRef, q as createFlavor, r as decorator, s as deepCompare, t as defer, u as derived, v as effect, w as effectAggregator, x as flavorOptions, y as flavored, z as getActivationLog, B as getActiveEffect, C as getState, E as immutables, G as isConstructor, H as isNonReactive, J as isOwnAccessor, K as isReactive, L as legacyDecorator, M as mixin, N as modernDecorator, O as named, P as onEffectThrow, Q as onEffectTrigger, S as reactive, T as reactiveOptions, U as registerNativeReactivity, V as renamed, W as reset, X as root, Y as tag, _ as touched, $ as touched1, a0 as untracked, a1 as unwrap, a2 as zip } from './chunks/index-CtA2AWl3.esm.js';
-export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, R as Register, b as allocated, c as allocatedValues, d as attend, e as cache, f as cached, g as callOnGC, h as chainPromise, i as debounce, j as deepWatch, k as deprecated, l as describe, m as descriptor, n as destructor, o as forwardArray, p as getActiveProjection, q as getAt, r as isCached, s as lift, t as memoize, u as organize, v as organized, w as profileInfo, x as project, y as register, z as scan, B as setAt, C as throttle, F as unreactive, G as watch } from './chunks/index-2vea86wD.esm.js';
-
-// 1. Generic async_hooks implementation for Hooks
-// This maintains support for 'asyncHooks.addHook' for generic use cases.
-const contexts = new Map();
-const activeUndoers = new Map();
-// Helper to capture current hooks state
-function captureRestorers() {
-    if (hooks.size === 0)
-        return [];
-    const restorers = [];
-    for (const h of hooks) {
-        const r = h();
-        if (r)
-            restorers.push(r);
-    }
-    return restorers;
-}
-// Manual Wrap function to handle Promise callbacks
-function wrap(fn) {
-    if (typeof fn !== 'function')
-        return fn;
-    const restorers = captureRestorers();
-    if (restorers.length === 0)
-        return fn;
-    return function (...args) {
-        const undoers = [];
-        for (const restore of restorers) {
-            const u = restore();
-            if (u)
-                undoers.push(u);
-        }
-        try {
-            return fn.apply(this, args);
-        }
-        finally {
-            for (let i = undoers.length - 1; i >= 0; i--)
-                undoers[i]();
-        }
-    };
-}
-const hook = createHook({
-    init(asyncId, _type, _triggerId, _resource) {
-        // Used for native resources like Timers
-        const restorers = captureRestorers();
-        if (restorers.length > 0)
-            contexts.set(asyncId, restorers);
-    },
-    before(asyncId) {
-        const restorers = contexts.get(asyncId);
-        if (!restorers)
-            return;
-        const undoers = [];
-        for (const restore of restorers) {
-            const u = restore();
-            if (u)
-                undoers.push(u);
-        }
-        if (undoers.length > 0)
-            activeUndoers.set(asyncId, undoers);
-    },
-    after(asyncId) {
-        const undoers = activeUndoers.get(asyncId);
-        if (!undoers)
-            return;
-        for (let i = undoers.length - 1; i >= 0; i--)
-            undoers[i]();
-        activeUndoers.delete(asyncId);
-    },
-    destroy(asyncId) {
-        contexts.delete(asyncId);
-        activeUndoers.delete(asyncId);
-    },
-});
-hook.enable();
-// 2. Shadow Promise Implementation
-// Ensures V8 await resumptions are visible as .then callbacks, wrapping them to restore context.
-const OriginalPromise = globalThis.Promise;
-const originalMethods = {
-    then: OriginalPromise.prototype.then,
-    catch: OriginalPromise.prototype.catch,
-    finally: OriginalPromise.prototype.finally};
-// Patch prototype
-OriginalPromise.prototype.then = function (onFulfilled, onRejected) {
-    return originalMethods.then.call(this, wrap(onFulfilled), wrap(onRejected));
-};
-OriginalPromise.prototype.catch = function (onRejected) {
-    return originalMethods.catch.call(this, wrap(onRejected));
-};
-OriginalPromise.prototype.finally = function (onFinally) {
-    return originalMethods.finally.call(this, wrap(onFinally));
-};
-
-export { hooks };
+import './chunks/node-nKJBk8iJ.esm.js';
+export { A as ArrayReadForward, D as Destroyable, a as DestructionError, E as Eventful, I as Indexable, R as Register, b as allocated, c as allocatedValues, d as arrayDiff, e as attend, f as cache, g as cached, h as callOnGC, i as chainPromise, j as debounce, k as deepWatch, l as deprecated, m as descriptor, n as destructor, o as forwardArray, p as getAt, q as isCached, r as lift, s as memoize, t as morph, u as organize, v as organized, w as profileInfo, t as project, x as register, y as resource, z as scan, B as setAt, C as throttle, F as unreactive, G as watch, H as when } from './chunks/index-CaaQQlPJ.esm.js';
+export { A as AZone, D as DecoratorError, I as IterableWeakMap, a as IterableWeakSet, R as ReactiveBase, b as ReactiveError, c as ReactiveErrorCode, Z as Zone, d as ZoneAggregator, e as ZoneHistory, f as addBatchCleanup, g as arrayEquals, h as asyncHook, i as asyncHooks, j as asyncZone, k as atom, l as atomic, m as biDi, n as caught, o as cleanedBy, p as cleanup, q as createFlavor, r as decorator, s as deepCompare, t as defer, u as effect, v as effectAggregator, w as flavorOptions, x as flavored, y as formatCleanupReason, z as getActivationLog, B as getActiveEffect, C as getState, E as hooks, F as immutables, G as isConstructor, H as isNonReactive, J as isObject, K as isReactive, L as legacyDecorator, M as mixin, N as modernDecorator, O as named, P as objectToProxy, Q as onEffectThrow, S as proxyToObject, T as reactive, U as reactiveOptions, V as reset, W as root, X as stopped, Y as tag, _ as touched, $ as touched1, a0 as untracked, a1 as unwrap, a2 as zip } from './chunks/proxy-r7lARftl.esm.js';
+import 'node:async_hooks';
 //# sourceMappingURL=node.esm.js.map

package/dist/node.esm.js.map

@@ -1 +1 @@
-{"version":3,"file":"node.esm.js","sources":["../src/async/node.ts"],"sourcesContent":["import { createHook } from 'node:async_hooks'\nimport { hooks, type Restorer } from '.'\n\n// 1. Generic async_hooks implementation for Hooks\n// This maintains support for 'asyncHooks.addHook' for generic use cases.\n\nconst contexts = new Map<number, Restorer[]>()\nconst activeUndoers = new Map<number, (() => void)[]>()\n\n// Helper to capture current hooks state\nfunction captureRestorers() {\n\tif (hooks.size === 0) return []\n\tconst restorers: Restorer[] = []\n\tfor (const h of hooks) {\n\t\tconst r = h()\n\t\tif (r) restorers.push(r)\n\t}\n\treturn restorers\n}\n\n// Manual Wrap function to handle Promise callbacks\nfunction wrap<Args extends any[], R>(fn: ((...args: Args) => R) | null | undefined) {\n\tif (typeof fn !== 'function') return fn\n\tconst restorers = captureRestorers()\n\tif (restorers.length === 0) return fn\n\n\treturn function (this: any, ...args: Args) {\n\t\tconst undoers: (() => void)[] = []\n\t\tfor (const restore of restorers) {\n\t\t\tconst u = restore()\n\t\t\tif (u) undoers.push(u)\n\t\t}\n\t\ttry {\n\t\t\treturn fn.apply(this, args)\n\t\t} finally {\n\t\t\tfor (let i = undoers.length - 1; i >= 0; i--) undoers[i]()\n\t\t}\n\t}\n}\n\nconst hook = createHook({\n\tinit(asyncId, _type, _triggerId, _resource) {\n\t\t// Used for native resources like Timers\n\t\tconst restorers = captureRestorers()\n\t\tif (restorers.length > 0) contexts.set(asyncId, restorers)\n\t},\n\tbefore(asyncId) {\n\t\tconst restorers = contexts.get(asyncId)\n\t\tif (!restorers) return\n\t\tconst undoers: (() => void)[] = []\n\t\tfor (const restore of restorers) {\n\t\t\tconst u = restore()\n\t\t\tif (u) undoers.push(u)\n\t\t}\n\t\tif (undoers.length > 0) activeUndoers.set(asyncId, undoers)\n\t},\n\tafter(asyncId) {\n\t\tconst undoers = activeUndoers.get(asyncId)\n\t\tif (!undoers) return\n\t\tfor (let i = undoers.length - 1; i >= 0; i--) undoers[i]()\n\t\tactiveUndoers.delete(asyncId)\n\t},\n\tdestroy(asyncId) {\n\t\tcontexts.delete(asyncId)\n\t\tactiveUndoers.delete(asyncId)\n\t},\n})\nhook.enable()\n\n// 2. Shadow Promise Implementation\n// Ensures V8 await resumptions are visible as .then callbacks, wrapping them to restore context.\n\nconst OriginalPromise = globalThis.Promise\nconst originalMethods = {\n\tthen: OriginalPromise.prototype.then,\n\tcatch: OriginalPromise.prototype.catch,\n\tfinally: OriginalPromise.prototype.finally,\n\tresolve: OriginalPromise.resolve,\n\treject: OriginalPromise.reject,\n\tall: OriginalPromise.all,\n}\n\n// Patch prototype\nOriginalPromise.prototype.then = function (onFulfilled, onRejected) {\n\treturn originalMethods.then.call(this, wrap(onFulfilled), wrap(onRejected))\n} as any\nOriginalPromise.prototype.catch = function (onRejected) {\n\treturn originalMethods.catch.call(this, wrap(onRejected))\n} as any\nOriginalPromise.prototype.finally = function (onFinally) {\n\treturn originalMethods.finally.call(this, wrap(onFinally))\n} as any\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"node.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

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

@@ -74,28 +74,70 @@ interface EffectAccess {
      */
     ascend: FunctionWrapper;
     /**
-     * Indicates whether the effect is running as a reaction (i.e. not the first call)
-     * - `false`: First execution when the effect is created
-     * - `true`: Subsequent executions triggered by dependency changes
+     * `false` on the first execution, `true` or `CleanupReason` on subsequent runs.
+     * `true` means this is a re-run but detailed reason gathering is disabled or unavailable.
+     * A `CleanupReason` describes *why* the previous run was torn down.
      * @example
      * ```typescript
      * effect(({ reaction }) => {
      *   if (!reaction) {
-     *     console.log('Effect initialized')
-     *     // Setup code that should only run once
-     *   } else {
-     *     console.log('Effect re-ran due to dependency change')
-     *     // Code that runs on every update
+     *     // First run — setup
+     *   } else if (reaction !== true && reaction.type === 'propChange') {
+     *     // Re-run due to dependency change (with details)
+     *     for (const { evolution } of reaction.triggers)
+     *       console.log(`${'prop' in evolution ? evolution.prop : evolution.method}: ${evolution.type}`)
      *   }
      * })
      * ```
      */
-    reaction: boolean;
+    reaction: boolean | CleanupReason;
 }
 /**
  * Base type for effect callbacks - simple function without additional properties
  */
-type ScopedCallback = () => void;
+type ScopedCallback = (reason?: CleanupReason) => void;
+type PropTrigger = {
+    obj: object;
+    evolution: Evolution;
+    dependency?: unknown;
+    touch?: unknown;
+};
+/**
+ * Reason for an effect cleanup/reaction
+ */
+type CleanupReason = {
+    type: 'propChange';
+    triggers: PropTrigger[];
+} | {
+    type: 'invalidate';
+    cause: CleanupReason;
+} | {
+    type: 'stopped';
+} | {
+    type: 'gc';
+} | {
+    type: 'lineage';
+    parent: CleanupReason;
+} | {
+    type: 'error';
+    error: unknown;
+} | {
+    type: 'multiple';
+    reasons: CleanupReason[];
+};
+/**
+ * Console-friendly description of a `CleanupReason`.
+ * Returns an array of arguments to spread into `console.log` / `console.warn`,
+ * mixing strings and raw object references so the console can render them as inspectable values.
+ *
+ * @example
+ * ```typescript
+ * effect(({ reaction }) => {
+ *   if (reaction !== true) console.log(...formatCleanupReason(reaction))
+ * })
+ * ```
+ */
+declare function formatCleanupReason(reason: CleanupReason, depth?: number): unknown[];
 /**
  * Type for effect cleanup functions with stopped state tracking
  */
@@ -164,49 +206,48 @@ declare const stopped: unique symbol;
  * Symbol to access effect cleanup function
  */
 declare const cleanup: unique symbol;
-type EffectCloser = (error?: any) => void;
+type EffectCloser = (reason?: CleanupReason) => void;
 type CatchFunction = (error: any) => EffectCloser | undefined | void;
-/**
- * Context for a running projection item effect
- */
-interface ProjectionContext {
-    source: any;
-    key?: any;
-    target: any;
-    depth: number;
-    parent?: ProjectionContext;
-}
 /**
  * Structured error codes for machine-readable diagnosis
  */
 declare enum ReactiveErrorCode {
-    CycleDetected = "CYCLE_DETECTED",
-    MaxDepthExceeded = "MAX_DEPTH_EXCEEDED",
-    MaxReactionExceeded = "MAX_REACTION_EXCEEDED",
-    WriteInComputed = "WRITE_IN_COMPUTED",
-    TrackingError = "TRACKING_ERROR",
-    BrokenEffects = "BROKEN_EFFECTS"
+    CycleDetected = "Cycle detected",
+    MaxDepthExceeded = "Max depth exceeded",
+    MaxReactionExceeded = "Max reaction exceeded",
+    WriteInComputed = "Write in computed",
+    TrackingError = "Tracking error",
+    BrokenEffects = "Broken effects"
 }
 type CycleDebugInfo = {
     code: ReactiveErrorCode.CycleDetected;
     cycle: string[];
     details?: string;
+    causalChain?: string[];
+    lineage?: unknown;
 };
 type MaxDepthDebugInfo = {
     code: ReactiveErrorCode.MaxDepthExceeded;
-    depth: number;
-    chain: string[];
+    effectuatedRoots: any[];
+    cycle: any[] | null;
+    trace: string;
+    maxEffectChain: number;
+    queued: string[];
+    queuedCount: number;
+    causalChain?: string[];
+    lineage?: unknown;
 };
 type MaxReactionDebugInfo = {
     code: ReactiveErrorCode.MaxReactionExceeded;
     count: number;
     effect: string;
+    causalChain?: string[];
+    lineage?: unknown;
 };
 type GenericDebugInfo = {
     code: ReactiveErrorCode;
     causalChain?: string[];
-    creationStack?: string | any[];
-    lineage?: any[];
+    lineage?: unknown;
     [key: string]: any;
 };
 type ReactiveDebugInfo = CycleDebugInfo | MaxDepthDebugInfo | MaxReactionDebugInfo | GenericDebugInfo;
@@ -256,7 +297,7 @@ declare const options: {
      * @param props - The properties that changed
      * @param deps - The dependencies that changed
      */
-    touched: (_obj: any, _evolution: Evolution, _props?: any[], _deps?: Set<EffectTrigger>) => void;
+    touched: (_obj: any, _evolution: Evolution, _props?: any[], _deps?: EffectTrigger[]) => void;
     /**
      * Debug purpose: called when an effect is skipped because it's already running
      * @param effect - The effect that is already running
@@ -366,20 +407,30 @@ declare const options: {
     asyncMode: AsyncExecutionMode | false;
     warn: (...args: any[]) => void;
     /**
-     * Configuration for the introspection system
+     * Introspection and debug aids. Set to `null` to disable all debug overhead in production.
+     *
+     * - `gatherReasons`: collect `PropTrigger[]` for `CleanupReason` on effect re-runs (default `true`)
+     *   - `lineages`: what lineages to capture in PropTrigger (default `'touch'`)
+     * - `logErrors`: log errors with detailed context (default `true`)
+     * - `enableHistory`: keep a history of mutations (default `true`)
+     * - `historySize`: number of mutations to keep in history (default `50`)
+     *
+     * `enableDevTools()` sets `logErrors` to `true` automatically.
+     *
+     * @example
+     * ```typescript
+     * // Production: disable all introspection
+     * reactiveOptions.introspection = null
+     * ```
      */
     introspection: {
-        /**
-         * Whether to keep a history of mutations for debugging
-         * @default false
-         */
+        gatherReasons: {
+            lineages: "none" | "touch" | "dependency" | "both";
+        };
+        logErrors: boolean;
         enableHistory: boolean;
-        /**
-         * Number of mutations to keep in history
-         * @default 50
-         */
         historySize: number;
-    };
+    } | null;
     /**
      * Configuration for zone hooks - control which async APIs are hooked
      * Each option controls whether the corresponding async API is wrapped to preserve effect context
@@ -409,6 +460,10 @@ declare const options: {
         queueMicrotask: boolean;
     };
 };
+declare const objectToProxy: WeakMap<object, object>;
+declare const proxyToObject: WeakMap<object, object>;
+declare function unwrap<T>(obj: T): T;
+declare function isReactive(obj: any): boolean;
 
-export { AZone as A, ReactiveError as R, ZoneAggregator as Z, cleanup as c, ReactiveErrorCode as h, Zone as i, ZoneHistory as j, asyncZone as k, options as o };
-export type { CatchFunction as C, EffectTrigger as E, FunctionWrapper as F, ProjectionContext as P, ScopedCallback as S, Evolution as a, EffectCleanup as b, EffectCloser as d, EffectAccess as e, State as f, EffectOptions as g };
+export { AZone as A, ReactiveError as R, ZoneAggregator as Z, cleanup as c, ReactiveErrorCode as i, Zone as j, ZoneHistory as k, asyncZone as l, formatCleanupReason as m, isReactive as n, objectToProxy as o, proxyToObject as p, options as q, stopped as s, unwrap as u };
+export type { CatchFunction as C, EffectTrigger as E, FunctionWrapper as F, PropTrigger as P, ScopedCallback as S, Evolution as a, EffectCleanup as b, EffectCloser as d, EffectAccess as e, State as f, EffectOptions as g, CleanupReason as h };