storion 0.9.0 → 0.10.0

package/dist/{index-C8B6Mo8r.js → effect-BDQU8Voz.js}

@@ -1,37 +1,14 @@
-import { a as SetupPhaseError, c as LifetimeMismatchError, w as withHooks, I as InvalidActionError, h as hasReadHook, t as trackRead, f as hasWriteHook, g as trackWrite, d as StoreDisposedError, s as scheduleNotification, b as batch, u as untrack, i as getHooks, H as HooksContextError } from "./effect-C6h0PDDI.js";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { e as emitter } from "./emitter-j4rC71vY.js";
-import "./meta-40r-AZfe.js";
 const STORION_TYPE = Symbol("STORION");
 function is$1(value, kind) {
   return value !== null && (typeof value === "object" || typeof value === "function") && STORION_TYPE in value && value[STORION_TYPE] === kind;
 }
-function isStorion(value) {
-  return value !== null && (typeof value === "object" || typeof value === "function") && STORION_TYPE in value && typeof value[STORION_TYPE] === "string";
-}
-function getKind(value) {
-  return value[STORION_TYPE];
-}
 function isSpec(value) {
   return is$1(value, "store.spec");
 }
-function isContainer(value) {
-  return is$1(value, "container");
-}
-function isStore(value) {
-  return is$1(value, "store");
-}
-function isFocus(value) {
-  return is$1(value, "focus");
-}
-function isStoreContext(value) {
-  return is$1(value, "store.context");
-}
-function isSelectorContext(value) {
-  return is$1(value, "selector.context");
-}
-function isAction(value) {
-  return is$1(value, "store.action");
-}
 var NOTHING = Symbol.for("immer-nothing");
 var DRAFTABLE = Symbol.for("immer-draftable");
 var DRAFT_STATE = Symbol.for("immer-state");
@@ -831,6 +808,106 @@ function currentImpl(value) {
 }
 var immer = new Immer2();
 var produce = immer.produce;
+function tryDispose(value) {
+  if (isDisposable(value)) {
+    const dispose = value.dispose;
+    if (Array.isArray(dispose)) {
+      for (const item of dispose) {
+        if (typeof item === "function") {
+          item();
+        } else {
+          tryDispose(item);
+        }
+      }
+    } else if (typeof dispose === "function") {
+      dispose();
+    }
+  }
+}
+function isDisposable(value) {
+  return (typeof value === "object" || typeof value === "function") && !!value && "dispose" in value;
+}
+function willDispose(value) {
+  return () => tryDispose(value);
+}
+class StorionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StorionError";
+  }
+}
+class SetupPhaseError extends StorionError {
+  constructor(method, hint) {
+    super(
+      `${method}() can only be called during setup phase. Do not call ${method}() inside actions or async callbacks.` + (hint ? ` ${hint}` : "")
+    );
+    this.name = "SetupPhaseError";
+  }
+}
+class LifetimeMismatchError extends StorionError {
+  constructor(parentName, childName, operation) {
+    super(
+      `Lifetime mismatch: Store "${parentName}" (keepAlive) cannot ${operation} store "${childName}" (autoDispose). A long-lived store cannot ${operation} a store that may be disposed. Either change "${parentName}" to autoDispose, or change "${childName}" to keepAlive.`
+    );
+    this.name = "LifetimeMismatchError";
+  }
+}
+class AsyncFunctionError extends StorionError {
+  constructor(context, hint) {
+    super(`${context} must be synchronous. ${hint}`);
+    this.name = "AsyncFunctionError";
+  }
+}
+class StoreDisposedError extends StorionError {
+  constructor(storeId) {
+    super(`Cannot call action on disposed store: ${storeId}`);
+    this.name = "StoreDisposedError";
+  }
+}
+class InvalidActionError extends StorionError {
+  constructor(actionName, actualType) {
+    super(
+      `Action "${actionName}" must be a function, got ${actualType}. If using focus(), destructure it and return the getter/setter separately: const [get, set] = focus("path"); return { get, set };`
+    );
+    this.name = "InvalidActionError";
+  }
+}
+class HooksContextError extends StorionError {
+  constructor(method, requiredContext) {
+    super(
+      `${method}() must be called inside ${requiredContext}. It requires an active tracking context.`
+    );
+    this.name = "HooksContextError";
+  }
+}
+class ProviderMissingError extends StorionError {
+  constructor(hook, provider) {
+    super(`${hook} must be used within a ${provider}`);
+    this.name = "ProviderMissingError";
+  }
+}
+class LocalStoreDependencyError extends StorionError {
+  constructor(storeName, dependencyCount) {
+    super(
+      `Local store must not have dependencies, but "${storeName}" has ${dependencyCount} dependencies. Use useStore() with a global container for stores with dependencies.`
+    );
+    this.name = "LocalStoreDependencyError";
+  }
+}
+class EffectRefreshError extends StorionError {
+  constructor() {
+    super("Effect is already running, cannot refresh");
+    this.name = "EffectRefreshError";
+  }
+}
+class ScopedOutsideSelectorError extends StorionError {
+  constructor() {
+    super(
+      "scoped() can only be called during selector execution. Do not call scoped() in callbacks, event handlers, or async functions."
+    );
+    this.name = "ScopedOutsideSelectorError";
+  }
+}
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
@@ -1233,8 +1310,8 @@ function arraySome$1(array, predicate) {
   return false;
 }
 var _arraySome = arraySome$1;
-function cacheHas$1(cache2, key) {
-  return cache2.has(key);
+function cacheHas$1(cache, key) {
+  return cache.has(key);
 }
 var _cacheHas = cacheHas$1;
 var SetCache = _SetCache, arraySome = _arraySome, cacheHas = _cacheHas;
@@ -1302,7 +1379,7 @@ function setToArray$1(set2) {
   return result;
 }
 var _setToArray = setToArray$1;
-var Symbol$1 = _Symbol, Uint8Array = _Uint8Array, eq = eq_1, equalArrays$1 = _equalArrays, mapToArray = _mapToArray, setToArray = _setToArray;
+var Symbol$1 = _Symbol, Uint8Array2 = _Uint8Array, eq = eq_1, equalArrays$1 = _equalArrays, mapToArray = _mapToArray, setToArray = _setToArray;
 var COMPARE_PARTIAL_FLAG$2 = 1, COMPARE_UNORDERED_FLAG = 2;
 var boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag = "[object Symbol]";
 var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$2 = "[object DataView]";
@@ -1316,7 +1393,7 @@ function equalByTag$1(object, other, tag, bitmask, customizer, equalFunc, stack)
       object = object.buffer;
       other = other.buffer;
     case arrayBufferTag$1:
-      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
         return false;
       }
       return true;
@@ -1437,8 +1514,8 @@ var stubFalse_1 = stubFalse;
   var freeExports = exports$1 && !exports$1.nodeType && exports$1;
   var freeModule = freeExports && true && module && !module.nodeType && module;
   var moduleExports = freeModule && freeModule.exports === freeExports;
-  var Buffer = moduleExports ? root2.Buffer : void 0;
-  var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+  var Buffer2 = moduleExports ? root2.Buffer : void 0;
+  var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
   var isBuffer2 = nativeIsBuffer || stubFalse2;
   module.exports = isBuffer2;
 })(isBuffer$2, isBuffer$2.exports);
