mutts 1.0.12 → 1.0.13

package/dist/chunks/{index-BUop6B2U.esm.js → index-XsYTUhHx.esm.js}

@@ -1,4 +1,4 @@
-import { t as decorator, B as flavored, O as isReactive, $ as reactive, x as effect, a4 as touched, S as link, G as getState, aa as dependant, a5 as touched1, ab as keysOf, ac as markWithRoot, ad as objectsWithDeepWatchers, ae as effectToDeepWatchedObjects, a7 as untracked, af as deepWatchers, a0 as options, L as isNonReactive, a8 as unwrap, ag as registerDeepWatcher, V as named, ah as rootFunctionSymbol, _ as proxyToObject, ai as getRoot, u as deepCompare, aj as optionCall, a2 as root, ak as FoolProof, z as flavorOptions, al as effectHistory, p as captured, am as unreactiveProperties, g as addUnreactiveProps, an as __runInitializers, ao as __esDecorate, n as atomic, ap as batch, aq as contentRef, ar as notifyPropertyChange, as as metaProtos, at as wrapProtos, au as objectParents, av as watchers, aw as effectToReactiveObjects, W as objectToProxy } from './proxy-D2C49sXH.esm.js';
+import { u as decorator, p as captioned, a4 as options, y as effect, af as markWithRoot, W as link, F as flavored, a7 as tag, a3 as reactive, a9 as touched1, T as isReactive, a8 as touched, K as getState, ag as dependant, J as getActiveEffect, ah as getEffectNode, ai as chainExternalReason, aj as keysOf, ak as objectsWithDeepWatchers, al as effectToDeepWatchedObjects, ab as untracked, am as deepWatchers, P as isNonReactive, ac as unwrap, an as registerDeepWatcher, _ as named, ao as rootFunctionSymbol, a2 as proxyToObject, ap as getRoot, v as deepCompare, aq as optionCall, a6 as root, ar as FoolProof, E as flavorOptions, as as effectHistory, q as captured, at as unreactiveProperties, g as addUnreactiveProps, au as __runInitializers, av as __esDecorate, n as atomic, aw as batch, ax as contentRef, ay as notifyPropertyChange, az as metaProtos, aA as wrapProtos, aB as objectParents, aC as watchers, aD as effectToReactiveObjects, $ as objectToProxy } from './proxy-BtmPFjSr.esm.js';
 
 // Integrated with `using` statement via Symbol.dispose
 const fr = new FinalizationRegistry((f) => f());
@@ -256,46 +256,57 @@ function buildPatches(history, A, B, offset, finalX, finalY, finalD, finalK, vOf
 var _a, _b;
 const events = Symbol('events');
 const hooks = Symbol('hooks');
+function getEventMap(target) {
+    return target[events];
+}
+function getHookSet(target) {
+    return target[hooks];
+}
 const eventBehavior = {
     on(eventOrEvents, cb) {
+        const self = this;
+        const eventMap = getEventMap(self);
         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();
+            const callbacks = eventMap.get(eventOrEvents) ?? new Set();
             if (!callbacks.has(cb))
                 callbacks.add(cb);
-            this[events].set(eventOrEvents, callbacks);
+            eventMap.set(eventOrEvents, callbacks);
         }
         return () => this.off(eventOrEvents, cb);
     },
     off(eventOrEvents, cb) {
+        const self = this;
+        const eventMap = getEventMap(self);
         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);
+            const callbacks = eventMap.get(eventOrEvents);
             if (callbacks) {
                 callbacks.delete(cb);
                 if (!callbacks.size)
-                    this[events].delete(eventOrEvents);
+                    eventMap.delete(eventOrEvents);
             }
         }
         else {
             // Remove all listeners for this event
-            this[events].delete(eventOrEvents);
+            eventMap.delete(eventOrEvents);
         }
     },
     emit(event, ...args) {
-        const callbacks = this[events].get(event);
+        const self = this;
+        const callbacks = getEventMap(self).get(event);
         if (callbacks)
             for (const cb of callbacks)
                 cb.apply(this, args);
-        for (const cb of this[hooks])
+        for (const cb of getHookSet(self))
             cb.call(this, event, ...args);
     },
 };
