storion 0.7.10 → 0.8.0

package/dist/async/index.js

@@ -1,5 +1,4 @@
-import { e as effect } from "../effect-ByI1oRBq.js";
-import { u as untrack, A as AsyncFunctionError } from "../emitter-XwTUpyGv.js";
+import { e as effect, u as untrack, A as AsyncFunctionError } from "../effect-C6h0PDDI.js";
 class AsyncNotReadyError extends Error {
   constructor(message, status) {
     super(message);

package/dist/core/container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../src/core/container.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAML,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAEhB,MAAM,UAAU,CAAC;AAYlB,UAAU,uBAAuB;IAC/B,sDAAsD;IACtD,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC;IACnB,qDAAqD;IACrD,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;CACrB;AAYD;;GAEG;AACH,UAAU,WAAW;IACnB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,cAAc,CAAC;IAC7C;;OAEG;IACH,QAAQ,EAAE;QACR,CAAC,MAAM,CAAC,EAAE,uBAAuB,GAAG,IAAI,CAAC;QACzC,KAAK,IAAI,IAAI,CAAC;KACf,CAAC;CACH;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE,WAkLvB,CAAC"}
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../src/core/container.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAML,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAEhB,MAAM,UAAU,CAAC;AAYlB,UAAU,uBAAuB;IAC/B,sDAAsD;IACtD,GAAG,CAAC,EAAE,UAAU,EAAE,CAAC;IACnB,qDAAqD;IACrD,IAAI,CAAC,EAAE,UAAU,EAAE,CAAC;CACrB;AAYD;;GAEG;AACH,UAAU,WAAW;IACnB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,cAAc,CAAC;IAC7C;;OAEG;IACH,QAAQ,EAAE;QACR,CAAC,MAAM,CAAC,EAAE,uBAAuB,GAAG,IAAI,CAAC;QACzC,KAAK,IAAI,IAAI,CAAC;KACf,CAAC;CACH;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,EAAE,WAsLvB,CAAC"}

package/dist/core/createResolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createResolver.d.ts","sourceRoot":"","sources":["../../src/core/createResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EACV,OAAO,EAEP,UAAU,EACV,QAAQ,EACR,eAAe,EAIhB,MAAM,UAAU,CAAC;AAKlB,YAAY,EACV,OAAO,EACP,UAAU,EACV,iBAAiB,EACjB,QAAQ,EACR,eAAe,GAChB,MAAM,UAAU,CAAC;AAmClB;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,eAAoB,GAAG,QAAQ,CA6JtE;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAClB,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,EACxC,UAAU,EAAE,UAAU,GACrB,UAAU,CAOZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,SAAa,GAAG,UAAU,CAUvE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,GACpD,UAAU,CAMZ"}
+{"version":3,"file":"createResolver.d.ts","sourceRoot":"","sources":["../../src/core/createResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EACV,OAAO,EAEP,UAAU,EACV,QAAQ,EACR,eAAe,EAIhB,MAAM,UAAU,CAAC;AAMlB,YAAY,EACV,OAAO,EACP,UAAU,EACV,iBAAiB,EACjB,QAAQ,EACR,eAAe,GAChB,MAAM,UAAU,CAAC;AAmClB;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,eAAoB,GAAG,QAAQ,CAiKtE;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAClB,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,EACxC,UAAU,EAAE,UAAU,GACrB,UAAU,CAOZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,SAAa,GAAG,UAAU,CAUvE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,GACpD,UAAU,CAMZ"}

package/dist/core/middleware.d.ts

@@ -1,12 +1,7 @@
-import { Middleware, MiddlewareContext, StoreMiddlewareContext } from '../types';
+import { Middleware, MiddlewareContext, StoreMiddleware } from '../types';
 
 /** Pattern type for matching displayName */
 export type SpecPattern = string | RegExp;
-/**
- * Compose multiple middleware into one.
- * Middleware are applied in order (first middleware wraps the chain).
- */
-export declare function compose(...middlewares: Middleware[]): Middleware;
 /**
  * Conditionally apply middleware based on a predicate or pattern(s).
  *
@@ -52,7 +47,7 @@ export declare function compose(...middlewares: Middleware[]): Middleware;
  * ```
  */
 export declare function applyFor(predicate: (ctx: MiddlewareContext) => boolean, middleware: Middleware | Middleware[]): Middleware;
-export declare function applyFor(patterns: SpecPattern | SpecPattern[], middleware: Middleware | Middleware[]): Middleware;
+export declare function applyFor(patterns: SpecPattern | SpecPattern[], middleware: StoreMiddleware | StoreMiddleware[]): Middleware;
 /**
  * Apply middleware to all except those matching predicate or pattern(s).
  *
@@ -97,5 +92,5 @@ export declare function applyExcept(patterns: SpecPattern | SpecPattern[], middl
  * });
  * ```
  */
-export declare function forStores(storeMiddleware: (ctx: StoreMiddlewareContext) => unknown): Middleware;
+export declare function forStores(storeMiddleware: StoreMiddleware | StoreMiddleware[]): Middleware;
 //# sourceMappingURL=middleware.d.ts.map

package/dist/core/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/core/middleware.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,sBAAsB,EACvB,MAAM,UAAU,CAAC;AAElB,4CAA4C;AAC5C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AA2D1C;;;GAGG;AACH,wBAAgB,OAAO,CAAC,GAAG,WAAW,EAAE,UAAU,EAAE,GAAG,UAAU,CA6BhE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,OAAO,EAC9C,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AACd,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,EACrC,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AA4Bd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,WAAW,CACzB,SAAS,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,OAAO,EAC9C,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AACd,wBAAgB,WAAW,CACzB,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,EACrC,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AAmBd;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,eAAe,EAAE,CAAC,GAAG,EAAE,sBAAsB,KAAK,OAAO,GACxD,UAAU,CAOZ"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/core/middleware.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAEV,UAAU,EACV,iBAAiB,EACjB,eAAe,EAChB,MAAM,UAAU,CAAC;AAElB,4CAA4C;AAC5C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;AA8F1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,QAAQ,CACtB,SAAS,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,OAAO,EAC9C,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AACd,wBAAgB,QAAQ,CACtB,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,EACrC,UAAU,EAAE,eAAe,GAAG,eAAe,EAAE,GAC9C,UAAU,CAAC;AA4Bd;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,WAAW,CACzB,SAAS,EAAE,CAAC,GAAG,EAAE,iBAAiB,KAAK,OAAO,EAC9C,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AACd,wBAAgB,WAAW,CACzB,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,EACrC,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,GACpC,UAAU,CAAC;AAmBd;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,eAAe,EAAE,eAAe,GAAG,eAAe,EAAE,GACnD,UAAU,CAWZ"}

package/dist/core/store.d.ts

@@ -9,7 +9,7 @@ import { StateBase, ActionsBase, StoreSpec, StoreOptions, StoreInstance, Resolve
  *
  * Instances are created lazily via container.get() or by calling spec directly.
  */
-export declare function store<TState extends StateBase, TActions extends ActionsBase>(options: StoreOptions<TState, TActions>): StoreSpec<TState, TActions>;
+export declare function store<TState extends StateBase = StateBase, TActions extends ActionsBase = ActionsBase>(options: StoreOptions<TState, TActions>): StoreSpec<TState, TActions>;
 /** Options for creating store instance */
 export interface CreateStoreInstanceOptions {
     autoDispose?: AutoDisposeOptions;

package/dist/core/store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/core/store.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,QAAQ,EAKb,KAAK,kBAAkB,EACxB,MAAM,UAAU,CAAC;AA0BlB;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,MAAM,SAAS,SAAS,EAAE,QAAQ,SAAS,WAAW,EAC1E,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,GACtC,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CAqB7B;AAYD,0CAA0C;AAC1C,MAAM,WAAW,0BAA0B;IACzC,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,EAE5B,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,EACjC,QAAQ,EAAE,QAAQ,EAClB,eAAe,GAAE,0BAA+B,GAC/C,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,CAsrBjC"}
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/core/store.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,QAAQ,EAKb,KAAK,kBAAkB,EACxB,MAAM,UAAU,CAAC;AA0BlB;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CACnB,MAAM,SAAS,SAAS,GAAG,SAAS,EACpC,QAAQ,SAAS,WAAW,GAAG,WAAW,EAC1C,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,CA4BtE;AAYD,0CAA0C;AAC1C,MAAM,WAAW,0BAA0B;IACzC,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,WAAW,EAE5B,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,QAAQ,CAAC,EACjC,QAAQ,EAAE,QAAQ,EAClB,eAAe,GAAE,0BAA+B,GAC/C,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,CA2rBjC"}

package/dist/devtools/index.js

@@ -1,6 +1,4 @@
-import { S as STORION_TYPE } from "../is-KT6PknjJ.js";
-import { c as createStoreInstance } from "../store-C3dmtJ4u.js";
-import { e as emitter } from "../emitter-XwTUpyGv.js";
+import { e as emitter } from "../emitter-j4rC71vY.js";
 let snapshotIdCounter = 0;
 let eventIdCounter = 0;
 const DEFAULT_MAX_EVENTS = 200;
@@ -163,44 +161,26 @@ function devtoolsMiddleware(options = {}) {
     if (ctx.type !== "store") {
       return ctx.next();
     }
-    const { spec, resolver } = ctx;
-    return handleStoreCreation(
+    const { spec } = ctx;
+    const instance = ctx.next();
+    return enhanceStoreWithDevtools(
+      instance,
       spec,
-      resolver,
       registerStore,
       unregisterStore,
       recordStateChange
     );
   };
 }
-function handleStoreCreation(spec, resolver, registerStore, unregisterStore, recordStateChange) {
-  const originalSetup = spec.options.setup;
-  const modifiedOptions = {
-    ...spec.options,
-    setup: (context) => {
-      const originalActions = originalSetup(context);
-      const devtoolsActions = {
-        __revertState: (newState) => {
-          context.update(() => newState);
-        },
-        __takeSnapshot: () => {
-        }
-      };
-      return {
-        ...originalActions,
-        ...devtoolsActions
-      };
+function enhanceStoreWithDevtools(instance, spec, registerStore, unregisterStore, recordStateChange) {
+  const devtoolsActions = {
+    __revertState: (newState) => {
+      instance.hydrate(newState, { force: true });
+    },
+    __takeSnapshot: () => {
     }
   };
-  const modifiedSpec = function(r) {
-    return createStoreInstance(modifiedSpec, r, {});
-  };
-  Object.defineProperties(modifiedSpec, {
-    [STORION_TYPE]: { value: "store.spec", enumerable: false },
-    displayName: { value: spec.displayName, enumerable: true, writable: false },
-    options: { value: modifiedOptions, enumerable: true, writable: false }
-  });
-  const instance = modifiedSpec(resolver);
+  Object.assign(instance.actions, devtoolsActions);
   registerStore({
     id: instance.id,
     name: spec.displayName,

package/dist/devtools/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/devtools/middleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,UAAU,EAKX,MAAM,UAAU,CAAC;AAIlB,OAAO,KAAK,EACV,kBAAkB,EAClB,yBAAyB,EAE1B,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,GAAE,yBAA8B,GACtC,UAAU,CAoDZ;AAwGD;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,kBAAkB,GAAG,SAAS,CAKtE"}
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/devtools/middleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,UAAU,EAIX,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EACV,kBAAkB,EAClB,yBAAyB,EAE1B,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,GAAE,yBAA8B,GACtC,UAAU,CAwDZ;AA2ED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,kBAAkB,GAAG,SAAS,CAKtE"}

package/dist/{effect-ByI1oRBq.js → effect-C6h0PDDI.js}

@@ -1,6 +1,143 @@
-import { g as getHooks, E as EffectRefreshError, w as withHooks, A as AsyncFunctionError, s as scheduleNotification, e as emitter } from "./emitter-XwTUpyGv.js";
-function isPromiseLike(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+import { e as emitter } from "./emitter-j4rC71vY.js";
+import { i as isPromiseLike } from "./isPromiseLike-bFkfHAbm.js";
+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";
+  }
+}
+let globalHooks = {
+  scheduleNotification(notify) {
+    notify();
+  },
+  scheduleEffect(runEffect) {
+    runEffect();
+  }
+};
+function getHooks() {
+  return globalHooks;
+}
+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(
+    (current) => ({
+      ...current,
+      scheduleNotification: (notify, key) => {
+        const actualKey = key ?? notify;
+        pending.set(actualKey, notify);
+      }
+    }),
+    fn,
+    // Flush on finish
+    () => {
+      for (const notify of pending.values()) {
+        notify();
+      }
+    }
+  );
 }
 function createEffectContext(nth, onRefresh) {
   let cleanupEmitter = null;
@@ -286,5 +423,24 @@ function effect(fn, options) {
   return dispose;
 }
 export {
-  effect as e
+  AsyncFunctionError as A,
+  EffectRefreshError as E,
+  HooksContextError as H,
+  InvalidActionError as I,
+  LocalStoreDependencyError as L,
+  ProviderMissingError as P,
+  StorionError as S,
+  SetupPhaseError as a,
+  batch as b,
+  LifetimeMismatchError as c,
+  StoreDisposedError as d,
+  effect as e,
+  hasWriteHook as f,
+  trackWrite as g,
+  hasReadHook as h,
+  getHooks as i,
+  scheduleNotification as s,
+  trackRead as t,
+  untrack as u,
+  withHooks as w
 };

package/dist/{emitter-XwTUpyGv.js → emitter-j4rC71vY.js}

@@ -1,142 +1,3 @@
-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";
-  }
-}
-let globalHooks = {
-  scheduleNotification(notify) {
-    notify();
-  },
-  scheduleEffect(runEffect) {
-    runEffect();
-  }
-};
-function getHooks() {
-  return globalHooks;
-}
-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(
-    (current) => ({
-      ...current,
-      scheduleNotification: (notify, key) => {
-        const actualKey = key ?? notify;
-        pending.set(actualKey, notify);
-      }
-    }),
-    fn,
-    // Flush on finish
-    () => {
-      for (const notify of pending.values()) {
-        notify();
-      }
-    }
-  );
-}
 function emitter(initialListeners) {
   const listeners = /* @__PURE__ */ new Set([]);
   let settledPayload;
@@ -285,24 +146,5 @@ function emitter(initialListeners) {
   };
 }
 export {
-  AsyncFunctionError as A,
-  EffectRefreshError as E,
-  HooksContextError as H,
-  InvalidActionError as I,
-  LocalStoreDependencyError as L,
-  ProviderMissingError as P,
-  StorionError as S,
-  SetupPhaseError as a,
-  batch as b,
-  LifetimeMismatchError as c,
-  StoreDisposedError as d,
-  emitter as e,
-  hasWriteHook as f,
-  getHooks as g,
-  hasReadHook as h,
-  trackWrite as i,
-  scheduleNotification as s,
-  trackRead as t,
-  untrack as u,
-  withHooks as w
+  emitter as e
 };