@storve/core 1.0.0

package/dist/store.d.ts

@@ -0,0 +1,12 @@
+import { Store, StoreDefinition, StoreOptions } from './types';
+/**
+ * Creates a reactive store with auto-tracking features via Proxies.
+ * Any mutations to the state via setState or directly to deep objects will notify subscribers.
+ * Extensions (async, computed) register when their modules are imported and extend the store.
+ *
+ * @param definition - The initial state object including optional actions.
+ * @param options - Configuration options for the store (e.g., immer).
+ * @returns A generic store instance with getState, setState, subscribe, batch, and actions.
+ */
+export declare function createStore<D extends object>(definition: StoreDefinition<D>, options?: StoreOptions): Store<D>;
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,eAAe,EAAY,YAAY,EAA4B,MAAM,SAAS,CAAA;AAMlG;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,EACxC,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC,EAC9B,OAAO,GAAE,YAAiB,GAC3B,KAAK,CAAC,CAAC,CAAC,CAuOV"}

package/dist/sync/channel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Opens a BroadcastChannel if available in the current environment.
+ * Gracefully returns null in SSR or older browsers.
+ * @internal
+ */
+export declare function openChannel(name: string): BroadcastChannel | null;
+//# sourceMappingURL=channel.d.ts.map

package/dist/sync/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../../src/sync/channel.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CASjE"}

package/dist/sync/index.d.ts

@@ -0,0 +1,3 @@
+export { withSync } from './withSync';
+export type { SyncOptions } from './withSync';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sync/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/sync/protocol.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Random tab ID generated once per tab session.
+ */
+export declare const tabId: string;
+/**
+ * Message types for cross-tab synchronization.
+ * @template S - The state type
+ */
+export type SyncMessage<S> = {
+    type: 'STATE_UPDATE';
+    payload: Partial<S>;
+    tabId: string;
+} | {
+    type: 'REQUEST_STATE';
+    tabId: string;
+} | {
+    type: 'PROVIDE_STATE';
+    payload: S;
+    targetTabId: string;
+    tabId: string;
+};
+//# sourceMappingURL=protocol.d.ts.map

package/dist/sync/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/sync/protocol.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,KAAK,QAKd,CAAC;AAEL;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IACnB;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC5D;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,CAAC,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/sync/withSync.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Options for configuring cross-tab synchronization.
+ */
+export interface SyncOptions {
+    /** Unique name for the BroadcastChannel */
+    channel: string;
+    /** Optional list of keys to sync. If omitted, all keys are synced. */
+    keys?: string[];
+    /** Whether sync is enabled (default true) */
+    enabled?: boolean;
+}
+/**
+ * Wraps a store definition with cross-tab synchronization.
+ * Updates to the store will be broadcast to other tabs via BroadcastChannel.
+ */
+export declare function withSync<D extends object>(definition: D, options: SyncOptions): D;
+//# sourceMappingURL=withSync.d.ts.map

package/dist/sync/withSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withSync.d.ts","sourceRoot":"","sources":["../../src/sync/withSync.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,6CAA6C;IAC7C,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAKD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EACrC,UAAU,EAAE,CAAC,EACb,OAAO,EAAE,WAAW,GACrB,CAAC,CAOH"}

package/dist/sync.cjs

@@ -0,0 +1,2 @@
+"use strict";var t=require("./registry-qtr1UpFU.js");const e="undefined"!=typeof crypto&&"function"==typeof crypto.randomUUID?crypto.randomUUID():Math.random().toString(36).substring(2,11),n=Symbol("storve_sync_options");t.registerExtension({key:"sync",extendStore:t=>{const{store:o,definition:a}=t,s=a[n];if(!s||!1===s.enabled)return{};const r=function(t){if("undefined"==typeof window)return null;if("undefined"==typeof BroadcastChannel)return null;try{return new BroadcastChannel(t)}catch{return null}}(s.channel);if(!r)return{};let c=!1,y=!1;const i=o.setState.bind(o);return o.setState=t=>{const n={...o.getState()};if(i(t),!c){const t=((t,e)=>{const n=s.keys||Object.keys(t),o={};let a=!1;for(const s of n)"symbol"!=typeof s&&t[s]!==e[s]&&(o[s]=t[s],a=!0);return a?o:null})(o.getState(),n);t&&r.postMessage({type:"STATE_UPDATE",payload:t,tabId:e})}},r.onmessage=t=>{const n=t.data;if(n.tabId!==e)switch(n.type){case"STATE_UPDATE":c=!0,o.setState(n.payload),c=!1;break;case"REQUEST_STATE":{const t=o.getState(),a={},c=s.keys||Object.keys(t);for(const e of c)"symbol"!=typeof e&&e in t&&(a[e]=t[e]);r.postMessage({type:"PROVIDE_STATE",payload:a,targetTabId:n.tabId,tabId:e});break}case"PROVIDE_STATE":n.targetTabId!==e||y||(y=!0,c=!0,o.setState(n.payload),c=!1)}},r.postMessage({type:"REQUEST_STATE",tabId:e}),{__sync_channel:r}}}),exports.withSync=function(t,e){return Object.defineProperty(t,n,{value:e,enumerable:!1,configurable:!0}),t};
+//# sourceMappingURL=sync.cjs.map

