storion 0.10.1 → 0.11.0

package/dist/storion.js

@@ -1,7 +1,7 @@
-import { C as tryDispose, i as isSpec, u as untrack, k as STORION_TYPE, D as unwrapFn, q as shallowEqual, l as resolveEquality } from "./effect-BDQU8Voz.js";
-import { d, E, H, I, L, z, P, S, y, x, n, v, e, o, m, p, B, a, h } from "./effect-BDQU8Voz.js";
+import { D as tryDispose, i as isSpec, u as untrack, k as STORION_TYPE, o as batch, F as unwrapFn, v as shallowEqual, m as resolveEquality } from "./effect-1beiYe_c.js";
+import { d, E, H, I, L, B, P, S, z, y, x, e, q, n, p, C, a, h } from "./effect-1beiYe_c.js";
 import { e as emitter } from "./emitter-j4rC71vY.js";
-import { m as m2 } from "./meta-40r-AZfe.js";
+import { m } from "./meta-40r-AZfe.js";
 function createMetaQuery(entries) {
   const entryArray = Array.isArray(entries) ? entries : entries ? [entries] : [];
   const single = (type) => {
@@ -306,114 +306,169 @@ container.defaults = defaultsFn;
 function isObject(value) {
   return typeof value === "object" && value !== null;
 }
-function createDisposalTracker() {
-  let pendingDisposedItems = /* @__PURE__ */ new Set();
-  let disposalScheduled = false;
+const namedGroups = /* @__PURE__ */ new Map();
+function getNamedGroup(name) {
+  let group = namedGroups.get(name);
+  if (!group) {
+    group = disposalGroup();
+    namedGroups.set(name, group);
+  }
+  return group;
+}
+function isDisposalGroup(value) {
+  return typeof value === "object" && value !== null && "scheduleDisposal" in value && "cancelDisposal" in value && "isPending" in value && "flush" in value;
+}
+function normalizeAutoDispose(autoDispose) {
+  if (autoDispose === false || autoDispose === void 0) {
+    return false;
+  }
+  if (autoDispose === true) {
+    return { enabled: true, gracePeriodMs: 0, group: null };
+  }
+  if (typeof autoDispose === "number") {
+    return { enabled: true, gracePeriodMs: autoDispose, group: null };
+  }
+  if (typeof autoDispose === "string") {
+    return {
+      enabled: true,
+      gracePeriodMs: 0,
+      group: getNamedGroup(autoDispose)
+    };
+  }
+  if (isDisposalGroup(autoDispose)) {
+    return { enabled: true, gracePeriodMs: 0, group: autoDispose };
+  }
+  const opts = autoDispose;
+  let group = null;
+  if (opts.group) {
+    group = typeof opts.group === "string" ? getNamedGroup(opts.group) : opts.group;
+  }
   return {
-    /**
-     * Schedule items for async disposal.
-     * Items will be disposed in a microtask unless cancelled.
-     * Only objects are tracked - primitives are skipped.
-     */
-    scheduleDisposal(items) {
-      if (items.length === 0) return;
-      const newPending = new Set(pendingDisposedItems);
-      let hasNewItems = false;
+    enabled: true,
+    gracePeriodMs: opts.gracePeriodMs ?? 0,
+    group
+  };
+}
+function disposalGroup() {
+  const pendingItems = /* @__PURE__ */ new Map();
+  return {
+    scheduleDisposal(items, gracePeriodMs) {
       for (const item of items) {
-        if (isObject(item)) {
-          newPending.add(item);
-          hasNewItems = true;
-        }
-      }
-      if (!hasNewItems) return;
-      pendingDisposedItems = newPending;
-      if (!disposalScheduled) {
-        disposalScheduled = true;
-        queueMicrotask(() => {
-          disposalScheduled = false;
-          const toDispose = pendingDisposedItems;
-          pendingDisposedItems = /* @__PURE__ */ new Set();
-          for (const item of toDispose) {
+        if (!isObject(item)) continue;
+        if (pendingItems.has(item)) continue;
+        if (gracePeriodMs <= 0) {
+          pendingItems.set(item, "microtask");
+          queueMicrotask(() => {
+            if (pendingItems.get(item) === "microtask") {
+              pendingItems.delete(item);
+              tryDispose(item);
+            }
+          });
+        } else {
+          const timeout = setTimeout(() => {
+            pendingItems.delete(item);
             tryDispose(item);
-          }
-        });
+          }, gracePeriodMs);
+          pendingItems.set(item, timeout);
+        }
       }
     },
-    /**
-     * Cancel disposal for items that are being re-added.
-     * Call this when items are pushed/inserted back into the collection.
-     * Only objects are checked - primitives are skipped.
-     */
     cancelDisposal(items) {
-      if (items.length === 0 || pendingDisposedItems.size === 0) return;
-      let hasChanges = false;
       for (const item of items) {
-        if (isObject(item) && pendingDisposedItems.has(item)) {
-          hasChanges = true;
-          break;
+        if (!isObject(item)) continue;
+        const pending = pendingItems.get(item);
+        if (pending === void 0) continue;
+        if (pending !== "microtask") {
+          clearTimeout(pending);
         }
+        pendingItems.delete(item);
       }
-      if (!hasChanges) return;
-      const newPending = new Set(pendingDisposedItems);
+    },
+    isPending(item) {
+      return isObject(item) && pendingItems.has(item);
+    },
+    flush() {
+      for (const [item, pending] of pendingItems) {
+        if (pending !== "microtask") {
+          clearTimeout(pending);
+        }
+        tryDispose(item);
+      }
+      pendingItems.clear();
+    }
+  };
+}
+function createLocalDisposalTracker(gracePeriodMs) {
+  const pendingItems = /* @__PURE__ */ new Map();
+  return {
+    scheduleDisposal(items) {
       for (const item of items) {
-        if (isObject(item)) {
-          newPending.delete(item);
+        if (!isObject(item)) continue;
+        if (pendingItems.has(item)) continue;
+        if (gracePeriodMs <= 0) {
+          pendingItems.set(item, "microtask");
+          queueMicrotask(() => {
+            if (pendingItems.get(item) === "microtask") {
+              pendingItems.delete(item);
+              tryDispose(item);
+            }
+          });
+        } else {
+          const timeout = setTimeout(() => {
+            pendingItems.delete(item);
+            tryDispose(item);
+          }, gracePeriodMs);
+          pendingItems.set(item, timeout);
         }
       }
-      pendingDisposedItems = newPending;
     },
-    /**
-     * Check if an item is pending disposal.
-     */
+    cancelDisposal(items) {
+      for (const item of items) {
+        if (!isObject(item)) continue;
+        const pending = pendingItems.get(item);
+        if (pending === void 0) continue;
+        if (pending !== "microtask") {
+          clearTimeout(pending);
+        }
+        pendingItems.delete(item);
+      }
+    },
     isPending(item) {
-      return isObject(item) && pendingDisposedItems.has(item);
+      return isObject(item) && pendingItems.has(item);
     }
   };
 }
-function toggle() {
-  return (prev) => !prev;
-}
-function increment(amount = 1) {
-  return (prev) => (prev ?? 0) + amount;
-}
-function decrement(amount = 1) {
-  return (prev) => (prev ?? 0) - amount;
-}
-function multiply(factor) {
-  return (prev) => (prev ?? 0) * factor;
-}
-function divide(divisor) {
-  return (prev) => (prev ?? 0) / divisor;
-}
-function clamp(min, max) {
-  return (prev) => Math.min(max, Math.max(min, prev ?? 0));
-}
-function append(suffix) {
-  return (prev) => (prev ?? "") + suffix;
-}
-function prepend(prefix) {
-  return (prev) => prefix + (prev ?? "");
-}
-function merge(partial) {
-  return (prev) => ({ ...prev, ...partial });
-}
-function reset(defaultValue) {
-  return () => defaultValue;
-}
 function list(options) {
-  const autoDispose = (options == null ? void 0 : options.autoDispose) ?? false;
+  const autoDisposeResult = normalizeAutoDispose(options == null ? void 0 : options.autoDispose);
+  const gracePeriodMs = autoDisposeResult ? autoDisposeResult.gracePeriodMs : 0;
+  const group = autoDisposeResult ? autoDisposeResult.group : null;
+  const onAdded = options == null ? void 0 : options.onAdded;
+  const onRemoved = options == null ? void 0 : options.onRemoved;
   return (inputFocus) => {
     const focus = inputFocus;
     const [getter, setter] = focus;
     const defaultValue = [];
-    const tracker = autoDispose ? createDisposalTracker() : null;
+    const tracker = autoDisposeResult ? group ?? createLocalDisposalTracker(gracePeriodMs) : null;
     const getArray = () => getter() ?? defaultValue;
     const scheduleDisposal = (items) => {
-      tracker == null ? void 0 : tracker.scheduleDisposal(items);
+      if (!tracker) return;
+      if ("flush" in tracker) {
+        tracker.scheduleDisposal(items, gracePeriodMs);
+      } else {
+        tracker.scheduleDisposal(items);
+      }
     };
     const cancelDisposal = (items) => {
       tracker == null ? void 0 : tracker.cancelDisposal(items);
     };
+    const notifyAdded = (items, startIndex) => {
+      if (!onAdded) return;
+      items.forEach((item, i) => onAdded(item, startIndex + i));
+    };
+    const notifyRemoved = (items, indices) => {
+      if (!onRemoved) return;
+      items.forEach((item, i) => onRemoved(item, indices[i]));
+    };
     return {
       get() {
         return getArray();
@@ -435,43 +490,59 @@ function list(options) {
         return arr[arr.length - 1];
       },
       push(...items) {
-        cancelDisposal(items);
-        setter((draft) => {
-          const arr = draft ?? [];
-          arr.push(...items);
-          return arr;
+        if (items.length === 0) return;
+        batch(() => {
+          cancelDisposal(items);
+          const startIndex = getArray().length;
+          setter((draft) => {
+            const arr = draft ?? [];
+            arr.push(...items);
+            return arr;
+          });
+          notifyAdded(items, startIndex);
         });
       },
       unshift(...items) {
-        cancelDisposal(items);
-        setter((draft) => {
-          const arr = draft ?? [];
-          arr.unshift(...items);
-          return arr;
+        if (items.length === 0) return;
+        batch(() => {
+          cancelDisposal(items);
+          setter((draft) => {
+            const arr = draft ?? [];
+            arr.unshift(...items);
+            return arr;
+          });
+          notifyAdded(items, 0);
         });
       },
       pop() {
         const currentArray = getArray();
         if (currentArray.length === 0) return void 0;
-        const removed = currentArray[currentArray.length - 1];
-        setter((draft) => {
-          const arr = draft ?? [];
-          arr.pop();
-          return arr;
+        const index = currentArray.length - 1;
+        const removed = currentArray[index];
+        batch(() => {
+          setter((draft) => {
+            const arr = draft ?? [];
+            arr.pop();
+            return arr;
+          });
+          scheduleDisposal([removed]);
+          notifyRemoved([removed], [index]);
         });
-        scheduleDisposal([removed]);
         return removed;
       },
       shift() {
         const currentArray = getArray();
         if (currentArray.length === 0) return void 0;
         const removed = currentArray[0];
-        setter((draft) => {
-          const arr = draft ?? [];
-          arr.shift();
-          return arr;
+        batch(() => {
+          setter((draft) => {
+            const arr = draft ?? [];
+            arr.shift();
+            return arr;
+          });
+          scheduleDisposal([removed]);
+          notifyRemoved([removed], [0]);
         });
-        scheduleDisposal([removed]);
         return removed;
       },
       remove(...items) {
@@ -486,27 +557,33 @@ function list(options) {
           }
         }
         if (removed.length === 0) return 0;
-        indicesToRemove.sort((a2, b) => b - a2);
-        setter((draft) => {
-          const arr = draft ?? [];
-          for (const idx of indicesToRemove) {
-            arr.splice(idx, 1);
-          }
-          return arr;
+        const sortedIndices = [...indicesToRemove].sort((a2, b) => b - a2);
+        batch(() => {
+          setter((draft) => {
+            const arr = draft ?? [];
+            for (const idx of sortedIndices) {
+              arr.splice(idx, 1);
+            }
+            return arr;
+          });
+          scheduleDisposal(removed);
+          notifyRemoved(removed, indicesToRemove);
         });
-        scheduleDisposal(removed);
         return removed.length;
       },
       removeAt(index) {
         const currentArray = getArray();
         if (index < 0 || index >= currentArray.length) return void 0;
         const removed = currentArray[index];
-        setter((draft) => {
-          const arr = draft ?? [];
-          arr.splice(index, 1);
-          return arr;
+        batch(() => {
+          setter((draft) => {
+            const arr = draft ?? [];
+            arr.splice(index, 1);
+            return arr;
+          });
+          scheduleDisposal([removed]);
+          notifyRemoved([removed], [index]);
         });
-        scheduleDisposal([removed]);
         return removed;
       },
       removeWhere(predicate) {
@@ -520,23 +597,30 @@ function list(options) {
           }
         }
         if (removed.length === 0) return 0;
-        indicesToRemove.sort((a2, b) => b - a2);
-        setter((draft) => {
-          const arr = draft ?? [];
-          for (const idx of indicesToRemove) {
-            arr.splice(idx, 1);
-          }
-          return arr;
+        const sortedIndices = [...indicesToRemove].sort((a2, b) => b - a2);
+        batch(() => {
+          setter((draft) => {
+            const arr = draft ?? [];
+            for (const idx of sortedIndices) {
+              arr.splice(idx, 1);
+            }
+            return arr;
+          });
+          scheduleDisposal(removed);
+          notifyRemoved(removed, indicesToRemove);
         });
-        scheduleDisposal(removed);
         return removed.length;
       },
       insert(index, ...items) {
-        cancelDisposal(items);
-        setter((draft) => {
-          const arr = draft ?? [];
-          arr.splice(index, 0, ...items);
-          return arr;
+        if (items.length === 0) return;
+        batch(() => {
+          cancelDisposal(items);
+          setter((draft) => {
+            const arr = draft ?? [];
+            arr.splice(index, 0, ...items);
+            return arr;
+          });
+          notifyAdded(items, index);
         });
       },
       set(index, itemOrReducerOrUpdater) {
@@ -545,39 +629,91 @@ function list(options) {
         if (isFunction && (index < 0 || index >= currentArray.length)) {
           return;
         }
-        if (!isFunction) {
-          cancelDisposal([itemOrReducerOrUpdater]);
-        }
         const old = index >= 0 && index < currentArray.length ? currentArray[index] : void 0;
-        setter((draft) => {
-          const arr = draft ?? [];
-          if (isFunction) {
-            const fn = itemOrReducerOrUpdater;
-            if (index >= 0 && index < arr.length) {
-              const result = fn(arr[index]);
-              if (result !== void 0) {
-                arr[index] = result;
+        batch(() => {
+          if (!isFunction) {
+            cancelDisposal([itemOrReducerOrUpdater]);
+          }
+          setter((draft) => {
+            const arr = draft ?? [];
+            if (isFunction) {
+              const fn = itemOrReducerOrUpdater;
+              if (index >= 0 && index < arr.length) {
+                const result = fn(arr[index]);
+                if (result !== void 0) {
+                  arr[index] = result;
+                }
               }
+            } else {
+              arr[index] = itemOrReducerOrUpdater;
             }
-          } else {
-            arr[index] = itemOrReducerOrUpdater;
+            return arr;
+          });
+          const newValue = getArray()[index];
+          if (old !== void 0 && old !== newValue) {
+            scheduleDisposal([old]);
+            notifyRemoved([old], [index]);
+            notifyAdded([newValue], index);
           }
+        });
+      },
+      tryGet(index, create) {
+        const currentArray = getArray();
+        if (index >= 0 && index < currentArray.length) {
+          return currentArray[index];
+        }
+        const item = create();
+        batch(() => {
+          cancelDisposal([item]);
+          setter((draft) => {
+            const arr = draft ?? [];
+            while (arr.length <= index) {
+              arr.push(void 0);
+            }
+            arr[index] = item;
+            return arr;
+          });
+          notifyAdded([item], index);
+        });
+        return item;
+      },
+      swap(indexA, indexB) {
+        if (indexA === indexB) return;
+        const currentArray = getArray();
+        if (indexA < 0 || indexA >= currentArray.length || indexB < 0 || indexB >= currentArray.length) {
+          return;
+        }
+        setter((draft) => {
+          const arr = draft ?? [];
+          const temp = arr[indexA];
+          arr[indexA] = arr[indexB];
+          arr[indexB] = temp;
           return arr;
         });
-        const newValue = getArray()[index];
-        if (old !== void 0 && old !== newValue) scheduleDisposal([old]);
       },
       clear() {
         const old = getArray();
-        setter([]);
-        scheduleDisposal(old);
+        if (old.length === 0) return;
+        const indices = old.map((_, i) => i);
+        batch(() => {
+          setter([]);
+          scheduleDisposal(old);
+          notifyRemoved(old, indices);
+        });
       },
       replace(items) {
-        cancelDisposal(items);
         const old = getArray();
-        setter(items);
-        const toDispose = old.filter((item) => !items.includes(item));
-        scheduleDisposal(toDispose);
+        batch(() => {
+          cancelDisposal(items);
+          setter(items);
+          const toDispose = old.filter((item) => !items.includes(item));
+          const removedIndices = toDispose.map((item) => old.indexOf(item));
+          scheduleDisposal(toDispose);
+          notifyRemoved(toDispose, removedIndices);
+          const newItems = items.filter((item) => !old.includes(item));
+          const addedIndices = newItems.map((item) => items.indexOf(item));
+          newItems.forEach((item, i) => onAdded == null ? void 0 : onAdded(item, addedIndices[i]));
+        });
       },
       find(predicate) {
         return getArray().find(predicate);
@@ -601,15 +737,24 @@ function list(options) {
   };
 }
 function map(options) {
-  const autoDispose = (options == null ? void 0 : options.autoDispose) ?? false;
+  const autoDisposeResult = normalizeAutoDispose(options == null ? void 0 : options.autoDispose);
+  const gracePeriodMs = autoDisposeResult ? autoDisposeResult.gracePeriodMs : 0;
+  const group = autoDisposeResult ? autoDisposeResult.group : null;
+  const onAdded = options == null ? void 0 : options.onAdded;
+  const onRemoved = options == null ? void 0 : options.onRemoved;
   const defaultValue = {};
   return (inputFocus) => {
     const focus = inputFocus;
     const [getter, setter] = focus;
-    const tracker = autoDispose ? createDisposalTracker() : null;
+    const tracker = autoDisposeResult ? group ?? createLocalDisposalTracker(gracePeriodMs) : null;
     const getRecord = () => getter() ?? defaultValue;
     const scheduleDisposal = (items) => {
-      tracker == null ? void 0 : tracker.scheduleDisposal(items);
+      if (!tracker) return;
+      if ("flush" in tracker) {
+        tracker.scheduleDisposal(items, gracePeriodMs);
+      } else {
+        tracker.scheduleDisposal(items);
+      }
     };
     const cancelDisposal = (items) => {
       tracker == null ? void 0 : tracker.cancelDisposal(items);
@@ -632,80 +777,136 @@ function map(options) {
         const isFunction = typeof valueOrReducerOrUpdater === "function";
         const currentRecord = getRecord();
         if (isFunction && !(key in currentRecord)) return;
-        if (!isFunction) {
-          cancelDisposal([valueOrReducerOrUpdater]);
-        }
         const old = currentRecord[key];
-        setter((draft) => {
-          const rec = draft ?? {};
-          if (isFunction) {
-            const fn = valueOrReducerOrUpdater;
-            const result = fn(rec[key]);
-            if (result !== void 0) {
-              rec[key] = result;
+        const hadKey = key in currentRecord;
+        batch(() => {
+          if (!isFunction) {
+            cancelDisposal([valueOrReducerOrUpdater]);
+          }
+          setter((draft) => {
+            const rec = draft ?? {};
+            if (isFunction) {
+              const fn = valueOrReducerOrUpdater;
+              const result = fn(rec[key]);
+              if (result !== void 0) {
+                rec[key] = result;
+              }
+            } else {
+              rec[key] = valueOrReducerOrUpdater;
             }
-          } else {
-            rec[key] = valueOrReducerOrUpdater;
+            return rec;
+          });
+          const newValue = getRecord()[key];
+          if (hadKey && old !== newValue) {
+            scheduleDisposal([old]);
+            onRemoved == null ? void 0 : onRemoved(old, key);
+          }
+          if (!hadKey || old !== newValue) {
+            onAdded == null ? void 0 : onAdded(newValue, key);
           }
+        });
+      },
+      tryGet(key, create) {
+        const currentRecord = getRecord();
+        if (key in currentRecord) {
+          return currentRecord[key];
+        }
+        const value = create();
+        batch(() => {
+          cancelDisposal([value]);
+          setter((draft) => {
+            const rec = draft ?? {};
+            rec[key] = value;
+            return rec;
+          });
+          onAdded == null ? void 0 : onAdded(value, key);
+        });
+        return value;
+      },
+      swap(keyA, keyB) {
+        if (keyA === keyB) return;
+        const currentRecord = getRecord();
+        if (!(keyA in currentRecord) || !(keyB in currentRecord)) return;
+        setter((draft) => {
+          const rec = draft ?? {};
+          const temp = rec[keyA];
+          rec[keyA] = rec[keyB];
+          rec[keyB] = temp;
           return rec;
         });
-        const newValue = getRecord()[key];
-        if (old !== void 0 && old !== newValue) scheduleDisposal([old]);
       },
       delete(...keys) {
         const currentRecord = getRecord();
         const removed = [];
-        const keysToDelete = [];
         for (const key of keys) {
           if (key in currentRecord) {
-            removed.push(currentRecord[key]);
-            keysToDelete.push(key);
+            removed.push({ value: currentRecord[key], key });
           }
         }
         if (removed.length === 0) return 0;
-        setter((draft) => {
-          const rec = draft ?? {};
-          for (const key of keysToDelete) {
-            delete rec[key];
-          }
-          return rec;
+        batch(() => {
+          setter((draft) => {
+            const rec = draft ?? {};
+            for (const { key } of removed) {
+              delete rec[key];
+            }
+            return rec;
+          });
+          scheduleDisposal(removed.map((r) => r.value));
+          removed.forEach(({ value, key }) => onRemoved == null ? void 0 : onRemoved(value, key));
         });
-        scheduleDisposal(removed);
         return removed.length;
       },
       deleteWhere(predicate) {
         const currentRecord = getRecord();
         const removed = [];
-        const keysToDelete = [];
         for (const key of Object.keys(currentRecord)) {
           if (predicate(currentRecord[key], key)) {
-            removed.push(currentRecord[key]);
-            keysToDelete.push(key);
+            removed.push({ value: currentRecord[key], key });
           }
         }
         if (removed.length === 0) return 0;
-        setter((draft) => {
-          const rec = draft ?? {};
-          for (const key of keysToDelete) {
-            delete rec[key];
-          }
-          return rec;
+        batch(() => {
+          setter((draft) => {
+            const rec = draft ?? {};
+            for (const { key } of removed) {
+              delete rec[key];
+            }
+            return rec;
+          });
+          scheduleDisposal(removed.map((r) => r.value));
+          removed.forEach(({ value, key }) => onRemoved == null ? void 0 : onRemoved(value, key));
         });
-        scheduleDisposal(removed);
         return removed.length;
       },
       clear() {
-        const old = Object.values(getRecord());
-        setter({});
-        scheduleDisposal(old);
+        const old = getRecord();
+        const entries = Object.entries(old);
+        if (entries.length === 0) return;
+        batch(() => {
+          setter({});
+          scheduleDisposal(Object.values(old));
+          entries.forEach(([key, value]) => onRemoved == null ? void 0 : onRemoved(value, key));
+        });
       },
       replace(record) {
-        cancelDisposal(Object.values(record));
         const old = getRecord();
-        setter(record);
-        const newKeys = new Set(Object.keys(record));
-        const toDispose = Object.entries(old).filter(([key]) => !newKeys.has(key)).map(([, value]) => value);
-        scheduleDisposal(toDispose);
+        batch(() => {
+          cancelDisposal(Object.values(record));
+          setter(record);
+          const newKeys = new Set(Object.keys(record));
+          const toDispose = Object.entries(old).filter(
+            ([key]) => !newKeys.has(key)
+          );
+          scheduleDisposal(toDispose.map(([, value]) => value));
+          toDispose.forEach(([key, value]) => onRemoved == null ? void 0 : onRemoved(value, key));
+          const oldKeys = new Set(Object.keys(old));
+          Object.entries(record).forEach(([key, value]) => {
+            if (!oldKeys.has(key) || old[key] !== value) {
+              onAdded == null ? void 0 : onAdded(value, key);
+            }
+          });
+        });
       },
       keys() {
         return Object.keys(getRecord());
@@ -722,6 +923,36 @@ function map(options) {
     };
   };
 }
+function toggle() {
+  return (prev) => !prev;
+}
+function increment(amount = 1) {
+  return (prev) => (prev ?? 0) + amount;
+}
+function decrement(amount = 1) {
+  return (prev) => (prev ?? 0) - amount;
+}
+function multiply(factor) {
+  return (prev) => (prev ?? 0) * factor;
+}
+function divide(divisor) {
+  return (prev) => (prev ?? 0) / divisor;
+}
+function clamp(min, max) {
+  return (prev) => Math.min(max, Math.max(min, prev ?? 0));
+}
+function append(suffix) {
+  return (prev) => (prev ?? "") + suffix;
+}
+function prepend(prefix) {
+  return (prev) => prefix + (prev ?? "");
+}
+function merge(partial) {
+  return (prev) => ({ ...prev, ...partial });
+}
+function reset(defaultValue) {
+  return () => defaultValue;
+}
 function patternToPredicate(pattern) {
   if (pattern instanceof RegExp) {
     return (name) => pattern.test(name);
@@ -880,33 +1111,35 @@ export {
   H as HooksContextError,
   I as InvalidActionError,
   L as LifetimeMismatchError,
-  z as LocalStoreDependencyError,
+  B as LocalStoreDependencyError,
   P as ProviderMissingError,
   STORION_TYPE,
   S as SetupPhaseError,
-  y as StoreDisposedError,
-  x as StorionError,
+  z as StoreDisposedError,
+  y as StorionError,
   append,
   applyExcept,
   applyFor,
-  n as batch,
+  batch,
   clamp,
   container,
   decrement,
-  v as deepEqual,
+  x as deepEqual,
+  disposalGroup,
   divide,
   e as effect,
-  o as equality,
+  q as equality,
   forStores,
+  getNamedGroup,
   increment,
-  m as is,
+  n as is,
   list,
   map,
   merge,
-  m2 as meta,
+  m as meta,
   multiply,
   p as pick,
-  B as pool,
+  C as pool,
   prepend,
   reset,
   createResolver as resolver,