storion 0.7.10 → 0.8.1

package/CHANGELOG.md

@@ -0,0 +1,220 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- `MetaEntry.fields` now supports arrays for applying meta to multiple fields at once
+  ```ts
+  meta: [notPersisted.for(["password", "token"])]
+  ```
+
+---
+
+## [0.8.0] - 2024-12-21
+
+### Added
+- **Persist Module** (`storion/persist`)
+  - `persistMiddleware(options)` for automatic state persistence
+  - `notPersisted` meta for excluding stores or fields from persistence
+  - Supports sync and async `load`/`save` handlers
+  - `force` option to override dirty state during hydration
+- **Meta System**
+  - `meta()` function for creating typed metadata builders
+  - `MetaType.for(field)` and `MetaType.for([fields])` for field-level meta
+  - `MetaQuery` with `.all()` and `.any()` query methods
+  - `withMeta(factory, entries)` for attaching meta to factories
+  - Meta available in middleware via `ctx.meta(type)`
+- **Middleware Utilities**
+  - `forStores(middleware)` helper for store-only middleware
+  - `applyFor(patterns, middleware)` for conditional middleware
+  - `applyExcept(patterns, middleware)` for exclusion patterns
+- `store.hydrate(state, { force })` - force option to override dirty properties
+
+### Changed
+- `StoreMiddlewareContext` now includes `meta` property for querying store metadata
+- `FactoryMiddlewareContext` now includes `meta` property for querying factory metadata
+
+---
+
+## [0.7.0] - 2024-12-15
+
+### Added
+- **DevTools Module** (`storion/devtools`)
+  - `devtoolsMiddleware()` for state inspection
+  - `__revertState` and `__takeSnapshot` injected actions
+  - State history tracking with configurable `maxHistory`
+  - DevTools panel (`storion/devtools-panel`)
+- **withStore HOC** for React
+  - Separates data selection from rendering
+  - Automatic memoization
+  - Direct mode and HOC mode
+- `createWithStore(useContextHook)` factory for custom `withStore` implementations
+- `create()` shorthand for single-store apps returning `[instance, useHook, withStore]`
+
+### Changed
+- Improved TypeScript inference for store actions
+
+---
+
+## [0.6.0] - 2024-12-01
+
+### Added
+- **Async Module** (`storion/async`)
+  - `async.fresh<T>()` - throws during loading (Suspense-compatible)
+  - `async.stale<T>(initialData)` - returns stale data during loading
+  - `async.wait(state)` - extracts data or throws
+  - Automatic request cancellation via `ctx.signal`
+  - `ctx.safe(promise)` for effect-safe async operations
+- `trigger(action, deps, ...args)` for declarative data fetching in components
+
+### Changed
+- Effects now require synchronous functions (use `ctx.safe()` for async)
+
+---
+
+## [0.5.0] - 2024-11-15
+
+### Added
+- **Focus (Lens-like Access)**
+  - `focus(path)` for nested state access
+  - Returns `[getter, setter]` tuple
+  - Type-safe path inference
+- **Reactive Effects**
+  - `effect(fn, options)` with automatic dependency tracking
+  - `ctx.cleanup()` for teardown logic
+  - `ctx.refresh()` for manual re-execution
+  - Error handling strategies: `"throw"`, `"ignore"`, `"retry"`
+- `batch(fn)` for batching multiple state updates
+- `untrack(fn)` for reading state without tracking
+
+---
+
+## [0.4.0] - 2024-11-01
+
+### Added
+- **Middleware System**
+  - `container({ middleware: [...] })` for middleware injection
+  - Middleware receives `MiddlewareContext` with `type`, `next`, `resolver`
+  - Discriminated union: `StoreMiddlewareContext` vs `FactoryMiddlewareContext`
+- `createLoggingMiddleware()` built-in middleware
+- `createValidationMiddleware()` built-in middleware
+
+### Changed
+- Container now uses middleware chain pattern
+
+---
+
+## [0.3.0] - 2024-10-15
+
+### Added
+- **Store Lifecycle**
+  - `lifetime: "keepAlive"` (default) - persists until container disposal
+  - `lifetime: "autoDispose"` - disposes when no subscribers
+  - `store.dispose()` method
+  - `store.subscribe(listener)` for change notifications
+- `store.dehydrate()` for serializing state
+- `store.hydrate(state)` for restoring state
+- `store.dirty` property tracking modified fields
+- `store.reset()` to restore initial state
+
+### Changed
+- Stores now track dirty state automatically
+
+---
+
+## [0.2.0] - 2024-10-01
+
+### Added
+- **Dependency Injection**
+  - `container()` for managing store instances
+  - `get(factory)` for resolving dependencies
+  - Services (plain factories) support
+  - `mixin(factory)` for setup-time composition
+- `StoreProvider` React component
+- `useContainer()` hook
+
+### Changed
+- Stores are now lazily instantiated via container
+
+---
+
+## [0.1.0] - 2024-09-15
+
+### Added
+- **Core Store**
+  - `store(options)` factory function
+  - `state` - reactive state object
+  - `actions` - returned from `setup()` function
+  - `update(producer)` for Immer-style nested updates
+- **React Integration**
+  - `useStore(selector)` hook with auto-tracking
+  - `useLocalStore(spec)` for component-scoped stores
+- **Reactivity**
+  - Proxy-based dependency tracking
+  - Fine-grained updates (only re-render on accessed properties)
+  - `pick(state, equality)` for custom comparison
+- **Type Safety**
+  - Full TypeScript support
+  - Inferred state and action types
+- **Equality Utilities**
+  - `strictEqual` (default)
+  - `shallowEqual`
+  - `deepEqual`
+
+---
+
+## Migration Guides
+
+### Migrating to 0.8.0
+
+#### Meta System Changes
+If you were using internal meta APIs, update to the new public API:
+
+```ts
+// Before (internal)
+spec.meta // was MetaEntry[]
+
+// After (0.8.0)
+ctx.meta(persistMeta).store    // query store-level
+ctx.meta(persistMeta).fields   // query field-level
+ctx.meta.all(type)             // get all values
+ctx.meta.any(type1, type2)     // check existence
+```
+
+### Migrating to 0.6.0
+
+#### Async Effects
+Effects must now be synchronous:
+
+```ts
+// Before (broken in 0.6.0)
+effect(async (ctx) => {
+  const data = await fetchData();
+  state.data = data;
+});
+
+// After
+effect((ctx) => {
+  ctx.safe(fetchData()).then((data) => {
+    state.data = data;
+  });
+});
+```
+
+---
+
+[Unreleased]: https://github.com/linq2js/storion/compare/v0.8.0...HEAD
+[0.8.0]: https://github.com/linq2js/storion/compare/v0.7.0...v0.8.0
+[0.7.0]: https://github.com/linq2js/storion/compare/v0.6.0...v0.7.0
+[0.6.0]: https://github.com/linq2js/storion/compare/v0.5.0...v0.6.0
+[0.5.0]: https://github.com/linq2js/storion/compare/v0.4.0...v0.5.0
+[0.4.0]: https://github.com/linq2js/storion/compare/v0.3.0...v0.4.0
+[0.3.0]: https://github.com/linq2js/storion/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/linq2js/storion/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/linq2js/storion/releases/tag/v0.1.0
+