@@ -305,7 +316,7 @@ function perEvent(eventful, fct, use) {
         get(target, prop) {
             if (typeof prop !== 'string')
                 return target[prop];
-            if (use && !eventful[events].has(prop) && !eventful[hooks].size)
+            if (use && !getEventMap(eventful).has(prop) && !getHookSet(eventful).size)
                 return () => { };
             // Return cached function or create and cache
             let cached = cache.get(prop);
@@ -744,7 +755,7 @@ function chainPromise(given) {
     return chained;
 }
 
-function attend(source, callback) {
+const attend = captioned(function attend(source, callback) {
     const enumerate = typeof source === 'function'
         ? source
         : Array.isArray(source)
@@ -755,14 +766,16 @@ function attend(source, callback) {
                     ? () => source.values()
                     : () => Object.keys(source);
     const keyEffects = new Map();
-    const outer = effect.named('attend')(({ ascend }) => {
+    const callbackLabel = callback.name ? callback.name : '';
+    const outer = effect `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(() => effect.named(`attend:${key}`)((access) => callback(key, access))));
+            const indexRef = { value: key };
+            keyEffects.set(key, ascend(() => effect `attend${callbackLabel ? `:${callbackLabel}` : ''}:${key}`((access) => callback(indexRef.value, access))));
         }
         for (const key of Array.from(keyEffects.keys())) {
             if (!keys.has(key)) {
@@ -777,17 +790,50 @@ function attend(source, callback) {
             stop(reason);
         keyEffects.clear();
     };
-}
-function lift(cb) {
+}, {
+    name: 'attend',
+    callbackIndex: 1,
+    warn: (message) => options.warn(`[reactive] ${message}`),
+});
+/**
+ * Lifts a callback that returns an object into a reactive object that automatically
+ * synchronizes with the source object returned by the callback.
+ *
+ * The returned reactive object will update whenever the callback's dependencies change,
+ * efficiently syncing only the properties that differ from the previous result using
+ * Object.assign(). Properties that no longer exist in the source are automatically removed.
+ *
+ * @example
+ * ```typescript
+ * const user = reactive({ name: 'John', age: 30 })
+ * const profile = lift(() => ({
+ *   displayName: user.name.toUpperCase(),
+ *   isAdult: user.age >= 18,
+ *   description: `${user.name} is ${user.age} years old`
+ * }))
+ *
+ * console.log(profile.displayName) // JOHN
+ * console.log(profile.isAdult) // true
+ *
+ * user.name = 'Jane'
+ * console.log(profile.displayName) // JANE
+ * console.log(profile.description) // Jane is 30 years old
+ * ```
+ *
+ * @param cb Callback function that returns an object
+ * @returns A reactive object synchronized with the callback's result, with a [cleanup] property to stop tracking
+ */
+const lift = captioned(function lift(cb) {
     let result;
     let rawResult;
-    const liftCleanup = effect.named(`lift:${cb.name}`)(markWithRoot((access) => {
+    const resultName = `lift:${cb.name || 'anonymous'}`;
+    const liftCleanup = effect `lift:${cb.name}`(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);
+            rawResult = tag(resultName, Array.isArray(source) ? [] : Object.create(sourceProto));
             result = reactive(rawResult);
         }
         if (sourceProto !== Object.getPrototypeOf(result))
@@ -798,6 +844,7 @@ function lift(cb) {
                 res.splice(indexA, sliceA.length, ...sliceB);
         }
         else {
+            const recordResult = rawResult;
             for (const key of Object.keys(source)) {
                 const had = key in rawResult;
                 const newDesc = Object.getOwnPropertyDescriptor(source, key);
@@ -806,7 +853,7 @@ function lift(cb) {
                     const sameAccessor = oldDesc && newDesc.get && oldDesc.get === newDesc.get;
                     Object.defineProperty(rawResult, key, newDesc);
                     if (!sameAccessor &&
-                        rawResult[key] !==
+                        recordResult[key] !==
                             (oldDesc ? (oldDesc.get ? oldDesc.get() : oldDesc.value) : undefined))
                         touched1(rawResult, { type: 'set', prop: key }, key);
                 }
@@ -817,13 +864,16 @@ function lift(cb) {
             }
             for (const key of Object.keys(rawResult))
                 if (!(key in source)) {
-                    delete rawResult[key];
+                    delete recordResult[key];
                     touched1(rawResult, { type: 'del', prop: key }, key);
                 }
         }
     }, cb));
     return link(result, liftCleanup);
-}
+}, {
+    name: 'lift',
+    warn: (message) => options.warn(`[reactive] ${message}`),
+});
 /**
  * Reactively maps an array source through `fn`, producing a lazy reactive output array.
  *
@@ -847,12 +897,18 @@ function morphArray(source, fn, options) {
     }
     let track;
     const itemEffects = new Map();
-    const cache = [];
+    const cache = tag(`morph:${fn.name || 'anonymous'}`, []);
     let input = [];
     function stopItem(key) {
         const entry = itemEffects.get(key);
         if (entry) {
-            entry.stop({ type: 'stopped' });
+            const activeEffect = getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            entry.stop(chainExternalReason({ type: 'stopped', chain }));
             itemEffects.delete(key);
         }
     }
@@ -865,12 +921,22 @@ function morphArray(source, fn, options) {
         }
         else {
             const indexRef = { value: key };
-            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+            const stop = track(() => effect.opaque `morph:${fn.name}:${key}`((access) => {
                 cache[indexRef.value] = fn(input, access);
                 return (reason) => {
                     delete cache[indexRef.value];
                     touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
+                    const activeEffect = getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: chainExternalReason(chain),
+                    });
                 };
             }));
             itemEffects.set(key, { stop, index: indexRef });
@@ -889,7 +955,7 @@ function morphArray(source, fn, options) {
             return Reflect.has(input, prop);
         },
     });
-    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = effect `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);
@@ -963,12 +1029,18 @@ function morphMap(source, fn, options) {
     }
     let track;
     const itemEffects = new Map();
-    const cache = new Map();
+    const cache = tag(`morph:${fn.name || 'anonymous'}`, new Map());
     Object.defineProperty(cache, 'constructor', { value: Object, enumerable: false });
     function stopItem(key) {
         const stop = itemEffects.get(key);
         if (stop) {
-            stop({ type: 'stopped' });
+            const activeEffect = getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            stop({ type: 'stopped', chain });
             itemEffects.delete(key);
         }
     }
@@ -978,12 +1050,25 @@ function morphMap(source, fn, options) {
             cache.set(key, track(() => fn(val, key)));
         }
         else {
-            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
-                cache.set(key, fn(source.get(key), key, access));
+            const stop = track(() => effect.opaque `morph:${fn.name}:${key}`((access) => {
+                const next = source.get(key);
+                if (next === undefined && !source.has(key))
+                    return;
+                cache.set(key, fn(next, key, access));
                 return (reason) => {
                     cache.delete(key);
                     touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
+                    const activeEffect = getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: chainExternalReason(chain),
+                    });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1027,7 +1112,7 @@ function morphMap(source, fn, options) {
         },
     });
     let stateSnapshot = getState(source);
-    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
         dependant(source, keysOf);
         while ('evolution' in stateSnapshot) {
@@ -1074,7 +1159,13 @@ function morphRecord(source, fn, options) {
     function stopItem(key) {
         const stop = itemEffects.get(key);
         if (stop) {
-            stop({ type: 'stopped' });
+            const activeEffect = getActiveEffect();
+            let chain;
+            if (activeEffect) {
+                const node = getEffectNode(activeEffect);
+                chain = node.currentReason;
+            }
+            stop({ type: 'stopped', chain });
             itemEffects.delete(key);
         }
     }
@@ -1084,12 +1175,22 @@ function morphRecord(source, fn, options) {
             cache[key] = track(() => fn(val, key));
         }
         else {
-            const stop = track(() => effect.named(`morph:${fn.name}:${key}`).opaque((access) => {
+            const stop = track(() => effect.opaque `morph:${fn.name}:${key}`((access) => {
                 cache[key] = fn(source[key], key, access);
                 return (reason) => {
                     delete cache[key];
                     touched1(cache, { type: 'invalidate', prop: 'morph' }, String(key));
-                    stop?.({ type: 'invalidate', cause: reason });
+                    const activeEffect = getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const node = getEffectNode(activeEffect);
+                        chain = node.currentReason;
+                    }
+                    stop?.({
+                        type: 'invalidate',
+                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: chainExternalReason(chain),
+                    });
                 };
             }));
             itemEffects.set(key, stop);
@@ -1116,7 +1217,7 @@ function morphRecord(source, fn, options) {
         },
     });
     let stateSnapshot = getState(source);
-    const stopMain = effect.named(`morph:${fn.name}`)(({ ascend }) => {
+    const stopMain = effect `morph:${fn.name}`(({ ascend }) => {
         track = ascend;
         // Track only structural changes on source
         dependant(source, keysOf);
@@ -1157,7 +1258,7 @@ function morphRecord(source, fn, options) {
  * // Changing users[0].name only recomputes names[0]
  * ```
  */
-const morph = flavored(function morph(source, fn, options) {
+const morph = captioned(flavored(function morph(source, fn, options) {
     if (Array.isArray(source) || typeof source === 'function')
         return morphArray(source, fn, options);
     if (source instanceof Map)
@@ -1167,6 +1268,10 @@ const morph = flavored(function morph(source, fn, options) {
     get pure() {
         return (source, fn, _opt) => this(source, fn, { pure: true });
     },
+}), {
+    name: 'morph',
+    callbackIndex: 1,
+    warn: (message) => options.warn(`[reactive] ${message}`),
 });
 
 /**
@@ -1192,7 +1297,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
     const wrappedCallback = markWithRoot((() => callback(target)), callback);
     registerDeepWatcher();
     // Use the existing effect system to register dependencies
-    return effect.named('deepWatch')(() => {
+    return effect `deepWatch`(() => {
         // Mark the target object as having deep watchers
         objectsWithDeepWatchers.add(target);
         // Track which objects this effect is watching for cleanup
@@ -1256,7 +1361,7 @@ function deepWatch(target, callback, { immediate = false } = {}) {
         traverseAndTrack(target);
         // Only call the callback if immediate is true or if it's not the first run
         if (immediate) {
-            untracked(() => callback(target));
+            untracked `deepWatch:callback`(() => callback(target));
         }
         immediate = true;
         // Return a cleanup function that properly removes deep watcher tracking
@@ -1323,7 +1428,7 @@ function memoizeFunction(fn, opts) {
                 const wasVerification = options.isVerificationRun;
                 options.isVerificationRun = true;
                 try {
-                    const fresh = untracked(() => fn.apply(this, args));
+                    const fresh = untracked `memoize:verify-calculation`(() => fn.apply(this, args));
                     if (!deepCompare(node.result, fresh)) {
                         optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'calculation');
                     }
@@ -1336,7 +1441,7 @@ function memoizeFunction(fn, opts) {
         }
         // 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 = root(() => effect.named('memoize')(() => {
+        node.cleanup = root `memoize:root`(() => effect `memoize`(() => {
             // Execute the function and track its dependencies
             // The function execution will automatically track dependencies on reactive objects
             node.result = fn.apply(this, args);
@@ -1347,7 +1452,17 @@ function memoizeFunction(fn, opts) {
                 // 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 });
+                    const activeEffect = getActiveEffect();
+                    let chain;
+                    if (activeEffect) {
+                        const effectNode = getEffectNode(activeEffect);
+                        chain = effectNode.currentReason;
+                    }
+                    node.cleanup({
+                        type: 'invalidate',
+                        cause: chainExternalReason(reason ?? { type: 'stopped', chain }),
+                        chain: chainExternalReason(chain),
+                    });
                     node.cleanup = undefined;
                 }
             };
@@ -1356,7 +1471,7 @@ function memoizeFunction(fn, opts) {
             const wasVerification = options.isVerificationRun;
             options.isVerificationRun = true;
             try {
-                const fresh = untracked(() => fn.apply(this, args));
+                const fresh = untracked `memoize:verify-comparison`(() => fn.apply(this, args));
                 if (!deepCompare(node.result, fresh)) {
                     optionCall('onMemoizationDiscrepancy', node.result, fresh, fn, args, 'comparison');
                 }
@@ -1548,12 +1663,12 @@ const memoize = flavored(makeMemoizeDecorator(), {
 function organized(source, apply, baseTarget = {}) {
     const observedSource = reactive(source);
     const target = reactive(baseTarget);
-    const stop = attend(() => {
+    const stop = attend `organized:entries`(function enumerateObservedSourceKeys() {
         const keys = [];
         for (const key in observedSource)
             keys.push(key);
         return keys;
-    }, (key) => {
+    }, function applyObservedSourceKey(key) {
         const sourceKey = key;
         const accessBase = {
             key: sourceKey,
@@ -1591,7 +1706,7 @@ function organize(target, property, access) {
 
 //#region watch
 const unsetYet = Symbol('unset-yet');
-const watch = flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
+const watch = captioned(flavored(function watch(value, //object | ((dep: DependencyAccess) => object),
 changed, options = {}) {
     return typeof value === 'function'
         ? watchCallBack(value, changed, options)
@@ -1607,11 +1722,14 @@ changed, options = {}) {
     get immediate() {
         return flavorOptions(this, { immediate: true });
     },
+}), {
+    name: 'watch',
+    warn: (message) => options.warn(`[reactive] ${message}`),
 });
 function watchObject(value, changed, { immediate = false, deep = false } = {}) {
     if (deep)
         return deepWatch(value, changed, { immediate });
-    return effect.named('watch:object')(() => {
+    return effect `watch:object`(() => {
         dependant(value);
         if (immediate)
             changed(value);
@@ -1621,16 +1739,16 @@ function watchObject(value, changed, { immediate = false, deep = false } = {}) {
 function watchCallBack(value, changed, { immediate = false, deep = false } = {}) {
     let oldValue = unsetYet;
     let deepCleanup;
-    const cbCleanup = effect.named('watch:callback')(markWithRoot((access) => {
+    const cbCleanup = effect `watch:callback`(markWithRoot((access) => {
         const newValue = value(access);
         if (oldValue !== newValue) {
             const old = oldValue;
             if (old === unsetYet) {
                 if (immediate)
-                    untracked(() => changed(newValue));
+                    untracked `watch:changed`(() => changed(newValue));
             }
             else
-                untracked(() => changed(newValue, old));
+                untracked `watch:changed`(() => changed(newValue, old));
         }
         oldValue = newValue;
         if (deep) {
@@ -1657,7 +1775,7 @@ function watchCallBack(value, changed, { immediate = false, deep = false } = {})
 function when(predicate, timeout) {
     return new Promise((resolve, reject) => {
         let timer;
-        const stop = effect.named('watch:when')((access) => {
+        const stop = effect `watch:when`((access) => {
             try {
                 const value = predicate(access);
                 if (value) {
@@ -1764,7 +1882,7 @@ function resource(fetcher, options = {}) {
     // Solve race conditions: make sure a new fast request is not overloaded by a slow old one
     let counter = 0;
     return lazyInit(resource, () => {
-        link(resource, effect.named('watch:resource')((access) => {
+        link(resource, effect `watch:resource`((access) => {
             // Track reload signal to enable manual reloading
             void reloadSignal.value;
             const id = ++counter;
@@ -1930,6 +2048,7 @@ let ReactiveArrayWrapper = (() => {
                 return super.findLastIndex((v, i, a) => predicate.call(thisArg, reactive(v), i, a), thisArg);
             }
             flat(depth) {
+                dependant(this, keysOf);
                 return reactive(super.flat(depth));
             }
             flatMap(callbackfn, thisArg) {
@@ -2356,59 +2475,62 @@ function isCached(object, propertyKey) {
 function cache(object, propertyKey, value) {
     Object.defineProperty(object, propertyKey, { value });
 }
+function descriptorBase(descriptor) {
+    return function descriptorDecorator(...properties) {
+        return (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));
+                    }
+                }
+            };
+        };
+    };
+}
 /**
  * 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 = 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));
-                }
-            }
-        };
-    };
-}, {
+const descriptor = Object.assign(descriptorBase, {
     /**
      * enumerable: true
      */
     get enumerable() {
-        return descriptor({ enumerable: true });
+        return descriptorBase({ enumerable: true });
     },
     /**
      * enumerable: false
      */
     get hidden() {
-        return descriptor({ enumerable: false });
+        return descriptorBase({ enumerable: false });
     },
     /**
      * configurable: true
      */
     get configurable() {
-        return descriptor({ configurable: true });
+        return descriptorBase({ configurable: true });
     },
     /**
      * configurable: false
      */
     get frozen() {
-        return descriptor({ configurable: false });
+        return descriptorBase({ configurable: false });
     },
     /**
      * writable: true
      */
     get writable() {
-        return descriptor({ writable: true });
+        return descriptorBase({ writable: true });
     },
     /**
      * writable: false
      */
     get readonly() {
-        return descriptor({ writable: false });
+        return descriptorBase({ writable: false });
     },
 });
 /**
@@ -2537,24 +2659,25 @@ function throttle(delay) {
     });
 }
 
-var version$1 = "1.0.12";
+var version$1 = "1.0.13";
 var pkg = {
 	version: version$1};
 
 const { version } = pkg;
 const GLOBAL_MUTTS_KEY = '__MUTTS_INSTANCE__';
+const runtimeGlobals = globalThis;
 const globalScope = (typeof globalThis !== 'undefined'
     ? globalThis
-    : typeof window !== 'undefined'
-        ? window
-        : typeof global !== 'undefined'
-            ? global
+    : runtimeGlobals.window
+        ? runtimeGlobals.window
+        : runtimeGlobals.global
+            ? runtimeGlobals.global
             : false);
 if (globalScope) {
     let source = 'mutts/index';
     try {
-        if (typeof __filename !== 'undefined')
-            source = __filename;
+        if (runtimeGlobals.__filename)
+            source = runtimeGlobals.__filename;
         else if (typeof import.meta !== 'undefined' && import.meta.url) {
             source = import.meta.url;
         }
@@ -2574,4 +2697,4 @@ if (globalScope) {
 }
 
 export { ArrayReadForward as A, unreactive as B, watch as C, Destroyable as D, Eventful as E, when as F, Indexable as I, DestructionError as a, allocated as b, allocatedValues as c, arrayDiff as d, attend as e, cache as f, cached as g, callOnGC as h, chainPromise as i, debounce as j, deepWatch as k, deprecated as l, descriptor as m, destructor as n, forwardArray as o, getAt as p, isCached as q, lift as r, memoize as s, morph as t, organize as u, organized as v, profileInfo as w, resource as x, setAt as y, throttle as z };
-//# sourceMappingURL=index-BUop6B2U.esm.js.map
+//# sourceMappingURL=index-XsYTUhHx.esm.js.map