mutts 1.0.11 → 1.0.12

package/dist/browser.cjs

@@ -1,2583 +1,220 @@
 'use strict';
 
-require('./chunks/async-browser-Dgr5CreQ.cjs');
-var proxy = require('./chunks/proxy-Cc79Lrzj.cjs');
-var asyncCore = require('./chunks/async-core-CRLKP3l-.cjs');
-require('./chunks/async-node-3PrbVAbB.cjs');
-require('node:async_hooks');
+var proxy = require('./chunks/proxy-BvM4yewA.cjs');
+var index = require('./chunks/index-yK0HVxHv.cjs');
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-// Integrated with `using` statement via Symbol.dispose
-const fr = new FinalizationRegistry((f) => f());
-/**
- * Symbol for marking destructor methods
- */
-const destructor = Symbol('destructor');
-/**
- * Symbol for accessing allocated values in destroyable objects
- */
-const allocatedValues = Symbol('allocated');
-/**
- * Error thrown when attempting to access a destroyed object
- */
-class DestructionError extends Error {
-    static throw(msg) {
-        return () => {
-            throw new DestructionError(msg);
-        };
-    }
-    constructor(msg) {
-        super(`Object is destroyed. ${msg}`);
-        this.name = 'DestroyedAccessError';
+const promiseContexts = new WeakMap();
+// [HACK]: Sanitization
+// If a Promise is created inside the zone, it carries the "Sticky" zone context.
+// If returned to the outer scope, that context leaks. We wrap it in a new Promise
+// created here (in the outer scope) to break the chain and sanitize the return value.
+// See BROWSER_ASYNC_POLYFILL.md for full details.
+proxy.asyncHooks.sanitizePromise = (res) => {
+    if (res && typeof res.then === 'function') {
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                res.then(resolve, reject);
+            }, 0);
+        });
     }
-}
-const destroyedHandler = {
-    [Symbol.toStringTag]: 'MutTs Destroyable',
-    get: DestructionError.throw('Cannot access destroyed object'),
-    set: DestructionError.throw('Cannot access destroyed object'),
+    return res;
 };