package/README.md

@@ -17,6 +17,7 @@
 </p>
 
 <p align="center">
+  <a href="https://linq2js.github.io/storion/">📚 Documentation</a> •
   <a href="#features">Features</a> •
   <a href="#installation">Installation</a> •
   <a href="#quick-start">Quick Start</a> •

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

@@ -1,47 +1,7 @@
-import { Factory, Middleware, Resolver, ResolverOptions } from '../types';
+import { Resolver, ResolverOptions } from '../types';
 
-export type { Factory, Middleware, MiddlewareContext, Resolver, ResolverOptions, } from '../types';
 /**
  * Create a new resolver with optional middleware and parent.
  */
 export declare function createResolver(options?: ResolverOptions): Resolver;
-/**
- * Create a middleware that only applies to factories matching a predicate.
- *
- * @example
- * ```ts
- * const storeOnlyMiddleware = when(
- *   (factory) => is(factory, "store.spec"),
- *   (ctx) => {
- *     console.log("Creating store:", ctx.factory.name);
- *     return ctx.next();
- *   }
- * );
- * ```
- */
-export declare function when(predicate: (factory: Factory) => boolean, middleware: Middleware): Middleware;
-/**
- * Create a logging middleware for debugging.
- *
- * @example
- * ```ts
- * const app = createResolver({
- *   middleware: [createLoggingMiddleware("App")],
- * });
- * ```
- */
-export declare function createLoggingMiddleware(prefix?: string): Middleware;
-/**
- * Create a middleware that validates factory results.
- *
- * @example
- * ```ts
- * const validateMiddleware = createValidationMiddleware((result) => {
- *   if (result === null || result === undefined) {
- *     throw new Error("Factory returned null/undefined");
- *   }
- * });
- * ```
- */
-export declare function createValidationMiddleware(validate: (result: unknown, factory: Factory) => void): Middleware;
 //# sourceMappingURL=createResolver.d.ts.map

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,EAGV,QAAQ,EACR,eAAe,EAIhB,MAAM,UAAU,CAAC;AAsClB;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,eAAoB,GAAG,QAAQ,CAiKtE"}

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
 };