storion 0.7.10 → 0.8.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/meta/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/meta/meta.d.ts

@@ -0,0 +1,71 @@
+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
+ *
+ * Retrieve meta via `ctx.meta(type)` which returns first value (default),
+ * or use `ctx.meta.all(type)` for all values.
+ *
+ * @example Store-level meta (boolean flag)
+ * ```ts
+ * const persist = meta();
+ *
+ * const userStore = store({
+ *   state: { name: "" },
+ *   meta: [persist()],
+ * });
+ *
+ * ctx.meta(persist).store;           // true (first value)
+ * ctx.meta.all(persist).store;       // [true] (all values)
+ * ```
+ *
+ * @example Store-level meta (with value)
+ * ```ts
+ * const priority = meta((level: number) => level);
+ *
+ * const criticalStore = store({
+ *   state: { data: null },
+ *   meta: [priority(1), priority(2)],
+ * });
+ *
+ * ctx.meta(priority).store;           // 1 (first)
+ * ctx.meta.all(priority).store;       // [1, 2] (all)
+ * ```
+ *
+ * @example Field-level meta
+ * ```ts
+ * const validate = meta((rule: string) => rule);
+ *
+ * const formStore = store({
+ *   state: { email: "", age: 0 },
+ *   meta: [
+ *     validate.for("email", "email-format"),
+ *     validate.for("age", "positive-number"),
+ *   ],
+ * });
+ *
+ * formStore.meta(validate).fields.email;  // "email-format"
+ * 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`.
+ * @returns A MetaType that creates MetaEntry objects
+ */
+export declare function meta(): MetaType<any, [], true>;
+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

@@ -0,0 +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"}

package/dist/meta/withMeta.d.ts

@@ -0,0 +1,48 @@
+import { Factory, MetaEntry } from '../types';
+
+/**
+ * Attach metadata to a service or factory function.
+ *
+ * This allows middleware to access meta information for any factory,
+ * not just stores. Meta is queried via `ctx.meta` in middleware context.
+ *
+ * @example Basic usage
+ * ```ts
+ * const persist = meta();
+ * const priority = meta((level: number) => level);
+ *
+ * // Attach meta to a service factory
+ * const apiService = withMeta(
+ *   (resolver) => ({ fetch: () => {} }),
+ *   [persist(), priority(1)]
+ * );
+ *
+ * // In middleware, query via ctx.meta
+ * const middleware: Middleware = (ctx) => {
+ *   if (ctx.meta.any(persist)) {
+ *     console.log("This factory should be persisted");
+ *   }
+ *   return ctx.next();
+ * };
+ * ```
+ *
+ * @example Combined with store meta
+ * ```ts
+ * // Factory meta and store spec meta are merged in ctx.meta
+ * const userStore = store({
+ *   name: "user",
+ *   state: { name: "" },
+ *   meta: [persist()], // spec meta
+ * });
+ *
+ * // In middleware, ctx.meta includes both factory.meta and spec.meta
+ * ```
+ *
+ * @param factory - The factory function to attach meta to
+ * @param meta - Single MetaEntry or array of MetaEntry
+ * @returns The same factory function with `.meta` property attached
+ */
+export declare function withMeta<TFactory extends Factory, TField extends ReturnType<TFactory> extends object ? keyof ReturnType<TFactory> : any>(factory: TFactory, meta: MetaEntry<TField, any> | MetaEntry<TField, any>[]): TFactory & {
+    meta: MetaEntry<TField, any>[];
+};
+//# sourceMappingURL=withMeta.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withMeta.d.ts","sourceRoot":"","sources":["../../src/meta/withMeta.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,QAAQ,CACtB,QAAQ,SAAS,OAAO,EACxB,MAAM,SAAS,UAAU,CAAC,QAAQ,CAAC,SAAS,MAAM,GAC9C,MAAM,UAAU,CAAC,QAAQ,CAAC,GAC1B,GAAG,EAEP,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,GACtD,QAAQ,GAAG;IACZ,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAC;CAChC,CAIA"}

package/dist/meta-u3yOx5Kh.js