-function Destroyable(base, destructorObj) {
-    var _a;
-    if (base && typeof base !== 'function') {
-        destructorObj = base;
-        base = undefined;
-    }
-    if (!base) {
-        base = class {
-        };
-    }
-    return _a = class Destroyable extends base {
-            static destroy(obj) {
-                const destructor = _a.destructors.get(obj);
-                if (!destructor)
-                    return false;
-                fr.unregister(obj[allocatedValues]);
-                _a.destructors.delete(obj);
-                Object.setPrototypeOf(obj, new Proxy({}, destroyedHandler));
-                // Clear all own properties
-                for (const key of Object.getOwnPropertyNames(obj)) {
-                    delete obj[key];
-                }
-                destructor();
-                return true;
-            }
-            static isDestroyable(obj) {
-                return _a.destructors.has(obj);
-            }
-            constructor(...args) {
-                super(...args);
-                const allocated = {};
-                this[allocatedValues] = allocated;
-                // @ts-expect-error `this` is an AbstractDestroyable
-                const myDestructor = destructorObj?.destructor ?? this[destructor];
-                if (!myDestructor) {
-                    throw new DestructionError('Destructor is not defined');
-                }
-                function destruction() {
-                    myDestructor(allocated);
-                }
-                _a.destructors.set(this, destruction);
-                fr.register(this, destruction, allocated);
-            }
-        },
-        _a.destructors = new WeakMap(),
-        _a;
-}
-/**
- * Decorator that marks properties to be stored in the allocated object and passed to the destructor
- * Use with accessor properties or explicit get/set pairs
- */
-const allocated = proxy.decorator({
-    setter(original, _target, propertyKey) {
-        return function (value) {
-            this[allocatedValues][propertyKey] = value;
-            return original.call(this, value);
-        };
-    },
-});
-/**
- * Registers a callback to be called when an object is garbage collected
- * @param cb - The callback function to execute on garbage collection
- * @returns The object whose reference can be collected
- */
-function callOnGC(cb) {
-    let called = false;
-    const forward = () => {
-        if (called)
-            return;
-        called = true;
-        cb();
-    };
-    fr.register(forward, cb, cb);
-    return forward;
-}
-
-/** Max edit distance before bailing out to a single "replace all" patch */
-const BAILOUT_D = 256;
-/**
- * Myers' diff producing grouped patches: `{indexA, indexB, sliceA, sliceB}[]`.
- * - O(N) for identical or prefix/suffix-only differences
- * - O(ND) for small D, with a hard bailout at D=BAILOUT_D → single replacement patch
- */
-function arrayDiff(A, B) {
-    let start = 0;
-    let endA = A.length;
-    let endB = B.length;
-    // Trim common prefix
-    while (start < endA && start < endB && A[start] === B[start])
-        start++;
-    // Trim common suffix
-    while (endA > start && endB > start && A[endA - 1] === B[endB - 1]) {
-        endA--;
-        endB--;
-    }
-    const lenA = endA - start;
-    const lenB = endB - start;
-    if (lenA === 0 && lenB === 0)
-        return [];
-    if (lenA === 0)
-        return [{ indexA: start, indexB: start, sliceA: [], sliceB: B.slice(start, endB) }];
-    if (lenB === 0)
-        return [{ indexA: start, indexB: start, sliceA: A.slice(start, endA), sliceB: [] }];
-    // Myers with bailout
-    const maxD = Math.min(lenA + lenB, BAILOUT_D);
-    const vSize = 2 * maxD + 1;
-    const vOffset = maxD;
-    const V = new Int32Array(vSize);
-    V[vOffset + 1] = 0;
-    const history = [];
-    for (let d = 0; d <= maxD; d++) {
-        for (let k = -d; k <= d; k += 2) {
-            let x;
-            if (k === -d || (k !== d && V[vOffset + k - 1] < V[vOffset + k + 1])) {
-                x = V[vOffset + k + 1];
-            }
-            else {
-                x = V[vOffset + k - 1] + 1;
-            }
-            let y = x - k;
-            while (x < lenA && y < lenB && A[start + x] === B[start + y]) {
-                x++;
-                y++;
-            }
-            V[vOffset + k] = x;
-            if (x >= lenA && y >= lenB)
-                return buildPatches(history, A, B, start, x, y, d, k, vOffset);
-        }
-        history.push(new Int32Array(V));
-    }
-    // Bailout: too many differences
-    return [
-        { indexA: start, indexB: start, sliceA: A.slice(start, endA), sliceB: B.slice(start, endB) },
-    ];
-}
-function buildPatches(history, A, B, offset, finalX, finalY, finalD, finalK, vOffset) {
-    // Backtrack from (finalX, finalY) at step finalD to step 0, collecting ops in reverse
-    const ops = []; // 0=eq, 1=ins, 2=del
-    let x = finalX;
-    let y = finalY;
-    let k = finalK;
-    for (let d = finalD; d > 0; d--) {
-        const prev = history[d - 1];
-        let prevK;
-        let down;
-        if (k === -d) {
-            prevK = k + 1;
-            down = true;
-        }
-        else if (k === d) {
-            prevK = k - 1;
-            down = false;
-        }
-        else if (prev[vOffset + k - 1] < prev[vOffset + k + 1]) {
-            prevK = k + 1;
-            down = true;
-        }
-        else {
-            prevK = k - 1;
-            down = false;
-        }
-        const prevXEnd = prev[vOffset + prevK];
-        const prevYEnd = prevXEnd - prevK;
-        const xStart = down ? prevXEnd : prevXEnd + 1;
-        const yStart = down ? prevYEnd + 1 : prevXEnd + 1 - k;
-        // Diagonal matches (pushed in reverse)
-        while (x > xStart && y > yStart) {
-            ops.push(0);
-            x--;
-            y--;
-        }
-        // The edit step
-        if (down) {
-            ops.push(1); // ins
-            y--;
-        }
-        else {
-            ops.push(2); // del
-            x--;
-        }
-        k = prevK;
-    }
-    // Walk ops forward (they were pushed in reverse), grouping contiguous edits
-    const patches = [];
-    let currA = offset;
-    let currB = offset;
-    let sliceA = [];
-    let sliceB = [];
-    let patchA = -1;
-    let patchB = -1;
-    const flush = () => {
-        if (patchA !== -1) {
-            patches.push({ indexA: patchA, indexB: patchB, sliceA, sliceB });
-            sliceA = [];
-            sliceB = [];
-            patchA = -1;
+function captureRestorers() {
+    const restorers = new Set();
+    for (const hook of proxy.hooks) {
+        const restorer = hook();
+        if (restorer)
+            restorers.add(restorer);
+    }
+    return restorers;
+}
+function wrap(fn, capturedRestorers) {
+    if (typeof fn !== 'function')
+        return fn;
+    const restorers = capturedRestorers || captureRestorers();
+    return function (...args) {
+        const undoers = [];
+        for (const restore of restorers)
+            undoers.push(restore());
+        try {
+            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]()
+            }*/
         }
     };
-    for (let i = ops.length - 1; i >= 0; i--) {
-        const op = ops[i];
-        if (op === 0) {
-            flush();
-            currA++;
-            currB++;
-        }
-        else if (op === 1) {
-            if (patchA === -1) {
-                patchA = currA;
-                patchB = currB;
-            }
-            sliceB.push(B[currB++]);
-        }
-        else {
-            if (patchA === -1) {
-                patchA = currA;
-                patchB = currB;
-            }
-            sliceA.push(A[currA++]);
-        }
-    }
-    flush();
-    return patches;
 }
-
-var _a, _b;
-const events = Symbol('events');
-const hooks = Symbol('hooks');
-const eventBehavior = {
-    on(eventOrEvents, cb) {
-        if (typeof eventOrEvents === 'object') {
-            for (const e of Object.keys(eventOrEvents)) {
-                this.on(e, eventOrEvents[e]);
-            }
-        }
-        else if (cb !== undefined) {
-            const callbacks = this[events].get(eventOrEvents) ?? new Set();
-            if (!callbacks.has(cb))
-                callbacks.add(cb);
-            this[events].set(eventOrEvents, callbacks);
-        }
-        return () => this.off(eventOrEvents, cb);
-    },
-    off(eventOrEvents, cb) {
-        if (typeof eventOrEvents === 'object') {
-            for (const e of Object.keys(eventOrEvents)) {
-                this.off(e, eventOrEvents[e]);
-            }
-        }
-        else if (cb !== null && cb !== undefined) {
-            const callbacks = this[events].get(eventOrEvents);
-            if (callbacks) {
-                callbacks.delete(cb);
-                if (!callbacks.size)
-                    this[events].delete(eventOrEvents);
-            }
-        }
-        else {
-            // Remove all listeners for this event
-            this[events].delete(eventOrEvents);
-        }
-    },
-    emit(event, ...args) {
-        const callbacks = this[events].get(event);
-        if (callbacks)
-            for (const cb of callbacks)
-                cb.apply(this, args);
-        for (const cb of this[hooks])
-            cb.call(this, event, ...args);
-    },
-};
-function perEvent(eventful, fct, use) {
-    const cache = new Map();
-    return new Proxy(fct, {
-        get(target, prop) {
-            if (typeof prop !== 'string')
-                return target[prop];
-            if (use && !eventful[events].has(prop) && !eventful[hooks].size)
-                return () => { };
-            // Return cached function or create and cache
-            let cached = cache.get(prop);
-            if (!cached) {
-                cached = (...args) => fct.apply(eventful, [prop, ...args]);
-                cache.set(prop, cached);
-            }
-            return cached;
-        },
-    });
-}
-/**
- * A type-safe event system that provides a clean API for event handling
- * @template Events - The event map defining event names and their handler signatures
- */
-class Eventful {
-    constructor() {
-        this[_a] = new Map();
-        this[_b] = new Set();
-        this.on = perEvent(this, eventBehavior.on);
-        this.off = perEvent(this, eventBehavior.off);
-        this.emit = perEvent(this, eventBehavior.emit, 'use');
-    }
-    hook(cb) {
-        this[hooks].add(cb);
-        return () => {
-            this[hooks].delete(cb);
-        };
-    }
-}
-_a = events, _b = hooks;
-
-/**
- * Symbol for defining custom getter logic for numeric index access
- */
-const getAt = Symbol('getAt');
-/**
- * Symbol for defining custom setter logic for numeric index access
- */
-const setAt = Symbol('setAt');
-function Indexable(base, accessor) {
-    if (base && typeof base !== 'function') {
-        accessor = base;
-        base = undefined;
-    }
-    if (!base) {
-        //@ts-expect-error
-        base = class {
-        };
-    }
-    if (!accessor) {
-        accessor = {
-            get(index) {
-                if (typeof this[getAt] !== 'function') {
-                    throw new Error('Indexable class must have an [getAt] method');
-                }
-                return this[getAt](index);
-            },
-            set(index, value) {
-                if (typeof this[setAt] !== 'function') {
-                    throw new Error('Indexable class has read-only numeric index access');
-                }
-                this[setAt](index, value);
-            },
-        };
-    }
-    class Indexable extends base {
-    }
-    Object.setPrototypeOf(Indexable.prototype, new Proxy(base.prototype, {
-        //@ts-expect-error
-        [Symbol.toStringTag]: 'MutTs Indexable',
-        get(target, prop, receiver) {
-            if (prop in target) {
-                const getter = Object.getOwnPropertyDescriptor(target, prop)?.get;
-                return getter ? getter.call(receiver) : target[prop];
-            }
-            if (typeof prop === 'string') {
-                if (prop === 'length' && accessor.getLength)
-                    return accessor.getLength.call(receiver);
-                const numProp = Number(prop);
-                if (!Number.isNaN(numProp)) {
-                    return accessor.get.call(receiver, numProp);
-                }
-            }
-            return undefined;
-        },
-        set(target, prop, value, receiver) {
-            if (prop in target) {
-                const setter = Object.getOwnPropertyDescriptor(target, prop)?.set;
-                if (setter)
-                    setter.call(receiver, value);
-                else
-                    target[prop] = value;
-                return true;
-            }
-            if (typeof prop === 'string') {
-                if (prop === 'length' && accessor.setLength) {
-                    accessor.setLength.call(receiver, value);
-                    return true;
-                }
-                const numProp = Number(prop);
-                if (!Number.isNaN(numProp)) {
-                    if (!accessor.set)
-                        throw new Error('Indexable class has read-only numeric index access');
-                    accessor.set.call(receiver, numProp, value);
-                    return true;
-                }
-            }
-            Object.defineProperty(receiver, prop, {
-                value,
-                writable: true,
-                enumerable: true,
-                configurable: true,
-            });
-            return true;
-        },
-        has(target, prop) {
-            if (prop in target)
-                return true;
-            if (typeof prop === 'string') {
-                if (prop === 'length' && accessor.getLength)
-                    return true;
-                const numProp = Number(prop);
-                if (!Number.isNaN(numProp))
-                    return true;
-            }
-            return false;
-        },
-        ownKeys(target) {
-            const keys = Reflect.ownKeys(target);
-            if (accessor.getLength) {
-                keys.push('length');
-                const len = accessor.getLength.call(this);
-                for (let i = 0; i < len; i++)
-                    keys.push(String(i));
-            }
-            return keys;
-        },
-        getOwnPropertyDescriptor(target, prop) {
-            if (prop in target)
-                return Object.getOwnPropertyDescriptor(target, prop);
-            if (typeof prop === 'string') {
-                if (prop === 'length' && accessor.getLength) {
-                    return {
-                        enumerable: false,
-                        configurable: true,
-                        get: () => accessor.getLength.call(this),
-                    };
-                }
-                const numProp = Number(prop);
-                if (!Number.isNaN(numProp)) {
-                    return {
-                        enumerable: true,
-                        configurable: true,
-                        get: () => accessor.get.call(this, numProp),
-                        set: accessor.set
-                            ? (v) => accessor.set.call(this, numProp, v)
-                            : undefined,
-                    };
-                }
-            }
-            return undefined;
-        },
-    }));
-    return Indexable;
-}
-/**
- * Symbol for accessing the forwarded array in ArrayReadForward
- */
-const forwardArray = Symbol('forwardArray');
-/**
- * A read-only array forwarder that implements all reading/iterating methods of Array
- * but does not implement modification methods.
- *
- * The constructor takes a callback that returns an array, and all methods forward
- * their behavior to the result of that callback.
- */
-class ArrayReadForward {
-    get [forwardArray]() {
-        throw new Error('ArrayReadForward is not implemented');
-    }
-    /**
-     * Get the length of the array
-     */
-    get length() {
-        return this[forwardArray].length;
-    }
-    /**
-     * Iterator protocol support
-     */
-    [Symbol.iterator]() {
-        return this[forwardArray][Symbol.iterator]();
-    }
-    // Reading/Iterating methods
-    /**
-     * Creates a new array with the results of calling a provided function on every element
-     */
-    map(callbackfn, thisArg) {
-        return this[forwardArray].map(callbackfn, thisArg);
-    }
-    filter(predicate, thisArg) {
-        return this[forwardArray].filter(predicate, thisArg);
-    }
-    reduce(callbackfn, initialValue) {
-        return initialValue !== undefined
-            ? this[forwardArray].reduce(callbackfn, initialValue)
-            : this[forwardArray].reduce(callbackfn);
-    }
-    reduceRight(callbackfn, initialValue) {
-        return initialValue !== undefined
-            ? this[forwardArray].reduceRight(callbackfn, initialValue)
-            : this[forwardArray].reduceRight(callbackfn);
-    }
-    /**
-     * Executes a provided function once for each array element
-     */
-    forEach(callbackfn, thisArg) {
-        this[forwardArray].forEach(callbackfn, thisArg);
-    }
-    find(predicate, thisArg) {
-        return this[forwardArray].find(predicate, thisArg);
-    }
-    /**
-     * Returns the index of the first element in the array that satisfies the provided testing function
-     */
-    findIndex(predicate, thisArg) {
-        return this[forwardArray].findIndex(predicate, thisArg);
-    }
-    findLast(predicate, thisArg) {
-        return this[forwardArray].findLast(predicate, thisArg);
-    }
-    /**
-     * Returns the index of the last element in the array that satisfies the provided testing function
-     */
-    findLastIndex(predicate, thisArg) {
-        return this[forwardArray].findLastIndex(predicate, thisArg);
-    }
-    /**
-     * Determines whether an array includes a certain value among its entries
-     */
-    includes(searchElement, fromIndex) {
-        return this[forwardArray].includes(searchElement, fromIndex);
-    }
-    /**
-     * Returns the first index at which a given element can be found in the array
-     */
-    indexOf(searchElement, fromIndex) {
-        return this[forwardArray].indexOf(searchElement, fromIndex);
-    }
-    /**
-     * Returns the last index at which a given element can be found in the array
-     */
-    lastIndexOf(searchElement, fromIndex) {
-        return this[forwardArray].lastIndexOf(searchElement, fromIndex);
-    }
-    /**
-     * Returns a shallow copy of a portion of an array into a new array object
-     */
-    slice(start, end) {
-        return this[forwardArray].slice(start, end);
-    }
-    concat(...items) {
-        return this[forwardArray].concat(...items);
-    }
-    /**
-     * Tests whether all elements in the array pass the test implemented by the provided function
-     */
-    every(predicate, thisArg) {
-        return this[forwardArray].every(predicate, thisArg);
-    }
-    /**
-     * Tests whether at least one element in the array passes the test implemented by the provided function
-     */
-    some(predicate, thisArg) {
-        return this[forwardArray].some(predicate, thisArg);
-    }
-    /**
-     * Joins all elements of an array into a string
-     */
-    join(separator) {
-        return this[forwardArray].join(separator);
-    }
-    /**
-     * Returns a new array iterator that contains the keys for each index in the array
-     */
-    keys() {
-        return this[forwardArray].keys();
-    }
-    /**
-     * Returns a new array iterator that contains the values for each index in the array
-     */
-    values() {
-        return this[forwardArray].values();
-    }
-    /**
-     * Returns a new array iterator that contains the key/value pairs for each index in the array
-     */
-    entries() {
-        return this[forwardArray].entries();
-    }
-    /**
-     * Returns a string representation of the array
-     */
-    toString() {
-        return this[forwardArray].toString();
-    }
-    /**
-     * Returns a localized string representing the array
-     */
-    toLocaleString(locales, options) {
-        return this[forwardArray].toLocaleString(locales, options);
-    }
-    /**
-     * Returns the element at the specified index, or undefined if the index is out of bounds
-     */
-    at(index) {
-        return this[forwardArray].at(index);
-    }
-    /**
-     * Returns a new array with all sub-array elements concatenated into it recursively up to the specified depth
-     */
-    flat(depth) {
-        return this[forwardArray].flat(depth);
-    }
-    /**
-     * Returns a new array formed by applying a given callback function to each element of the array,
-     * and then flattening the result by one level
-     */
-    flatMap(callback, thisArg) {
-        return this[forwardArray].flatMap(callback, thisArg);
-    }
-    /**
-     * Returns a new array with elements in reversed order (ES2023)
-     */
-    toReversed() {
-        return this[forwardArray].toReversed?.() ?? [...this[forwardArray]].reverse();
-    }
-    /**
-     * Returns a new array with elements sorted (ES2023)
-     */
-    toSorted(compareFn) {
-        return this[forwardArray].toSorted?.(compareFn) ?? [...this[forwardArray]].sort(compareFn);
-    }
-    /**
-     * Returns a new array with some elements removed and/or replaced at a given index (ES2023)
-     */
-    toSpliced(start, deleteCount, ...items) {
-        if (deleteCount === undefined)
-            return this[forwardArray].toSpliced(start);
-        return this[forwardArray].toSpliced(start, deleteCount, ...items);
-    }
-    /**
-     * Returns a new array with the element at the given index replaced with the given value (ES2023)
-     */
-    with(index, value) {
-        return this[forwardArray].with(index, value);
-    }
-    get [Symbol.unscopables]() {
-        return this[forwardArray][Symbol.unscopables];
-    }
-}
-
-const forward = (name, target) => (...args) => {
-    return target[name](...args);
-};
-const alreadyChained = new WeakMap();
-const originals = new WeakMap();
-function cache$1(target, rv) {
-    originals.set(rv, target);
-    alreadyChained.set(target, rv);
-}
-const promiseProxyHandler = {
-    //@ts-expect-error
-    [Symbol.toStringTag]: 'MutTs PromiseChain function',
-    get(target, prop) {
-        if (prop === Symbol.toStringTag)
-            return 'PromiseProxy';
-        if (typeof prop === 'string' && ['then', 'catch', 'finally'].includes(prop))
-            return target[prop];
-        return chainPromise(target.then((r) => r[prop]));
-    },
-};
-const promiseForward = (target) => ({
-    // biome-ignore lint/suspicious/noThenProperty: This one is the whole point
-    then: forward('then', target),
-    catch: forward('catch', target),
-    finally: forward('finally', target),
-});
-const objectProxyHandler = {
-    //@ts-expect-error
-    [Symbol.toStringTag]: 'MutTs PromiseChain object',
-    get(target, prop, receiver) {
-        const getter = Object.getOwnPropertyDescriptor(target, prop)?.get;
-        const rv = getter ? getter.call(receiver) : target[prop];
-        // Allows fct.call or fct.apply to bypass the chain system
-        if (typeof target === 'function')
-            return rv;
-        return chainPromise(rv);
-    },
-    apply(target, thisArg, args) {
-        return chainPromise(target.apply(thisArg, args));
-    },
-};
-function chainObject(given) {
-    const rv = new Proxy(given, objectProxyHandler);
-    cache$1(given, rv);
-    return rv;
-}
-function chainable(x) {
-    return x && ['function', 'object'].includes(typeof x);
-}
-/**
- * Transforms a promise or value into a chainable object
- * Allows calling methods directly on promise results without awaiting them first
- * @param given - The promise or value to make chainable
- * @returns A chainable version of the input
- */
-function chainPromise(given) {
-    if (!chainable(given))
-        return given;
-    if (alreadyChained.has(given))
-        return alreadyChained.get(given);
-    if (!(given instanceof Promise))
-        return chainObject(given);
-    // @ts-expect-error It's ok as we check if it's an object above
-    given = given.then((r) => (chainable(r) ? chainObject(r) : r));
-    const target = Object.assign(function (...args) {
-        return chainPromise(given.then((r) => {
-            return this?.then
-                ? this.then((t) => r.apply(t, args))
-                : r.apply(this, args);
-        }));
-    }, promiseForward(given));
-    const chained = new Proxy(target, promiseProxyHandler);
-    cache$1(given, chained);
-    return chained;
-}
-
-function attend(source, callback) {
-    const enumerate = typeof source === 'function'
-        ? source
-        : Array.isArray(source)
-            ? () => Array.from({ length: source.length }, (_, i) => i)
-            : source instanceof Map
-                ? () => source.keys()
-                : source instanceof Set
-                    ? () => source.values()
-                    : () => Object.keys(source);
-    const keyEffects = new Map();
-    const outer = proxy.effect.named('attend')(({ ascend }) => {
-        const keys = new Set();
-        for (const key of enumerate())
-            keys.add(key);
-        for (const key of keys) {
-            if (keyEffects.has(key))
-                continue;
-            keyEffects.set(key, ascend(() => proxy.effect.named(`attend:${key}`)((access) => callback(key, access))));
-        }
-        for (const key of Array.from(keyEffects.keys())) {
-            if (!keys.has(key)) {
-                keyEffects.get(key)();
-                keyEffects.delete(key);
-            }
-        }
-    });
-    return (reason) => {
-        outer(reason);
-        for (const stop of keyEffects.values())
-            stop(reason);
-        keyEffects.clear();
+const GLOBAL_ORIGINALS = Symbol.for('mutts.originals');
+const GLOBAL_PROMISE = Symbol.for('mutts.OriginalPromise');
+let originals;
+let OriginalPromise;
+if (globalThis[GLOBAL_ORIGINALS]) {
+    originals = globalThis[GLOBAL_ORIGINALS];
+    OriginalPromise = globalThis[GLOBAL_PROMISE];
+}
+else {
+    OriginalPromise = globalThis.Promise;
+    originals = {
+        // biome-ignore lint/suspicious/noThenProperty: Intentional Promise.prototype patching
+        then: OriginalPromise.prototype.then,
+        catch: OriginalPromise.prototype.catch,
+        finally: OriginalPromise.prototype.finally,
+        resolve: OriginalPromise.resolve,
+        reject: OriginalPromise.reject,
+        all: OriginalPromise.all,
+        allSettled: OriginalPromise.allSettled,
+        race: OriginalPromise.race,
+        any: OriginalPromise.any,
+        setTimeout: globalThis.setTimeout,
+        setInterval: globalThis.setInterval,
+        setImmediate: globalThis.setImmediate,
+        requestAnimationFrame: globalThis.requestAnimationFrame,
+        queueMicrotask: globalThis.queueMicrotask,
     };
-}
-function lift(cb) {
-    let result;
-    let rawResult;
-    const liftCleanup = proxy.effect.named(`lift:${cb.name}`)(proxy.markWithRoot((access) => {
-        const source = cb(access);
-        if (!source || typeof source !== 'object')
-            throw new Error('lift callback must return an array or object');
-        const sourceProto = Object.getPrototypeOf(source);
-        if (!result) {
-            rawResult = Array.isArray(source) ? [] : Object.create(sourceProto);
-            result = proxy.reactive(rawResult);
-        }
-        if (sourceProto !== Object.getPrototypeOf(result))
-            throw new Error('lift callback must return the same type as the previous result');
-        if (Array.isArray(source)) {
-            const res = result;
-            for (const { indexA, sliceA, sliceB } of arrayDiff(res, source).sort((a, b) => a.indexA - b.indexA))
-                res.splice(indexA, sliceA.length, ...sliceB);
-        }
-        else {
-            for (const key of Object.keys(source)) {
-                const had = key in rawResult;
-                const newDesc = Object.getOwnPropertyDescriptor(source, key);
-                if (had) {
-                    const oldDesc = Object.getOwnPropertyDescriptor(rawResult, key);
-                    const sameAccessor = oldDesc && newDesc.get && oldDesc.get === newDesc.get;
-                    Object.defineProperty(rawResult, key, newDesc);
-                    if (!sameAccessor &&
-                        rawResult[key] !==
-                            (oldDesc ? (oldDesc.get ? oldDesc.get() : oldDesc.value) : undefined))
-                        proxy.touched1(rawResult, { type: 'set', prop: key }, key);
-                }
-                else {
-                    Object.defineProperty(rawResult, key, newDesc);
-                    proxy.touched1(rawResult, { type: 'add', prop: key }, key);
-                }
-            }
-            for (const key of Object.keys(rawResult))
-                if (!(key in source)) {
-                    delete rawResult[key];
-                    proxy.touched1(rawResult, { type: 'del', prop: key }, key);
-                }
-        }
-    }, cb));
-    return proxy.link(result, liftCleanup);
-}
-/**
- * Reactively maps an array source through `fn`, producing a lazy reactive output array.
- *
- * Each source item gets its own isolated effect (via `root()`) so that changes to one item
- * only recompute that item's projection. Structural changes (push, splice, reorder) are detected
- * via `arrayDiff` and surgically applied to the output cache.
- *
- * The source can be a reactive array or a function returning an array. When a function is provided,
- * the function is re-evaluated inside an effect whenever its dependencies change.
- *
- * Output elements are computed lazily — accessing `result[i]` triggers computation if not yet cached.
- *
- * @param source - A reactive array or a function returning an array
- * @param fn - Mapping function applied to each element
- * @param options - Optional purity hints to skip per-item effects
- * @returns A readonly reactive array with a `[cleanup]` method to dispose all effects
- */
-function morphArray(source, fn, options) {
-    if (typeof source !== 'function' && !proxy.isReactive(source) && options?.pure === true) {
-        return source.map((i) => fn(i));
-    }
-    let track;
-    const itemEffects = new Map();
-    const cache = [];
-    let input = [];
-    function stopItem(key) {
-        const entry = itemEffects.get(key);
-        if (entry) {
-            entry.stop({ type: 'stopped' });
-            itemEffects.delete(key);
-        }
-    }
-    function computeItem(key, input) {
-        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(input));
-        if (isPure) {
-            track(() => {
-                cache[key] = fn(input);
-            });
-        }
-        else {
-            const indexRef = { value: key };
-            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
-                cache[indexRef.value] = fn(input, access);
-                return (reason) => {
-                    delete cache[indexRef.value];
-                    proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
-                };
-            }));
-            itemEffects.set(key, { stop, index: indexRef });
-        }
-    }
-    const proxy$1 = proxy.reactive(cache, {
-        get(cache, prop) {
-            const n = typeof prop === 'string' ? Number(prop) : NaN;
-            if (Number.isNaN(n))
-                return cache[prop];
-            if (!(n in cache))
-                computeItem(n, input[n]);
-            return cache[n];
-        },
-        has(_cache, prop) {
-            return Reflect.has(input, prop);
-        },
-    });
-    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
-        track = ascend;
-        const newInput = [...(typeof source === 'function' ? source() : source)];
-        const diffs = arrayDiff(input, newInput).toSorted((a, b) => b.indexA - a.indexA);
-        if (diffs.length > 0) {
-            for (const diff of diffs) {
-                // Stop items in removed range
-                for (let i = diff.indexA; i < diff.indexA + diff.sliceA.length; i++)
-                    stopItem(i);
-                // Shift existing itemEffects in the Map to match the new indices
-                const shift = diff.sliceB.length - diff.sliceA.length;
-                if (shift !== 0) {
-                    // We need to move entries in the Map.
-                    const entries = Array.from(itemEffects.entries()).sort((a, b) => a[0] - b[0]);
-                    // Remove entries that will be shifted
-                    for (const [idx, _entry] of entries) {
-                        if (idx >= diff.indexA + diff.sliceA.length) {
-                            itemEffects.delete(idx);
-                        }
-                    }
-                    // Re-add them with shifted indices
-                    for (const [idx, entry] of entries) {
-                        if (idx >= diff.indexA + diff.sliceA.length) {
-                            const newIdx = idx + shift;
-                            entry.index.value = newIdx;
-                            itemEffects.set(newIdx, entry);
-                        }
-                    }
-                }
-                // Splice the cache
-                cache.splice(diff.indexA, diff.sliceA.length, ...new Array(diff.sliceB.length).fill(undefined));
-                // Make holes for lazy computation
-                for (let i = diff.indexA; i < diff.indexA + diff.sliceB.length; i++)
-                    delete cache[i];
-            }
-            const invalidates = new Set([proxy.keysOf]);
-            if (input.length !== newInput.length)
-                invalidates.add('length');
-            for (const diff of diffs) {
-                const max = Math.max(diff.sliceA.length, diff.sliceB.length);
-                for (let i = 0; i < max; i++)
-                    invalidates.add(String(diff.indexA + i));
-            }
-            proxy.touched(cache, { type: 'bunch', method: 'morph-input' }, invalidates);
-        }
-        input = newInput;
-    });
-    return proxy.link(proxy$1, (reason) => {
-        stopMain(reason);
-        for (const entry of itemEffects.values())
-            entry.stop(reason);
-        itemEffects.clear();
-    });
-}
-/**
- * Reactively maps a `Map` source through `fn`, producing a reactive output Map.
- *
- * Each key gets its own isolated effect so that value changes for one key only recompute
- * that key's projection. Key additions and removals are tracked via `keysOf` dependency.
- *
- * @param source - A reactive Map
- * @param fn - Mapping function applied to each value
- * @param options - Optional purity hints to skip per-key effects
- * @returns A reactive Map with a `[cleanup]` method to dispose all effects
- */
-function morphMap(source, fn, options) {
-    if (!proxy.isReactive(source) && options?.pure === true) {
-        const res = new Map();
-        for (const [k, v] of source)
-            res.set(k, fn(v, k));
-        return res;
-    }
-    let track;
-    const itemEffects = new Map();
-    const cache = new Map();
-    Object.defineProperty(cache, 'constructor', { value: Object, enumerable: false });
-    function stopItem(key) {
-        const stop = itemEffects.get(key);
-        if (stop) {
-            stop({ type: 'stopped' });
-            itemEffects.delete(key);
-        }
-    }
-    function computeItem(key, val) {
-        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
-        if (isPure) {
-            cache.set(key, track(() => fn(val, key)));
-        }
-        else {
-            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
-                cache.set(key, fn(source.get(key), key, access));
-                return (reason) => {
-                    cache.delete(key);
-                    proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
-                };
-            }));
-            itemEffects.set(key, stop);
-        }
-    }
-    const proxy$1 = proxy.reactive(cache, {
-        get(cache, prop) {
-            if (prop === 'get')
-                return (key) => {
-                    if (!cache.has(key) && source.has(key))
-                        computeItem(key, source.get(key));
-                    return cache.get(key);
-                };
-            if (prop === 'has')
-                return (key) => {
-                    return source.has(key);
-                };
-            if (prop === 'keys')
-                return () => {
-                    return source.keys();
-                };
-            if (prop === 'values')
-                return function* () {
-                    for (const key of source.keys()) {
-                        yield proxy$1.get(key);
-                    }
-                };
-            if (prop === 'entries')
-                return function* () {
-                    for (const key of source.keys()) {
-                        yield [key, proxy$1.get(key)];
-                    }
-                };
-            if (prop === Symbol.iterator)
-                return function* () {
-                    for (const key of source.keys()) {
-                        yield [key, proxy$1.get(key)];
-                    }
-                };
-            return cache[prop];
-        },
-    });
-    let stateSnapshot = proxy.getState(source);
-    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
-        track = ascend;
-        proxy.dependant(source, proxy.keysOf);
-        while ('evolution' in stateSnapshot) {
-            const { evolution } = stateSnapshot;
-            stateSnapshot = stateSnapshot.next;
-            if (evolution.type === 'add') {
-                proxy.touched1(cache, evolution, evolution.prop);
-            }
-            else if (evolution.type === 'del') {
-                stopItem(evolution.prop);
-                cache.delete(evolution.prop);
-                proxy.touched1(cache, evolution, evolution.prop);
-            }
-        }
-    });
-    return proxy.link(proxy$1, (reason) => {
-        stopMain(reason);
-        for (const stop of itemEffects.values())
-            stop(reason);
-        itemEffects.clear();
-    });
-}
-/**
- * Reactively maps a record/object source through `fn`, producing a reactive output record.
- *
- * Each key gets its own isolated effect so that value changes for one key only recompute
- * that key's projection. Key additions and removals are tracked automatically.
- *
- * @param source - A reactive record
- * @param fn - Mapping function applied to each value
- * @param options - Optional purity hints to skip per-key effects
- * @returns A reactive record with a `[cleanup]` method to dispose all effects
- */
-function morphRecord(source, fn, options) {
-    if (!proxy.isReactive(source) && options?.pure === true) {
-        const res = {};
-        for (const k of Object.keys(source))
-            res[k] = fn(source[k], k);
-        return res;
-    }
-    let track;
-    const itemEffects = new Map();
-    const cache = {};
-    function stopItem(key) {
-        const stop = itemEffects.get(key);
-        if (stop) {
-            stop({ type: 'stopped' });
-            itemEffects.delete(key);
-        }
-    }
-    function computeItem(key, val) {
-        const isPure = options?.pure === true || (typeof options?.pure === 'function' && options.pure(val));
-        if (isPure) {
-            cache[key] = track(() => fn(val, key));
-        }
-        else {
-            const stop = track(() => proxy.effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
-                cache[key] = fn(source[key], key, access);
-                return (reason) => {
-                    delete cache[key];
-                    proxy.touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
-                };
-            }));
-            itemEffects.set(key, stop);
-        }
-    }
-    function get(prop) {
-        if (!(prop in cache) && prop in source)
-            computeItem(prop, source[prop]);
-        return cache[prop];
-    }
-    const proxy$1 = proxy.reactive(cache, {
-        get(_, prop) {
-            return get(prop);
-        },
-        has(_, prop) {
-            return prop in source;
-        },
-        ownKeys() {
-            return Reflect.ownKeys(source);
-        },
-        getOwnPropertyDescriptor(_cache, prop) {
-            if (prop in source)
-                return { configurable: true, enumerable: true, get: () => get(prop) };
-        },
-    });
-    let stateSnapshot = proxy.getState(source);
-    const stopMain = proxy.effect.named(`morph:${fn.name}`)(({ ascend }) => {
-        track = ascend;
-        // Track only structural changes on source
-        proxy.dependant(source, proxy.keysOf);
-        while ('evolution' in stateSnapshot) {
-            const { evolution } = stateSnapshot;
-            stateSnapshot = stateSnapshot.next;
-            if (evolution.type === 'add') {
-                proxy.touched1(cache, evolution, evolution.prop);
-            }
-            else if (evolution.type === 'del') {
-                stopItem(evolution.prop);
-                delete cache[evolution.prop];
-                proxy.touched1(cache, evolution, evolution.prop);
-            }
-        }
-    });
-    return proxy.link(proxy$1, (reason) => {
-        stopMain(reason);
-        for (const stop of itemEffects.values())
-            stop(reason);
-        itemEffects.clear();
-    });
-}
-/**
- * Reactively maps a collection (array, Map, or record) through a per-entry function.
- *
- * Each entry in the source gets its own reactive context — when only one entry's dependencies
- * change, only that entry's projection recomputes. Structural changes (additions, removals,
- * reorders) are detected via diffing and applied surgically.
- *
- * Use `morph.pure(source, fn)` when `fn` has no reactive reads (skips per-item effects).
- *
- * @example
- * ```ts
- * const users = reactive([{ name: 'John' }, { name: 'Jane' }])
- * const names = morph(users, u => u.name.toUpperCase())
- * // names[0] = 'JOHN', names[1] = 'JANE'
- * // Changing users[0].name only recomputes names[0]
- * ```
- */
-const morph = proxy.flavored(function morph(source, fn, options) {
-    if (Array.isArray(source) || typeof source === 'function')
-        return morphArray(source, fn, options);
-    if (source instanceof Map)
-        return morphMap(source, fn, options);
-    return morphRecord(source, fn, options);
-}, {
-    get pure() {
-        return (source, fn, _opt) => this(source, fn, { pure: true });
-    },
+    globalThis[GLOBAL_ORIGINALS] = originals;
+    globalThis[GLOBAL_PROMISE] = OriginalPromise;
+}
+// Ensure modern statics are captured even if originals was cached from an older version
+if (!originals.allSettled)
+    originals.allSettled = OriginalPromise.allSettled;
+if (!originals.any)
+    originals.any = OriginalPromise.any;
+if (!originals.race)
+    originals.race = OriginalPromise.race;
+function patchedThen(onFulfilled, onRejected) {
+    const context = promiseContexts.get(this) || captureRestorers();
+    const nextPromise = originals.then.call(this, wrap(onFulfilled, context), wrap(onRejected, context));
+    if (context.size > 0)
+        promiseContexts.set(nextPromise, context);
+    return nextPromise;
+}
+function patchedCatch(onRejected) {
+    const context = promiseContexts.get(this) || captureRestorers();
+    const nextPromise = originals.catch.call(this, wrap(onRejected, context));
+    if (context.size > 0)
+        promiseContexts.set(nextPromise, context);
+    return nextPromise;
+}
+function patchedFinally(onFinally) {
+    const context = promiseContexts.get(this) || captureRestorers();
+    const nextPromise = originals.finally.call(this, wrap(onFinally, context));
+    if (context.size > 0)
+        promiseContexts.set(nextPromise, context);
+    return nextPromise;
+}
+function PatchedPromise(executor) {
+    if (typeof executor === 'function') {
+        const p = new OriginalPromise((resolve, reject) => {
+            const wrappedResolve = wrap(resolve);
+            const wrappedReject = wrap(reject);
+            executor(wrappedResolve, wrappedReject);
+        });
+        const context = captureRestorers();
+        promiseContexts.set(p, context); // Always set, even if empty (Sticky Root)
+        return p;
+    }
+    return new OriginalPromise(executor);
+}
+// Copy statics
+Object.assign(PatchedPromise, OriginalPromise);
+// Inherit prototype for instanceof checks
+PatchedPromise.prototype = OriginalPromise.prototype;
+PatchedPromise.resolve = ((value) => {
+    const p = originals.resolve.call(OriginalPromise, value);
+    const context = captureRestorers();
+    // Ensure we don't overwrite if it already has context (e.g. from constructor)
+    if (context.size > 0 && !promiseContexts.has(p))
+        promiseContexts.set(p, context);
+    return p;
 });
-
-/**
- * Deep watch an object and all its nested properties
- * @param target - The object to watch deeply
- * @param callback - The callback to call when any nested property changes
- * @param options - Options for the deep watch
- * @returns A cleanup function to stop watching
- */
-/**
- * Sets up deep watching for an object, tracking all nested property changes
- * @param target - The object to watch
- * @param callback - The callback to call when changes occur
- * @param options - Options for deep watching
- * @returns A cleanup function to stop deep watching
- */
-function deepWatch(target, callback, { immediate = false } = {}) {
-    if (target === null || target === undefined)
-        return undefined;
-    if (typeof target !== 'object')
-        throw new Error('Target of deep watching must be an object');
-    // Create a wrapper callback that matches EffectTrigger signature
-    const wrappedCallback = proxy.markWithRoot((() => callback(target)), callback);
-    proxy.registerDeepWatcher();
-    // Use the existing effect system to register dependencies
-    return proxy.effect.named('deepWatch')(() => {
-        // Mark the target object as having deep watchers
-        proxy.objectsWithDeepWatchers.add(target);
-        // Track which objects this effect is watching for cleanup
-        let effectObjects = proxy.effectToDeepWatchedObjects.get(wrappedCallback);
-        if (!effectObjects) {
-            effectObjects = new Set();
-            proxy.effectToDeepWatchedObjects.set(wrappedCallback, effectObjects);
-        }
-        effectObjects.add(target);
-        // Traverse the object graph and register dependencies
-        // This will re-run every time the effect runs, ensuring we catch all changes
-        const visited = new WeakSet();
-        function traverseAndTrack(obj, depth = 0) {
-            // Prevent infinite recursion and excessive depth
-            if (!obj || visited.has(obj) || typeof obj !== 'object' || depth > proxy.options.maxDeepWatchDepth)
-                return;
-            // Do not traverse into unreactive objects
-            if (proxy.isNonReactive(obj))
-                return;
-            visited.add(obj);
-            // Mark this object as having deep watchers
-            proxy.objectsWithDeepWatchers.add(obj);
-            effectObjects.add(obj);
-            // Traverse all properties to register dependencies
-            // unwrap to avoid kicking dependency
-            for (const key in proxy.unwrap(obj)) {
-                if (Object.hasOwn(obj, key)) {
-                    // Access the property to register dependency
-                    const value = obj[key];
-                    // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
-                    traverseAndTrack(reactiveValue, depth + 1);
-                }
-            }
-            // Also handle array indices and length
-            // Handle arrays and collections using iterators to ensure proxy tracking is triggered
-            if (typeof obj[Symbol.iterator] === 'function') {
-                // Access the iterator to track additions/removals/collection changes
-                for (const value of obj) {
-                    // Make the value reactive if it's an object
-                    const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
-                    traverseAndTrack(reactiveValue, depth + 1);
-                }
-                // Explicitly depend on length so array mutations changing count trigger re-evaluation
-                if ('length' in obj) {
-                    proxy.dependant(obj, 'length');
-                }
-                // For Maps, also ensure we track values explicitly if the iterator yields entries
-                if (obj instanceof Map) {
-                    for (const value of obj.values()) {
-                        const reactiveValue = typeof value === 'object' && value !== null ? proxy.reactive(value) : value;
-                        traverseAndTrack(reactiveValue, depth + 1);
-                    }
-                }
-            }
-            // Note: WeakSet and WeakMap cannot be iterated, so we can't deep watch their contents
-            // They will only trigger when the collection itself is replaced
-        }
-        // Traverse the target object to register all dependencies
-        // This will register dependencies on all current properties and array elements
-        traverseAndTrack(target);
-        // Only call the callback if immediate is true or if it's not the first run
-        if (immediate) {
-            proxy.untracked(() => callback(target));
-        }
-        immediate = true;
-        // Return a cleanup function that properly removes deep watcher tracking
-        return () => {
-            // Get the objects this effect was watching
-            const effectObjects = proxy.effectToDeepWatchedObjects.get(wrappedCallback);
-            if (effectObjects) {
-                // Remove deep watcher tracking from all objects this effect was watching
-                for (const obj of effectObjects) {
-                    // Check if this object still has other deep watchers
-                    const watchers = proxy.deepWatchers.get(obj);
-                    if (watchers) {
-                        // Remove this effect's callback from the watchers
-                        watchers.delete(wrappedCallback);
-                        // If no more watchers, remove the object from deep watchers tracking
-                        if (watchers.size === 0) {
-                            proxy.deepWatchers.delete(obj);
-                            proxy.objectsWithDeepWatchers.delete(obj);
-                        }
-                    }
-                    else {
-                        // No watchers found, remove from deep watchers tracking
-                        proxy.objectsWithDeepWatchers.delete(obj);
-                    }
-                }
-                // Clean up the tracking data
-                proxy.effectToDeepWatchedObjects.delete(wrappedCallback);
-            }
-        };
-    });
-}
-
-const memoizedRegistry = new WeakMap();
-const wrapperRegistry = new WeakMap();
-function getBranch(tree, key) {
-    tree.branches ?? (tree.branches = new WeakMap());
-    let branch = tree.branches.get(key);
-    if (!branch) {
-        branch = {};
-        tree.branches.set(key, branch);
-    }
-    return branch;
-}
-function memoizeFunction(fn, opts) {
-    const fnRoot = proxy.getRoot(fn);
-    const existing = memoizedRegistry.get(fnRoot);
-    if (existing)
-        return existing;
-    const cacheRoot = {};
-    const memoized = proxy.markWithRoot(function memoized(...args) {
-        if (args.some((arg) => !(arg && ['object', 'symbol', 'function'].includes(typeof arg)))) {
-            if (opts?.lenient)
-                return fn.apply(this, args);
-            throw new Error('memoize expects non-null object arguments');
-        }
-        let node = cacheRoot;
-        // Note: decorators add `this` as first argument
-        for (const arg of args) {
-            node = getBranch(node, arg);
-        }
-        proxy.dependant(node, 'memoize');
-        if ('result' in node) {
-            if (proxy.options.onMemoizationDiscrepancy) {
-                const wasVerification = proxy.options.isVerificationRun;
-                proxy.options.isVerificationRun = true;
-                try {
-                    const fresh = proxy.untracked(() => fn.apply(this, args));
-                    if (!proxy.deepCompare(node.result, fresh)) {
-                        proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
-                    }
-                }
-                finally {
-                    proxy.options.isVerificationRun = wasVerification;
-                }
-            }
-            return node.result;
-        }
-        // Create memoize internal effect to track dependencies and invalidate cache
-        // Use untracked to prevent the effect creation from being affected by parent effects
-        node.cleanup = proxy.root(() => proxy.effect.named('memoize')(() => {
-            // Execute the function and track its dependencies
-            // The function execution will automatically track dependencies on reactive objects
-            node.result = fn.apply(this, args);
-            return (reason) => {
-                // When dependencies change, clear the cache and notify consumers
-                delete node.result;
-                proxy.touched1(node, { type: 'invalidate', prop: args }, 'memoize');
-                // Lazy memoization: stop the effect so it doesn't re-run immediately.
-                // It will be re-created on next access.
-                if (node.cleanup) {
-                    node.cleanup({ type: 'invalidate', cause: reason });
-                    node.cleanup = undefined;
-                }
-            };
-        }, { opaque: true }));
-        if (proxy.options.onMemoizationDiscrepancy) {
-            const wasVerification = proxy.options.isVerificationRun;
-            proxy.options.isVerificationRun = true;
-            try {
-                const fresh = proxy.untracked(() => fn.apply(this, args));
-                if (!proxy.deepCompare(node.result, fresh)) {
-                    proxy.optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
-                }
-            }
-            finally {
-                proxy.options.isVerificationRun = wasVerification;
-            }
-        }
-        return node.result;
-    }, fn);
-    memoizedRegistry.set(fnRoot, memoized);
-    memoizedRegistry.set(memoized, memoized);
-    return memoized;
-}
-function memoizeObject(target, opts) {
-    const existing = memoizedRegistry.get(target);
-    if (existing)
-        return existing;
-    const proxy$1 = new Proxy(target, {
-        get(source, prop, receiver) {
-            // 1. Walk prototype chain to find descriptor
-            let current = source;
-            let desc;
-            while (current) {
-                desc = Object.getOwnPropertyDescriptor(current, prop);
-                if (desc)
-                    break;
-                current = Object.getPrototypeOf(current);
-            }
-            if (!desc)
-                return Reflect.get(source, prop, receiver);
-            // 2. If getter, memoize
-            if (desc.get) {
-                const originalGetter = desc.get;
-                let wrapper = wrapperRegistry.get(originalGetter);
-                if (!wrapper) {
-                    wrapper = proxy.markWithRoot(proxy.named(`${String(source?.constructor?.name ?? 'Object')}.${String(prop)}`, (that) => {
-                        return originalGetter.call(that);
-                    }), {
-                        propertyKey: prop,
-                    });
-                    const origRoot = originalGetter[proxy.rootFunctionSymbol];
-                    if (origRoot)
-                        wrapper[proxy.rootFunctionSymbol] = origRoot;
-                    wrapperRegistry.set(originalGetter, wrapper);
-                }
-                const memoized = memoizeFunction(wrapper, opts);
-                return memoized(receiver);
-            }
-            // 3. Otherwise forward
-            return Reflect.get(source, prop, receiver);
-        },
-        // Forward set to the target (source) to ensure it acts as the receiver for reactivity notifications
-        set(source, prop, value, _receiver) {
-            // By strictly passing `source` as receiver, we ensure that if `source` is a reactive proxy,
-            // it recognizes itself and triggers change notifications.
-            return Reflect.set(source, prop, value, source);
-        },
-    });
-    proxy.proxyToObject.set(proxy$1, target);
-    memoizedRegistry.set(target, proxy$1);
-    return proxy$1;
-}
-/**
- * Decorator and function wrapper for memoizing computed values based on reactive dependencies.
- *
- * When used as a decorator on getters or methods, it caches the result and automatically
- * invalidates the cache when reactive dependencies change.
- *
- * When used as a function wrapper, it memoizes based on object arguments (WeakMap-based cache).
- *
- * @example
- * ```typescript
- * class User {
- *   @memoize
- *   get fullName() {
- *     return `${this.firstName} ${this.lastName}`
- *   }
- * }
- *
- * // Or as a function wrapper
- * const expensive = memoize((obj: SomeObject) => {
- *   return heavyComputation(obj)
- * })
- * ```
- */
-function makeMemoizeDecorator(memoizeOpts) {
-    return proxy.decorator({
-        getter(original, target, propertyKey) {
-            return function () {
-                let wrapper = wrapperRegistry.get(original);
-                if (!wrapper) {
-                    wrapper = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(propertyKey)}`, (that) => {
-                        return original.call(that);
-                    }), {
-                        method: original,
-                        propertyKey,
-                    });
-                    const origRoot = original[proxy.rootFunctionSymbol];
-                    if (origRoot)
-                        wrapper[proxy.rootFunctionSymbol] = origRoot;
-                    wrapperRegistry.set(original, wrapper);
-                }
-                const memoized = memoizeFunction(wrapper, memoizeOpts);
-                return memoized(this);
-            };
-        },
-        method(original, target, name) {
-            return function (...args) {
-                let wrapper = wrapperRegistry.get(original);
-                if (!wrapper) {
-                    wrapper = proxy.markWithRoot(proxy.named(`${String(target?.constructor?.name ?? target?.name ?? 'Object')}.${String(name)}`, (that, ...args) => {
-                        return original.call(that, ...args);
-                    }), {
-                        method: original,
-                        propertyKey: name,
-                    });
-                    const origRoot = original[proxy.rootFunctionSymbol];
-                    if (origRoot)
-                        wrapper[proxy.rootFunctionSymbol] = origRoot;
-                    wrapperRegistry.set(original, wrapper);
-                }
-                const memoized = memoizeFunction(wrapper, memoizeOpts);
-                return memoized(this, ...args);
-            };
-        },
-        default: (target) => typeof target === 'object'
-            ? memoizeObject(target, memoizeOpts)
-            : memoizeFunction(target, memoizeOpts),
-    });
-}
-const memoize = proxy.flavored(makeMemoizeDecorator(), {
-    get lenient() {
-        return makeMemoizeDecorator({ lenient: true });
-    },
+PatchedPromise.reject = ((reason) => {
+    const p = originals.reject.call(OriginalPromise, reason);
+    const context = captureRestorers();
+    if (context.size > 0)
+        promiseContexts.set(p, context);
+    return p;
 });
-
-/**
- * Organizes a source object's properties into a target object using a callback function.
- * This creates a reactive mapping between source properties and a target object,
- * automatically handling property additions, updates, and removals.
- *
- * @template Source - The type of the source object
- * @template Target - The type of the target object (defaults to Record<PropertyKey, any>)
- *
- * @param {Source} source - The source object to organize
- * @param {OrganizedCallback<Source, Target>} apply - Callback function that defines how each source property is mapped to the target
- * @param {Target} [baseTarget={}] - Optional base target object to use (will be made reactive if not already)
- *
- * @returns {OrganizedResult<Target>} The target object with cleanup capability
- *
- * @example
- * // Organize user permissions into role-based access
- * const user = reactive({ isAdmin: true, canEdit: false });
- * const permissions = organized(
- *   user,
- *   (access, target) => {
- *     if (access.key === 'isAdmin') {
- *       target.hasFullAccess = access.value;
- *     }
- *     target[`can${access.key.charAt(0).toUpperCase() + access.key.slice(1)}`] = access.value;
- *   }
- * );
- *
- * @example
- * // Transform object structure with cleanup
- * const source = reactive({ firstName: 'John', lastName: 'Doe' });
- * const formatted = organized(
- *   source,
- *   (access, target) => {
- *     if (access.key === 'firstName' || access.key === 'lastName') {
- *       target.fullName = `${source.firstName} ${source.lastName}`.trim();
- *     }
- *   }
- * );
- *
- * @example
- * // Using with cleanup in a component
- * effect(() => {
- *   const data = fetchData();
- *   const organizedData = organized(data, (access, target) => {
- *     // Transform data
- *   });
- *
- *   // The cleanup will be called automatically when the effect is disposed
- *   return () => organizedData[cleanup]();
- * });
- */
-function organized(source, apply, baseTarget = {}) {
-    const observedSource = proxy.reactive(source);
-    const target = proxy.reactive(baseTarget);
-    const stop = attend(() => {
-        const keys = [];
-        for (const key in observedSource)
-            keys.push(key);
-        return keys;
-    }, (key) => {
-        const sourceKey = key;
-        const accessBase = {
-            key: sourceKey,
-            get: () => proxy.FoolProof.get(observedSource, sourceKey, observedSource),
-            set: (value) => proxy.FoolProof.set(observedSource, sourceKey, value, observedSource),
-        };
-        Object.defineProperty(accessBase, 'value', {
-            get: accessBase.get,
-            set: accessBase.set,
-            configurable: true,
-            enumerable: true,
-        });
-        return apply(accessBase, target);
-    });
-    return proxy.link(target, (reason) => stop(reason));
-}
-/**
- * Organizes a property on a target object
- * Shortcut for defineProperty/delete with touched signal
- * @param target - The target object
- * @param property - The property to organize
- * @param access - The access object
- * @returns The property descriptor
- */
-function organize(target, property, access) {
-    Object.defineProperty(target, property, {
-        get: access.get,
-        set: access.set,
-        configurable: true,
-        enumerable: true,
-    });
-    proxy.touched1(target, { type: 'set', prop: property }, property);
-    return () => delete target[property];
-}
-
-//#region watch
-const unsetYet = Symbol('unset-yet');
-const watch = proxy.flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
-changed, options = {}) {
-    return typeof value === 'function'
-        ? watchCallBack(value, changed, options)
-        : typeof value === 'object' && value !== null
-            ? watchObject(value, changed, options)
-            : (() => {
-                throw new Error('watch: value must be a function or an object');
-            })();
-}, {
-    get deep() {
-        return proxy.flavorOptions(this, { deep: true });
-    },
-    get immediate() {
-        return proxy.flavorOptions(this, { immediate: true });
-    },
+PatchedPromise.all = ((values) => {
+    const p = originals.all.call(OriginalPromise, values);
+    const context = captureRestorers();
+    if (context.size > 0)
+        promiseContexts.set(p, context);
+    return p;
 });
-function watchObject(value, changed, { immediate = false, deep = false } = {}) {
-    if (deep)
-        return deepWatch(value, changed, { immediate });
-    return proxy.effect.named('watch:object')(() => {
-        proxy.dependant(value);
-        if (immediate)
-            changed(value);
-        immediate = true;
-    });
-}
-function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
-    let oldValue = unsetYet;
-    let deepCleanup;
-    const cbCleanup = proxy.effect.named('watch:callback')(proxy.markWithRoot((access) => {
-        const newValue = value(access);
-        if (oldValue !== newValue) {
-            const old = oldValue;
-            if (old === unsetYet) {
-                if (immediate)
-                    proxy.untracked(() => changed(newValue));
-            }
-            else
-                proxy.untracked(() => changed(newValue, old));
-        }
-        oldValue = newValue;
-        if (deep) {
-            if (deepCleanup)
-                deepCleanup();
-            deepCleanup = deepWatch(newValue, (value) => changed(value, value));
-        }
-    }, value));
-    return (() => {
-        cbCleanup();
-        if (deepCleanup)
-            deepCleanup();
-    });
-}
-//#endregion
-//#region when
-/**
- * Returns a promise that resolves when the predicate returns a truthy value.
- * The predicate is evaluated reactively — it re-runs whenever its dependencies change.
- * @param predicate - Reactive function that returns a value; resolves when truthy
- * @param timeout - Optional timeout in milliseconds — rejects if condition is not met within this duration
- * @returns Promise that resolves with the first truthy return value
- */
-function when(predicate, timeout) {
-    return new Promise((resolve, reject) => {
-        let timer;
-        const stop = proxy.effect.named('watch:when')((access) => {
-            try {
-                const value = predicate(access);
-                if (value) {
-                    if (timer !== undefined)
-                        clearTimeout(timer);
-                    timer = undefined;
-                    queueMicrotask(() => stop());
-                    resolve(value);
-                }
-            }
-            catch (error) {
-                if (timer !== undefined)
-                    clearTimeout(timer);
-                timer = undefined;
-                reject(error);
-            }
-        });
-        if (timeout !== undefined) {
-            timer = setTimeout(() => {
-                stop();
-                timer = undefined;
-                reject(new Error(`when: timed out after ${timeout}ms`));
-            }, timeout);
-        }
-    });
-}
-//#endregion
-//#region nonReactive
-/**
- * Mark an object as non-reactive. This object and all its properties will never be made reactive.
- * @param obj - The object to mark as non-reactive
- */
-function shallowNonReactive(obj) {
-    obj = proxy.unwrap(obj);
-    if (proxy.isNonReactive(obj))
-        return obj;
-    obj[proxy.unreactiveProperties] = true;
-    return obj;
-}
-function unreactiveApplication(arg1, ...args) {
-    return typeof arg1 === 'object'
-        ? shallowNonReactive(arg1)
-        : ((original) => {
-            // Copy the parent's unreactive properties if they exist
-            const parentMarker = original.prototype[proxy.unreactiveProperties];
-            // If parent is fully unreactive, child is too
-            if (parentMarker === true) {
-                original.prototype[proxy.unreactiveProperties] = true;
-            }
-            else {
-                const set = new Set(parentMarker || []);
-                // Add all arguments (including the first one)
-                set.add(arg1);
-                for (const arg of args)
-                    set.add(arg);
-                proxy.addUnreactiveProps(original.prototype, set);
-            }
-            return original; // Return the class
-        });
-}
-/**
- * Decorator that marks classes or properties as non-reactive
- * Prevents objects from being made reactive
- */
-const unreactive = proxy.decorator({
-    class(original) {
-        original.prototype[proxy.unreactiveProperties] = true;
-    },
-    default: unreactiveApplication,
+PatchedPromise.allSettled = ((values) => {
+    const p = originals.allSettled.call(OriginalPromise, values);
+    const context = captureRestorers();
+    if (context.size > 0)
+        promiseContexts.set(p, context);
+    return p;
 });
-//#endregion
-//#region resource
-function lazyInit(resource, load) {
-    const creation = proxy.effectHistory.active;
-    let fresh = true;
-    return new Proxy(resource, {
-        [Symbol.toStringTag]: 'LazyInit',
-        get(target, prop) {
-            if (fresh) {
-                proxy.captured(creation, load)();
-                fresh = false;
-            }
-            return target[prop];
-        },
-    });
-}
-/**
- * Creates a reactive resource that automatically tracks async state.
- * @param fetcher - Async function that returns the value. Reactive dependencies are tracked.
- * @param options - Resource options (initialValue)
- * @returns Reactive Resource object with value, loading, error, latest properties
- */
-function resource(fetcher, options = {}) {
-    const resource = proxy.reactive({
-        value: options.initialValue,
-        loading: true,
-        error: undefined,
-        latest: options.initialValue,
-        reload() {
-            reloadSignal.value++;
-        },
-    });
-    const reloadSignal = proxy.reactive({ value: 0 });
-    // Solve race conditions: make sure a new fast request is not overloaded by a slow old one
-    let counter = 0;
-    return lazyInit(resource, () => {
-        proxy.link(resource, proxy.effect.named('watch:resource')((access) => {
-            // Track reload signal to enable manual reloading
-            void reloadSignal.value;
-            const id = ++counter;
-            resource.loading = true;
-            resource.error = undefined;
-            try {
-                const result = fetcher(access);
-                if (result instanceof Promise) {
-                    resource.promise = result
-                        .then((val) => {
-                        if (id === counter) {
-                            resource.value = val;
-                            resource.latest = val;
-                            resource.loading = false;
-                        }
-                    })
-                        .catch((err) => {
-                        if (id === counter) {
-                            resource.error = err;
-                            resource.loading = false;
-                        }
-                    });
-                }
-                else {
-                    resource.promise = Promise.resolve();
-                    resource.value = result;
-                    resource.latest = result;
-                    resource.loading = false;
-                }
-            }
-            catch (err) {
-                resource.promise = Promise.reject(err);
-                resource.error = err;
-                resource.loading = false;
-            }
-        }));
-    });
-}
-//#endregion
-
-/**
- * Converts an iterator to a generator that yields reactive values
- */
-function* makeReactiveIterator(iterator) {
-    let result = iterator.next();
-    while (!result.done) {
-        yield proxy.reactive(result.value);
-        result = iterator.next();
-    }
-}
-/**
- * Converts an iterator of key-value pairs to a generator that yields reactive key-value pairs
- */
-function* makeReactiveEntriesIterator(iterator) {
-    let result = iterator.next();
-    while (!result.done) {
-        const [key, value] = result.value;
-        yield [proxy.reactive(key), proxy.reactive(value)];
-        result = iterator.next();
-    }
-}
-
-function* index(i, { length = true } = {}) {
-    if (length)
-        yield 'length';
-    yield i;
-}
-class Indexer extends Array {
-    get(i) {
-        proxy.dependant(this, i);
-        return proxy.reactive(this[i]);
-    }
-    // Returns undefined intentionally: signals the proxy handler that notifications
-    // were already dispatched via touched(), preventing double notification
-    set(i, value) {
-        const added = i >= this.length;
-        this[i] = value;
-        proxy.touched(this, { type: 'set', prop: i }, index(i, { length: added }));
-    }
-}
-const indexLess = { get: proxy.FoolProof.get, set: proxy.FoolProof.set };
-// Fast numeric-string check: first char is a digit (0-9)
-function asIndex(prop) {
-    const c = prop.charCodeAt(0);
-    if (c < 48 || c > 57)
-        return -1; // not 0-9
-    const n = +prop; // coerce — faster than parseInt, handles "0", "12", etc.
-    return n === (n | 0) && n >= 0 ? n : -1;
-}
-Object.assign(proxy.FoolProof, {
-    get(obj, prop, receiver) {
-        if (Array.isArray(obj) && typeof prop === 'string') {
-            const i = asIndex(prop);
-            if (i >= 0)
-                return Indexer.prototype.get.call(obj, i);
-        }
-        return indexLess.get(obj, prop, receiver);
-    },
-    set(obj, prop, value, receiver) {
-        if (Array.isArray(obj) && typeof prop === 'string') {
-            const i = asIndex(prop);
-            if (i >= 0)
-                return Indexer.prototype.set.call(obj, i, value);
-        }
-        return indexLess.set(obj, prop, value, receiver);
-    },
+PatchedPromise.race = ((values) => {
+    const p = originals.race.call(OriginalPromise, values);
+    const context = captureRestorers();
+    if (context.size > 0)
+        promiseContexts.set(p, context);
+    return p;
 });
-class ReactiveArray extends Array {
-    toJSON() {
-        return this;
-    }
-}
-/**
- * This is a wrapper class for Array that adds reactive behavior.
- * It extends Array and overrides methods to add reactive behavior, while making sure that the internal representation is not reactive.
- */
-let ReactiveArrayWrapper = (() => {
-    var _a;
-    let _classSuper = Array;
-    let _instanceExtraInitializers = [];
-    let _fill_decorators;
-    let _copyWithin_decorators;
-    let _pop_decorators;
-    let _push_decorators;
-    let _reverse_decorators;
-    let _shift_decorators;
-    let _sort_decorators;
-    let _splice_decorators;
-    let _unshift_decorators;
-    return _a = class ReactiveArrayWrapper extends _classSuper {
-            at(index) {
-                return proxy.reactive(super.at(index));
-            }
-            concat(...items) {
-                return proxy.reactive(super.concat(...items.map(proxy.unwrap)));
-            }
-            entries() {
-                proxy.dependant(this, proxy.keysOf);
-                return makeReactiveEntriesIterator(super.entries());
-            }
-            every(predicate, thisArg) {
-                return super.every((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
-            }
-            fill(value, start, end) {
-                return super.fill(proxy.unwrap(value), start, end);
-            }
-            copyWithin(target, start, end) {
-                return super.copyWithin(target, start, end);
-            }
-            filter(predicate, thisArg) {
-                return proxy.reactive(super.filter((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
-            }
-            find(predicate, thisArg) {
-                return proxy.reactive(super.find((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
-            }
-            findIndex(predicate, thisArg) {
-                return super.findIndex((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
-            }
-            findLast(predicate, thisArg) {
-                return proxy.reactive(super.findLast((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg));
-            }
-            findLastIndex(predicate, thisArg) {
-                return super.findLastIndex((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
-            }
-            flat(depth) {
-                return proxy.reactive(super.flat(depth));
-            }
-            flatMap(callbackfn, thisArg) {
-                return proxy.reactive(super.flatMap((v, i, a) => proxy.unwrap(callbackfn.call(thisArg, proxy.reactive(v), i, a)), thisArg));
-            }
-            forEach(callbackfn, thisArg) {
-                super.forEach((v, i, a) => {
-                    callbackfn.call(thisArg, proxy.reactive(v), i, a);
-                }, thisArg);
-            }
-            includes(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.includes(proxy.unwrap(searchElement), fromIndex)
-                    : super.includes(proxy.unwrap(searchElement));
-            }
-            indexOf(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.indexOf(proxy.unwrap(searchElement), fromIndex)
-                    : super.indexOf(proxy.unwrap(searchElement));
-            }
-            join(separator) {
-                return super.join(separator);
-            }
-            keys() {
-                proxy.dependant(this, 'length');
-                return super.keys();
-            }
-            lastIndexOf(searchElement, fromIndex) {
-                return arguments.length > 1
-                    ? super.lastIndexOf(proxy.unwrap(searchElement), fromIndex)
-                    : super.lastIndexOf(proxy.unwrap(searchElement));
-            }
-            map(callbackfn, thisArg) {
-                return proxy.reactive(super.map((v, i, a) => proxy.unwrap(callbackfn.call(thisArg, proxy.reactive(v), i, a)), thisArg));
-            }
-            pop() {
-                return proxy.reactive(super.pop());
-            }
-            push(...items) {
-                return super.push(...items.map(proxy.unwrap));
-            }
-            reduce(callbackfn, initialValue) {
-                return proxy.reactive(arguments.length > 1
-                    ? super.reduce((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a)), initialValue)
-                    : super.reduce((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a))));
-            }
-            reduceRight(callbackfn, initialValue) {
-                return proxy.reactive(arguments.length > 1
-                    ? super.reduceRight((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a)), initialValue)
-                    : super.reduceRight((acc, v, i, a) => proxy.unwrap(callbackfn(acc, proxy.reactive(v), i, a))));
-            }
-            reverse() {
-                return proxy.reactive(super.reverse());
-            }
-            shift() {
-                return proxy.reactive(super.shift());
-            }
-            slice(start, end) {
-                return proxy.reactive(super.slice(start, end));
-            }
-            some(predicate, thisArg) {
-                return super.some((v, i, a) => predicate.call(thisArg, proxy.reactive(v), i, a), thisArg);
-            }
-            sort(compareFn) {
-                const wrappedCompare = compareFn
-                    ? (a, b) => compareFn(proxy.reactive(a), proxy.reactive(b))
-                    : undefined;
-                return super.sort(wrappedCompare);
-            }
-            splice(start, deleteCount, ...items) {
-                if (arguments.length > 2)
-                    return proxy.reactive(super.splice(start, deleteCount, ...items.map(proxy.unwrap)));
-                if (arguments.length === 2)
-                    return proxy.reactive(super.splice(start, deleteCount));
-                if (arguments.length === 1)
-                    return proxy.reactive(super.splice(start));
-                return proxy.reactive([]);
-            }
-            unshift(...items) {
-                return super.unshift(...items.map(proxy.unwrap));
-            }
-            values() {
-                proxy.dependant(this, proxy.keysOf);
-                return makeReactiveIterator(super.values());
-            }
-            [(_fill_decorators = [proxy.atomic], _copyWithin_decorators = [proxy.atomic], _pop_decorators = [proxy.atomic], _push_decorators = [proxy.atomic], _reverse_decorators = [proxy.atomic], _shift_decorators = [proxy.atomic], _sort_decorators = [proxy.atomic], _splice_decorators = [proxy.atomic], _unshift_decorators = [proxy.atomic], Symbol.iterator)]() {
-                proxy.dependant(this, proxy.keysOf);
-                return makeReactiveIterator(super[Symbol.iterator]());
-            }
-            toReversed() {
-                return proxy.reactive(super.toReversed());
-            }
-            toSorted(compareFn) {
-                const wrappedCompare = compareFn
-                    ? (a, b) => compareFn(proxy.reactive(a), proxy.reactive(b))
-                    : undefined;
-                return proxy.reactive(super.toSorted(wrappedCompare));
-            }
-            toSpliced(start, deleteCount, ...items) {
-                if (arguments.length > 2)
-                    return proxy.reactive(super.toSpliced(start, deleteCount, ...items.map(proxy.unwrap)));
-                if (arguments.length === 2)
-                    return proxy.reactive(super.toSpliced(start, deleteCount));
-                if (arguments.length === 1)
-                    return proxy.reactive(super.toSpliced(start));
-                return proxy.reactive([...this]);
-            }
-            with(index, value) {
-                return proxy.reactive(super.with(index, proxy.unwrap(value)));
-            }
-            constructor() {
-                super(...arguments);
-                proxy.__runInitializers(this, _instanceExtraInitializers);
-            }
-        },
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            proxy.__esDecorate(_a, null, _fill_decorators, { kind: "method", name: "fill", static: false, private: false, access: { has: obj => "fill" in obj, get: obj => obj.fill }, metadata: _metadata }, null, _instanceExtraInitializers);
-            proxy.__esDecorate(_a, null, _copyWithin_decorators, { kind: "method", name: "copyWithin", static: false, private: false, access: { has: obj => "copyWithin" in obj, get: obj => obj.copyWithin }, metadata: _metadata }, null, _instanceExtraInitializers);
-            proxy.__esDecorate(_a, null, _pop_decorators, { kind: "method", name: "pop", static: false, private: false, access: { has: obj => "pop" in obj, get: obj => obj.pop }, metadata: _metadata }, null, _instanceExtraInitializers);
-            proxy.__esDecorate(_a, null, _push_decorators, { kind: "method", name: "push", static: false, private: false, access: { has: obj => "push" in obj, get: obj => obj.push }, metadata: _metadata }, null, _instanceExtraInitializers);
-            proxy.__esDecorate(_a, null, _reverse_decorators, { kind: "method", name: "reverse", static: false, private: false, access: { has: obj => "reverse" in obj, get: obj => obj.reverse }, metadata: _metadata }, null, _instanceExtraInitializers);
-            proxy.__esDecorate(_a, null, _shift_decorators, { kind: "method", name: "shift", static: false, private: false, access: { has: obj => "shift" in obj, get: obj => obj.shift }, metadata: _metadata }, null, _instanceExtraInitializers);
-            proxy.__esDecorate(_a, null, _sort_decorators, { kind: "method", name: "sort", static: false, private: false, access: { has: obj => "sort" in obj, get: obj => obj.sort }, metadata: _metadata }, null, _instanceExtraInitializers);
-            proxy.__esDecorate(_a, null, _splice_decorators, { kind: "method", name: "splice", static: false, private: false, access: { has: obj => "splice" in obj, get: obj => obj.splice }, metadata: _metadata }, null, _instanceExtraInitializers);
-            proxy.__esDecorate(_a, null, _unshift_decorators, { kind: "method", name: "unshift", static: false, private: false, access: { has: obj => "unshift" in obj, get: obj => obj.unshift }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        _a;
-})();
-
-/**
- * Reactive wrapper around JavaScript's WeakMap class
- * Only tracks individual key operations, no size tracking (WeakMap limitation)
- */
-class ReactiveWeakMap extends WeakMap {
-    // Implement WeakMap interface methods with reactivity
-    delete(key) {
-        const hadKey = this.has(key);
-        const result = super.delete(key);
-        if (hadKey)
-            proxy.touched1(proxy.contentRef(this), { type: 'del', prop: key }, key);
-        return result;
-    }
-    get(key) {
-        proxy.dependant(proxy.contentRef(this), key);
-        return proxy.reactive(super.get(key));
-    }
-    has(key) {
-        proxy.dependant(proxy.contentRef(this), key);
-        return super.has(key);
-    }
-    set(key, value) {
-        const hadKey = this.has(key);
-        const oldValue = this.get(key);
-        const reactiveValue = proxy.reactive(value);
-        this.set(key, reactiveValue);
-        if (!hadKey || oldValue !== reactiveValue) {
-            proxy.notifyPropertyChange(proxy.contentRef(this), key, oldValue, reactiveValue, hadKey);
-        }
-        return this;
-    }
-}
-/**
- * Reactive wrapper around JavaScript's Map class
- * Tracks size changes, individual key operations, and collection-wide operations
- */
-class ReactiveMap extends Map {
-    // Implement Map interface methods with reactivity
-    get size() {
-        proxy.dependant(this, 'size'); // The ReactiveMap instance still goes through proxy
-        return super.size;
-    }
-    clear() {
-        const hadEntries = this.size > 0;
-        super.clear();
-        if (hadEntries) {
-            const evolution = { type: 'bunch', method: 'clear' };
-            // Clear triggers all effects since all keys are affected
-            proxy.batch(() => {
-                proxy.touched1(this, evolution, 'size');
-                proxy.touched(proxy.contentRef(this), evolution);
-            });
-        }
-    }
-    entries() {
-        proxy.dependant(proxy.contentRef(this));
-        return makeReactiveEntriesIterator(this.entries());
-    }
-    forEach(callbackfn, thisArg) {
-        proxy.dependant(proxy.contentRef(this));
-        this.forEach(callbackfn, thisArg);
-    }
-    keys() {
-        proxy.dependant(proxy.contentRef(this), proxy.keysOf);
-        return this.keys();
-    }
-    values() {
-        proxy.dependant(proxy.contentRef(this));
-        return makeReactiveIterator(this.values());
-    }
-    [Symbol.iterator]() {
-        proxy.dependant(proxy.contentRef(this));
-        const it = Map.prototype[Symbol.iterator].call(this);
-        const nativeNext = it.next.bind(it);
-        it.next = () => {
-            const result = nativeNext();
-            if (result.done)
-                return result;
-            const [key, value] = result.value;
-            return { value: [proxy.reactive(key), proxy.reactive(value)], done: false };
-        };
-        return it;
-    }
-    // Implement Map methods with reactivity
-    delete(key) {
-        const hadKey = this.has(key);
-        const result = super.delete(key);
-        if (hadKey) {
-            const evolution = { type: 'del', prop: key };
-            proxy.batch(() => {
-                proxy.touched1(proxy.contentRef(this), evolution, key);
-                proxy.touched1(this, evolution, 'size');
-            });
-        }
-        return result;
-    }
-    get(key) {
-        proxy.dependant(proxy.contentRef(this), key);
-        return proxy.reactive(super.get(key));
-    }
-    has(key) {
-        proxy.dependant(proxy.contentRef(this), key);
-        return super.has(key);
-    }
-    set(key, value) {
-        const hadKey = this.has(key);
-        const oldValue = this.get(key);
-        const reactiveValue = proxy.reactive(value);
-        super.set(key, reactiveValue);
-        if (!hadKey || oldValue !== reactiveValue) {
-            proxy.batch(() => {
-                proxy.notifyPropertyChange(proxy.contentRef(this), key, oldValue, reactiveValue, hadKey);
-                // Also notify size change for Map (WeakMap doesn't track size)
-                const evolution = { type: hadKey ? 'set' : 'add', prop: key };
-                proxy.touched1(this, evolution, 'size');
-            });
-        }
-        return this;
-    }
-}
-
-/**
- * Reactive wrapper around JavaScript's WeakSet class
- * Only tracks individual value operations, no size tracking (WeakSet limitation)
- */
-class ReactiveWeakSet extends WeakSet {
-    add(value) {
-        const had = this.has(value);
-        super.add(value);
-        if (!had) {
-            // touch the specific value and the collection view
-            proxy.touched1(proxy.contentRef(this), { type: 'add', prop: value }, value);
-            // no size/allProps for WeakSet
-        }
-        return this;
-    }
-    delete(value) {
-        const had = this.has(value);
-        const res = super.delete(value);
-        if (had)
-            proxy.touched1(proxy.contentRef(this), { type: 'del', prop: value }, value);
-        return res;
-    }
-    has(value) {
-        proxy.dependant(proxy.contentRef(this), value);
-        return super.has(value);
-    }
-}
-/**
- * Reactive wrapper around JavaScript's Set class
- * Tracks size changes, individual value operations, and collection-wide operations
- */
-class ReactiveSet extends Set {
-    get size() {
-        // size depends on the wrapper instance, like Map counterpart
-        proxy.dependant(this, 'size');
-        return this.size;
-    }
-    add(value) {
-        const had = this.has(value);
-        const reactiveValue = proxy.reactive(value);
-        super.add(reactiveValue);
-        if (!had) {
-            const evolution = { type: 'add', prop: reactiveValue };
-            // touch for value-specific and aggregate dependencies
-            proxy.batch(() => {
-                proxy.touched1(proxy.contentRef(this), evolution, reactiveValue);
-                proxy.touched1(this, evolution, 'size');
-            });
-        }
-        return this;
-    }
-    clear() {
-        const hadEntries = this.size > 0;
-        super.clear();
-        if (hadEntries) {
-            const evolution = { type: 'bunch', method: 'clear' };
-            proxy.batch(() => {
-                proxy.touched1(this, evolution, 'size');
-                proxy.touched(proxy.contentRef(this), evolution);
-            });
-        }
-    }
-    delete(value) {
-        const had = this.has(value);
-        const res = super.delete(value);
-        if (had) {
-            const evolution = { type: 'del', prop: value };
-            proxy.batch(() => {
-                proxy.touched1(proxy.contentRef(this), evolution, value);
-                proxy.touched1(this, evolution, 'size');
-            });
-        }
-        return res;
-    }
-    has(value) {
-        proxy.dependant(proxy.contentRef(this), value);
-        return this.has(value);
-    }
-    entries() {
-        proxy.dependant(proxy.contentRef(this));
-        return makeReactiveEntriesIterator(this.entries());
-    }
-    forEach(callbackfn, thisArg) {
-        proxy.dependant(proxy.contentRef(this));
-        this.forEach(callbackfn, thisArg);
-    }
-    keys() {
-        proxy.dependant(proxy.contentRef(this));
-        return makeReactiveIterator(this.keys());
-    }
-    values() {
-        proxy.dependant(proxy.contentRef(this));
-        return makeReactiveIterator(this.values());
-    }
-    [Symbol.iterator]() {
-        proxy.dependant(proxy.contentRef(this));
-        const it = Set.prototype[Symbol.iterator].call(this);
-        const nativeNext = it.next.bind(it);
-        it.next = () => {
-            const result = nativeNext();
-            if (result.done)
-                return result;
-            return { value: proxy.reactive(result.value), done: false };
-        };
-        return it;
-    }
-}
-
-// Register native collection types to use specialized reactive wrappers
-proxy.metaProtos.set(Array, ReactiveArray.prototype);
-proxy.metaProtos.set(Set, ReactiveSet.prototype);
-proxy.metaProtos.set(WeakSet, ReactiveWeakSet.prototype);
-proxy.metaProtos.set(Map, ReactiveMap.prototype);
-proxy.metaProtos.set(WeakMap, ReactiveWeakMap.prototype);
-proxy.wrapProtos.set(Array, ReactiveArrayWrapper.prototype);
-/**
- * Object containing internal reactive system state for debugging and profiling
- */
-const profileInfo = {
-    objectToProxy: proxy.objectToProxy,
-    proxyToObject: proxy.proxyToObject,
-    effectToReactiveObjects: proxy.effectToReactiveObjects,
-    watchers: proxy.watchers,
-    objectParents: proxy.objectParents,
-    objectsWithDeepWatchers: proxy.objectsWithDeepWatchers,
-    deepWatchers: proxy.deepWatchers,
-    effectToDeepWatchedObjects: proxy.effectToDeepWatchedObjects,
-};
-
-// In order to avoid async re-entrance, we could use zone.js or something like that.
-const syncCalculating = [];
-/**
- * Decorator that caches the result of a getter method and only recomputes when dependencies change
- * Prevents circular dependencies and provides automatic cache invalidation
- */
-const cached = proxy.decorator({
-    getter(original, _target, propertyKey) {
-        return function () {
-            const alreadyCalculating = syncCalculating.findIndex((c) => c.object === this && c.prop === propertyKey);
-            if (alreadyCalculating > -1)
-                throw new Error(`Circular dependency detected: ${syncCalculating
-                    .slice(alreadyCalculating)
-                    .map((c) => `${c.object.constructor.name}.${String(c.prop)}`)
-                    .join(' -> ')} -> again`);
-            syncCalculating.push({ object: this, prop: propertyKey });
-            try {
-                const rv = original.call(this);
-                cache(this, propertyKey, rv);
-                return rv;
-            }
-            finally {
-                syncCalculating.pop();
-            }
-        };
-    },
+PatchedPromise.any = ((values) => {
+    const p = originals.any.call(OriginalPromise, values);
+    const context = captureRestorers();
+    if (context.size > 0)
+        promiseContexts.set(p, context);
+    return p;
 });
-/**
- * Checks if a property is cached (has a cached value)
- * @param object - The object to check
- * @param propertyKey - The property key to check
- * @returns True if the property has a cached value
- */
-function isCached(object, propertyKey) {
-    return !!Object.getOwnPropertyDescriptor(object, propertyKey);
-}
-/**
- * Caches a value for a property on an object
- * @param object - The object to cache the value on
- * @param propertyKey - The property key to cache
- * @param value - The value to cache
- */
-function cache(object, propertyKey, value) {
-    Object.defineProperty(object, propertyKey, { value });
+// Only apply patches if not already applied (or re-apply safely)
+// Note: OriginalPromise.prototype might be shared if we used the global one.
+// We must ensure we don't patch it twice if it's the SAME object.
+if (OriginalPromise.prototype.then !== patchedThen) {
+    // biome-ignore lint/suspicious/noThenProperty: Intentional Promise.prototype patching
+    OriginalPromise.prototype.then = patchedThen;
+    OriginalPromise.prototype.catch = patchedCatch;
+    OriginalPromise.prototype.finally = patchedFinally;
+}
+try {
+    Object.defineProperty(OriginalPromise, Symbol.species, {
+        get: () => PatchedPromise,
+        configurable: true,
+    });
 }
-/**
- * Creates a decorator that modifies property descriptors for specified properties
- * @param descriptor - The descriptor properties to apply
- * @returns A class decorator that applies the descriptor to specified properties
- */
-const descriptor = proxy.flavored(function descriptor(descriptor) {
-    return (...properties) => (Base) => {
-        return class extends Base {
-            constructor(...args) {
-                super(...args);
-                for (const key of properties) {
-                    const existing = Object.getOwnPropertyDescriptor(this, key);
-                    Object.defineProperty(this, key, Object.assign(existing || {}, descriptor));
-                }
-            }
-        };
-    };
-}, {
-    /**
-     * enumerable: true
-     */
-    get enumerable() {
-        return descriptor({ enumerable: true });
-    },
-    /**
-     * enumerable: false
-     */
-    get hidden() {
-        return descriptor({ enumerable: false });
-    },
-    /**
-     * configurable: true
-     */
-    get configurable() {
-        return descriptor({ configurable: true });
-    },
-    /**
-     * configurable: false
-     */
-    get frozen() {
-        return descriptor({ configurable: false });
-    },
-    /**
-     * writable: true
-     */
-    get writable() {
-        return descriptor({ writable: true });
-    },
-    /**
-     * writable: false
-     */
-    get readonly() {
-        return descriptor({ writable: false });
-    },
+catch (_e) { }
+globalThis.Promise = PatchedPromise;
+globalThis.setTimeout = ((callback, ...args) => {
+    return originals.setTimeout.call(globalThis, wrap(callback), ...args);
 });
-/**
- * Decorator that marks methods, properties, or classes as deprecated
- * Provides warning messages when deprecated items are used
- */
-const deprecated = Object.assign(proxy.decorator({
-    method(original, _target, propertyKey) {
-        return function (...args) {
-            deprecated.warn(this, propertyKey);
-            return original.apply(this, args);
-        };
-    },
-    getter(original, _target, propertyKey) {
-        return function () {
-            deprecated.warn(this, propertyKey);
-            return original.call(this);
-        };
-    },
-    setter(original, _target, propertyKey) {
-        return function (value) {
-            deprecated.warn(this, propertyKey);
-            return original.call(this, value);
-        };
-    },
-    class(original) {
-        return class extends original {
-            constructor(...args) {
-                super(...args);
-                deprecated.warn(this, 'constructor');
-            }
-        };
-    },
-    default(message) {
-        return proxy.decorator({
-            method(original, _target, propertyKey) {
-                return function (...args) {
-                    deprecated.warn(this, propertyKey, message);
-                    return original.apply(this, args);
-                };
-            },
-            getter(original, _target, propertyKey) {
-                return function () {
-                    deprecated.warn(this, propertyKey, message);
-                    return original.call(this);
-                };
-            },
-            setter(original, _target, propertyKey) {
-                return function (value) {
-                    deprecated.warn(this, propertyKey, message);
-                    return original.call(this, value);
-                };
-            },
-            class(original) {
-                return class extends original {
-                    constructor(...args) {
-                        super(...args);
-                        deprecated.warn(this, 'constructor', message);
-                    }
-                };
-            },
-        });
-    },
-}), {
-    warn: (target, propertyKey, message) => {
-        proxy.options.warn(`${target.constructor.name}.${String(propertyKey)} is deprecated${message ? `: ${message}` : ''}`);
-    },
+globalThis.setInterval = ((callback, ...args) => {
+    return originals.setInterval.call(globalThis, wrap(callback), ...args);
 });
-/**
- * Creates a debounced method decorator that delays execution until after the delay period has passed
- * @param delay - The delay in milliseconds
- * @returns A method decorator that debounces method calls
- */
-function debounce(delay) {
-    return proxy.decorator({
-        method(original, _target, _propertyKey) {
-            let timeoutId = null;
-            return function (...args) {
-                // Clear existing timeout
-                if (timeoutId) {
-                    clearTimeout(timeoutId);
-                }
-                // Set new timeout
-                timeoutId = setTimeout(() => {
-                    original.apply(this, args);
-                    timeoutId = null;
-                }, delay);
-            };
-        },
+if (originals.setImmediate) {
+    globalThis.setImmediate = ((callback, ...args) => {
+        return originals.setImmediate.call(globalThis, wrap(callback), ...args);
     });
 }
-/**
- * Creates a throttled method decorator that limits execution to once per delay period
- * @param delay - The delay in milliseconds
- * @returns A method decorator that throttles method calls
- */
-function throttle(delay) {
-    return proxy.decorator({
-        method(original, _target, _propertyKey) {
-            let lastCallTime = 0;
-            let timeoutId = null;
-            return function (...args) {
-                const now = Date.now();
-                // If enough time has passed since last call, execute immediately
-                if (now - lastCallTime >= delay) {
-                    // Clear any pending timeout since we're executing now
-                    if (timeoutId) {
-                        clearTimeout(timeoutId);
-                        timeoutId = null;
-                    }
-                    lastCallTime = now;
-                    return original.apply(this, args);
-                }
-                // Otherwise, schedule execution for when the delay period ends
-                if (!timeoutId) {
-                    const remainingTime = delay - (now - lastCallTime);
-                    const scheduledArgs = [...args]; // Capture args at scheduling time
-                    timeoutId = setTimeout(() => {
-                        lastCallTime = Date.now();
-                        original.apply(this, scheduledArgs);
-                        timeoutId = null;
-                    }, remainingTime);
-                }
-            };
-        },
-    });
+if (originals.requestAnimationFrame) {
+    globalThis.requestAnimationFrame = (callback) => {
+        return originals.requestAnimationFrame.call(globalThis, wrap(callback));
+    };
 }
-
-var version$1 = "1.0.11";
-var pkg = {
-	version: version$1};
-
-const { version } = pkg;
-const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
-const globalScope = (typeof globalThis !== 'undefined'
-    ? globalThis
-    : typeof window !== 'undefined'
-        ? window
-        : typeof global !== 'undefined'
-            ? global
-            : false);
-if (globalScope) {
-    let source = 'mutts/index';
-    try {
-        if (typeof __filename !== 'undefined')
-            source = __filename;
-        else if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('browser.cjs', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('browser.cjs', document.baseURI).href))) {
-            source = (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('browser.cjs', document.baseURI).href));
-        }
-    }
-    catch (_e) { }
-    const currentSourceInfo = { version, source, timestamp: Date.now() };
-    if (globalScope[GLOBAL_MUTTS_KEY]) {
-        const existing = globalScope[GLOBAL_MUTTS_KEY];
-        throw new Error(`[Mutts] Multiple instances detected!\n` +
-            `Existing instance: ${JSON.stringify(existing, null, 2)}\n` +
-            `New instance: ${JSON.stringify(currentSourceInfo, null, 2)}\n` +
-            `This usually happens when 'mutts' is both installed as a dependency and bundled, ` +
-            `or when different versions are loaded. ` +
-            `Please check your build configuration (aliases, externals) to ensure a single source of truth.`);
-    }
-    globalScope[GLOBAL_MUTTS_KEY] = currentSourceInfo;
+if (originals.queueMicrotask) {
+    globalThis.queueMicrotask = (callback) => {
+        originals.queueMicrotask.call(globalThis, wrap(callback));
+    };
 }
 
 exports.AZone = proxy.AZone;
@@ -2597,6 +234,8 @@ 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;
@@ -2617,6 +256,7 @@ exports.formatCleanupReason = proxy.formatCleanupReason;
 exports.getActivationLog = proxy.getActivationLog;
 exports.getActiveEffect = proxy.getActiveEffect;
 exports.getState = proxy.getState;
+exports.hooks = proxy.hooks;
 exports.isConstructor = proxy.isConstructor;
 exports.isDev = proxy.isDev;
 exports.isNonReactive = proxy.isNonReactive;
@@ -2644,41 +284,38 @@ exports.unlink = proxy.unlink;
 exports.untracked = proxy.untracked;
 exports.unwrap = proxy.unwrap;
 exports.zip = proxy.zip;
-exports.asyncHook = asyncCore.asyncHook;
-exports.asyncHooks = asyncCore.asyncHooks;
-exports.hooks = asyncCore.hooks;
-exports.ArrayReadForward = ArrayReadForward;
-exports.Destroyable = Destroyable;
-exports.DestructionError = DestructionError;
-exports.Eventful = Eventful;
-exports.Indexable = Indexable;
-exports.allocated = allocated;
-exports.allocatedValues = allocatedValues;
-exports.arrayDiff = arrayDiff;
-exports.attend = attend;
-exports.cache = cache;
-exports.cached = cached;
-exports.callOnGC = callOnGC;
-exports.chainPromise = chainPromise;
-exports.debounce = debounce;
-exports.deepWatch = deepWatch;
-exports.deprecated = deprecated;
-exports.descriptor = descriptor;
-exports.destructor = destructor;
-exports.forwardArray = forwardArray;
-exports.getAt = getAt;
-exports.isCached = isCached;
-exports.lift = lift;
-exports.memoize = memoize;
-exports.morph = morph;
-exports.organize = organize;
-exports.organized = organized;
-exports.profileInfo = profileInfo;
-exports.project = morph;
-exports.resource = resource;
-exports.setAt = setAt;
-exports.throttle = throttle;
-exports.unreactive = unreactive;
-exports.watch = watch;
-exports.when = when;
+exports.ArrayReadForward = index.ArrayReadForward;
+exports.Destroyable = index.Destroyable;
+exports.DestructionError = index.DestructionError;
+exports.Eventful = index.Eventful;
+exports.Indexable = index.Indexable;
+exports.allocated = index.allocated;
+exports.allocatedValues = index.allocatedValues;
+exports.arrayDiff = index.arrayDiff;
+exports.attend = index.attend;
+exports.cache = index.cache;
+exports.cached = index.cached;
+exports.callOnGC = index.callOnGC;
+exports.chainPromise = index.chainPromise;
+exports.debounce = index.debounce;
+exports.deepWatch = index.deepWatch;
+exports.deprecated = index.deprecated;
+exports.descriptor = index.descriptor;
+exports.destructor = index.destructor;
+exports.forwardArray = index.forwardArray;
+exports.getAt = index.getAt;
+exports.isCached = index.isCached;
+exports.lift = index.lift;
+exports.memoize = index.memoize;
+exports.morph = index.morph;
+exports.organize = index.organize;
+exports.organized = index.organized;
+exports.profileInfo = index.profileInfo;
+exports.project = index.morph;
+exports.resource = index.resource;
+exports.setAt = index.setAt;
+exports.throttle = index.throttle;
+exports.unreactive = index.unreactive;
+exports.watch = index.watch;
+exports.when = index.when;
 //# sourceMappingURL=browser.cjs.map