@@ -1732,28 +1809,234 @@ function resolveEquality(e) {
 function equality(shorthand) {
   return resolveEquality(shorthand);
 }
-function tryDispose(value) {
-  if (isDisposable(value)) {
-    const dispose = value.dispose;
-    if (Array.isArray(dispose)) {
-      for (const item of dispose) {
-        if (typeof item === "function") {
-          item();
-        } else {
-          tryDispose(item);
-        }
+function createStableFn(fn) {
+  const originalFn = fn;
+  let currentFn = fn;
+  return Object.assign(
+    (...args) => {
+      return currentFn(...args);
+    },
+    {
+      getOriginal: () => originalFn,
+      getCurrent: () => currentFn,
+      setCurrent(newFn) {
+        currentFn = newFn;
+      }
+    }
+  );
+}
+function isStableFn(value) {
+  return typeof value === "function" && "getOriginal" in value && "getCurrent" in value && "setCurrent" in value;
+}
+function tryStabilize(prev, next, equalityFn) {
+  if (!prev) {
+    if (typeof next === "function") {
+      return [createStableFn(next), false];
+    }
+    return [next, false];
+  }
+  if (typeof next === "function") {
+    if (isStableFn(prev.value)) {
+      prev.value.setCurrent(next);
+      return [prev.value, true];
+    }
+    return [createStableFn(next), false];
+  }
+  if (next && next instanceof Date) {
+    if (prev.value && prev.value instanceof Date) {
+      if (next.getTime() === prev.value.getTime()) {
+        return [prev.value, true];
       }
-    } else if (typeof dispose === "function") {
-      dispose();
     }
+    return [next, false];
   }
+  if (equalityFn(prev.value, next)) {
+    return [prev.value, true];
+  }
+  return [next, false];
 }
-function isDisposable(value) {
-  return (typeof value === "object" || typeof value === "function") && !!value && "dispose" in value;
+let globalHooks = {
+  scheduleNotification(notify) {
+    notify();
+  },
+  scheduleEffect(runEffect) {
+    runEffect();
+  }
+};
+function getHooks() {
+  return globalHooks;
 }
-function willDispose(value) {
-  return () => tryDispose(value);
+function hasReadHook() {
+  return globalHooks.onRead !== void 0;
+}
+function hasWriteHook() {
+  return globalHooks.onWrite !== void 0;
+}
+function withHooks(hooksOrSetup, fn, onFinish) {
+  const prev = globalHooks;
+  if (typeof hooksOrSetup === "function") {
+    globalHooks = {
+      ...globalHooks,
+      ...hooksOrSetup(prev)
+    };
+  } else {
+    globalHooks = { ...prev, ...hooksOrSetup };
+  }
+  try {
+    return fn();
+  } finally {
+    globalHooks = prev;
+    onFinish == null ? void 0 : onFinish();
+  }
+}
+function trackRead(storeId, prop, value, subscribe) {
+  var _a;
+  const key = `${storeId}.${prop}`;
+  (_a = globalHooks.onRead) == null ? void 0 : _a.call(globalHooks, { key, value, subscribe });
+}
+function trackWrite(storeId, prop, next, prev) {
+  var _a;
+  const key = `${storeId}.${prop}`;
+  (_a = globalHooks.onWrite) == null ? void 0 : _a.call(globalHooks, { key, next, prev });
+}
+function untrack(fn) {
+  return withHooks({ onRead: void 0, onWrite: void 0 }, fn);
+}
+function scheduleNotification(notify, key) {
+  globalHooks.scheduleNotification(notify, key);
+}
+function batch(fn) {
+  const pending = /* @__PURE__ */ new Map();
+  return withHooks(
+    (current2) => ({
+      ...current2,
+      scheduleNotification: (notify, key) => {
+        const actualKey = key ?? notify;
+        pending.set(actualKey, notify);
+      }
+    }),
+    fn,
+    // Flush on finish
+    () => {
+      for (const notify of pending.values()) {
+        notify();
+      }
+    }
+  );
+}
+let pickIdCounter = 0;
+function pick(selector, equality2) {
+  var _a;
+  const parentHooks = getHooks();
+  if (!parentHooks.onRead) {
+    throw new HooksContextError("pick", "an effect or useStore selector");
+  }
+  const equalityFn = resolveEquality(equality2);
+  const currentReads = [];
+  const evaluate = () => {
+    currentReads.length = 0;
+    const value = withHooks(
+      {
+        onRead: (event) => {
+          currentReads.push(event);
+        }
+      },
+      selector
+    );
+    return value;
+  };
+  let currentValue = evaluate();
+  if (!currentReads.length) {
+    return currentValue;
+  }
+  const pickKey = `pick:${++pickIdCounter}`;
+  const subscribe = (listener) => {
+    const onCleanup = emitter();
+    const setupSubscriptions = () => {
+      for (const read of currentReads) {
+        const unsub = read.subscribe(handleChange);
+        onCleanup.on(unsub);
+      }
+    };
+    const clearSubscriptions = () => {
+      onCleanup.emitAndClear();
+    };
+    const handleChange = () => {
+      try {
+        const prevValue = currentValue;
+        clearSubscriptions();
+        currentValue = evaluate();
+        setupSubscriptions();
+        if (!equalityFn(prevValue, currentValue)) {
+          listener();
+        }
+      } catch (error) {
+        clearSubscriptions();
+        listener();
+      }
+    };
+    setupSubscriptions();
+    return clearSubscriptions;
+  };
+  (_a = parentHooks.onRead) == null ? void 0 : _a.call(parentHooks, {
+    key: pickKey,
+    value: currentValue,
+    subscribe
+  });
+  return currentValue;
+}
+function checkIsDev() {
+  var _a;
+  if (typeof __DEV__ !== "undefined") {
+    return __DEV__;
+  }
+  try {
+    const p = globalThis.process;
+    if ((_a = p == null ? void 0 : p.env) == null ? void 0 : _a.NODE_ENV) {
+      return p.env.NODE_ENV !== "production";
+    }
+  } catch {
+  }
+  return false;
+}
+function dev(fn) {
+  const isDev = checkIsDev();
+  if (fn) {
+    if (isDev) {
+      fn();
+    }
+    return isDev;
+  }
+  return isDev;
 }
+((dev2) => {
+  function log(message, ...args) {
+    if (checkIsDev()) {
+      console.log(`[rextive] ${message}`, ...args);
+    }
+  }
+  dev2.log = log;
+  function warn(message, ...args) {
+    if (checkIsDev()) {
+      console.warn(`[rextive] ${message}`, ...args);
+    }
+  }
+  dev2.warn = warn;
+  function error(message, ...args) {
+    if (checkIsDev()) {
+      console.error(`[rextive] ${message}`, ...args);
+    }
+  }
+  dev2.error = error;
+  function assert(condition, message) {
+    if (checkIsDev()) {
+      if (!condition) {
+        throw new Error(`[rextive] Assertion failed: ${message}`);
+      }
+    }
+  }
+  dev2.assert = assert;
+})(dev || (dev = {}));
 function getAtPath(obj, segments) {
   let current2 = obj;
   for (const key of segments) {
@@ -1762,15 +2045,30 @@ function getAtPath(obj, segments) {
   }
   return current2;
 }
-function createFocus(context, segments, isSetupPhase, options) {
-  if (!isSetupPhase()) {
-    throw new SetupPhaseError(
-      "createFocus",
-      "Focus can only be called during setup phase."
-    );
+function getCacheKey(segments) {
+  return segments.join(".");
+}
+function optionsMatch(a, b) {
+  if (!a && !b) return true;
+  if (!a || !b) return false;
+  if (a.equality !== b.equality) return false;
+  if (a.fallback !== b.fallback) return false;
+  return true;
+}
+function createFocus(storeContext, resolver, context, segments, cache, options) {
+  const cacheKey = getCacheKey(segments);
+  const cached = cache.get(cacheKey);
+  if (cached) {
+    if (!optionsMatch(cached.options, options)) {
+      dev.warn(
+        `focus("${cacheKey}") called with different options. The first options are used. If you need different behavior, use a different path.`
+      );
+    }
+    return cached.focus;
   }
   const { fallback, equality: equalityOption } = options ?? {};
   const equalityFn = resolveEquality(equalityOption);
+  const initialValue = getAtPath(context.get(), segments);
   const getter = () => {
     const state = context.get();
     const value = getAtPath(state, segments);
@@ -1779,6 +2077,10 @@ function createFocus(context, segments, isSetupPhase, options) {
     }
     return value;
   };
+  const getterWithPick = getter;
+  getterWithPick.pick = (equality2) => {
+    return pick(getter, equality2);
+  };
   const setter = (valueOrReducerOrProduce) => {
     context.update((draft) => {
       let current2 = draft;
@@ -1819,22 +2121,48 @@ function createFocus(context, segments, isSetupPhase, options) {
   };
   const to = (relativePath, childOptions) => {
     return createFocus(
+      storeContext,
+      resolver,
       context,
       [...segments, ...relativePath.split(".")],
-      isSetupPhase,
+      cache,
       childOptions
     );
   };
-  const focus = [getter, setter];
+  const dirty = () => {
+    const currentValue = getter();
+    return !equalityFn(currentValue, initialValue);
+  };
+  const reset = () => {
+    setter(initialValue);
+  };
+  const focusPick = (equality2) => {
+    return pick(getter, equality2);
+  };
+  const focus = [getterWithPick, setter];
+  const as = (helper) => {
+    return helper(focus);
+  };
   Object.assign(focus, {
     [STORION_TYPE]: "focus",
     on,
     to,
+    as,
+    dirty,
+    reset,
+    pick: focusPick,
     context,
+    _storeContext: storeContext,
+    _resolver: resolver,
     segments
   });
+  cache.set(cacheKey, { focus, options });
   return focus;
 }
+function storeTuple(instance) {
+  const { state, actions } = instance;
+  return Object.assign([state, actions, instance], { state, actions });
+}
 function createUpdateFn(update) {
   const updateFn = (updaterOrPartial) => {
     if (typeof updaterOrPartial === "function") {
@@ -1869,6 +2197,7 @@ function createStoreContext(options) {
     isSetupPhase
   } = options;
   const currentLifetime = spec.options.lifetime ?? "keepAlive";
+  const focusCache = /* @__PURE__ */ new Map();
   const ctx = {
     [STORION_TYPE]: "store.context",
     get state() {
@@ -1894,32 +2223,16 @@ function createStoreContext(options) {
       }
       const instance = resolver.get(depSpec);
       onDependency == null ? void 0 : onDependency(instance);
-      const tuple = [instance.state, instance.actions];
-      return Object.assign(tuple, {
-        state: instance.state,
-        actions: instance.actions
-      });
+      return storeTuple(instance);
     },
     // Implementation handles StoreSpec, Factory, and parameterized Factory overloads
     create(specOrFactory, ...args) {
-      if (!isSetupPhase()) {
-        throw new SetupPhaseError(
-          "create",
-          "Declare all child stores at the top of your setup function."
-        );
-      }
       if (!isSpec(specOrFactory)) {
         const instance2 = specOrFactory(resolver, ...args);
         onDispose == null ? void 0 : onDispose(willDispose(instance2));
         return instance2;
       }
       const childSpec = specOrFactory;
-      const childLifetime = childSpec.options.lifetime ?? "keepAlive";
-      if (currentLifetime === "keepAlive" && childLifetime === "autoDispose") {
-        const currentName = spec.options.name ?? "unknown";
-        const childName = childSpec.name ?? "unknown";
-        throw new LifetimeMismatchError(currentName, childName, "create");
-      }
       const instance = resolver.create(childSpec);
       onDispose == null ? void 0 : onDispose(willDispose(instance));
       return instance;
@@ -1934,6 +2247,9 @@ function createStoreContext(options) {
     onDispose(callback) {
       onDispose == null ? void 0 : onDispose(callback);
     },
+    isSetupPhase() {
+      return isSetupPhase();
+    },
     mixin(mixin, ...args) {
       if (!isSetupPhase()) {
         throw new SetupPhaseError("mixin");
@@ -1948,7 +2264,14 @@ function createStoreContext(options) {
         },
         subscribe
       };
-      return createFocus(focusCtx, path.split("."), isSetupPhase, options2);
+      return createFocus(
+        ctx,
+        resolver,
+        focusCtx,
+        path.split("."),
+        focusCache,
+        options2
+      );
     }
   };
   return ctx;
@@ -1971,46 +2294,147 @@ function unwrapFn(fn) {
   const original = fn[ORIGINAL_FN];
   return original ?? fn;
 }
-function isWrappedFn(fn) {
-  return ORIGINAL_FN in fn;
-}
-function collection(createItem, initialItems) {
-  const map = /* @__PURE__ */ new Map([]);
-  return {
-    with(key, callback) {
-      if (map.has(key)) {
-        callback(map.get(key));
+function pool(createItem, optionsOrInitial) {
+  const isOptionsObject = optionsOrInitial && !Array.isArray(optionsOrInitial) && typeof optionsOrInitial === "object";
+  const options = isOptionsObject ? optionsOrInitial : void 0;
+  const initial = isOptionsObject ? options == null ? void 0 : options.initial : optionsOrInitial;
+  const keyOf = options == null ? void 0 : options.keyOf;
+  const keyEquality = (options == null ? void 0 : options.equality) && !keyOf ? resolveEquality(options.equality) : null;
+  const shouldAutoDispose = !!(options == null ? void 0 : options.autoDispose);
+  if (keyOf) {
+    const map2 = /* @__PURE__ */ new Map();
+    for (const [k, v] of initial ?? []) {
+      map2.set(keyOf(k), { key: k, value: v });
+    }
+    const get22 = (key) => {
+      const hash = keyOf(key);
+      const entry = map2.get(hash);
+      if (entry) return entry.value;
+      const value = createItem(key);
+      map2.set(hash, { key, value });
+      return value;
+    };
+    return Object.assign(get22, {
+      tap(key, callback) {
+        const entry = map2.get(keyOf(key));
+        if (entry) callback(entry.value);
+        return this;
+      },
+      has: (key) => map2.has(keyOf(key)),
+      get: get22,
+      set(key, value) {
+        const hash = keyOf(key);
+        if (shouldAutoDispose) {
+          const existing = map2.get(hash);
+          if (existing && existing.value !== value) {
+            tryDispose(existing.value);
+          }
+        }
+        map2.set(hash, { key, value });
+        return this;
+      },
+      size() {
+        return map2.size;
+      },
+      clear() {
+        if (shouldAutoDispose) {
+          for (const entry of map2.values()) {
+            tryDispose(entry.value);
+          }
+        }
+        map2.clear();
+        return this;
+      },
+      delete(key) {
+        const hash = keyOf(key);
+        if (shouldAutoDispose) {
+          const entry = map2.get(hash);
+          if (entry) tryDispose(entry.value);
+        }
+        map2.delete(hash);
+        return this;
+      },
+      *keys() {
+        for (const entry of map2.values()) yield entry.key;
+      },
+      *values() {
+        for (const entry of map2.values()) yield entry.value;
+      },
+      *entries() {
+        for (const entry of map2.values())
+          yield [entry.key, entry.value];
+      }
+    });
+  }
+  const map = new Map(initial ?? []);
+  const findKey = (key) => {
+    if (!keyEquality) return map.has(key) ? key : void 0;
+    for (const k of map.keys()) {
+      if (keyEquality(k, key)) return k;
+    }
+    return void 0;
+  };
+  const get2 = (key) => {
+    const existingKey = findKey(key);
+    if (existingKey !== void 0) {
+      return map.get(existingKey);
+    }
+    const value = createItem(key);
+    map.set(key, value);
+    return value;
+  };
+  return Object.assign(get2, {
+    tap(key, callback) {
+      const existingKey = findKey(key);
+      if (existingKey !== void 0) {
+        callback(map.get(existingKey));
       }
       return this;
     },
     /** Check if key exists (does NOT create item) */
     has(key) {
-      return map.has(key);
-    },
-    /** Get item by key, creating it if it doesn't exist */
-    get(key) {
-      if (!map.has(key)) {
-        map.set(key, createItem(key));
-      }
-      return map.get(key);
+      return findKey(key) !== void 0;
     },
+    get: get2,
     /** Explicitly set an item */
     set(key, value) {
-      map.set(key, value);
+      const existingKey = findKey(key);
+      if (existingKey !== void 0) {
+        if (shouldAutoDispose) {
+          const existing = map.get(existingKey);
+          if (existing !== value) {
+            tryDispose(existing);
+          }
+        }
+        map.set(existingKey, value);
+      } else {
+        map.set(key, value);
+      }
       return this;
     },
-    /** Number of items in the collection */
-    get size() {
+    /** Number of items in the pool */
+    size() {
       return map.size;
     },
     /** Remove all items */
     clear() {
+      if (shouldAutoDispose) {
+        for (const value of map.values()) {
+          tryDispose(value);
+        }
+      }
       map.clear();
       return this;
     },
     /** Remove a specific item */
     delete(key) {
-      map.delete(key);
+      const existingKey = findKey(key);
+      if (existingKey !== void 0) {
+        if (shouldAutoDispose) {
+          tryDispose(map.get(existingKey));
+        }
+        map.delete(existingKey);
+      }
       return this;
     },
     /** Iterate over keys */
@@ -2025,7 +2449,7 @@ function collection(createItem, initialItems) {
     entries() {
       return map.entries();
     }
-  };
+  });
 }
 function store(options) {
   const displayName = options.name ?? generateSpecName();
@@ -2087,10 +2511,12 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
   };
   const changeEmitter = emitter();
   const disposeEmitter = emitter();
-  const propertyEmitters = collection(() => emitter());
+  const propertyEmitters = pool(
+    () => emitter()
+  );
   const actionInvocations = /* @__PURE__ */ new Map();
   const actionNthCounters = /* @__PURE__ */ new Map();
-  const actionEmitters = collection(
+  const actionEmitters = pool(
     () => emitter()
   );
   const wildcardActionEmitter = emitter();
@@ -2122,7 +2548,7 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
     if (isSetupPhase) {
       return;
     }
-    propertyEmitters.with(
+    propertyEmitters.tap(
       key,
       (em) => em.emit({ newValue, oldValue })
     );
@@ -2393,7 +2819,10 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
     disposeEffectsEmitter.on(dispose);
   }
   initialState = currentState;
-  Object.assign(instance, { deps: Array.from(deps) });
+  Object.assign(instance, {
+    deps: Array.from(deps),
+    toJSON: () => currentState
+  });
   deps.clear();
   const wrappedActions = {};
   for (const [name, action] of Object.entries(actions)) {
@@ -2457,539 +2886,768 @@ function createStoreInstance(spec, resolver, instanceOptions = {}) {
   instanceActions = wrappedActions;
   return instance;
 }
-function createMetaQuery(entries) {
-  const entryArray = Array.isArray(entries) ? entries : entries ? [entries] : [];
-  const single = (type) => {
-    const result = { store: void 0, fields: {} };
-    for (const entry of entryArray) {
-      if (entry.type !== type) continue;
-      if (entry.fields && entry.fields.length > 0) {
-        for (const field of entry.fields) {
-          const fieldKey = field;
-          if (!(fieldKey in result.fields)) {
-            result.fields[fieldKey] = entry.value;
-          }
-        }
-      } else {
-        if (result.store === void 0) {
-          result.store = entry.value;
-        }
-      }
+const abortableSymbol = Symbol.for("storion.abortable");
+function isAbortable(fn) {
+  return typeof fn === "function" && abortableSymbol in fn && fn[abortableSymbol] === true;
+}
+class AbortableAbortedError extends Error {
+  constructor(message = "Abortable was aborted") {
+    super(message);
+    __publicField(this, "name", "AbortableAbortedError");
+  }
+}
+function createAbortableContext(controller, pauseState, takeState, setStatus) {
+  const signal = controller.signal;
+  const checkPauseAndAbort = async () => {
+    if (signal.aborted) {
+      throw new AbortableAbortedError();
+    }
+    if (pauseState.isPaused) {
+      setStatus("paused");
+      await new Promise((resolve) => {
+        pauseState.resumeResolve = resolve;
+      });
+      pauseState.resumeResolve = null;
+      setStatus("running");
+    }
+    if (signal.aborted) {
+      throw new AbortableAbortedError();
     }
-    return result;
   };
-  const all = (type) => {
-    const result = { store: [], fields: {} };
-    for (const entry of entryArray) {
-      if (entry.type !== type) continue;
-      if (entry.fields && entry.fields.length > 0) {
-        for (const field of entry.fields) {
-          const fieldKey = field;
-          let arr = result.fields[fieldKey];
-          if (!arr) {
-            arr = [];
-            result.fields[fieldKey] = arr;
-          }
-          arr.push(entry.value);
-        }
-      } else {
-        result.store.push(entry.value);
+  const afterCheck = async (value) => {
+    await checkPauseAndAbort();
+    return value;
+  };
+  const join = (resultOrResults) => {
+    if (signal.aborted) {
+      return Promise.reject(new AbortableAbortedError());
+    }
+    const isArray2 = Array.isArray(resultOrResults);
+    const results = isArray2 ? resultOrResults : [resultOrResults];
+    const abortAll = () => {
+      for (const result of results) {
+        result.abort();
       }
+    };
+    signal.addEventListener("abort", abortAll, { once: true });
+    const promise = Promise.all(results).then(async (values) => {
+      signal.removeEventListener("abort", abortAll);
+      await checkPauseAndAbort();
+      return isArray2 ? values : values[0];
+    }).catch(async (error) => {
+      signal.removeEventListener("abort", abortAll);
+      abortAll();
+      if (signal.aborted) {
+        throw new AbortableAbortedError();
+      }
+      throw error;
+    });
+    return promise;
+  };
+  const baseSafe = createSafe(
+    () => signal,
+    () => signal.aborted
+  );
+  const safeFn = async (fnOrPromise, ...args) => {
+    if (isAbortable(fnOrPromise)) {
+      const abortableResult = fnOrPromise.withSignal(signal, ...args);
+      return join(abortableResult);
     }
+    const result = await baseSafe(fnOrPromise, ...args);
+    await checkPauseAndAbort();
     return result;
   };
-  const fields = (type, predicate) => {
-    const result = /* @__PURE__ */ new Set();
-    for (const entry of entryArray) {
-      if (entry.type !== type) continue;
-      if (entry.fields && entry.fields.length > 0) {
-        if (!predicate || predicate(entry.value)) {
-          for (const field of entry.fields) {
-            result.add(field);
-          }
-        }
-      }
-    }
-    return Array.from(result);
+  const safe = Object.assign(safeFn, {
+    all: baseSafe.all,
+    race: baseSafe.race,
+    settled: baseSafe.settled,
+    any: baseSafe.any,
+    callback: baseSafe.callback
+  });
+  const take = (key) => {
+    const takeKey = String(key ?? "__checkpoint__");
+    if (signal.aborted) {
+      return Promise.reject(new AbortableAbortedError());
+    }
+    const existing = takeState.pendingTakes.get(takeKey);
+    if (existing) {
+      return existing.promise.then(afterCheck);
+    }
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    takeState.pendingTakes.set(takeKey, {
+      resolve,
+      reject,
+      promise
+    });
+    setStatus("waiting");
+    return promise.then(afterCheck);
   };
-  const any = (...types) => {
-    return entryArray.some((entry) => types.includes(entry.type));
+  return {
+    signal,
+    safe,
+    take,
+    join,
+    aborted: () => signal.aborted,
+    abort: () => {
+      if (signal.aborted) return false;
+      controller.abort();
+      return true;
+    },
+    checkpoint: checkPauseAndAbort
   };
-  const query = Object.assign(
-    (type) => single(type),
-    { single, all, any, fields }
-  );
-  return query;
 }
-function extractDisplayName(factory) {
-  if (isSpec(factory)) {
-    return factory.displayName;
-  }
-  if (typeof factory.displayName === "string" && factory.displayName) {
-    return factory.displayName;
-  }
-  if (factory.name && factory.name !== "") {
-    return factory.name;
-  }
-  return void 0;
+function createSend(takeState, setStatus) {
+  return (key, value) => {
+    const takeKey = String(key ?? "__checkpoint__");
+    const pending = takeState.pendingTakes.get(takeKey);
+    if (pending) {
+      pending.resolve(value);
+      takeState.pendingTakes.delete(takeKey);
+      setStatus("running");
+    }
+  };
 }
-function createResolver(options = {}) {
-  const {
-    middleware = [],
-    parent,
-    invokeResolver: invokeResolverOption
-  } = options;
-  const cache2 = /* @__PURE__ */ new Map();
-  const overrides = /* @__PURE__ */ new Map();
-  const resolve = (factory) => overrides.get(factory) ?? factory;
-  const invoke = (factory, resolverForCtx) => {
-    const isStoreSpec = isSpec(factory);
-    const displayName = extractDisplayName(factory);
-    const meta = createMetaQuery(factory.meta);
-    const chain = middleware.reduceRight(
-      (next, mw) => () => {
-        if (isStoreSpec) {
-          const ctx = {
-            type: "store",
-            factory,
-            resolver: resolverForCtx,
-            next,
-            displayName,
-            spec: factory,
-            meta
-          };
-          return mw(ctx);
-        } else {
-          const ctx = {
-            type: "factory",
-            factory,
-            resolver: resolverForCtx,
-            next,
-            displayName,
-            meta
-          };
-          return mw(ctx);
-        }
-      },
-      () => factory(resolverForCtx)
-    );
-    return chain();
+function executeAbortable(fn, args, parentSignal) {
+  const controller = new AbortController();
+  if (parentSignal) {
+    if (parentSignal.aborted) {
+      controller.abort();
+    } else {
+      const onParentAbort = () => controller.abort();
+      parentSignal.addEventListener("abort", onParentAbort, { once: true });
+      controller.signal.addEventListener(
+        "abort",
+        () => parentSignal.removeEventListener("abort", onParentAbort),
+        { once: true }
+      );
+    }
+  }
+  let status = "running";
+  let resultValue;
+  let errorValue;
+  const pauseState = {
+    isPaused: false,
+    resumeResolve: null
+  };
+  const takeState = {
+    pendingTakes: /* @__PURE__ */ new Map()
+  };
+  const setStatus = (newStatus) => {
+    if (!["success", "error", "aborted"].includes(status)) {
+      status = newStatus;
+    }
   };
-  const resolver = {
-    get(factory) {
-      if (cache2.has(factory)) {
-        return cache2.get(factory);
+  const ctx = createAbortableContext(
+    controller,
+    pauseState,
+    takeState,
+    setStatus
+  );
+  const wrappedFn = async () => {
+    try {
+      if (controller.signal.aborted) {
+        throw new AbortableAbortedError();
       }
-      if (parent && overrides.size === 0 && parent.has(factory)) {
-        return parent.get(factory);
+      const result = await fn(ctx, ...args);
+      return result;
+    } catch (e) {
+      if (controller.signal.aborted) {
+        throw new AbortableAbortedError();
       }
-      const instance = invoke(
-        resolve(factory),
-        invokeResolverOption ?? resolver
-      );
-      cache2.set(factory, instance);
-      return instance;
-    },
-    create(factory, ...args) {
-      const resolverForCtx = invokeResolverOption ?? resolver;
-      if (args.length > 0) {
-        return factory(resolverForCtx, ...args);
+      throw e;
+    }
+  };
+  const promise = wrappedFn().then((result) => {
+    status = "success";
+    resultValue = result;
+    return result;
+  }).catch((error) => {
+    if (error instanceof AbortableAbortedError || controller.signal.aborted) {
+      status = "aborted";
+      errorValue = error instanceof Error ? error : new AbortableAbortedError();
+    } else {
+      status = "error";
+      errorValue = error instanceof Error ? error : new Error(String(error));
+    }
+    throw errorValue;
+  });
+  const send = createSend(takeState, setStatus);
+  return Object.assign(promise, {
+    send,
+    // Status checks
+    failed: () => status === "error",
+    completed: () => ["success", "error", "aborted"].includes(status),
+    running: () => status === "running",
+    succeeded: () => status === "success",
+    paused: () => status === "paused",
+    waiting: () => status === "waiting",
+    aborted: () => status === "aborted",
+    status: () => status,
+    // Result access
+    result: () => resultValue,
+    error: () => errorValue,
+    // Control methods
+    pause: () => {
+      if (pauseState.isPaused || ["success", "error", "aborted"].includes(status)) {
+        return false;
       }
-      return invoke(resolve(factory), resolverForCtx);
-    },
-    set(factory, override) {
-      overrides.set(factory, override);
-      cache2.delete(factory);
-    },
-    has(factory) {
-      const inParent = parent && overrides.size === 0 && parent.has(factory);
-      return cache2.has(factory) || (inParent ?? false);
+      pauseState.isPaused = true;
+      status = "paused";
+      return true;
     },
-    tryGet(factory) {
-      if (cache2.has(factory)) {
-        return cache2.get(factory);
+    resume: () => {
+      if (!pauseState.isPaused) {
+        return false;
       }
-      if (parent && overrides.size === 0) {
-        return parent.tryGet(factory);
+      pauseState.isPaused = false;
+      status = "running";
+      if (pauseState.resumeResolve) {
+        pauseState.resumeResolve();
       }
-      return void 0;
+      return true;
     },
-    delete(factory) {
-      const instance = cache2.get(factory);
-      if (instance) {
-        tryDispose(instance);
-        cache2.delete(factory);
-        return true;
+    abort: () => {
+      if (controller.signal.aborted || ["success", "error"].includes(status)) {
+        return false;
       }
-      return false;
-    },
-    clear() {
-      for (const instance of cache2.values()) {
-        tryDispose(instance);
+      status = "aborted";
+      controller.abort();
+      const abortError = new AbortableAbortedError();
+      for (const [, pending] of takeState.pendingTakes) {
+        pending.reject(abortError);
       }
-      cache2.clear();
-    },
-    scope(scopeOptions = {}) {
-      return createResolver({
-        middleware: scopeOptions.middleware ?? middleware,
-        parent: resolver,
-        ...scopeOptions
-      });
+      takeState.pendingTakes.clear();
+      if (pauseState.resumeResolve) {
+        pauseState.resumeResolve();
+      }
+      return true;
     }
+  });
+}
+function abortable(fn) {
+  const wrapper = (...args) => {
+    return executeAbortable(fn, args);
   };
-  return resolver;
-}
-let defaultMiddlewareConfig = {};
-const container = function(options = {}) {
-  const middleware = [
-    ...defaultMiddlewareConfig.pre ?? [],
-    ...Array.isArray(options.middleware) ? options.middleware : options.middleware ? [options.middleware] : [],
-    ...defaultMiddlewareConfig.post ?? []
-  ];
-  const instancesById = /* @__PURE__ */ new Map();
-  const creationOrder = [];
-  const createEmitter = emitter();
-  const disposeEmitter = emitter();
-  const parent = options._parent;
-  let containerApi;
-  const internalResolver = createResolver({
-    middleware,
-    parent,
-    get invokeResolver() {
-      return containerApi;
-    }
+  wrapper.withSignal = (signal, ...args) => {
+    return executeAbortable(fn, args, signal);
+  };
+  wrapper.use = (wrapperFn) => {
+    const wrappedHandler = wrapperFn(fn);
+    return abortable(wrappedHandler);
+  };
+  wrapper.as = () => {
+    return wrapper;
+  };
+  Object.defineProperty(wrapper, abortableSymbol, {
+    value: true,
+    writable: false,
+    enumerable: false,
+    configurable: false
   });
-  function trackStore(spec, instance) {
-    instancesById.set(instance.id, instance);
-    creationOrder.push(spec);
-    if (typeof instance.onDispose === "function") {
-      instance.onDispose(() => {
-        disposeEmitter.emit(instance);
-        instancesById.delete(instance.id);
-        internalResolver.delete(spec);
-        const index = creationOrder.indexOf(spec);
-        if (index !== -1) {
-          creationOrder.splice(index, 1);
+  return wrapper;
+}
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
+}
+function toPromise(value) {
+  if (typeof value === "function") {
+    try {
+      const result = value();
+      return toPromise(result);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  if (isPromiseLike(value)) {
+    return Promise.resolve(value);
+  }
+  return Promise.resolve(value);
+}
+class AggregateErrorImpl extends Error {
+  constructor(errors2, message) {
+    super(message);
+    __publicField(this, "errors");
+    this.name = "AggregateError";
+    this.errors = errors2;
+  }
+}
+function promiseAny(promises) {
+  return new Promise((resolve, reject) => {
+    const promiseArray = Array.from(promises);
+    if (promiseArray.length === 0) {
+      reject(new AggregateErrorImpl([], "All promises were rejected"));
+      return;
+    }
+    const errors2 = [];
+    let rejectedCount = 0;
+    promiseArray.forEach((promise, index) => {
+      Promise.resolve(promise).then(resolve, (error) => {
+        errors2[index] = error;
+        rejectedCount++;
+        if (rejectedCount === promiseArray.length) {
+          reject(new AggregateErrorImpl(errors2, "All promises were rejected"));
         }
       });
+    });
+  });
+}
+function createSafe(getSignal, isCancelled) {
+  function wrapPromise(promise) {
+    return new Promise((resolve, reject) => {
+      promise.then(
+        (value) => {
+          if (!isCancelled()) {
+            resolve(value);
+          }
+        },
+        (error) => {
+          if (!isCancelled()) {
+            reject(error);
+          }
+        }
+      );
+    });
+  }
+  function wrapResult(result) {
+    if (isPromiseLike(result)) {
+      return wrapPromise(result);
     }
-    createEmitter.emit(instance);
+    return result;
   }
-  containerApi = {
-    [STORION_TYPE]: "container",
-    // Get by ID or factory/spec
-    get(specOrIdOrFactory) {
-      if (typeof specOrIdOrFactory === "string") {
-        return instancesById.get(specOrIdOrFactory);
-      }
-      const wasCached = internalResolver.has(specOrIdOrFactory);
-      const instance = untrack(() => internalResolver.get(specOrIdOrFactory));
-      if (!wasCached && isSpec(specOrIdOrFactory)) {
-        trackStore(specOrIdOrFactory, instance);
-      }
-      return instance;
-    },
-    create(specOrFactory, ...args) {
-      const instance = untrack(
-        () => internalResolver.create(specOrFactory, ...args)
-      );
-      if (isSpec(specOrFactory)) {
-        const storeInstance = instance;
-        instancesById.set(storeInstance.id, storeInstance);
-        if (typeof storeInstance.onDispose === "function") {
-          storeInstance.onDispose(() => {
-            disposeEmitter.emit(storeInstance);
-            instancesById.delete(storeInstance.id);
-          });
-        }
-      }
-      return instance;
-    },
-    set(spec, override) {
-      const existing = internalResolver.tryGet(spec);
-      tryDispose(existing);
-      internalResolver.set(spec, override);
-    },
-    has(spec) {
-      return internalResolver.has(spec);
-    },
-    tryGet(spec) {
-      return internalResolver.tryGet(spec);
-    },
-    delete(spec) {
-      const instance = internalResolver.tryGet(spec);
-      if (instance) {
-        tryDispose(instance);
-        return true;
+  function wrapInput(input) {
+    return wrapPromise(toPromise(input));
+  }
+  function safe(input, ...args) {
+    if (isCancelled()) {
+      if (isPromiseLike(input)) {
+        return new Promise(() => {
+        });
       }
-      return false;
-    },
-    clear() {
-      const specs = [...creationOrder].reverse();
-      for (const spec of specs) {
-        const instance = internalResolver.tryGet(spec);
-        tryDispose(instance);
-      }
-      internalResolver.clear();
-      instancesById.clear();
-      creationOrder.length = 0;
-    },
-    dispose(spec) {
-      return containerApi.delete(spec);
-    },
-    scope(scopeOptions = {}) {
-      return container({
-        middleware: scopeOptions.middleware ?? middleware,
-        _parent: containerApi
+    }
+    if (isPromiseLike(input)) {
+      return wrapPromise(input);
+    }
+    if (isAbortable(input)) {
+      const signal = getSignal();
+      const result = input.withSignal(signal, ...args);
+      return wrapResult(result);
+    }
+    if (typeof input === "function") {
+      const result = input(...args);
+      return wrapResult(result);
+    }
+    return input;
+  }
+  const all = (inputs) => {
+    if (isCancelled()) {
+      return new Promise(() => {
       });
-    },
-    onCreate: createEmitter.on,
-    onDispose: disposeEmitter.on
+    }
+    if (Array.isArray(inputs)) {
+      return Promise.all(inputs.map(wrapInput));
+    }
+    const obj = inputs;
+    const keys2 = Object.keys(obj);
+    return Promise.all(keys2.map((k) => wrapInput(obj[k]))).then(
+      (values) => Object.fromEntries(keys2.map((k, i) => [k, values[i]]))
+    );
   };
-  return containerApi;
-};
-const defaultsFn = (config = {}) => {
-  defaultMiddlewareConfig = {
-    pre: [...defaultMiddlewareConfig.pre ?? [], ...config.pre ?? []],
-    post: [...defaultMiddlewareConfig.post ?? [], ...config.post ?? []]
+  const race = (inputs) => {
+    if (isCancelled()) {
+      return new Promise(() => {
+      });
+    }
+    if (Array.isArray(inputs)) {
+      return Promise.race(inputs.map(wrapInput));
+    }
+    const obj = inputs;
+    const keys2 = Object.keys(obj);
+    return Promise.race(
+      keys2.map((k) => wrapInput(obj[k]).then((v) => [k, v]))
+    );
   };
-};
-defaultsFn.clear = () => {
-  defaultMiddlewareConfig = {};
-};
-container.defaults = defaultsFn;
-let pickIdCounter = 0;
-function pick(selector, equality2) {
-  var _a;
-  const parentHooks = getHooks();
-  if (!parentHooks.onRead) {
-    throw new HooksContextError("pick", "an effect or useStore selector");
-  }
-  const equalityFn = resolveEquality(equality2);
-  const currentReads = [];
-  const evaluate = () => {
-    currentReads.length = 0;
-    const value = withHooks(
-      {
-        onRead: (event) => {
-          currentReads.push(event);
-        }
-      },
-      selector
+  const settled = (inputs) => {
+    if (isCancelled()) {
+      return new Promise(() => {
+      });
+    }
+    if (Array.isArray(inputs)) {
+      return wrapPromise(Promise.allSettled(inputs.map(toPromise)));
+    }
+    const obj = inputs;
+    const keys2 = Object.keys(obj);
+    return wrapPromise(
+      Promise.allSettled(keys2.map((k) => toPromise(obj[k])))
+    ).then(
+      (results) => Object.fromEntries(keys2.map((k, i) => [k, results[i]]))
     );
-    return value;
   };
-  let currentValue = evaluate();
-  if (!currentReads.length) {
-    return currentValue;
-  }
-  const pickKey = `pick:${++pickIdCounter}`;
-  const subscribe = (listener) => {
-    const onCleanup = emitter();
-    const setupSubscriptions = () => {
-      for (const read of currentReads) {
-        const unsub = read.subscribe(handleChange);
-        onCleanup.on(unsub);
-      }
-    };
-    const clearSubscriptions = () => {
-      onCleanup.emitAndClear();
-    };
-    const handleChange = () => {
-      try {
-        const prevValue = currentValue;
-        clearSubscriptions();
-        currentValue = evaluate();
-        setupSubscriptions();
-        if (!equalityFn(prevValue, currentValue)) {
-          listener();
-        }
-      } catch (error) {
-        clearSubscriptions();
-        listener();
+  const any = (inputs) => {
+    if (isCancelled()) {
+      return new Promise(() => {
+      });
+    }
+    if (Array.isArray(inputs)) {
+      return wrapPromise(promiseAny(inputs.map(toPromise)));
+    }
+    const obj = inputs;
+    const keys2 = Object.keys(obj);
+    return wrapPromise(
+      promiseAny(
+        keys2.map((k) => toPromise(obj[k]).then((v) => [k, v]))
+      )
+    );
+  };
+  const callback = (cb) => {
+    return (...args) => {
+      if (isCancelled()) {
+        return;
       }
+      cb(...args);
     };
-    setupSubscriptions();
-    return clearSubscriptions;
   };
-  (_a = parentHooks.onRead) == null ? void 0 : _a.call(parentHooks, {
-    key: pickKey,
-    value: currentValue,
-    subscribe
+  return Object.assign(safe, {
+    all,
+    race,
+    settled,
+    any,
+    callback
   });
-  return currentValue;
 }
-function patternToPredicate(pattern) {
-  if (pattern instanceof RegExp) {
-    return (name) => pattern.test(name);
-  }
-  const startsWithWildcard = pattern.startsWith("*");
-  const endsWithWildcard = pattern.endsWith("*");
-  if (startsWithWildcard && endsWithWildcard) {
-    const substr = pattern.slice(1, -1);
-    return (name) => name.includes(substr);
-  }
-  if (startsWithWildcard) {
-    const suffix = pattern.slice(1);
-    return (name) => name.endsWith(suffix);
-  }
-  if (endsWithWildcard) {
-    const prefix = pattern.slice(0, -1);
-    return (name) => name.startsWith(prefix);
-  }
-  return (name) => name === pattern;
-}
-function patternsToPredicate(patterns) {
-  if (Array.isArray(patterns)) {
-    const predicates = patterns.map(patternToPredicate);
-    return (ctx) => ctx.displayName !== void 0 && predicates.some((p) => p(ctx.displayName));
-  }
-  const predicate = patternToPredicate(patterns);
-  return (ctx) => ctx.displayName !== void 0 && predicate(ctx.displayName);
-}
-function compose(...middlewares) {
-  if (middlewares.length === 0) {
-    return (ctx) => ctx.next();
-  }
-  if (middlewares.length === 1) {
-    return middlewares[0];
+const retryStrategy = {
+  /** Exponential backoff: 1s, 2s, 4s, 8s... (max 30s) */
+  backoff: (attempt) => Math.min(1e3 * 2 ** attempt, 3e4),
+  /** Linear: 1s, 2s, 3s, 4s... (max 30s) */
+  linear: (attempt) => Math.min(1e3 * (attempt + 1), 3e4),
+  /** Fixed 1 second delay */
+  fixed: () => 1e3,
+  /** Fibonacci: 1s, 1s, 2s, 3s, 5s, 8s... (max 30s) */
+  fibonacci: (attempt) => {
+    const fib = [1, 1, 2, 3, 5, 8, 13, 21, 30];
+    return Math.min(fib[attempt] ?? 30, 30) * 1e3;
+  },
+  /** Immediate retry (no delay) */
+  immediate: () => 0,
+  /** Add jitter (±30%) to any strategy */
+  withJitter: (strategy) => (attempt) => {
+    const base = strategy(attempt);
+    const jitter = base * 0.3 * (Math.random() * 2 - 1);
+    return Math.max(0, Math.round(base + jitter));
   }
-  return (ctx) => {
-    let index = 0;
-    const executeNext = () => {
-      if (index >= middlewares.length) {
-        return ctx.next();
+};
+class AsyncNotReadyError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "AsyncNotReadyError";
+  }
+}
+class AsyncAggregateError extends Error {
+  constructor(message, errors2) {
+    super(message);
+    this.errors = errors2;
+    this.name = "AsyncAggregateError";
+  }
+}
+function createEffectContext(nth, onRefresh) {
+  let cleanupEmitter = null;
+  let abortController = null;
+  let isStale = false;
+  const runCleanups = () => {
+    if (isStale) return;
+    isStale = true;
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    if (cleanupEmitter && cleanupEmitter.size > 0) {
+      cleanupEmitter.emitAndClearLifo();
+    }
+  };
+  const safe = createSafe(
+    () => abortController ? abortController.signal : void 0,
+    () => isStale
+  );
+  const context = {
+    nth,
+    get signal() {
+      if (!abortController) {
+        abortController = new AbortController();
       }
-      const currentMiddleware = middlewares[index];
-      index++;
-      const wrappedCtx = ctx.type === "store" ? { ...ctx, next: executeNext } : { ...ctx, next: executeNext };
-      return currentMiddleware(wrappedCtx);
-    };
-    return executeNext();
+      return abortController.signal;
+    },
+    onCleanup(listener) {
+      if (!cleanupEmitter) {
+        cleanupEmitter = emitter();
+      }
+      return cleanupEmitter.on(listener);
+    },
+    safe,
+    refresh() {
+      if (!isStale) {
+        onRefresh();
+      }
+    }
   };
-}
-function applyFor(predicateOrPatternsOrMap, middleware) {
-  if (typeof predicateOrPatternsOrMap === "object" && !Array.isArray(predicateOrPatternsOrMap) && !(predicateOrPatternsOrMap instanceof RegExp)) {
-    const entries = Object.entries(predicateOrPatternsOrMap);
-    const pairs = entries.map(([pattern, mw]) => ({
-      predicate: patternsToPredicate(pattern),
-      middleware: Array.isArray(mw) ? compose(...mw) : mw
-    }));
-    return (ctx) => {
-      for (const { predicate: predicate2, middleware: middleware2 } of pairs) {
-        if (predicate2(ctx)) {
-          return middleware2(ctx);
+  return Object.assign(context, { _runCleanups: runCleanups });
+}
+function resolveErrorStrategy(effectOptions) {
+  return (effectOptions == null ? void 0 : effectOptions.onError) ?? "keepAlive";
+}
+function getRetryDelay(config, attempt) {
+  const { delay = "backoff" } = config;
+  if (typeof delay === "string") {
+    return retryStrategy[delay](attempt);
+  }
+  if (typeof delay === "function") {
+    return delay(attempt);
+  }
+  return delay;
+}
+function effect(fn, options) {
+  let currentContext = null;
+  let subscriptionEmitter = null;
+  let isStarted = false;
+  let isRunning = false;
+  let isDisposed = false;
+  let runGeneration = 0;
+  let retryCount = 0;
+  let retryTimeout = null;
+  let errorStrategy = "keepAlive";
+  let onErrorCallback = null;
+  let prevTrackedDeps = /* @__PURE__ */ new Map();
+  let prevSubscriptionEmitter = null;
+  let trackedDeps = /* @__PURE__ */ new Map();
+  const writtenProps = /* @__PURE__ */ new Set();
+  let newTrackedDeps = null;
+  const getSubscriptionEmitter = () => {
+    if (!subscriptionEmitter) {
+      subscriptionEmitter = emitter();
+    }
+    return subscriptionEmitter;
+  };
+  const clearSubscriptions = () => {
+    if (subscriptionEmitter && subscriptionEmitter.size > 0) {
+      subscriptionEmitter.emitAndClear();
+    }
+  };
+  const areDepsChanged = (prev, next) => {
+    if (prev.size !== next.size) return true;
+    for (const key of next.keys()) {
+      if (!prev.has(key)) return true;
+    }
+    return false;
+  };
+  const subscribeToTrackedDeps = () => {
+    for (const [key, dep] of trackedDeps) {
+      if (writtenProps.has(key)) continue;
+      const unsub = dep.subscribe(() => {
+        scheduleNotification(execute, fn);
+      });
+      getSubscriptionEmitter().on(unsub);
+    }
+  };
+  const handleError = (error) => {
+    onErrorCallback == null ? void 0 : onErrorCallback(error);
+    if (errorStrategy === "failFast") {
+      throw error;
+    }
+    if (errorStrategy === "keepAlive") {
+      console.error("Effect error (keepAlive):", error);
+      if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
+        trackedDeps = new Map(prevTrackedDeps);
+        subscriptionEmitter = prevSubscriptionEmitter;
+        prevSubscriptionEmitter = null;
+        return;
+      }
+      if (newTrackedDeps && newTrackedDeps.size > 0) {
+        trackedDeps = newTrackedDeps;
+      }
+      subscribeToTrackedDeps();
+      return;
+    }
+    if (typeof errorStrategy === "function") {
+      const retry = () => {
+        retryCount++;
+        execute();
+      };
+      errorStrategy({ error, retry, retryCount });
+      return;
+    }
+    const retryConfig = errorStrategy;
+    if (retryCount < retryConfig.retries) {
+      const delay = getRetryDelay(retryConfig, retryCount);
+      retryCount++;
+      retryTimeout = setTimeout(() => {
+        retryTimeout = null;
+        execute();
+      }, delay);
+    } else {
+      console.error(
+        `Effect failed after ${retryConfig.retries} retries:`,
+        error
+      );
+    }
+  };
+  let cachedHooks = null;
+  const getTrackingHooks = (current2) => {
+    if (!cachedHooks) {
+      cachedHooks = {
+        ...current2,
+        onRead: (event) => {
+          var _a;
+          (_a = current2.onRead) == null ? void 0 : _a.call(current2, event);
+          if (!newTrackedDeps.has(event.key)) {
+            newTrackedDeps.set(event.key, {
+              key: event.key,
+              value: event.value,
+              subscribe: event.subscribe
+            });
+          }
+        },
+        onWrite: (event) => {
+          var _a;
+          (_a = current2.onWrite) == null ? void 0 : _a.call(current2, event);
+          writtenProps.add(event.key);
+        },
+        scheduleNotification: current2.scheduleNotification,
+        scheduleEffect: current2.scheduleEffect
+      };
+    }
+    return cachedHooks;
+  };
+  const execute = () => {
+    if (isDisposed || isRunning) return;
+    isRunning = true;
+    let shouldRefresh = false;
+    const currentGeneration = ++runGeneration;
+    try {
+      currentContext == null ? void 0 : currentContext._runCleanups();
+      currentContext = null;
+      if (subscriptionEmitter && subscriptionEmitter.size > 0) {
+        prevTrackedDeps = new Map(trackedDeps);
+        prevSubscriptionEmitter = subscriptionEmitter;
+        subscriptionEmitter = null;
+      }
+      newTrackedDeps = /* @__PURE__ */ new Map();
+      writtenProps.clear();
+      let lazyContext = null;
+      if (fn.length) {
+        lazyContext = createEffectContext(currentGeneration, () => {
+          if (isRunning) {
+            throw new EffectRefreshError();
+          }
+          execute();
+        });
+      }
+      withHooks(getTrackingHooks, () => {
+        const result = fn(lazyContext);
+        if (result !== null && result !== void 0 && typeof result.then === "function") {
+          throw new AsyncFunctionError(
+            "Effect function",
+            "Use ctx.safe(promise) for async operations instead of returning a Promise."
+          );
+        }
+        if (lazyContext && lazyContext.refresh === result) {
+          shouldRefresh = true;
+        }
+      });
+      currentContext = lazyContext;
+      retryCount = 0;
+      const depsChanged = areDepsChanged(trackedDeps, newTrackedDeps);
+      if (depsChanged) {
+        if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
+          prevSubscriptionEmitter.emitAndClear();
+        }
+        trackedDeps = newTrackedDeps;
+        subscribeToTrackedDeps();
+      } else {
+        if (prevSubscriptionEmitter) {
+          subscriptionEmitter = prevSubscriptionEmitter;
         }
       }
-      return ctx.next();
-    };
-  }
-  const predicate = typeof predicateOrPatternsOrMap === "function" ? predicateOrPatternsOrMap : patternsToPredicate(predicateOrPatternsOrMap);
-  const composedMiddleware = Array.isArray(middleware) ? compose(...middleware) : middleware;
-  return (ctx) => {
-    if (predicate(ctx)) {
-      return composedMiddleware(ctx);
+      prevTrackedDeps.clear();
+      prevSubscriptionEmitter = null;
+    } catch (error) {
+      if (error instanceof EffectRefreshError) {
+        throw error;
+      }
+      handleError(error);
+    } finally {
+      isRunning = false;
+    }
+    if (shouldRefresh) {
+      execute();
     }
-    return ctx.next();
   };
-}
-function applyExcept(predicateOrPatterns, middleware) {
-  const matchPredicate = typeof predicateOrPatterns === "function" ? predicateOrPatterns : patternsToPredicate(predicateOrPatterns);
-  const invertedPredicate = (ctx) => !matchPredicate(ctx);
-  return applyFor(invertedPredicate, middleware);
-}
-function forStores(storeMiddleware) {
-  const composedMiddleware = Array.isArray(storeMiddleware) ? compose(...storeMiddleware) : storeMiddleware;
-  return (ctx) => {
-    if (ctx.type === "store") {
-      return composedMiddleware(ctx);
+  const dispose = () => {
+    if (isDisposed) return;
+    isDisposed = true;
+    runGeneration++;
+    if (retryTimeout) {
+      clearTimeout(retryTimeout);
+      retryTimeout = null;
+    }
+    currentContext == null ? void 0 : currentContext._runCleanups();
+    currentContext = null;
+    clearSubscriptions();
+    if (prevSubscriptionEmitter && prevSubscriptionEmitter.size > 0) {
+      prevSubscriptionEmitter.emitAndClear();
     }
-    return ctx.next();
   };
-}
-const DEFAULT_KEY = {};
-const cache = /* @__PURE__ */ new Map();
-function getKeyCache(key) {
-  let keyCache = cache.get(key);
-  if (!keyCache) {
-    keyCache = /* @__PURE__ */ new WeakMap();
-    cache.set(key, keyCache);
-  }
-  return keyCache;
-}
-function trigger(keyOrFn, fnOrDepsOrOptions, depsOrFirstArg, ...restArgs) {
-  let key;
-  let fn;
-  let deps;
-  let equality2;
-  let args;
-  if (typeof fnOrDepsOrOptions === "function") {
-    key = keyOrFn;
-    fn = fnOrDepsOrOptions;
-    deps = depsOrFirstArg ?? [];
-    args = restArgs;
-  } else if (Array.isArray(fnOrDepsOrOptions)) {
-    key = DEFAULT_KEY;
-    fn = keyOrFn;
-    deps = fnOrDepsOrOptions;
-    args = depsOrFirstArg !== void 0 ? [depsOrFirstArg, ...restArgs] : [];
-  } else {
-    const options = fnOrDepsOrOptions ?? {};
-    key = options.key ?? DEFAULT_KEY;
-    fn = keyOrFn;
-    deps = options.deps ?? [];
-    equality2 = options.equality ? resolveEquality(options.equality) : void 0;
-    args = depsOrFirstArg !== void 0 ? [depsOrFirstArg, ...restArgs] : [];
-  }
-  const cacheKey = unwrapFn(fn);
-  const keyCache = getKeyCache(key);
-  const cached = keyCache.get(cacheKey);
-  const eq2 = equality2 ?? (cached == null ? void 0 : cached.equality) ?? shallowEqual;
-  if (cached && eq2(cached.deps, deps)) {
-    return cached.result;
-  }
-  const result = fn(...args);
-  keyCache.set(cacheKey, { deps, result, equality: equality2 });
-  return result;
-}
-trigger.clear = (key) => {
-  cache.delete(key);
-};
-trigger.clearAll = () => {
-  cache.clear();
-};
-function withMeta(factory, meta) {
-  return Object.assign(factory, {
-    meta: Array.isArray(meta) ? meta : [meta]
+  const start = (runOptions) => {
+    if (isStarted) return;
+    isStarted = true;
+    errorStrategy = resolveErrorStrategy(options);
+    onErrorCallback = (runOptions == null ? void 0 : runOptions.onError) ?? null;
+    execute();
+  };
+  getHooks().scheduleEffect((runOptions) => {
+    start(runOptions);
+    return dispose;
   });
+  return dispose;
 }
 export {
-  withMeta as A,
-  STORION_TYPE as S,
-  is$1 as a,
-  isStorion as b,
-  container as c,
-  isContainer as d,
-  isStore as e,
-  isFocus as f,
-  getKind as g,
-  isAction as h,
+  AsyncNotReadyError as A,
+  pool as B,
+  tryDispose as C,
+  unwrapFn as D,
+  EffectRefreshError as E,
+  HooksContextError as H,
+  InvalidActionError as I,
+  LifetimeMismatchError as L,
+  ProviderMissingError as P,
+  SetupPhaseError as S,
+  store as a,
+  AsyncAggregateError as b,
+  createSafe as c,
+  AsyncFunctionError as d,
+  effect as e,
+  isAbortable as f,
+  abortable as g,
+  strictEqual as h,
   isSpec as i,
-  isStoreContext as j,
-  isSelectorContext as k,
-  createResolver as l,
-  applyFor as m,
-  applyExcept as n,
-  forStores as o,
+  ScopedOutsideSelectorError as j,
+  STORION_TYPE as k,
+  resolveEquality as l,
+  is$1 as m,
+  batch as n,
+  equality as o,
   pick as p,
-  equality as q,
-  resolveEquality as r,
-  store as s,
-  shallowEqual as t,
-  deepEqual as u,
-  strictEqual as v,
-  trigger as w,
-  wrapFn as x,
-  unwrapFn as y,
-  isWrappedFn as z
+  shallowEqual as q,
+  retryStrategy as r,
+  storeTuple as s,
+  tryStabilize as t,
+  untrack as u,
+  deepEqual as v,
+  withHooks as w,
+  StorionError as x,
+  StoreDisposedError as y,
+  LocalStoreDependencyError as z
 };