@@ -0,0 +1,29 @@
+function meta(builder) {
+  const metaType = Object.assign(
+    // Store-level meta: myMeta(...args)
+    (...args) => {
+      return {
+        fields: void 0,
+        value: (builder == null ? void 0 : builder(...args)) ?? true,
+        type: metaType
+        // reference the MetaType itself
+      };
+    },
+    {
+      // Field-level meta: myMeta.for("fieldName", ...args) or myMeta.for(["f1", "f2"], ...args)
+      for(fieldOrFields, ...args) {
+        const fields = Array.isArray(fieldOrFields) ? fieldOrFields : [fieldOrFields];
+        return {
+          fields,
+          value: (builder == null ? void 0 : builder(...args)) ?? true,
+          type: metaType
+          // reference the MetaType itself
+        };
+      }
+    }
+  );
+  return metaType;
+}
+export {
+  meta as m
+};

package/dist/persist/index.d.ts

@@ -5,5 +5,5 @@
  *
  * @packageDocumentation
  */
-export { persistMiddleware, type PersistOptions, type PersistLoadResult, } from './persist';
+export { persistMiddleware, notPersisted, type PersistOptions, type PersistLoadResult, } from './persist';
 //# sourceMappingURL=index.d.ts.map

package/dist/persist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/persist/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,iBAAiB,EACjB,KAAK,cAAc,EACnB,KAAK,iBAAiB,GACvB,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/persist/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,iBAAiB,EACjB,YAAY,EACZ,KAAK,cAAc,EACnB,KAAK,iBAAiB,GACvB,MAAM,WAAW,CAAC"}

package/dist/persist/index.js