package/dist/sync.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.cjs","sources":["../src/sync/protocol.ts","../src/sync/withSync.ts","../src/sync/channel.ts"],"sourcesContent":[null,null,null],"names":["tabId","crypto","randomUUID","Math","random","toString","substring","SYNC_OPTIONS","Symbol","registerExtension","key","extendStore","context","store","definition","options","enabled","channel","name","window","BroadcastChannel","openChannel","isSyncUpdate","rehydrated","originalSetState","setState","bind","updater","prevState","getState","payload","nextState","keysToSync","keys","Object","hasChanges","buildPayload","postMessage","type","onmessage","event","data","currentState","targetTabId","__sync_channel","defineProperty","value","enumerable","configurable"],"mappings":"qDAGO,MAAMA,EACa,oBAAXC,QAAuD,mBAAtBA,OAAOC,WACxCD,OAAOC,aAEXC,KAAKC,SAASC,SAAS,IAAIC,UAAU,EAAG,ICW7CC,EAAeC,OAAO,uBAkB5BC,EAAAA,kBAAkB,CACdC,IAAK,OACLC,YAAcC,IACV,MAAMC,MAAEA,EAAKC,WAAEA,GAAeF,EACxBG,EAAWD,EAAuCP,GAExD,IAAKQ,IAA+B,IAApBA,EAAQC,QAAmB,MAAO,CAAA,EAElD,MAAMC,ECvCR,SAAsBC,GACxB,GAAsB,oBAAXC,OAAwB,OAAO,KAC1C,GAAgC,oBAArBC,iBAAkC,OAAO,KACpD,IACI,OAAO,IAAIA,iBAAiBF,EAChC,CAAE,MAEE,OAAO,IACX,CACJ,CD8BwBG,CAAYN,EAAQE,SACpC,IAAKA,EAAS,MAAO,CAAA,EAErB,IAAIK,GAAe,EACfC,GAAa,EAGjB,MAkBMC,EAAmBX,EAAMY,SAASC,KAAKb,GAyE7C,OAxEAA,EAAMY,SAAYE,IACd,MAAMC,EAAY,IAAKf,EAAMgB,YAE7B,GADAL,EAAiBG,IACZL,EAAc,CACf,MACMQ,EAxBO,EAACC,EAAoCH,KACtD,MAAMI,EAAajB,EAAQkB,MAAQC,OAAOD,KAAKF,GACzCD,EAAmC,CAAA,EACzC,IAAIK,GAAa,EAEjB,IAAK,MAAMzB,KAAOsB,EAEK,iBAARtB,GAEPqB,EAAUrB,KAASkB,EAAUlB,KAC7BoB,EAAQpB,GAAOqB,EAAUrB,GACzByB,GAAa,GAGrB,OAAOA,EAAaL,EAAU,MAUVM,CADEvB,EAAMgB,WACgBD,GACpCE,GACAb,EAAQoB,YAAY,CAChBC,KAAM,eACNR,UACA9B,SAGZ,GAIJiB,EAAQsB,UAAaC,IACjB,MAAMC,EAAOD,EAAMC,KAGnB,GAAIA,EAAKzC,QAAUA,EAEnB,OAAQyC,EAAKH,MACT,IAAK,eACDhB,GAAe,EACfT,EAAMY,SAASgB,EAAKX,SACpBR,GAAe,EACf,MAEJ,IAAK,gBAAiB,CAElB,MAAMoB,EAAe7B,EAAMgB,WACrBC,EAAmC,CAAA,EACnCE,EAAajB,EAAQkB,MAAQC,OAAOD,KAAKS,GAE/C,IAAK,MAAMhC,KAAOsB,EACK,iBAARtB,GACPA,KAAOgC,IACPZ,EAAQpB,GAAOgC,EAAahC,IAIpCO,EAAQoB,YAAY,CAChBC,KAAM,gBACNR,UACAa,YAAaF,EAAKzC,MAClBA,UAEJ,KACJ,CACA,IAAK,gBAEGyC,EAAKE,cAAgB3C,GAAUuB,IAC/BA,GAAa,EACbD,GAAe,EACfT,EAAMY,SAASgB,EAAKX,SACpBR,GAAe,KAQ/BL,EAAQoB,YAAY,CAAEC,KAAM,gBAAiBtC,UAOtC,CACH4C,eAAgB3B,uBAvHtB,SACFH,EACAC,GAOA,OALAmB,OAAOW,eAAe/B,EAAYP,EAAc,CAC5CuC,MAAO/B,EACPgC,YAAY,EACZC,cAAc,IAEXlC,CACX"}

