mutts 1.0.13 → 1.0.15

package/dist/browser.d.ts

@@ -1,5 +1,5 @@
 import { c as EffectAccess, d as EffectCloser, S as ScopedCallback, e as State, a as Evolution, b as EffectCleanup, Z as ZoneAggregator, C as CleanupReason, H as HistoryValue, E as EffectTrigger, f as CatchFunction, g as EffectOptions } from './types.js';
-export { A as AZone, G as GetterWrapper, P as PropTrigger, R as ReactiveError, h as ReactiveErrorCode, i as Zone, 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 { A as AZone, h as CycleHandlingMode, D as DeprecatedCycleHandlingMode, G as GetterWrapper, P as PropTrigger, R as ReactiveError, i as ReactiveErrorCode, j as SchedulerMode, k as Zone, 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';
 
 type Restorer = () => () => void;
 type Hook = () => Restorer;
@@ -243,15 +243,15 @@ declare class Eventful<Events extends EventsBase> {
     emit: (<EventType extends keyof Events>(event: EventType, ...args: Parameters<Events[EventType]>) => void) & Events;
 }
 
-type AnyFunction = (...args: any[]) => any;
-type CaptionedOptions<T extends AnyFunction> = {
+type AnyFunction$1 = (...args: any[]) => any;
+type CaptionedOptions<T extends AnyFunction$1> = {
     callbackIndex?: number;
     name?: string;
     rename?: (caption: string, callback: Function) => unknown;
     warn?: (message: string) => void;
     shouldWarnAnonymous?: (callback: Function, args: Parameters<T>) => boolean;
 };
-type Captioned<T extends AnyFunction> = T & ((strings: TemplateStringsArray, ...values: readonly unknown[]) => T);
+type Captioned<T extends AnyFunction$1> = T & ((strings: TemplateStringsArray, ...values: readonly unknown[]) => T);
 /**
  * Wraps a callback-first function so it also accepts a tagged-template call form.
  *
@@ -271,8 +271,8 @@ type Captioned<T extends AnyFunction> = T & ((strings: TemplateStringsArray, ...
  * Anonymous uncaptioned callbacks may trigger a warning depending on
  * `shouldWarnAnonymous`.
  */
-declare function captioned<T extends AnyFunction>(fn: T, options?: CaptionedOptions<T>): Captioned<T>;
-declare function inheritCaption<T extends AnyFunction>(source: AnyFunction, target: T): T;
+declare function captioned<T extends AnyFunction$1>(fn: T, options?: CaptionedOptions<T>): Captioned<T>;
+declare function inheritCaption<T extends AnyFunction$1>(source: AnyFunction$1, target: T): T;
 /**
  * Creates a flavored (extensible) version of a function with chainable property modifiers.
  */
@@ -592,6 +592,7 @@ declare class IterableWeakSet<K extends WeakKey> implements Set<K> {
     [Symbol.iterator](): SetIterator<K>;
     readonly [Symbol.toStringTag]: string;
     union<U>(other: ReadonlySetLike<U>): Set<K | U>;
+    union(...sets: Set<K>[]): this;
     intersection<U>(other: ReadonlySetLike<U>): Set<K & U>;
     difference<U>(other: ReadonlySetLike<U>): Set<K>;
     symmetricDifference<U>(other: ReadonlySetLike<U>): Set<K | U>;
@@ -727,6 +728,15 @@ interface Lift {
  * @returns A reactive object synchronized with the callback's result, with a [cleanup] property to stop tracking
  */
 declare const lift: Lift;
+/**
+ * Position object provided to array morph callbacks.
+ *
+ * @property index - Current index of the item in the source array. The object is stable
+ *   per item and its `index` updates reactively when the item moves due to shifts/reorders.
+ */
+type MorphPosition = {
+    index: number;
+};
 /**
  * Options for `morph` and its variants.
  *
@@ -746,7 +756,7 @@ type MorphOptions<I> = {
  * @see morphRecord
  */
 type Morph = {
-    <I, O>(source: readonly I[] | (() => readonly I[]), fn: (arg: I, access?: EffectAccess) => O, options?: MorphOptions<I>): readonly O[];
+    <I, O>(source: readonly I[] | (() => readonly I[]), fn: (arg: I, position: MorphPosition, access?: EffectAccess) => O, options?: MorphOptions<I>): readonly O[];
     <K, V, O>(source: Map<K, V>, fn: (arg: V, key: K, access?: EffectAccess) => O, options?: MorphOptions<V>): Map<K, O>;
     <S extends Record<PropertyKey, any>, O>(source: S, fn: (arg: S[keyof S], key: keyof S, access?: EffectAccess) => O, options?: MorphOptions<S[keyof S]>): {
         [K in keyof S]: O;
@@ -901,6 +911,12 @@ declare function getActivationLog(): Omit<ActivationRecord, "batchId">[];
 declare function caught(onThrow: CatchFunction, effect?: EffectTrigger): void;
 /** @deprecated Use `caught` instead */
 declare const onEffectThrow: typeof caught;
+/** True after an unrecoverable reactive failure until `reset()`. */
+declare function isReactiveBroken(): boolean;
+type ReactiveBrokenHandler = (error: unknown) => void;
+type ReactiveResetHandler = () => void;
+declare function onReactiveBroken(handler: ReactiveBrokenHandler): () => void;
+declare function onReactiveReset(handler: ReactiveResetHandler): () => void;
 /**
  * Adds a cleanup function to be called when the current batch of effects completes
  * @param cleanup - The cleanup function to add
@@ -999,6 +1015,16 @@ declare const effect: Effect;
  */
 type RootRunner = <T>(fn: () => T) => T;
 declare const untracked: Captioned<RootRunner>;
+type AnyFunction = (this: any, ...args: any[]) => any;
+declare function wrapInert<Fn extends AnyFunction>(fn: Fn): Fn;
+type Inert = (<T>(fn: () => T) => T) & MethodDecorator & ((target: any, context: ClassMethodDecoratorContext) => any);
+/**
+ * Executes a function with fast-path reads that bypass proxy overhead and dependency tracking.
+ * Writes remain fully reactive. Uses a counter for safe nesting.
+ * Can also decorate methods so the whole method body runs inertly.
+ * @param fn - The function to execute
+ */
+declare const inert: Inert;
 /**
  * Executes a function from a virgin/root context - no parent effect, no tracking
  * Creates completely independent effects that won't be cleaned up by any parent
@@ -1082,6 +1108,9 @@ declare const memoize: ReturnType<typeof makeMemoizeDecorator> & {
  * If a set is provided, merges with existing unreactive properties (never overrides true).
  */
 declare function addUnreactiveProps<T extends object>(proto: T, set?: Iterable<PropertyKey>): T;
+declare function nonReactive<T extends object[]>(...obj: T): T[0];
+declare const markRaw: typeof nonReactive;
+declare const markRawProps: typeof addUnreactiveProps;
 declare function isNonReactive(obj: any): boolean;
 
 type SubProxy = {
@@ -1100,11 +1129,15 @@ declare const ReactiveBase: (new (...args: any[]) => {
     [x: string]: any;
 } & Base);
 declare function reactiveObject<T>(anyTarget: T, subProxy?: SubProxy): T;
+declare function shallowReactiveObject<T>(anyTarget: T): T;
+declare function readonlyReactiveObject<T>(anyTarget: T): T;
 /**
  * Main decorator for making classes reactive
  * Automatically makes class instances reactive when created
  */
 declare const reactive: LegacyClassDecorator<new (...args: any[]) => any> & ModernClassDecorator<new (...args: any[]) => any> & typeof reactiveObject;
+declare const shallowReactive: typeof shallowReactiveObject;
+declare const readonlyReactive: typeof readonlyReactiveObject;
 
 /**
  * Provides type-safe access to a source object's property within the organized callback.
@@ -1403,5 +1436,5 @@ declare const isDev: boolean;
 declare const isProd: boolean;
 declare const isTest: boolean;
 
-export { ArrayReadForward, CleanupReason, CompareSymbol, DecoratorError, Destroyable, DestructionError, EffectAccess, EffectCleanup, EffectCloser, EffectOptions, EffectTrigger, Eventful, Evolution, HistoryValue, Indexable, IterableWeakMap, IterableWeakSet, ReactiveBase, ScopedCallback, ZoneAggregator, 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$1 as 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 };
-export type { ArrayDiffResult, Captioned, ContextManager, Decorator, DecoratorDescription, DecoratorFactory, EffectContext, EventsBase, GenericClassDecorator, Hook, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, PromiseChain, Resource, Restorer };
+export { ArrayReadForward, CleanupReason, CompareSymbol, DecoratorError, Destroyable, DestructionError, EffectAccess, EffectCleanup, EffectCloser, EffectOptions, EffectTrigger, Eventful, Evolution, HistoryValue, Indexable, IterableWeakMap, IterableWeakSet, ReactiveBase, ScopedCallback, ZoneAggregator, 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$1 as 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 };
+export type { ArrayDiffResult, Captioned, ContextManager, Decorator, DecoratorDescription, DecoratorFactory, EffectContext, EventsBase, GenericClassDecorator, Hook, LegacyClassDecorator, LegacyPropertyDecorator, Memoizable, MemoizableArgument, MixinClass, MixinFunction, ModernAccessorDecorator, ModernClassDecorator, ModernGetterDecorator, ModernMethodDecorator, ModernSetterDecorator, MorphPosition, PromiseChain, Resource, Restorer };

package/dist/browser.dev.cjs

@@ -2,8 +2,8 @@
 
 require('./debug.cjs');
 require('./browser.cjs');
-var index = require('./chunks/index-CAdnMJev.cjs');
-var proxy = require('./chunks/proxy-DBHj3kGK.cjs');
+var index = require('./chunks/index-Dtj2qZ0d.cjs');
+var effects = require('./chunks/effects-oUauWxxl.cjs');
 
 
 
@@ -40,76 +40,86 @@ exports.throttle = index.throttle;
 exports.unreactive = index.unreactive;
 exports.watch = index.watch;
 exports.when = index.when;
-exports.AZone = proxy.AZone;
-exports.CompareSymbol = proxy.CompareSymbol;
-exports.DecoratorError = proxy.DecoratorError;
-exports.IterableWeakMap = proxy.IterableWeakMap;
-exports.IterableWeakSet = proxy.IterableWeakSet;
-exports.ReactiveBase = proxy.ReactiveBase;
-exports.ReactiveError = proxy.ReactiveError;
+exports.AZone = effects.AZone;
+exports.CompareSymbol = effects.CompareSymbol;
+exports.DecoratorError = effects.DecoratorError;
+exports.IterableWeakMap = effects.IterableWeakMap;
+exports.IterableWeakSet = effects.IterableWeakSet;
+exports.ReactiveBase = effects.ReactiveBase;
+exports.ReactiveError = effects.ReactiveError;
 Object.defineProperty(exports, "ReactiveErrorCode", {
 	enumerable: true,
-	get: function () { return proxy.ReactiveErrorCode; }
+	get: function () { return effects.ReactiveErrorCode; }
 });
-exports.Zone = proxy.Zone;
-exports.ZoneAggregator = proxy.ZoneAggregator;
-exports.ZoneHistory = proxy.ZoneHistory;
-exports.addBatchCleanup = proxy.addBatchCleanup;
-exports.addUnreactiveProps = proxy.addUnreactiveProps;
-exports.arrayEquals = proxy.arrayEquals;
-exports.assertUntracked = proxy.assertUntracked;
-exports.asyncHook = proxy.asyncHook;
-exports.asyncHooks = proxy.asyncHooks;
-exports.asyncZone = proxy.asyncZone;
-exports.atom = proxy.atom;
-exports.atomic = proxy.atomic;
-exports.biDi = proxy.biDi;
-exports.captioned = proxy.captioned;
-exports.captured = proxy.captured;
-exports.caught = proxy.caught;
-exports.createFlavor = proxy.createFlavor;
-exports.debugPreset = proxy.debugPreset;
-exports.decorator = proxy.decorator;
-exports.deepCompare = proxy.deepCompare;
-exports.defer = proxy.defer;
-exports.devPreset = proxy.devPreset;
-exports.effect = proxy.effect;
-exports.effectAggregator = proxy.effectAggregator;
-exports.effectContext = proxy.effectContext;
-exports.flavorOptions = proxy.flavorOptions;
-exports.flavored = proxy.flavored;
-exports.formatCleanupReason = proxy.formatCleanupReason;
-exports.getActivationLog = proxy.getActivationLog;
-exports.getActiveEffect = proxy.getActiveEffect;
-exports.getState = proxy.getState;
-exports.hooks = proxy.hooks;
-exports.inheritCaption = proxy.inheritCaption;
-exports.isConstructor = proxy.isConstructor;
-exports.isDev = proxy.isDev;
-exports.isNonReactive = proxy.isNonReactive;
-exports.isObject = proxy.isObject;
-exports.isProd = proxy.isProd;
-exports.isReactive = proxy.isReactive;
-exports.isTest = proxy.isTest;
-exports.legacyDecorator = proxy.legacyDecorator;
-exports.link = proxy.link;
-exports.mixin = proxy.mixin;
-exports.modernDecorator = proxy.modernDecorator;
-exports.named = proxy.named;
-exports.objectToProxy = proxy.objectToProxy;
-exports.onEffectThrow = proxy.onEffectThrow;
-exports.prodPreset = proxy.prodPreset;
-exports.proxyToObject = proxy.proxyToObject;
-exports.reactive = proxy.reactive;
-exports.reactiveOptions = proxy.options;
-exports.reset = proxy.reset;
-exports.root = proxy.root;
-exports.tag = proxy.tag;
-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.zip = proxy.zip;
+exports.Zone = effects.Zone;
+exports.ZoneAggregator = effects.ZoneAggregator;
+exports.ZoneHistory = effects.ZoneHistory;
+exports.addBatchCleanup = effects.addBatchCleanup;
+exports.addUnreactiveProps = effects.addUnreactiveProps;
+exports.arrayEquals = effects.arrayEquals;
+exports.assertUntracked = effects.assertUntracked;
+exports.asyncHook = effects.asyncHook;
+exports.asyncHooks = effects.asyncHooks;
+exports.asyncZone = effects.asyncZone;
+exports.atom = effects.atom;
+exports.atomic = effects.atomic;
+exports.biDi = effects.biDi;
+exports.captioned = effects.captioned;
+exports.captured = effects.captured;
+exports.caught = effects.caught;
+exports.createFlavor = effects.createFlavor;
+exports.debugPreset = effects.debugPreset;
+exports.decorator = effects.decorator;
+exports.deepCompare = effects.deepCompare;
+exports.defer = effects.defer;
+exports.devPreset = effects.devPreset;
+exports.effect = effects.effect;
+exports.effectAggregator = effects.effectAggregator;
+exports.effectContext = effects.effectContext;
+exports.flavorOptions = effects.flavorOptions;
+exports.flavored = effects.flavored;
+exports.formatCleanupReason = effects.formatCleanupReason;
+exports.getActivationLog = effects.getActivationLog;
+exports.getActiveEffect = effects.getActiveEffect;
+exports.getState = effects.getState;
+exports.hooks = effects.hooks;
+exports.inert = effects.inert;
+exports.inheritCaption = effects.inheritCaption;
+exports.isConstructor = effects.isConstructor;
+exports.isDev = effects.isDev;
+exports.isNonReactive = effects.isNonReactive;
+exports.isObject = effects.isObject;
+exports.isProd = effects.isProd;
+exports.isReactive = effects.isReactive;
+exports.isReactiveBroken = effects.isReactiveBroken;
+exports.isTest = effects.isTest;
+exports.legacyDecorator = effects.legacyDecorator;
+exports.link = effects.link;
+exports.markRaw = effects.markRaw;
+exports.markRawProps = effects.markRawProps;
+exports.mixin = effects.mixin;
+exports.modernDecorator = effects.modernDecorator;
+exports.named = effects.named;
+exports.objectToProxy = effects.objectToProxy;
+exports.onEffectThrow = effects.onEffectThrow;
+exports.onReactiveBroken = effects.onReactiveBroken;
+exports.onReactiveReset = effects.onReactiveReset;
+exports.prodPreset = effects.prodPreset;
+exports.proxyToObject = effects.proxyToObject;
+exports.reactive = effects.reactive;
+exports.reactiveOptions = effects.options;
+exports.readonlyReactive = effects.readonlyReactive;
+exports.reset = effects.reset;
+exports.root = effects.root;
+exports.shallowReactive = effects.shallowReactive;
+exports.tag = effects.tag;
+exports.toRaw = effects.toRaw;
+exports.touched = effects.touched;
+exports.touched1 = effects.touched1;
+exports.unlink = effects.unlink;
+exports.untracked = effects.untracked;
+exports.unwrap = effects.unwrap;
+exports.withEffectContext = effects.withEffectContext;
+exports.wrapInert = effects.wrapInert;
+exports.zip = effects.zip;
 //# sourceMappingURL=browser.dev.cjs.map

package/dist/browser.dev.cjs.map

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

package/dist/browser.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.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, 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/browser.dev.esm.js

@@ -1,5 +1,5 @@
 import './debug.esm.js';
 import './browser.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';
+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-YGpb1te7.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/effects-CPjf6gNA.esm.js';
 //# sourceMappingURL=browser.dev.esm.js.map

package/dist/browser.esm.js

@@ -1,6 +1,6 @@
-import { L as hooks, k as asyncHooks } from './chunks/proxy-BtmPFjSr.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, 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, 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';
-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';
+import { k as asyncHooks, a5 as onReactiveBroken, a6 as onReactiveReset, L as hooks } from './chunks/effects-CPjf6gNA.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, 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, 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, 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/effects-CPjf6gNA.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-YGpb1te7.esm.js';
 
 const promiseContexts = new WeakMap();
 // [HACK]: Sanitization
@@ -39,28 +39,14 @@ function wrap(fn, capturedRestorers) {
             return fn.apply(this, args);
         }
         finally {
-            /* cf BROWSER_ASYNC_POLYFILL.md
-            // Note: my fear about this code: in between 2~3~4 microtask waits, some other microtasks might have started, stopped, ...
-            // We might be in the middle of another promise hook trying to setup the zone
-            // TODO We might wish to have a flag :asyncZone.acquired - like a semaphore - that we falsify here and set back when we setup the zone
-            // - but this might perhaps be an overkill creating more problems than it solves
-            if (originals.queueMicrotask) {
-                // Double microtask ensures we run after the first await resumption microtask
-                originals.queueMicrotask.call(globalThis, () => {
-                    originals.queueMicrotask.call(globalThis, () => {
-                        originals.queueMicrotask.call(globalThis, () => {
-                            for (let i = undoers.length - 1; i >= 0; i--) undoers[i]()
-                        })
-                    })
-                })
-            } else {
-                for (let i = undoers.length - 1; i >= 0; i--) undoers[i]()
-            }*/
+            // Browser async context is backed by sticky Promise metadata. Running undoers here
+            // breaks await propagation and can orphan reactive resource observers.
         }
     };
 }
 const GLOBAL_ORIGINALS = Symbol.for('mutts.originals');
 const GLOBAL_PROMISE = Symbol.for('mutts.OriginalPromise');
+const schedulerGlobal = globalThis;
 let originals;
 let OriginalPromise;
 if (globalThis[GLOBAL_ORIGINALS]) {
@@ -81,9 +67,13 @@ else {
         race: OriginalPromise.race,
         any: OriginalPromise.any,
         setTimeout: globalThis.setTimeout,
+        clearTimeout: globalThis.clearTimeout,
         setInterval: globalThis.setInterval,
-        setImmediate: globalThis.setImmediate,
-        requestAnimationFrame: globalThis.requestAnimationFrame,
+        clearInterval: globalThis.clearInterval,
+        setImmediate: schedulerGlobal.setImmediate,
+        clearImmediate: schedulerGlobal.clearImmediate,
+        requestAnimationFrame: schedulerGlobal.requestAnimationFrame,
+        cancelAnimationFrame: schedulerGlobal.cancelAnimationFrame,
         queueMicrotask: globalThis.queueMicrotask,
     };
     globalThis[GLOBAL_ORIGINALS] = originals;
@@ -96,6 +86,74 @@ if (!originals.any)
     originals.any = OriginalPromise.any;
 if (!originals.race)
     originals.race = OriginalPromise.race;
+if (!originals.clearTimeout)
+    originals.clearTimeout = globalThis.clearTimeout;
+if (!originals.clearInterval)
+    originals.clearInterval = globalThis.clearInterval;
+if (!originals.clearImmediate)
+    originals.clearImmediate = schedulerGlobal.clearImmediate;
+if (!originals.cancelAnimationFrame)
+    originals.cancelAnimationFrame = schedulerGlobal.cancelAnimationFrame;
+const pendingTimeouts = new Set();
+const pendingIntervals = new Set();
+const pendingImmediates = new Set();
+const pendingAnimationFrames = new Set();
+let asyncSchedulersFrozen = false;
+function clearPendingSchedulers() {
+    for (const handle of Array.from(pendingTimeouts))
+        originals.clearTimeout.call(globalThis, handle);
+    for (const handle of Array.from(pendingIntervals))
+        originals.clearInterval.call(globalThis, handle);
+    if (originals.clearImmediate) {
+        for (const handle of Array.from(pendingImmediates)) {
+            originals.clearImmediate.call(globalThis, handle);
+        }
+    }
+    if (originals.cancelAnimationFrame) {
+        for (const handle of Array.from(pendingAnimationFrames)) {
+            originals.cancelAnimationFrame.call(globalThis, handle);
+        }
+    }
+    pendingTimeouts.clear();
+    pendingIntervals.clear();
+    pendingImmediates.clear();
+    pendingAnimationFrames.clear();
+}
+function freezeAsyncSchedulers() {
+    if (asyncSchedulersFrozen)
+        return;
+    asyncSchedulersFrozen = true;
+    clearPendingSchedulers();
+}
+function resumeAsyncSchedulers() {
+    asyncSchedulersFrozen = false;
+}
+function canceledTimeoutHandle() {
+    const handle = originals.setTimeout.call(globalThis, () => { }, 0);
+    originals.clearTimeout.call(globalThis, handle);
+    return handle;
+}
+function canceledIntervalHandle() {
+    const handle = originals.setInterval.call(globalThis, () => { }, 0);
+    originals.clearInterval.call(globalThis, handle);
+    return handle;
+}
+function canceledImmediateHandle() {
+    if (!originals.setImmediate || !originals.clearImmediate)
+        return undefined;
+    const handle = originals.setImmediate.call(globalThis, () => { });
+    originals.clearImmediate.call(globalThis, handle);
+    return handle;
+}
+function canceledAnimationFrameHandle() {
+    if (!originals.requestAnimationFrame || !originals.cancelAnimationFrame)
+        return 0;
+    const handle = originals.requestAnimationFrame.call(globalThis, () => { });
+    originals.cancelAnimationFrame.call(globalThis, handle);
+    return handle;
+}
+onReactiveBroken(freezeAsyncSchedulers);
+onReactiveReset(resumeAsyncSchedulers);
 function patchedThen(onFulfilled, onRejected) {
     const context = promiseContexts.get(this) || captureRestorers();
     const nextPromise = originals.then.call(this, wrap(onFulfilled, context), wrap(onRejected, context));
@@ -195,19 +253,70 @@ try {
 catch (_e) { }
 globalThis.Promise = PatchedPromise;
 globalThis.setTimeout = ((callback, ...args) => {
-    return originals.setTimeout.call(globalThis, wrap(callback), ...args);
+    if (asyncSchedulersFrozen)
+        return canceledTimeoutHandle();
+    const wrapped = wrap(callback);
+    const handle = originals.setTimeout.call(globalThis, (...callbackArgs) => {
+        pendingTimeouts.delete(handle);
+        wrapped(...callbackArgs);
+    }, ...args);
+    pendingTimeouts.add(handle);
+    return handle;
+});
+globalThis.clearTimeout = ((handle) => {
+    pendingTimeouts.delete(handle);
+    return originals.clearTimeout.call(globalThis, handle);
 });
 globalThis.setInterval = ((callback, ...args) => {
-    return originals.setInterval.call(globalThis, wrap(callback), ...args);
+    if (asyncSchedulersFrozen)
+        return canceledIntervalHandle();
+    const wrapped = wrap(callback);
+    const handle = originals.setInterval.call(globalThis, (...callbackArgs) => {
+        wrapped(...callbackArgs);
+    }, ...args);
+    pendingIntervals.add(handle);
+    return handle;
+});
+globalThis.clearInterval = ((handle) => {
+    pendingIntervals.delete(handle);
+    return originals.clearInterval.call(globalThis, handle);
 });
 if (originals.setImmediate) {
-    globalThis.setImmediate = ((callback, ...args) => {
-        return originals.setImmediate.call(globalThis, wrap(callback), ...args);
+    schedulerGlobal.setImmediate = ((callback, ...args) => {
+        if (asyncSchedulersFrozen)
+            return canceledImmediateHandle();
+        const wrapped = wrap(callback);
+        const handle = originals.setImmediate.call(globalThis, (...callbackArgs) => {
+            pendingImmediates.delete(handle);
+            wrapped(...callbackArgs);
+        }, ...args);
+        pendingImmediates.add(handle);
+        return handle;
+    });
+}
+if (originals.clearImmediate) {
+    schedulerGlobal.clearImmediate = ((handle) => {
+        pendingImmediates.delete(handle);
+        return originals.clearImmediate.call(globalThis, handle);
     });
 }
 if (originals.requestAnimationFrame) {
     globalThis.requestAnimationFrame = (callback) => {
-        return originals.requestAnimationFrame.call(globalThis, wrap(callback));
+        if (asyncSchedulersFrozen)
+            return canceledAnimationFrameHandle();
+        const wrapped = wrap(callback);
+        const handle = originals.requestAnimationFrame.call(globalThis, (time) => {
+            pendingAnimationFrames.delete(handle);
+            wrapped(time);
+        });
+        pendingAnimationFrames.add(handle);
+        return handle;
+    };
+}
+if (originals.cancelAnimationFrame) {
+    globalThis.cancelAnimationFrame = (handle) => {
+        pendingAnimationFrames.delete(handle);
+        return originals.cancelAnimationFrame.call(globalThis, handle);
     };
 }
 if (originals.queueMicrotask) {
@@ -216,5 +325,5 @@ if (originals.queueMicrotask) {
     };
 }
 
-export { asyncHooks, hooks };
+export { asyncHooks, hooks, onReactiveBroken, onReactiveReset };
 //# sourceMappingURL=browser.esm.js.map