@@ -1,22 +1,36 @@
-import { i as isStore } from "../is-KT6PknjJ.js";
-function isPromiseLike(value) {
-  return value !== null && typeof value === "object" && "then" in value && typeof value.then === "function";
-}
+import { m as meta } from "../meta-u3yOx5Kh.js";
+import { i as isPromiseLike } from "../isPromiseLike-bFkfHAbm.js";
+const notPersisted = meta();
 function persistMiddleware(options) {
-  const { filter, load, save, onError } = options;
-  return (ctx) => {
-    const instance = ctx.next();
-    if (!isStore(instance)) {
+  const { filter, load, save, onError, force = false } = options;
+  return ({ spec, next, meta: meta2 }) => {
+    const instance = next();
+    if (filter && !filter(spec)) {
       return instance;
     }
-    const spec = instance.spec;
-    if (filter && !filter(spec)) {
+    const notPersistedInfo = meta2(notPersisted);
+    if (notPersistedInfo.store === true) {
       return instance;
     }
+    const excludedFields = new Set(
+      Object.keys(notPersistedInfo.fields).filter(
+        (field) => notPersistedInfo.fields[field] === true
+      )
+    );
+    const filterState = (state) => {
+      if (excludedFields.size === 0) return state;
+      const filtered = {};
+      for (const key in state) {
+        if (!excludedFields.has(key)) {
+          filtered[key] = state[key];
+        }
+      }
+      return filtered;
+    };
     const hydrateWithState = (state) => {
       if (state != null) {
         try {
-          instance.hydrate(state);
+          instance.hydrate(filterState(state), { force });
         } catch (error) {
           onError == null ? void 0 : onError(spec, error, "load");
         }
@@ -41,7 +55,7 @@ function persistMiddleware(options) {
       instance.subscribe(() => {
         try {
           const state = instance.dehydrate();
-          save(spec, state);
+          save(spec, filterState(state));
         } catch (error) {
           onError == null ? void 0 : onError(spec, error, "save");
         }
@@ -51,5 +65,6 @@ function persistMiddleware(options) {
   };
 }
 export {
+  notPersisted,
   persistMiddleware
 };

package/dist/persist/persist.d.ts

@@ -1,5 +1,39 @@
-import { StoreSpec, Middleware } from '../types';
+import { StoreSpec, StoreMiddleware } from '../types';
 
+/**
+ * Mark stores or fields as not persisted.
+ *
+ * When called without arguments, marks the entire store as not persisted.
+ * When called with a field name, marks that specific field as not persisted.
+ *
+ * @example Store-level exclusion
+ * ```ts
+ * import { notPersisted } from 'storion/persist';
+ *
+ * const tempStore = store({
+ *   name: 'temp',
+ *   state: { sessionData: {} },
+ *   setup: () => ({}),
+ *   meta: [notPersisted()],  // entire store skipped
+ * });
+ * ```
+ *
+ * @example Field-level exclusion
+ * ```ts
+ * import { notPersisted } from 'storion/persist';
+ *
+ * const userStore = store({
+ *   name: 'user',
+ *   state: { name: '', password: '', token: '' },
+ *   setup: () => ({}),
+ *   meta: [
+ *     notPersisted('password'),
+ *     notPersisted('token'),
+ *   ],
+ * });
+ * ```
+ */
+export declare const notPersisted: import('..').MetaType<any, [], true>;
 /**
  * Result from load function - can be sync or async
  */
@@ -39,6 +73,17 @@ export interface PersistOptions {
      * @param operation - Whether the error occurred during 'load' or 'save'
      */
     onError?: (spec: StoreSpec, error: unknown, operation: "load" | "save") => void;
+    /**
+     * Force hydration to overwrite dirty (modified) state properties.
+     *
+     * By default (false), hydrate() skips properties that have been modified
+     * since initialization to avoid overwriting fresh data with stale persisted data.
+     *
+     * Set to true to always apply persisted data regardless of dirty state.
+     *
+     * @default false
+     */
+    force?: boolean;
 }
 /**
  * Creates a persist middleware that automatically saves and restores store state.
@@ -79,5 +124,5 @@ export interface PersistOptions {
  * });
  * ```
  */
-export declare function persistMiddleware(options: PersistOptions): Middleware;
+export declare function persistMiddleware(options: PersistOptions): StoreMiddleware;
 //# sourceMappingURL=persist.d.ts.map

package/dist/persist/persist.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"persist.d.ts","sourceRoot":"","sources":["../../src/persist/persist.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GACzB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvB,IAAI,GACJ,SAAS,GACT,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,OAAO,CAAC;IAEtC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,iBAAiB,CAAC;IAE9C;;;;;OAKG;IACH,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAEjE;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,CACR,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,GAAG,MAAM,KACvB,IAAI,CAAC;CACX;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,UAAU,CAkErE"}
+{"version":3,"file":"persist.d.ts","sourceRoot":"","sources":["../../src/persist/persist.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAI3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,YAAY,sCAAS,CAAC;AAEnC;;GAEG;AACH,MAAM,MAAM,iBAAiB,GACzB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvB,IAAI,GACJ,SAAS,GACT,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,OAAO,CAAC;IAEtC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,iBAAiB,CAAC;IAE9C;;;;;OAKG;IACH,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAEjE;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,CACR,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,GAAG,MAAM,KACvB,IAAI,CAAC;IAEV;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CAmG1E"}

package/dist/react/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/react/context.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,EAAE,EAGR,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAU/C;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,eAAO,MAAM,aAAa,EAAE,EAAE,CAAC,kBAAkB,CAShD,CAAC;AAEF;;GAEG;AACH,wBAAgB,YAAY,IAAI,cAAc,CAO7C"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/react/context.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAIL,KAAK,SAAS,EACd,KAAK,EAAE,EAIR,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAU/C;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,eAAO,MAAM,aAAa,EAAE,EAAE,CAAC,kBAAkB,CAoBhD,CAAC;AAEF;;GAEG;AACH,wBAAgB,YAAY,IAAI,cAAc,CAO7C"}

package/dist/react/index.js

@@ -1,21 +1,26 @@
 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, useMemo, createElement, createContext, useContext, useReducer, useRef, useEffect, useLayoutEffect, useState, forwardRef } from "react";
-import { container } from "../storion.js";
-import { applyExcept, applyFor, compose, createLoggingMiddleware, createResolver, createValidationMiddleware, forStores, pick, trigger, when } from "../storion.js";
-import { P as ProviderMissingError, L as LocalStoreDependencyError, w as withHooks, A as AsyncFunctionError } from "../emitter-XwTUpyGv.js";
-import { E, H, I, c, a, d, S, b, u } from "../emitter-XwTUpyGv.js";
-import { a as isSpec, S as STORION_TYPE } from "../is-KT6PknjJ.js";
-import { g, b as b2, f, d as d2, e, j, i, h, c as c2 } from "../is-KT6PknjJ.js";
+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 { 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 { r as resolveEquality, s as store } from "../store-C3dmtJ4u.js";
-import { d as d3, e as e2, i as i2, a as a2, b as b3, u as u2, w } from "../store-C3dmtJ4u.js";
-import { e as e3 } from "../effect-ByI1oRBq.js";
+import { m as m2 } from "../meta-u3yOx5Kh.js";
 const StoreContext = createContext(null);
 const StoreProvider = memo(
   ({ container: value, children }) => {
-    const valueOrDefault = useMemo(() => value ?? container(), [value]);
+    const defaultContainerRef = useRef();
+    const valueOrDefault = useMemo(() => {
+      if (value) {
+        return value;
+      }
+      if (!defaultContainerRef.current) {
+        defaultContainerRef.current = container();
+      }
+      return defaultContainerRef.current;
+    }, [value]);
     return createElement(
       StoreContext.Provider,
       { value: valueOrDefault },
@@ -83,7 +88,7 @@ const useIsomorphicLayoutEffect = isServer ? useEffect : useLayoutEffect;
 const shouldScheduleDispose = !isServer && typeof useLayoutEffect === "function" && dev();
 function useLocalStore(spec) {
   var _a;
-  const [, forceUpdate] = useReducer((x) => x + 1, 0);
+  const [, forceUpdate] = useReducer((x2) => x2 + 1, 0);
   const prevControllerRef = useRef(null);
   const controller = useMemo(() => new LocalStoreController(spec), [spec]);
   if (prevControllerRef.current !== controller) {
@@ -194,7 +199,7 @@ class LocalStoreController {
   }
 }
 function useStoreWithContainer(selector, container2) {
-  const [, forceUpdate] = useReducer((x) => x + 1, 0);
+  const [, forceUpdate] = useReducer((x2) => x2 + 1, 0);
   const [refs] = useState(() => ({
     fresh: void 0,
     stableFns: /* @__PURE__ */ new Map(),
@@ -407,45 +412,46 @@ export {
   LocalStoreDependencyError,
   ProviderMissingError,
   STORION_TYPE,
-  a as SetupPhaseError,
-  d as StoreDisposedError,
+  a2 as SetupPhaseError,
+  d2 as StoreDisposedError,
   StoreProvider,
   S as StorionError,
-  applyExcept,
-  applyFor,
-  b as batch,
-  compose,
+  q as applyExcept,
+  o as applyFor,
+  b2 as batch,
   container,
   create,
-  createLoggingMiddleware,
-  createResolver,
-  createValidationMiddleware,
+  m as createLoggingMiddleware,
+  l as createResolver,
+  n as createValidationMiddleware,
   createWithStore,
-  d3 as deepEqual,
-  e3 as effect,
-  e2 as equality,
-  forStores,
+  x as deepEqual,
+  e2 as effect,
+  u as equality,
+  t as forStores,
   g as getKind,
-  b2 as is,
-  f as isAction,
-  d2 as isContainer,
-  e as isFocus,
-  j as isSelectorContext,
+  a as is,
+  h as isAction,
+  d as isContainer,
+  f as isFocus,
+  k as isSelectorContext,
   isSpec,
-  i as isStore,
-  h as isStoreContext,
-  c2 as isStorion,
-  i2 as isWrappedFn,
-  pick,
-  a2 as shallowEqual,
+  e as isStore,
+  j as isStoreContext,
+  b as isStorion,
+  C as isWrappedFn,
+  m2 as meta,
+  p as pick,
+  v as shallowEqual,
   store,
-  b3 as strictEqual,
-  trigger,
-  u as untrack,
-  u2 as unwrapFn,
+  y as strictEqual,
+  z as trigger,
+  u2 as untrack,
+  B as unwrapFn,
   useContainer,
   useStore,
-  when,
+  w as when,
+  D as withMeta,
   withStore,
-  w as wrapFn
+  A as wrapFn
 };