package/dist/sync.mjs

@@ -0,0 +1,2 @@
+import{r as t}from"./registry-zaKZ1P-s.js";const e="undefined"!=typeof crypto&&"function"==typeof crypto.randomUUID?crypto.randomUUID():Math.random().toString(36).substring(2,11),n=Symbol("storve_sync_options");function o(t,e){return Object.defineProperty(t,n,{value:e,enumerable:!1,configurable:!0}),t}t({key:"sync",extendStore:t=>{const{store:o,definition:a}=t,s=a[n];if(!s||!1===s.enabled)return{};const r=function(t){if("undefined"==typeof window)return null;if("undefined"==typeof BroadcastChannel)return null;try{return new BroadcastChannel(t)}catch{return null}}(s.channel);if(!r)return{};let c=!1,y=!1;const d=o.setState.bind(o);return o.setState=t=>{const n={...o.getState()};if(d(t),!c){const t=((t,e)=>{const n=s.keys||Object.keys(t),o={};let a=!1;for(const s of n)"symbol"!=typeof s&&t[s]!==e[s]&&(o[s]=t[s],a=!0);return a?o:null})(o.getState(),n);t&&r.postMessage({type:"STATE_UPDATE",payload:t,tabId:e})}},r.onmessage=t=>{const n=t.data;if(n.tabId!==e)switch(n.type){case"STATE_UPDATE":c=!0,o.setState(n.payload),c=!1;break;case"REQUEST_STATE":{const t=o.getState(),a={},c=s.keys||Object.keys(t);for(const e of c)"symbol"!=typeof e&&e in t&&(a[e]=t[e]);r.postMessage({type:"PROVIDE_STATE",payload:a,targetTabId:n.tabId,tabId:e});break}case"PROVIDE_STATE":n.targetTabId!==e||y||(y=!0,c=!0,o.setState(n.payload),c=!1)}},r.postMessage({type:"REQUEST_STATE",tabId:e}),{__sync_channel:r}}});export{o as withSync};
+//# sourceMappingURL=sync.mjs.map

