storion 0.2.3 → 0.4.0

package/dist/storion.js

@@ -1,12 +1,812 @@
-import { d, a, b, f, c, e, p, s, u } from "./index-rLf6DusB.js";
+import { e as emitter, i as isSpec, S as STORION_TYPE, u as untrack, y as getHooks, w as withHooks, r as resolveEquality, z as scheduleNotification, v as unwrapFn, o as shallowEqual } from "./store-Yv-9gPVf.js";
+import { m, p, n, g, a, j, d, h, l, f, k, b, x, s, q, t } from "./store-Yv-9gPVf.js";
+let defaultMiddlewareConfig = {};
+const container = function(options = {}) {
+  const middleware = [
+    ...defaultMiddlewareConfig.pre ?? [],
+    ...options.middleware ?? [],
+    ...defaultMiddlewareConfig.post ?? []
+  ];
+  const cache2 = /* @__PURE__ */ new Map();
+  const factoryCache = /* @__PURE__ */ new Map();
+  const instancesById = /* @__PURE__ */ new Map();
+  const overrides = /* @__PURE__ */ new Map();
+  const factoryOverrides = /* @__PURE__ */ new Map();
+  const creationOrder = [];
+  const createEmitter = emitter();
+  const disposeEmitter = emitter();
+  const creating = /* @__PURE__ */ new Set();
+  const creatingFactories = /* @__PURE__ */ new Set();
+  const parent = options._parent;
+  const resolve = (spec) => overrides.get(spec) ?? spec;
+  function buildMiddlewareChain() {
+    return (spec) => {
+      let index = 0;
+      const executeNext = () => {
+        if (index >= middleware.length) {
+          return spec(containerApi);
+        }
+        const currentMiddleware = middleware[index];
+        index++;
+        const ctx = {
+          spec,
+          factory: spec,
+          resolver: containerApi,
+          next: executeNext,
+          displayName: spec.displayName
+        };
+        return currentMiddleware(ctx);
+      };
+      return executeNext();
+    };
+  }
+  const createWithMiddleware = buildMiddlewareChain();
+  function createInstance(spec) {
+    const instance = untrack(() => createWithMiddleware(spec));
+    if (typeof instance.onDispose === "function") {
+      instance.onDispose(() => {
+        disposeEmitter.emit(instance);
+        cache2.delete(spec);
+        instancesById.delete(instance.id);
+        const index = creationOrder.indexOf(spec);
+        if (index !== -1) {
+          creationOrder.splice(index, 1);
+        }
+      });
+    }
+    return instance;
+  }
+  const containerApi = {
+    [STORION_TYPE]: "container",
+    // ========================================================================
+    // Resolver Methods
+    // ========================================================================
+    // Implementation handles multiple overloads
+    get(specOrIdOrFactory) {
+      if (typeof specOrIdOrFactory === "string") {
+        return instancesById.get(specOrIdOrFactory);
+      }
+      if (!isSpec(specOrIdOrFactory)) {
+        const factory = specOrIdOrFactory;
+        if (factoryCache.has(factory)) {
+          return factoryCache.get(factory);
+        }
+        if (parent && factoryOverrides.size === 0 && "tryGet" in parent && typeof parent.tryGet === "function") {
+          const parentInstance = parent.tryGet(factory);
+          if (parentInstance !== void 0) {
+            return parentInstance;
+          }
+        }
+        if (creatingFactories.has(factory)) {
+          const name = factory.name || "anonymous";
+          throw new Error(
+            `Circular dependency detected: factory "${name}" is being created while already in creation stack.`
+          );
+        }
+        creatingFactories.add(factory);
+        try {
+          const mapped = factoryOverrides.get(factory) ?? factory;
+          const instance = mapped(containerApi);
+          factoryCache.set(factory, instance);
+          return instance;
+        } finally {
+          creatingFactories.delete(factory);
+        }
+      }
+      const spec = specOrIdOrFactory;
+      if (cache2.has(spec)) {
+        return cache2.get(spec);
+      }
+      if (parent && overrides.size === 0 && parent.has(spec)) {
+        return parent.get(spec);
+      }
+      if (creating.has(spec)) {
+        const name = spec.displayName ?? "unknown";
+        throw new Error(
+          `Circular dependency detected: "${name}" is being created while already in creation stack.`
+        );
+      }
+      creating.add(spec);
+      try {
+        const mapped = resolve(spec);
+        const instance = createInstance(mapped);
+        cache2.set(spec, instance);
+        instancesById.set(instance.id, instance);
+        creationOrder.push(spec);
+        createEmitter.emit(instance);
+        return instance;
+      } finally {
+        creating.delete(spec);
+      }
+    },
+    // Implementation handles both StoreSpec and Factory overloads
+    create(specOrFactory) {
+      if (!isSpec(specOrFactory)) {
+        const factory = specOrFactory;
+        const mapped2 = factoryOverrides.get(factory) ?? factory;
+        return mapped2(containerApi);
+      }
+      const mapped = resolve(specOrFactory);
+      return createInstance(mapped);
+    },
+    set(spec, override) {
+      overrides.set(spec, override);
+      const existing = cache2.get(spec);
+      if (existing) {
+        existing.dispose();
+      }
+    },
+    has(spec) {
+      const inParent = parent && overrides.size === 0 && parent.has(spec);
+      return cache2.has(spec) || (inParent ?? false);
+    },
+    tryGet(spec) {
+      if (cache2.has(spec)) {
+        return cache2.get(spec);
+      }
+      if (parent && overrides.size === 0) {
+        return parent.tryGet(spec);
+      }
+      return void 0;
+    },
+    delete(spec) {
+      const instance = cache2.get(spec);
+      if (instance) {
+        instance.dispose();
+        return true;
+      }
+      return false;
+    },
+    // ========================================================================
+    // Container-Specific Methods
+    // ========================================================================
+    clear() {
+      const specs = [...creationOrder].reverse();
+      for (const spec of specs) {
+        const instance = cache2.get(spec);
+        if (instance) {
+          instance.dispose();
+        }
+      }
+      cache2.clear();
+      instancesById.clear();
+      creationOrder.length = 0;
+    },
+    dispose(spec) {
+      return containerApi.delete(spec);
+    },
+    scope(scopeOptions = {}) {
+      return container({
+        middleware: scopeOptions.middleware ?? middleware,
+        _parent: containerApi
+      });
+    },
+    onCreate: createEmitter.on,
+    onDispose: disposeEmitter.on
+  };
+  return containerApi;
+};
+const defaultsFn = (config = {}) => {
+  defaultMiddlewareConfig = {
+    pre: [...defaultMiddlewareConfig.pre ?? [], ...config.pre ?? []],
+    post: [...defaultMiddlewareConfig.post ?? [], ...config.post ?? []]
+  };
+};
+defaultsFn.clear = () => {
+  defaultMiddlewareConfig = {};
+};
+container.defaults = defaultsFn;
+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 createResolver(options = {}) {
+  const { middleware = [], parent } = options;
+  const cache2 = /* @__PURE__ */ new Map();
+  const overrides = /* @__PURE__ */ new Map();
+  const resolve = (factory) => overrides.get(factory) ?? factory;
+  const invoke = (factory, resolver2) => {
+    const displayName = extractDisplayName(factory);
+    const chain = middleware.reduceRight(
+      (next, mw) => () => mw({
+        factory,
+        resolver: resolver2,
+        next,
+        displayName
+      }),
+      () => factory(resolver2)
+    );
+    return chain();
+  };
+  const resolver = {
+    get(factory) {
+      if (cache2.has(factory)) {
+        return cache2.get(factory);
+      }
+      if (parent && overrides.size === 0 && parent.has(factory)) {
+        return parent.get(factory);
+      }
+      const instance = invoke(resolve(factory), resolver);
+      cache2.set(factory, instance);
+      return instance;
+    },
+    create(factory) {
+      return invoke(resolve(factory), resolver);
+    },
+    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);
+    },
+    tryGet(factory) {
+      if (cache2.has(factory)) {
+        return cache2.get(factory);
+      }
+      if (parent && overrides.size === 0) {
+        return parent.tryGet(factory);
+      }
+      return void 0;
+    },
+    delete(factory) {
+      const instance = cache2.get(factory);
+      if (instance) {
+        if (instance && typeof instance === "object" && "dispose" in instance && typeof instance.dispose === "function") {
+          instance.dispose();
+        }
+        cache2.delete(factory);
+        return true;
+      }
+      return false;
+    },
+    clear() {
+      for (const instance of cache2.values()) {
+        if (instance && typeof instance === "object" && "dispose" in instance && typeof instance.dispose === "function") {
+          instance.dispose();
+        }
+      }
+      cache2.clear();
+    },
+    scope(scopeOptions = {}) {
+      return createResolver({
+        middleware: scopeOptions.middleware ?? middleware,
+        parent: resolver,
+        ...scopeOptions
+      });
+    }
+  };
+  return resolver;
+}
+function when(predicate, middleware) {
+  return (ctx) => {
+    if (predicate(ctx.factory)) {
+      return middleware(ctx);
+    }
+    return ctx.next();
+  };
+}
+function createLoggingMiddleware(prefix = "Resolver") {
+  return (ctx) => {
+    const name = ctx.factory.name || "anonymous";
+    console.log(`[${prefix}] Creating: ${name}`);
+    const start = performance.now();
+    const result = ctx.next();
+    const duration = (performance.now() - start).toFixed(2);
+    console.log(`[${prefix}] Created: ${name} (${duration}ms)`);
+    return result;
+  };
+}
+function createValidationMiddleware(validate) {
+  return (ctx) => {
+    const result = ctx.next();
+    validate(result, ctx.factory);
+    return result;
+  };
+}
+let pickIdCounter = 0;
+function pick(selector, equality) {
+  var _a;
+  const parentHooks = getHooks();
+  if (!parentHooks.onRead) {
+    throw new Error(
+      "pick() must be called inside an effect or useStore selector. It requires an active hooks.onRead context."
+    );
+  }
+  const equalityFn = resolveEquality(equality);
+  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 isPromiseLike(value) {
+  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function createEffectContext(nth) {
+  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();
+    }
+  };
+  function wrapPromise(promise) {
+    return new Promise((resolve, reject) => {
+      promise.then(
+        (value) => {
+          if (!isStale) {
+            resolve(value);
+          }
+        },
+        (error) => {
+          if (!isStale) {
+            reject(error);
+          }
+        }
+      );
+    });
+  }
+  const context = {
+    nth,
+    get signal() {
+      if (!abortController) {
+        abortController = new AbortController();
+      }
+      return abortController.signal;
+    },
+    onCleanup(listener) {
+      if (!cleanupEmitter) {
+        cleanupEmitter = emitter();
+      }
+      return cleanupEmitter.on(listener);
+    },
+    safe(promiseOrCallback) {
+      if (promiseOrCallback instanceof Promise) {
+        return wrapPromise(promiseOrCallback);
+      }
+      return (...args) => {
+        if (!isStale) {
+          const result = promiseOrCallback(
+            ...args
+          );
+          if (isPromiseLike(result)) {
+            return wrapPromise(result);
+          }
+          return result;
+        }
+        return void 0;
+      };
+    }
+  };
+  return Object.assign(context, { _runCleanups: runCleanups });
+}
+function resolveErrorStrategy(effectOptions) {
+  return (effectOptions == null ? void 0 : effectOptions.onError) ?? "keepAlive";
+}
+function getRetryDelay(config, attempt) {
+  if (typeof config.delay === "function") {
+    return config.delay(attempt);
+  }
+  return config.delay ?? 100 * Math.pow(2, attempt);
+}
+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.maxRetries) {
+      const delay = getRetryDelay(retryConfig, retryCount);
+      retryCount++;
+      retryTimeout = setTimeout(() => {
+        retryTimeout = null;
+        execute();
+      }, delay);
+    } else {
+      console.error(
+        `Effect failed after ${retryConfig.maxRetries} retries:`,
+        error
+      );
+    }
+  };
+  let cachedHooks = null;
+  const getTrackingHooks = (current) => {
+    if (!cachedHooks) {
+      cachedHooks = {
+        ...current,
+        onRead: (event) => {
+          var _a;
+          (_a = current.onRead) == null ? void 0 : _a.call(current, event);
+          if (!newTrackedDeps.has(event.key)) {
+            newTrackedDeps.set(event.key, {
+              key: event.key,
+              value: event.value,
+              subscribe: event.subscribe
+            });
+          }
+        },
+        onWrite: (event) => {
+          var _a;
+          (_a = current.onWrite) == null ? void 0 : _a.call(current, event);
+          writtenProps.add(event.key);
+        },
+        scheduleNotification: current.scheduleNotification,
+        scheduleEffect: current.scheduleEffect
+      };
+    }
+    return cachedHooks;
+  };
+  const execute = () => {
+    if (isDisposed || isRunning) return;
+    isRunning = true;
+    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;
+      const getOrCreateContext = () => {
+        if (!lazyContext) {
+          lazyContext = createEffectContext(currentGeneration);
+        }
+        return lazyContext;
+      };
+      const lazyContextProxy = new Proxy({}, {
+        get(_, prop) {
+          return getOrCreateContext()[prop];
+        }
+      });
+      withHooks(getTrackingHooks, () => {
+        const result = fn(lazyContextProxy);
+        if (result !== null && result !== void 0 && typeof result.then === "function") {
+          throw new Error(
+            "Effect function must be synchronous. Use ctx.safe(promise) for async operations instead of returning a Promise."
+          );
+        }
+      });
+      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;
+        }
+      }
+      prevTrackedDeps.clear();
+      prevSubscriptionEmitter = null;
+    } catch (error) {
+      handleError(error);
+    } finally {
+      isRunning = false;
+    }
+  };
+  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();
+    }
+  };
+  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;
+}
+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) => predicates.some((p2) => p2(ctx.displayName));
+  }
+  const predicate = patternToPredicate(patterns);
+  return (ctx) => predicate(ctx.displayName);
+}
+function compose(...middlewares) {
+  if (middlewares.length === 0) {
+    return (ctx) => ctx.next();
+  }
+  if (middlewares.length === 1) {
+    return middlewares[0];
+  }
+  return (ctx) => {
+    let index = 0;
+    const executeNext = () => {
+      if (index >= middlewares.length) {
+        return ctx.next();
+      }
+      const currentMiddleware = middlewares[index];
+      index++;
+      const wrappedCtx = {
+        ...ctx,
+        next: executeNext
+      };
+      return currentMiddleware(wrappedCtx);
+    };
+    return executeNext();
+  };
+}
+function applyFor(predicateOrPatterns, middleware) {
+  const predicate = typeof predicateOrPatterns === "function" ? predicateOrPatterns : patternsToPredicate(predicateOrPatterns);
+  const composedMiddleware = Array.isArray(middleware) ? compose(...middleware) : middleware;
+  return (ctx) => {
+    if (isSpec(ctx.factory)) {
+      const spec = ctx.factory;
+      const storeMiddlewareCtx = {
+        ...ctx,
+        spec
+      };
+      if (predicate(storeMiddlewareCtx)) {
+        return composedMiddleware(
+          storeMiddlewareCtx
+        );
+      }
+    }
+    return ctx.next();
+  };
+}
+function applyExcept(predicateOrPatterns, middleware) {
+  const matchPredicate = typeof predicateOrPatterns === "function" ? predicateOrPatterns : patternsToPredicate(predicateOrPatterns);
+  const invertedPredicate = (ctx) => !matchPredicate(ctx);
+  return applyFor(invertedPredicate, middleware);
+}
+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 equality;
+  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 ?? [];
+    equality = 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 eq = equality ?? (cached == null ? void 0 : cached.equality) ?? shallowEqual;
+  if (cached && eq(cached.deps, deps)) {
+    return cached.result;
+  }
+  const result = fn(...args);
+  keyCache.set(cacheKey, { deps, result, equality });
+  return result;
+}
+trigger.clear = (key) => {
+  cache.delete(key);
+};
+trigger.clearAll = () => {
+  cache.clear();
+};
 export {
-  d as applyExcept,
-  a as applyFor,
-  b as batch,
-  f as compose,
-  c as container,
-  e as effect,
-  p as pick,
+  STORION_TYPE,
+  applyExcept,
+  applyFor,
+  m as batch,
+  compose,
+  container,
+  createLoggingMiddleware,
+  createResolver,
+  createValidationMiddleware,
+  p as deepEqual,
+  effect,
+  n as equality,
+  g as getKind,
+  a as is,
+  j as isAction,
+  d as isContainer,
+  h as isFocus,
+  l as isSelectorContext,
+  isSpec,
+  f as isStore,
+  k as isStoreContext,
+  b as isStorion,
+  x as isWrappedFn,
+  pick,
+  shallowEqual,
   s as store,
-  u as untrack
+  q as strictEqual,
+  trigger,
+  untrack,
+  unwrapFn,
+  when,
+  t as wrapFn
 };