storion 0.8.0 → 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/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;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"}
+{"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/{index-CIFKRy71.js → index-OPaTR3zq.js}

@@ -1,6 +1,6 @@
 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";
 import { e as emitter } from "./emitter-j4rC71vY.js";
-import "./meta-u3yOx5Kh.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;
@@ -2621,32 +2621,6 @@ function createResolver(options = {}) {
   };
   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 defaultMiddlewareConfig = {};
 const container = function(options = {}) {
   const middleware = [
@@ -2957,10 +2931,7 @@ function withMeta(factory, meta) {
   });
 }
 export {
-  wrapFn as A,
-  unwrapFn as B,
-  isWrappedFn as C,
-  withMeta as D,
+  withMeta as A,
   STORION_TYPE as S,
   is$1 as a,
   isStorion as b,
@@ -2974,18 +2945,18 @@ export {
   isStoreContext as j,
   isSelectorContext as k,
   createResolver as l,
-  createLoggingMiddleware as m,
-  createValidationMiddleware as n,
-  applyFor as o,
+  applyFor as m,
+  applyExcept as n,
+  forStores as o,
   pick as p,
-  applyExcept as q,
+  equality as q,
   resolveEquality as r,
   store as s,
-  forStores as t,
-  equality as u,
-  shallowEqual as v,
-  when as w,
-  deepEqual as x,
-  strictEqual as y,
-  trigger as z
+  shallowEqual as t,
+  deepEqual as u,
+  strictEqual as v,
+  trigger as w,
+  wrapFn as x,
+  unwrapFn as y,
+  isWrappedFn as z
 };

package/dist/index.d.ts

@@ -8,7 +8,7 @@ export { is, isStorion, getKind, isSpec, isContainer, isStore, isFocus, isAction
 export { store } from './core/store';
 export { container } from './core/container';
 export { batch, untrack } from './core/tracking';
-export { createResolver, when, createLoggingMiddleware, createValidationMiddleware, } from './core/createResolver';
+export { createResolver } from './core/createResolver';
 export { pick } from './core/pick';
 export { effect, type EffectFn, type EffectContext, type EffectOptions, type EffectErrorStrategy, type EffectErrorContext, type EffectRetryConfig, } from './core/effect';
 export { applyFor, applyExcept, forStores, type SpecPattern, } from './core/middleware';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,YAAY,EACZ,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,YAAY,EAEjB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAEf,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACb,KAAK,QAAQ,GACd,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,EAAE,EACF,SAAS,EACT,OAAO,EACP,MAAM,EACN,WAAW,EACX,OAAO,EACP,OAAO,EACP,QAAQ,EACR,cAAc,EACd,iBAAiB,GAClB,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EACL,cAAc,EACd,IAAI,EACJ,uBAAuB,EACvB,0BAA0B,GAC3B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,OAAO,EACL,MAAM,EACN,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,QAAQ,EACR,WAAW,EACX,SAAS,EACT,KAAK,WAAW,GACjB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAGzD,OAAO,EAAE,MAAM,IAAI,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG3E,OAAO,EACL,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EACL,YAAY,EACZ,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,YAAY,EAEjB,KAAK,SAAS,EACd,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,UAAU,EAEf,KAAK,OAAO,EACZ,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACb,KAAK,QAAQ,GACd,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,EAAE,EACF,SAAS,EACT,OAAO,EACP,MAAM,EACN,WAAW,EACX,OAAO,EACP,OAAO,EACP,QAAQ,EACR,cAAc,EACd,iBAAiB,GAClB,MAAM,MAAM,CAAC;AAGd,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAGjD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGvD,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEnC,OAAO,EACL,MAAM,EACN,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC;AAGvB,OAAO,EACL,QAAQ,EACR,WAAW,EACX,SAAS,EACT,KAAK,WAAW,GACjB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,WAAW,GACZ,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAGzD,OAAO,EAAE,MAAM,IAAI,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG3E,OAAO,EACL,YAAY,EACZ,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/meta/meta.d.ts

@@ -4,13 +4,35 @@ import { MetaType } from '../types';
  * Create a metadata builder for decorating stores with custom metadata.
  *
  * Meta allows libraries and users to attach arbitrary typed metadata to:
- * - Store level: `myMeta(value)` - applies to the entire store
- * - Field level: `myMeta.for("fieldName", value)` - applies to specific state field
+ * - Store level: `myMeta()` or `myMeta(value)` - applies to the entire store
+ * - Field level: `myMeta.for("fieldName")` or `myMeta.for("fieldName", value)` - applies to specific field
  *
- * Retrieve meta via `ctx.meta(type)` which returns first value (default),
- * or use `ctx.meta.all(type)` for all values.
+ * ## Overloads
  *
- * @example Store-level meta (boolean flag)
+ * ### 1. `meta()` - Boolean flag meta
+ * Creates a meta type where calling `myMeta()` returns `MetaEntry<any, true>`
+ * ```ts
+ * const persist = meta();
+ * persist()              // MetaEntry with value: true
+ * persist.for("field")   // MetaEntry with value: true for field
+ * ```
+ *
+ * ### 2. `meta<TValue>()` - Typed value meta (requires value argument)
+ * Creates a meta type where calling `myMeta(value)` returns `MetaEntry<any, TValue>`
+ * ```ts
+ * const priority = meta<number>();
+ * priority(1)              // MetaEntry with value: 1
+ * priority.for("field", 5) // MetaEntry with value: 5 for field
+ * ```
+ *
+ * ### 3. `meta(builder)` - Custom builder meta
+ * Creates a meta type with custom value transformation
+ * ```ts
+ * const config = meta((name: string, value: number) => ({ name, value }));
+ * config("timeout", 5000)  // MetaEntry with value: { name: "timeout", value: 5000 }
+ * ```
+ *
+ * @example Boolean flag meta
  * ```ts
  * const persist = meta();
  *
@@ -19,26 +41,24 @@ import { MetaType } from '../types';
  *   meta: [persist()],
  * });
  *
- * ctx.meta(persist).store;           // true (first value)
- * ctx.meta.all(persist).store;       // [true] (all values)
+ * ctx.meta(persist).store;  // true
  * ```
  *
- * @example Store-level meta (with value)
+ * @example Typed value meta
  * ```ts
- * const priority = meta((level: number) => level);
+ * const priority = meta<number>();
  *
  * const criticalStore = store({
  *   state: { data: null },
- *   meta: [priority(1), priority(2)],
+ *   meta: [priority(1)],
  * });
  *
- * ctx.meta(priority).store;           // 1 (first)
- * ctx.meta.all(priority).store;       // [1, 2] (all)
+ * ctx.meta(priority).store;  // 1
  * ```
  *
  * @example Field-level meta
  * ```ts
- * const validate = meta((rule: string) => rule);
+ * const validate = meta<string>();
  *
  * const formStore = store({
  *   state: { email: "", age: 0 },
@@ -52,20 +72,12 @@ import { MetaType } from '../types';
  * formStore.meta(validate).fields.age;    // "positive-number"
  * ```
  *
- * @example Check meta existence
- * ```ts
- * const persist = meta();
- * const sync = meta();
- *
- * userStore.meta.any(persist);        // true
- * userStore.meta.any(sync);           // false
- * userStore.meta.any(persist, sync);  // true (has at least one)
- * ```
- *
  * @param builder - Optional function to transform arguments into meta value.
- *                  If omitted, meta value defaults to `true`.
+ *                  If omitted with no type param, meta value is `true`.
+ *                  If omitted with type param, first argument is returned as value.
  * @returns A MetaType that creates MetaEntry objects
  */
 export declare function meta(): MetaType<any, [], true>;
+export declare function meta<TValue>(): MetaType<any, [value: TValue], TValue>;
 export declare function meta<TValue, TArgs extends any[]>(builder: (...args: TArgs) => TValue): MetaType<any, TArgs, TValue>;
 //# sourceMappingURL=meta.d.ts.map

package/dist/meta/meta.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/meta/meta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,UAAU,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AACH,wBAAgB,IAAI,IAAI,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;AAChD,wBAAgB,IAAI,CAAC,MAAM,EAAE,KAAK,SAAS,GAAG,EAAE,EAC9C,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,MAAM,GAClC,QAAQ,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC"}
+{"version":3,"file":"meta.d.ts","sourceRoot":"","sources":["../../src/meta/meta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAsB,MAAM,UAAU,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,wBAAgB,IAAI,IAAI,QAAQ,CAAC,GAAG,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;AAChD,wBAAgB,IAAI,CAAC,MAAM,KAAK,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;AACvE,wBAAgB,IAAI,CAAC,MAAM,EAAE,KAAK,SAAS,GAAG,EAAE,EAC9C,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,MAAM,GAClC,QAAQ,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC"}

package/dist/{meta-u3yOx5Kh.js → meta-40r-AZfe.js}

@@ -1,4 +1,7 @@
 function meta(builder) {
+  if (!builder) {
+    builder = (...args) => args.length ? args[0] : true;
+  }
   const metaType = Object.assign(
     // Store-level meta: myMeta(...args)
     (...args) => {

package/dist/persist/index.js

@@ -1,4 +1,4 @@
-import { m as meta } from "../meta-u3yOx5Kh.js";
+import { m as meta } from "../meta-40r-AZfe.js";
 import { i as isPromiseLike } from "../isPromiseLike-bFkfHAbm.js";
 const notPersisted = meta();
 function persistMiddleware(options) {

package/dist/react/index.js

@@ -2,12 +2,12 @@ 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 { memo, useRef, useMemo, createElement, createContext, useContext, useReducer, useEffect, useLayoutEffect, useState, forwardRef } from "react";
-import { c as container, i as isSpec, S as STORION_TYPE, r as resolveEquality, s as store } from "../index-CIFKRy71.js";
-import { q, o, m, l, n, x, u, t, g, a, h, d, f, k, e, j, b, C, p, v, y, z, B, w, D, A } from "../index-CIFKRy71.js";
+import { c as container, i as isSpec, S as STORION_TYPE, r as resolveEquality, s as store } from "../index-OPaTR3zq.js";
+import { n, m, l, u, q, o, g, a, h, d, f, k, e, j, b, z, p, t, v, w, y, A, x } from "../index-OPaTR3zq.js";
 import { P as ProviderMissingError, L as LocalStoreDependencyError, w as withHooks, A as AsyncFunctionError } from "../effect-C6h0PDDI.js";
 import { E, H, I, c, a as a2, d as d2, S, b as b2, e as e2, u as u2 } from "../effect-C6h0PDDI.js";
 import { jsx } from "react/jsx-runtime";
-import { m as m2 } from "../meta-u3yOx5Kh.js";
+import { m as m2 } from "../meta-40r-AZfe.js";
 const StoreContext = createContext(null);
 const StoreProvider = memo(
   ({ container: value, children }) => {
@@ -416,19 +416,17 @@ export {
   d2 as StoreDisposedError,
   StoreProvider,
   S as StorionError,
-  q as applyExcept,
-  o as applyFor,
+  n as applyExcept,
+  m as applyFor,
   b2 as batch,
   container,
   create,
-  m as createLoggingMiddleware,
   l as createResolver,
-  n as createValidationMiddleware,
   createWithStore,
-  x as deepEqual,
+  u as deepEqual,
   e2 as effect,
-  u as equality,
-  t as forStores,
+  q as equality,
+  o as forStores,
   g as getKind,
   a as is,
   h as isAction,
@@ -439,19 +437,18 @@ export {
   e as isStore,
   j as isStoreContext,
   b as isStorion,
-  C as isWrappedFn,
+  z as isWrappedFn,
   m2 as meta,
   p as pick,
-  v as shallowEqual,
+  t as shallowEqual,
   store,
-  y as strictEqual,
-  z as trigger,
+  v as strictEqual,
+  w as trigger,
   u2 as untrack,
-  B as unwrapFn,
+  y as unwrapFn,
   useContainer,
   useStore,
-  w as when,
-  D as withMeta,
+  A as withMeta,
   withStore,
-  A as wrapFn
+  x as wrapFn
 };

package/dist/storion.js

@@ -1,6 +1,6 @@
-import { S, q, o, c, m, l, n, x, u, t, g, a, h, d, f, k, i, e, j, b, C, p, v, s, y, z, B, w, D, A } from "./index-CIFKRy71.js";
+import { S, n, m, c, l, u, q, o, g, a, h, d, f, k, i, e, j, b, z, p, t, s, v, w, y, A, x } from "./index-OPaTR3zq.js";
 import { A as A2, E, H, I, c as c2, L, P, a as a2, d as d2, S as S2, b as b2, e as e2, u as u2 } from "./effect-C6h0PDDI.js";
-import { m as m2 } from "./meta-u3yOx5Kh.js";
+import { m as m2 } from "./meta-40r-AZfe.js";
 export {
   A2 as AsyncFunctionError,
   E as EffectRefreshError,
@@ -13,17 +13,15 @@ export {
   a2 as SetupPhaseError,
   d2 as StoreDisposedError,
   S2 as StorionError,
-  q as applyExcept,
-  o as applyFor,
+  n as applyExcept,
+  m as applyFor,
   b2 as batch,
   c as container,
-  m as createLoggingMiddleware,
   l as createResolver,
-  n as createValidationMiddleware,
-  x as deepEqual,
+  u as deepEqual,
   e2 as effect,
-  u as equality,
-  t as forStores,
+  q as equality,
+  o as forStores,
   g as getKind,
   a as is,
   h as isAction,
@@ -34,16 +32,15 @@ export {
   e as isStore,
   j as isStoreContext,
   b as isStorion,
-  C as isWrappedFn,
+  z as isWrappedFn,
   m2 as meta,
   p as pick,
-  v as shallowEqual,
+  t as shallowEqual,
   s as store,
-  y as strictEqual,
-  z as trigger,
+  v as strictEqual,
+  w as trigger,
   u2 as untrack,
-  B as unwrapFn,
-  w as when,
-  D as withMeta,
-  A as wrapFn
+  y as unwrapFn,
+  A as withMeta,
+  x as wrapFn
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "storion",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Reactive stores for modern apps. Type-safe. Auto-tracked. Effortlessly composable",
   "type": "module",
   "main": "./dist/storion.js",
@@ -33,7 +33,8 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "dev": "vite build --watch",