package/dist/sync.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.mjs","sources":["../src/sync/protocol.ts","../src/sync/withSync.ts","../src/sync/channel.ts"],"sourcesContent":[null,null,null],"names":["tabId","crypto","randomUUID","Math","random","toString","substring","SYNC_OPTIONS","Symbol","withSync","definition","options","Object","defineProperty","value","enumerable","configurable","registerExtension","key","extendStore","context","store","enabled","channel","name","window","BroadcastChannel","openChannel","isSyncUpdate","rehydrated","originalSetState","setState","bind","updater","prevState","getState","payload","nextState","keysToSync","keys","hasChanges","buildPayload","postMessage","type","onmessage","event","data","currentState","targetTabId","__sync_channel"],"mappings":"2CAGO,MAAMA,EACa,oBAAXC,QAAuD,mBAAtBA,OAAOC,WACxCD,OAAOC,aAEXC,KAAKC,SAASC,SAAS,IAAIC,UAAU,EAAG,ICW7CC,EAAeC,OAAO,uBAMtB,SAAUC,EACZC,EACAC,GAOA,OALAC,OAAOC,eAAeH,EAAYH,EAAc,CAC5CO,MAAOH,EACPI,YAAY,EACZC,cAAc,IAEXN,CACX,CAEAO,EAAkB,CACdC,IAAK,OACLC,YAAcC,IACV,MAAMC,MAAEA,EAAKX,WAAEA,GAAeU,EACxBT,EAAWD,EAAuCH,GAExD,IAAKI,IAA+B,IAApBA,EAAQW,QAAmB,MAAO,CAAA,EAElD,MAAMC,ECvCR,SAAsBC,GACxB,GAAsB,oBAAXC,OAAwB,OAAO,KAC1C,GAAgC,oBAArBC,iBAAkC,OAAO,KACpD,IACI,OAAO,IAAIA,iBAAiBF,EAChC,CAAE,MAEE,OAAO,IACX,CACJ,CD8BwBG,CAAYhB,EAAQY,SACpC,IAAKA,EAAS,MAAO,CAAA,EAErB,IAAIK,GAAe,EACfC,GAAa,EAGjB,MAkBMC,EAAmBT,EAAMU,SAASC,KAAKX,GAyE7C,OAxEAA,EAAMU,SAAYE,IACd,MAAMC,EAAY,IAAKb,EAAMc,YAE7B,GADAL,EAAiBG,IACZL,EAAc,CACf,MACMQ,EAxBO,EAACC,EAAoCH,KACtD,MAAMI,EAAa3B,EAAQ4B,MAAQ3B,OAAO2B,KAAKF,GACzCD,EAAmC,CAAA,EACzC,IAAII,GAAa,EAEjB,IAAK,MAAMtB,KAAOoB,EAEK,iBAARpB,GAEPmB,EAAUnB,KAASgB,EAAUhB,KAC7BkB,EAAQlB,GAAOmB,EAAUnB,GACzBsB,GAAa,GAGrB,OAAOA,EAAaJ,EAAU,MAUVK,CADEpB,EAAMc,WACgBD,GACpCE,GACAb,EAAQmB,YAAY,CAChBC,KAAM,eACNP,UACApC,SAGZ,GAIJuB,EAAQqB,UAAaC,IACjB,MAAMC,EAAOD,EAAMC,KAGnB,GAAIA,EAAK9C,QAAUA,EAEnB,OAAQ8C,EAAKH,MACT,IAAK,eACDf,GAAe,EACfP,EAAMU,SAASe,EAAKV,SACpBR,GAAe,EACf,MAEJ,IAAK,gBAAiB,CAElB,MAAMmB,EAAe1B,EAAMc,WACrBC,EAAmC,CAAA,EACnCE,EAAa3B,EAAQ4B,MAAQ3B,OAAO2B,KAAKQ,GAE/C,IAAK,MAAM7B,KAAOoB,EACK,iBAARpB,GACPA,KAAO6B,IACPX,EAAQlB,GAAO6B,EAAa7B,IAIpCK,EAAQmB,YAAY,CAChBC,KAAM,gBACNP,UACAY,YAAaF,EAAK9C,MAClBA,UAEJ,KACJ,CACA,IAAK,gBAEG8C,EAAKE,cAAgBhD,GAAU6B,IAC/BA,GAAa,EACbD,GAAe,EACfP,EAAMU,SAASe,EAAKV,SACpBR,GAAe,KAQ/BL,EAAQmB,YAAY,CAAEC,KAAM,gBAAiB3C,UAOtC,CACHiD,eAAgB1B"}

package/dist/types.d.ts

@@ -0,0 +1,134 @@
+import type { ComputedValue } from './computed';
+/** @internal */
+export declare const ASYNC_VALUE_MARKER = "__rf_async";
+/** Re-export for consumers. Defined in computed.ts. */
+export type { ComputedValue } from './computed';
+/**
+ * Status of an async operation.
+ */
+export type AsyncStatus = 'idle' | 'loading' | 'success' | 'error';
+/**
+ * The shape of an async state value in the store.
+ */
+export interface AsyncState<T> {
+    /** The resolved data or null */
+    data: T | null;
+    /** Error message if the operation failed */
+    error: string | null;
+    /** Current status of the operation */
+    status: AsyncStatus;
+    /** Derived from status === 'loading' */
+    loading: boolean;
+    /** Re-runs the async function with the last used arguments */
+    refetch: () => Promise<void>;
+}
+/**
+ * Configuration options for an async value.
+ */
+export interface AsyncOptions {
+    /** Cache TTL in milliseconds. Default: 0 (no cache) */
+    ttl?: number;
+    /** Enable stale-while-revalidate behavior. Default: false */
+    staleWhileRevalidate?: boolean;
+}
+/**
+ * Internal interface for the async engine.
+ */
+export interface IAsyncEngine<T> {
+    getState: () => AsyncState<T>;
+    fetch: (...args: unknown[]) => Promise<void>;
+    refetch: () => Promise<void>;
+    invalidate: () => void;
+}
+/**
+ * Internal marker for values created via createAsync().
+ * Use this to distinguish async definitions from sync state.
+ */
+export interface AsyncValue<T> {
+    readonly [ASYNC_VALUE_MARKER]: true;
+    init: (onUpdate: (s: AsyncState<T>) => void) => IAsyncEngine<T>;
+}
+/** Keys of the definition that are computed values (read-only in setState). */
+export type ComputedKeys<D> = {
+    [K in keyof Omit<D, 'actions'>]: Omit<D, 'actions'>[K] extends ComputedValue<unknown> ? K : never;
+}[keyof Omit<D, 'actions'>];
+/**
+ * State shape with computed keys omitted. Use for setState payloads so TS flags setting computed keys.
+ */
+export type WritableStoreState<D> = Omit<StoreState<D>, ComputedKeys<D>>;
+/**
+ * Utility to extract state, omitting the actions key and unwrapping AsyncValues and ComputedValues.
+ */
+export type StoreState<D> = {
+    [K in keyof Omit<D, 'actions'>]: Omit<D, 'actions'>[K] extends AsyncValue<infer T> ? AsyncState<T> : Omit<D, 'actions'>[K] extends ComputedValue<infer T> ? T : Omit<D, 'actions'>[K];
+};
+/**
+ * Utility to extract actions from the definition.
+ */
+export type StoreActions<D> = D extends {
+    actions: infer A;
+} ? A : Record<string, never>;
+/**
+ * The shape of initial state passed to createStore.
+ * D represents the full definition including optional actions.
+ */
+export type StoreDefinition<D extends object> = D;
+/**
+ * Configuration options for the store.
+ */
+export interface StoreOptions {
+    /**
+     * Enable Immer for mutation-style state updates.
+     * @default false
+     */
+    immer?: boolean;
+}
+export type Listener<T> = (state: T) => void;
+export type Unsubscribe = () => void;
+/**
+ * The store instance returned by createStore().
+ */
+export type Store<D extends object> = {
+    /**
+     * Returns the current state snapshot.
+     */
+    getState: () => StoreState<D>;
+    /**
+     * Updates the state. Supports partial objects, updaters, and Immer mutators.
+     * Computed keys are read-only; passing them in the payload is a type error and is ignored at runtime.
+     */
+    setState: (updater: Partial<WritableStoreState<D>> | ((state: StoreState<D>) => Partial<WritableStoreState<D>>) | ((draft: StoreState<D>) => void)) => void;
+    /**
+     * Subscribes to state changes.
+     */
+    subscribe: (listener: Listener<StoreState<D>>) => Unsubscribe;
+    /**
+     * Batches multiple state updates to trigger only one notification.
+     */
+    batch: (fn: () => void) => void;
+    /**
+     * Stable reference to the store's actions.
+     */
+    actions: StoreActions<D>;
+    /**
+     * Triggers an async fetch for a specific key.
+     */
+    fetch: (key: keyof StoreState<D>, ...args: unknown[]) => Promise<void>;
+    /**
+     * Re-runs the async operation for a key with the last used arguments.
+     */
+    refetch: (key: keyof StoreState<D>) => Promise<void>;
+    /**
+     * Invalidates the cache for a specific async key.
+     */
+    invalidate: (key: keyof StoreState<D>) => void;
+    /**
+     * Invalidates all async caches in the store.
+     */
+    invalidateAll: () => void;
+    /**
+     * Gets the raw async state for a key (internal use).
+     */
+    getAsyncState: (key: keyof StoreState<D>) => AsyncState<unknown> | undefined;
+} & StoreActions<D>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,91 @@
+{
+    "name": "@storve/core",
+    "version": "1.0.0",
+    "main": "dist/index.cjs",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.cjs"
+        },
+        "./async": {
+            "types": "./dist/async-entry.d.ts",
+            "import": "./dist/async.mjs",
+            "require": "./dist/async.cjs"
+        },
+        "./computed": {
+            "types": "./dist/computed-entry.d.ts",
+            "import": "./dist/computed.mjs",
+            "require": "./dist/computed.cjs"
+        },
+        "./persist": {
+            "types": "./dist/persist/index.d.ts",
+            "import": "./dist/persist.mjs",
+            "require": "./dist/persist.cjs"
+        },
+        "./persist/adapters/localStorage": {
+            "types": "./dist/persist/adapters/localStorage.d.ts",
+            "import": "./dist/adapters/localStorage.mjs",
+            "require": "./dist/adapters/localStorage.cjs"
+        },
+        "./persist/adapters/sessionStorage": {
+            "types": "./dist/persist/adapters/sessionStorage.d.ts",
+            "import": "./dist/adapters/sessionStorage.mjs",
+            "require": "./dist/adapters/sessionStorage.cjs"
+        },
+        "./persist/adapters/memory": {
+            "types": "./dist/persist/adapters/memory.d.ts",
+            "import": "./dist/adapters/memory.mjs",
+            "require": "./dist/adapters/memory.cjs"
+        },
+        "./persist/adapters/indexedDB": {
+            "types": "./dist/persist/adapters/indexedDB.d.ts",
+            "import": "./dist/adapters/indexedDB.mjs",
+            "require": "./dist/adapters/indexedDB.cjs"
+        },
+        "./signals": {
+            "types": "./dist/signals.d.ts",
+            "import": "./dist/signals.mjs",
+            "require": "./dist/signals.cjs"
+        },
+        "./devtools": {
+            "types": "./dist/devtools.d.ts",
+            "import": "./dist/devtools.mjs",
+            "require": "./dist/devtools.cjs"
+        },
+        "./sync": {
+            "types": "./dist/sync/index.d.ts",
+            "import": "./dist/sync.mjs",
+            "require": "./dist/sync.cjs"
+        }
+    },
+    "scripts": {
+        "test": "vitest run --coverage && npx tsx benchmarks/run.ts && npx tsx benchmarks/week4.ts && npx tsx benchmarks/week5.ts",
+        "test:watch": "vitest --coverage",
+        "test:coverage": "vitest run --coverage",
+        "test:bench": "npx tsx benchmarks/run.ts",
+        "bench:week4": "npx tsx benchmarks/week4.ts",
+        "bench:week5": "npx tsx benchmarks/week5.ts",
+        "lint": "eslint src --ext .ts",
+        "build": "rollup -c",
+        "build:analyze": "rollup -c --environment ANALYZE:true"
+    },
+    "devDependencies": {
+        "@rollup/plugin-terser": "^0.4.4",
+        "@testing-library/react": "^16.3.2",
+        "@types/react": "^18.3.3",
+        "@types/react-dom": "^18.3.0",
+        "@vitest/coverage-v8": "^1.6.1",
+        "jsdom": "^24.1.3",
+        "react": "^18.3.1",
+        "react-dom": "^18.3.1",
+        "rollup-plugin-visualizer": "^5.12.0",
+        "tsx": "^4.21.0"
+    },
+    "peerDependencies": {
+        "immer": ">=10.0.0",
+        "react": ">=18.0.0"
+    }
+}

package/rollup.config.mjs

@@ -0,0 +1,44 @@
+import typescript from '@rollup/plugin-typescript';
+import terser from '@rollup/plugin-terser';
+import { visualizer } from 'rollup-plugin-visualizer';
+
+const analyze = process.env.ANALYZE === 'true';
+
+export default {
+    input: {
+        index: 'src/index.ts',
+        async: 'src/async-entry.ts',
+        computed: 'src/computed-entry.ts',
+        persist: 'src/persist/index.ts',
+        'adapters/localStorage': 'src/persist/adapters/localStorage.ts',
+        'adapters/sessionStorage': 'src/persist/adapters/sessionStorage.ts',
+        'adapters/memory': 'src/persist/adapters/memory.ts',
+        'adapters/indexedDB': 'src/persist/adapters/indexedDB.ts',
+        signals: 'src/signals/index.ts',
+        devtools: 'src/devtools/index.ts',
+        sync: 'src/sync/index.ts',
+    },
+    output: [
+        {
+            dir: 'dist',
+            format: 'es',
+            entryFileNames: '[name].mjs',
+            sourcemap: true,
+        },
+        {
+            dir: 'dist',
+            format: 'cjs',
+            entryFileNames: '[name].cjs',
+            sourcemap: true,
+        },
+    ],
+    plugins: [
+        typescript({
+            tsconfig: './tsconfig.json',
+            declaration: true,
+            declarationDir: 'dist',
+        }),
+        terser(),
+        analyze && visualizer({ filename: 'dist/stats.html', gzipSize: true }),
+    ].filter(Boolean),
+};

package/src/async-entry.ts

@@ -0,0 +1,6 @@
+/**
+ * Async entry point. Import from 'storve/async'.
+ * Side-effect: registers async extension so createStore handles createAsync values.
+ */
+export { createAsync } from './async';
+export type { AsyncState, AsyncOptions, AsyncStatus } from './types';

package/src/async.ts

@@ -0,0 +1,240 @@
+import { AsyncValue, AsyncOptions, AsyncState, AsyncStatus, ASYNC_VALUE_MARKER, IAsyncEngine } from './types';
+import { registerExtension } from './registry';
+
+/**
+ * Creates an async value definition for use in createStore.
+ * 
+ * @param fn - The async function to execute.
+ * @param options - Optional configuration (ttl, staleWhileRevalidate).
+ */
+export function createAsync<T, Args extends unknown[] = unknown[]>(
+    fn: (...args: Args) => Promise<T>,
+    options: AsyncOptions = {}
+): AsyncValue<T> {
+    return {
+        [ASYNC_VALUE_MARKER]: true,
+        init: (onUpdate: (s: AsyncState<T>) => void) =>
+            new AsyncEngine(fn as unknown as (...args: unknown[]) => Promise<T>, options, onUpdate)
+    };
+}
+
+/**
+ * Internal engine that manages the state of a single async key.
+ * Handles fetching, caching, and race condition protection.
+ * @internal
+ */
+export class AsyncEngine<T> implements IAsyncEngine<T> {
+    private lastRequestId = 0;
+    private lastArgs: unknown[] = [];
+    private cache = new Map<string, { data: T; expiresAt: number }>();
+    private status: AsyncStatus = 'idle';
+    private data: T | null = null;
+    private error: string | null = null;
+
+    // Rollback state for optimistic updates
+    private previousData: T | null = null;
+    private previousStatus: AsyncStatus = 'idle';
+    private hasPrevious = false;
+
+    // Stable state result to maintain identity
+    private lastState: AsyncState<T> | null = null;
+    private stableRefetch = () => this.refetch();
+
+    constructor(
+        private fn: (...args: unknown[]) => Promise<T>,
+        private options: AsyncOptions,
+        private onUpdate: (state: AsyncState<T>) => void
+    ) { }
+
+    /**
+     * Returns the current public state shape for this async key.
+     */
+    getState(): AsyncState<T> {
+        if (!this.lastState) {
+            this.lastState = {
+                data: this.data,
+                error: this.error,
+                status: this.status,
+                loading: this.status === 'loading',
+                refetch: this.stableRefetch,
+            };
+        }
+        return this.lastState;
+    }
+
+    /**
+     * Triggers a fetch. Handles TTL caching and SWR.
+     */
+    async fetch(...args: unknown[]): Promise<void> {
+        // Handle optional options as last argument if it looks like { optimistic: ... }
+        let fetchOptions: { optimistic?: { data: T, status?: AsyncStatus } } | undefined;
+        let actualArgs = args;
+
+        if (args.length > 0) {
+            const lastArg = args[args.length - 1];
+            if (lastArg && typeof lastArg === 'object' && 'optimistic' in lastArg) {
+                fetchOptions = lastArg as { optimistic?: { data: T, status?: AsyncStatus } };
+                actualArgs = args.slice(0, -1);
+            }
+        }
+
+        const now = Date.now();
+        const { ttl = 0, staleWhileRevalidate = false } = this.options;
+
+        // Argument-based cache key. v0.5+: replace JSON.stringify with a more robust stable hash
+        const cacheKey = JSON.stringify(actualArgs);
+        const cached = this.cache.get(cacheKey);
+
+        let fromOptimistic = false;
+        if (fetchOptions?.optimistic) {
+            this.previousData = this.data;
+            this.previousStatus = this.status;
+            this.hasPrevious = true;
+            this.data = fetchOptions.optimistic.data;
+            this.status = fetchOptions.optimistic.status || 'success';
+            this.lastArgs = actualArgs;
+            this.notify();
+            fromOptimistic = true;
+            // Fall through to runFetch which will handle result or rollback
+        } else {
+            // Cache hit logic (only if NOT optimistic)
+            if (ttl > 0 && cached && now < cached.expiresAt && this.status === 'success') {
+                if (this.data !== cached.data) {
+                    this.data = cached.data;
+                    this.lastArgs = actualArgs;
+                    this.notify();
+                }
+                return;
+            }
+
+            // Stale-While-Revalidate logic
+            const isStale = ttl > 0 && cached && now >= cached.expiresAt && this.status === 'success';
+
+            if (isStale && staleWhileRevalidate) {
+                this.data = cached.data;
+                this.lastArgs = actualArgs;
+                return this.runFetch(actualArgs, true);
+            }
+        }
+
+        this.lastArgs = actualArgs;
+        return this.runFetch(actualArgs, fromOptimistic);
+    }
+
+    /**
+     * Re-runs the operation with last used arguments. Bypasses TTL.
+     */
+    async refetch(): Promise<void> {
+        return this.runFetch(this.lastArgs, false);
+    }
+
+    /**
+     * Clears the cache for this key.
+     */
+    invalidate(): void {
+        this.cache.clear();
+    }
+
+    /**
+     * Internal runner for the async function with race protection.
+     */
+    private async runFetch(args: unknown[], background: boolean): Promise<void> {
+        const requestId = ++this.lastRequestId;
+
+        // If not a background SWR fetch and NOT already optimistic, show loading
+        if (!background) {
+            this.status = 'loading';
+            this.notify();
+        }
+
+        try {
+            const result = await this.fn(...args);
+
+            // Race condition protection: only the latest request wins
+            if (requestId !== this.lastRequestId) return;
+
+            this.data = result;
+            this.error = null;
+            this.status = 'success';
+            this.hasPrevious = false; // Resolved, no need to rollback anymore
+
+            const ttl = this.options.ttl || 0;
+            if (ttl > 0) {
+                const cacheKey = JSON.stringify(args);
+                this.cache.set(cacheKey, { data: result, expiresAt: Date.now() + ttl });
+            }
+        } catch (err: unknown) {
+            if (requestId !== this.lastRequestId) return;
+
+            this.error = err instanceof Error ? err.message : String(err);
+
+            // Rollback if we had previous data (likely from optimistic update)
+            if (this.hasPrevious) {
+                this.data = this.previousData;
+                this.status = this.previousStatus;
+                this.hasPrevious = false;
+            } else if (background) {
+                // Keep data but set error status
+                this.status = 'error';
+            } else {
+                this.data = null;
+                this.status = 'error';
+            }
+        }
+
+        this.notify();
+    }
+
+    private notify() {
+        this.lastState = null; // Invalidate cached state object
+        this.onUpdate(this.getState());
+    }
+}
+
+// Register async extension when module is imported (order 0 = runs before computed)
+registerExtension({
+    key: 'async',
+    order: 0,
+    processDefinition: (definition) => {
+        const state: Record<string, unknown> = {};
+        const asyncInits: Array<{ key: string; init: (onUpdate: (state: unknown) => void) => unknown }> = [];
+        for (const key of Object.keys(definition)) {
+            const val = definition[key];
+            if (val && typeof val === 'object' && ASYNC_VALUE_MARKER in val) {
+                const asyncVal = val as unknown as AsyncValue<unknown>;
+                asyncInits.push({ key, init: asyncVal.init });
+            } else {
+                state[key] = val;
+            }
+        }
+        return { state, asyncInits };
+    },
+    extendStore: (ctx) => {
+        const engines = ctx.engines as Map<string, IAsyncEngine<unknown>>;
+        return {
+            fetch: async (key: string, ...args: unknown[]) => {
+                if (!engines.has(key)) {
+                    throw new Error(`Storve: no async key "${key}" found in store`);
+                }
+                const engine = engines.get(key);
+                if (engine) await engine.fetch(...args);
+            },
+            refetch: async (key: string) => {
+                const engine = engines.get(key);
+                if (engine) await engine.refetch();
+            },
+            invalidate: (key: string) => {
+                const engine = engines.get(key);
+                if (engine) engine.invalidate();
+            },
+            invalidateAll: () => {
+                engines.forEach((engine) => engine.invalidate());
+            },
+            getAsyncState: (key: string) => {
+                const engine = engines.get(key);
+                return engine ? engine.getState() : undefined;
+            },
+        };
+    },
+});
+