@hamak/ui-store 0.5.9 → 0.7.1

package/dist/api/tokens/service-tokens.d.ts

@@ -7,4 +7,12 @@ export declare const MIDDLEWARE_REGISTRY_TOKEN: unique symbol;
 export declare const REDUCER_REGISTRY_TOKEN: unique symbol;
 export declare const STORE_EXTENSIONS_TOKEN: unique symbol;
 export declare const AUTOSAVE_REGISTRY_TOKEN: unique symbol;
+export declare const PERSISTENCE_PROVIDER_TOKEN: unique symbol;
+/**
+ * Global-registry alias for {@link PERSISTENCE_PROVIDER_TOKEN}. The unique
+ * symbol above only resolves for consumers that import it from this package;
+ * decoupled sibling plugins look the provider up via `Symbol.for(...)` instead
+ * (same convention as `Symbol.for('StoreManager')`, see #28 and #5).
+ */
+export declare const PERSISTENCE_PROVIDER_GLOBAL_TOKEN: unique symbol;
 //# sourceMappingURL=service-tokens.d.ts.map

package/dist/api/tokens/service-tokens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service-tokens.d.ts","sourceRoot":"","sources":["../../../src/api/tokens/service-tokens.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,mBAAmB,eAAyB,CAAC;AAC1D,eAAO,MAAM,yBAAyB,eAA+B,CAAC;AACtE,eAAO,MAAM,sBAAsB,eAA4B,CAAC;AAChE,eAAO,MAAM,sBAAsB,eAA4B,CAAC;AAGhE,eAAO,MAAM,uBAAuB,eAA6B,CAAC"}
+{"version":3,"file":"service-tokens.d.ts","sourceRoot":"","sources":["../../../src/api/tokens/service-tokens.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,mBAAmB,eAAyB,CAAC;AAC1D,eAAO,MAAM,yBAAyB,eAA+B,CAAC;AACtE,eAAO,MAAM,sBAAsB,eAA4B,CAAC;AAChE,eAAO,MAAM,sBAAsB,eAA4B,CAAC;AAGhE,eAAO,MAAM,uBAAuB,eAA6B,CAAC;AAKlE,eAAO,MAAM,0BAA0B,eAAgC,CAAC;AAExE;;;;;GAKG;AACH,eAAO,MAAM,iCAAiC,eAE7C,CAAC"}

package/dist/api/tokens/service-tokens.js

@@ -8,3 +8,14 @@ export const REDUCER_REGISTRY_TOKEN = Symbol('ReducerRegistry');
 export const STORE_EXTENSIONS_TOKEN = Symbol('StoreExtensions');
 // Autosave tokens
 export const AUTOSAVE_REGISTRY_TOKEN = Symbol('AutosaveRegistry');
+// Persistence token — resolves the active IPersistenceProvider so consumers
+// (or sibling plugins) can mount a custom provider instead of the default
+// web-storage one. See amah/app-framework#30.
+export const PERSISTENCE_PROVIDER_TOKEN = Symbol('PersistenceProvider');
+/**
+ * Global-registry alias for {@link PERSISTENCE_PROVIDER_TOKEN}. The unique
+ * symbol above only resolves for consumers that import it from this package;
+ * decoupled sibling plugins look the provider up via `Symbol.for(...)` instead
+ * (same convention as `Symbol.for('StoreManager')`, see #28 and #5).
+ */
+export const PERSISTENCE_PROVIDER_GLOBAL_TOKEN = Symbol.for('@hamak/ui-store:PersistenceProvider');

package/dist/api/types/store-types.d.ts

@@ -2,6 +2,25 @@
  * Store Type Definitions
  */
 import type { Store, Action, StoreEnhancer } from 'redux';
+/**
+ * State persistence configuration. Persistence is applied at the slice
+ * (top-level reducer key) level: a whitelisted slice is serialized to the
+ * configured web storage and rehydrated on boot. See amah/app-framework#30.
+ */
+export interface StorePersistenceConfig {
+    /** Enable state persistence */
+    enabled: boolean;
+    /** Storage key the serialized slice is written under */
+    key?: string;
+    /** Storage type (indexedDB is not yet implemented and falls back to localStorage) */
+    storage?: 'localStorage' | 'sessionStorage' | 'indexedDB';
+    /** Slices to persist (top-level reducer keys); when set, only these are written */
+    whitelist?: string[];
+    /** Slices to never persist (top-level reducer keys); applied after the whitelist */
+    blacklist?: string[];
+    /** Debounce window (ms) for save-on-change; defaults to 250ms */
+    debounceMs?: number;
+}
 /**
  * Store configuration
  */
@@ -13,18 +32,7 @@ export interface StoreConfig {
     /** Additional store enhancers */
     enhancers?: StoreEnhancer[];
     /** Persistence configuration */
-    persistence?: {
-        /** Enable state persistence */
-        enabled: boolean;
-        /** Storage key prefix */
-        key?: string;
-        /** Storage type */
-        storage?: 'localStorage' | 'sessionStorage' | 'indexedDB';
-        /** Keys to persist (whitelist) */
-        whitelist?: string[];
-        /** Keys to ignore (blacklist) */
-        blacklist?: string[];
-    };
+    persistence?: StorePersistenceConfig;
 }
 /**
  * Root state shape (can be extended by applications)

package/dist/api/types/store-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-types.d.ts","sourceRoot":"","sources":["../../../src/api/types/store-types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,wCAAwC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,8BAA8B;IAC9B,cAAc,CAAC,EAAE,GAAG,CAAC;IAErB,iCAAiC;IACjC,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;IAE5B,gCAAgC;IAChC,WAAW,CAAC,EAAE;QACZ,+BAA+B;QAC/B,OAAO,EAAE,OAAO,CAAC;QACjB,yBAAyB;QACzB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,mBAAmB;QACnB,OAAO,CAAC,EAAE,cAAc,GAAG,gBAAgB,GAAG,WAAW,CAAC;QAC1D,kCAAkC;QAClC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QACrB,iCAAiC;QACjC,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;KACtB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,MAAM,CAAC,MAAM,CAAC;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,CAAC,CAAC;IACZ,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC"}
+{"version":3,"file":"store-types.d.ts","sourceRoot":"","sources":["../../../src/api/types/store-types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE1D;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,+BAA+B;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,wDAAwD;IACxD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,qFAAqF;IACrF,OAAO,CAAC,EAAE,cAAc,GAAG,gBAAgB,GAAG,WAAW,CAAC;IAC1D,mFAAmF;IACnF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oFAAoF;IACpF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,wCAAwC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,8BAA8B;IAC9B,cAAc,CAAC,EAAE,GAAG,CAAC;IAErB,iCAAiC;IACjC,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;IAE5B,gCAAgC;IAChC,WAAW,CAAC,EAAE,sBAAsB,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,GAAG,GAAG,CAAE,SAAQ,MAAM,CAAC,MAAM,CAAC;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,CAAC,CAAC;IACZ,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,GAAG,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC"}

package/dist/impl/core/store-manager.d.ts

@@ -3,21 +3,33 @@
  */
 import { type Store, type Reducer } from '@reduxjs/toolkit';
 import type { IStoreManager, StoreConfig, RootState, AppAction } from '../../api/index.js';
+import type { IPersistenceProvider } from '../../spi/index.js';
 import { MiddlewareRegistry } from './middleware-registry.js';
 import { ReducerRegistry } from './reducer-registry.js';
+/**
+ * Internal store config. Extends the public {@link StoreConfig} with the
+ * resolved persistence provider, which the plugin factory injects after
+ * resolving it via DI (see amah/app-framework#30). Kept out of the public
+ * type so consumers configure persistence declaratively, not by passing
+ * provider instances.
+ */
+export interface StoreManagerConfig extends StoreConfig {
+    persistenceProvider?: IPersistenceProvider;
+}
 export declare class StoreManager implements IStoreManager {
     private store;
     private middlewareRegistry;
     private reducerRegistry;
     private initialized;
     private fileSystemAdapter;
+    private persistenceUnsubscribe;
     constructor();
     getMiddlewareRegistry(): MiddlewareRegistry;
     getReducerRegistry(): ReducerRegistry;
     setFileSystemAdapter(adapter: any): void;
     getFileSystemAdapter(): any;
     isInitialized(): boolean;
-    initialize(config?: StoreConfig): Store<RootState, AppAction>;
+    initialize(config?: StoreManagerConfig): Store<RootState, AppAction>;
     getStore(): Store<RootState, AppAction>;
     dispatch<A extends AppAction>(action: A): A;
     getState<S = RootState>(): S;

package/dist/impl/core/store-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-manager.d.ts","sourceRoot":"","sources":["../../../src/impl/core/store-manager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAkB,KAAK,KAAK,EAAE,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,qBAAa,YAAa,YAAW,aAAa;IAChD,OAAO,CAAC,KAAK,CAA4C;IACzD,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,iBAAiB,CAAoB;;IAY7C,qBAAqB;IAIrB,kBAAkB;IAIlB,oBAAoB,CAAC,OAAO,EAAE,GAAG;IAIjC,oBAAoB;IAIpB,aAAa,IAAI,OAAO;IAIxB,UAAU,CAAC,MAAM,GAAE,WAAgB,GAAG,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC;IAsDjE,QAAQ,IAAI,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC;IAOvC,QAAQ,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC;IAI3C,QAAQ,CAAC,CAAC,GAAG,SAAS,KAAK,CAAC;IAI5B,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAI3C,cAAc,CAAC,WAAW,EAAE,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,IAAI;IAIhE,OAAO,IAAI,IAAI;CAKhB"}
+{"version":3,"file":"store-manager.d.ts","sourceRoot":"","sources":["../../../src/impl/core/store-manager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAkB,KAAK,KAAK,EAAE,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAClF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAEtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;GAMG;AACH,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD,mBAAmB,CAAC,EAAE,oBAAoB,CAAC;CAC5C;AAED,qBAAa,YAAa,YAAW,aAAa;IAChD,OAAO,CAAC,KAAK,CAA4C;IACzD,OAAO,CAAC,kBAAkB,CAAqB;IAC/C,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,iBAAiB,CAAoB;IAC7C,OAAO,CAAC,sBAAsB,CAA6B;;IAY3D,qBAAqB;IAIrB,kBAAkB;IAIlB,oBAAoB,CAAC,OAAO,EAAE,GAAG;IAIjC,oBAAoB;IAIpB,aAAa,IAAI,OAAO;IAIxB,UAAU,CAAC,MAAM,GAAE,kBAAuB,GAAG,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC;IAiExE,QAAQ,IAAI,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC;IAOvC,QAAQ,CAAC,CAAC,SAAS,SAAS,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC;IAI3C,QAAQ,CAAC,CAAC,GAAG,SAAS,KAAK,CAAC;IAI5B,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAI3C,cAAc,CAAC,WAAW,EAAE,OAAO,CAAC,SAAS,EAAE,SAAS,CAAC,GAAG,IAAI;IAIhE,OAAO,IAAI,IAAI;CAShB"}

package/dist/impl/core/store-manager.js

@@ -2,6 +2,7 @@
  * Store Manager Implementation
  */
 import { configureStore } from '@reduxjs/toolkit';
+import { attachPersistenceSave } from '../persistence/index.js';
 import { MiddlewareRegistry } from './middleware-registry.js';
 import { ReducerRegistry } from './reducer-registry.js';
 export class StoreManager {
@@ -36,6 +37,12 @@ export class StoreManager {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "persistenceUnsubscribe", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
         this.middlewareRegistry = new MiddlewareRegistry();
         this.reducerRegistry = new ReducerRegistry((rootReducer) => {
             // Hot replacement callback
@@ -92,6 +99,12 @@ export class StoreManager {
             } : false,
         });
         this.initialized = true;
+        // Persist the whitelisted slice on change when persistence is enabled and a
+        // provider was injected (rehydration is handled upstream by the plugin via
+        // preloadedState, since load() is async). See amah/app-framework#30.
+        if (config.persistence?.enabled && config.persistenceProvider) {
+            this.persistenceUnsubscribe = attachPersistenceSave(this.store, config.persistenceProvider, config.persistence);
+        }
         console.log('[StoreManager] Store initialized with:', {
             reducers: this.reducerRegistry.getAllRegistrations().map(r => r.key),
             middleware: this.middlewareRegistry.getAllRegistrations().map(m => ({
@@ -122,6 +135,10 @@ export class StoreManager {
         this.getStore().replaceReducer(nextReducer);
     }
     destroy() {
+        if (this.persistenceUnsubscribe) {
+            this.persistenceUnsubscribe();
+            this.persistenceUnsubscribe = null;
+        }
         this.store = null;
         this.initialized = false;
         console.log('[StoreManager] Store destroyed');

package/dist/impl/index.d.ts

@@ -9,4 +9,5 @@ export * from './middleware/index.js';
 export * from './plugin/index.js';
 export * from './fs/index.js';
 export * from './autosave/index.js';
+export * from './persistence/index.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/impl/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AAEvB,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,MAAM,CAAC;AACrB,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/impl/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AAEvB,cAAc,QAAQ,CAAC;AACvB,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,MAAM,CAAC;AACrB,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC"}

package/dist/impl/index.js

@@ -10,3 +10,4 @@ export * from './middleware/index.js';
 export * from './plugin/index.js';
 export * from './fs/index.js';
 export * from './autosave/index.js';
+export * from './persistence/index.js';

package/dist/impl/persistence/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * State persistence implementations and wiring.
+ * See amah/app-framework#30.
+ */
+export * from './web-storage-persistence-provider.js';
+export * from './persistence-filter.js';
+export * from './persistence-resolver.js';
+export * from './persistence-wiring.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/persistence/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/impl/persistence/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,oCAAoC,CAAC;AACnD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC"}

package/dist/impl/persistence/index.js

@@ -0,0 +1,8 @@
+/**
+ * State persistence implementations and wiring.
+ * See amah/app-framework#30.
+ */
+export * from './web-storage-persistence-provider.js';
+export * from './persistence-filter.js';
+export * from './persistence-resolver.js';
+export * from './persistence-wiring.js';

package/dist/impl/persistence/persistence-filter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Slice-level whitelist/blacklist filtering for persisted state.
+ *
+ * Persistence operates at the top-level reducer key ("slice") granularity:
+ * a whitelist keeps only the named slices; a blacklist drops named slices.
+ * The whitelist is applied first, then the blacklist. See amah/app-framework#30.
+ */
+import type { StorePersistenceConfig } from '../../api/index.js';
+export type SliceSelection = Pick<StorePersistenceConfig, 'whitelist' | 'blacklist'>;
+export declare function pickPersistableState(state: Record<string, unknown> | null | undefined, selection: SliceSelection): Record<string, unknown>;
+//# sourceMappingURL=persistence-filter.d.ts.map

package/dist/impl/persistence/persistence-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence-filter.d.ts","sourceRoot":"","sources":["../../../src/impl/persistence/persistence-filter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAExD,MAAM,MAAM,cAAc,GAAG,IAAI,CAC/B,sBAAsB,EACtB,WAAW,GAAG,WAAW,CAC1B,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EACjD,SAAS,EAAE,cAAc,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgBzB"}

package/dist/impl/persistence/persistence-filter.js

@@ -0,0 +1,24 @@
+/**
+ * Slice-level whitelist/blacklist filtering for persisted state.
+ *
+ * Persistence operates at the top-level reducer key ("slice") granularity:
+ * a whitelist keeps only the named slices; a blacklist drops named slices.
+ * The whitelist is applied first, then the blacklist. See amah/app-framework#30.
+ */
+export function pickPersistableState(state, selection) {
+    if (!state || typeof state !== 'object')
+        return {};
+    const { whitelist, blacklist } = selection;
+    const result = {};
+    for (const key of Object.keys(state)) {
+        // A set whitelist constrains to its members (an empty whitelist persists
+        // nothing); an unset whitelist imposes no constraint. The blacklist is
+        // then applied on top.
+        if (whitelist && !whitelist.includes(key))
+            continue;
+        if (blacklist && blacklist.includes(key))
+            continue;
+        result[key] = state[key];
+    }
+    return result;
+}

package/dist/impl/persistence/persistence-resolver.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves a concrete `IPersistenceProvider` from a `StorePersistenceConfig`.
+ * Used to build the default provider when a consumer enables persistence but
+ * does not mount a custom one. See amah/app-framework#30.
+ */
+import type { StorePersistenceConfig } from '../../api/index.js';
+import type { IPersistenceProvider } from '../../spi/index.js';
+export declare function resolvePersistenceProvider(persistence: StorePersistenceConfig): IPersistenceProvider;
+//# sourceMappingURL=persistence-resolver.d.ts.map

package/dist/impl/persistence/persistence-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence-resolver.d.ts","sourceRoot":"","sources":["../../../src/impl/persistence/persistence-resolver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAMtD,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,sBAAsB,GAClC,oBAAoB,CAiBtB"}

package/dist/impl/persistence/persistence-resolver.js

@@ -0,0 +1,22 @@
+/**
+ * Resolves a concrete `IPersistenceProvider` from a `StorePersistenceConfig`.
+ * Used to build the default provider when a consumer enables persistence but
+ * does not mount a custom one. See amah/app-framework#30.
+ */
+import { createLocalStoragePersistenceProvider, createSessionStoragePersistenceProvider, } from './web-storage-persistence-provider.js';
+export function resolvePersistenceProvider(persistence) {
+    const storage = persistence.storage ?? 'localStorage';
+    switch (storage) {
+        case 'sessionStorage':
+            return createSessionStoragePersistenceProvider();
+        case 'indexedDB':
+            // Not yet implemented — fall back to localStorage so enabling it is not a
+            // silent no-op. Tracked as a follow-up in #30.
+            console.warn("[persistence] storage 'indexedDB' is not implemented yet; " +
+                'falling back to localStorage.');
+            return createLocalStoragePersistenceProvider();
+        case 'localStorage':
+        default:
+            return createLocalStoragePersistenceProvider();
+    }
+}

package/dist/impl/persistence/persistence-wiring.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Load/save wiring that connects a Redux store to an `IPersistenceProvider`.
+ *
+ * - `loadPersistedState` rehydrates the whitelisted slice on boot (async,
+ *   called before store creation so the result can seed `preloadedState`).
+ * - `attachPersistenceSave` subscribes to the store and writes the whitelisted
+ *   slice back, debounced, on every change. See amah/app-framework#30.
+ */
+import type { Store } from 'redux';
+import type { StorePersistenceConfig } from '../../api/index.js';
+import type { IPersistenceProvider } from '../../spi/index.js';
+/** Default storage key when `persistence.key` is not set. */
+export declare const DEFAULT_PERSISTENCE_KEY = "state";
+/** Default debounce window for save-on-change. */
+export declare const DEFAULT_PERSISTENCE_DEBOUNCE_MS = 250;
+export declare function persistenceKey(persistence: StorePersistenceConfig): string;
+/**
+ * Load the persisted slice and re-apply the whitelist/blacklist defensively
+ * (in case the config tightened since the data was written). Returns
+ * `undefined` when nothing is persisted, so callers can spread it into
+ * `preloadedState` without overwriting reducer defaults.
+ */
+export declare function loadPersistedState(provider: IPersistenceProvider, persistence: StorePersistenceConfig): Promise<Record<string, unknown> | undefined>;
+/**
+ * Subscribe to the store and persist the whitelisted slice on change,
+ * debounced. Returns an unsubscribe function that also cancels a pending save.
+ */
+export declare function attachPersistenceSave(store: Pick<Store, 'getState' | 'subscribe'>, provider: IPersistenceProvider, persistence: StorePersistenceConfig): () => void;
+//# sourceMappingURL=persistence-wiring.d.ts.map

package/dist/impl/persistence/persistence-wiring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persistence-wiring.d.ts","sourceRoot":"","sources":["../../../src/impl/persistence/persistence-wiring.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AACnC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAGtD,6DAA6D;AAC7D,eAAO,MAAM,uBAAuB,UAAU,CAAC;AAE/C,kDAAkD;AAClD,eAAO,MAAM,+BAA+B,MAAM,CAAC;AAEnD,wBAAgB,cAAc,CAAC,WAAW,EAAE,sBAAsB,GAAG,MAAM,CAE1E;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,oBAAoB,EAC9B,WAAW,EAAE,sBAAsB,GAClC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC,CAQ9C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,CAAC,EAC5C,QAAQ,EAAE,oBAAoB,EAC9B,WAAW,EAAE,sBAAsB,GAClC,MAAM,IAAI,CAyCZ"}

package/dist/impl/persistence/persistence-wiring.js

@@ -0,0 +1,69 @@
+/**
+ * Load/save wiring that connects a Redux store to an `IPersistenceProvider`.
+ *
+ * - `loadPersistedState` rehydrates the whitelisted slice on boot (async,
+ *   called before store creation so the result can seed `preloadedState`).
+ * - `attachPersistenceSave` subscribes to the store and writes the whitelisted
+ *   slice back, debounced, on every change. See amah/app-framework#30.
+ */
+import { pickPersistableState } from './persistence-filter.js';
+/** Default storage key when `persistence.key` is not set. */
+export const DEFAULT_PERSISTENCE_KEY = 'state';
+/** Default debounce window for save-on-change. */
+export const DEFAULT_PERSISTENCE_DEBOUNCE_MS = 250;
+export function persistenceKey(persistence) {
+    return persistence.key ?? DEFAULT_PERSISTENCE_KEY;
+}
+/**
+ * Load the persisted slice and re-apply the whitelist/blacklist defensively
+ * (in case the config tightened since the data was written). Returns
+ * `undefined` when nothing is persisted, so callers can spread it into
+ * `preloadedState` without overwriting reducer defaults.
+ */
+export async function loadPersistedState(provider, persistence) {
+    const loaded = await provider.load(persistenceKey(persistence));
+    if (loaded == null || typeof loaded !== 'object')
+        return undefined;
+    const filtered = pickPersistableState(loaded, persistence);
+    return Object.keys(filtered).length > 0 ? filtered : undefined;
+}
+/**
+ * Subscribe to the store and persist the whitelisted slice on change,
+ * debounced. Returns an unsubscribe function that also cancels a pending save.
+ */
+export function attachPersistenceSave(store, provider, persistence) {
+    const key = persistenceKey(persistence);
+    const debounceMs = persistence.debounceMs ?? DEFAULT_PERSISTENCE_DEBOUNCE_MS;
+    let timer = null;
+    // Seed the baseline with the current slice so a change that leaves the
+    // persisted slice untouched (e.g. a non-whitelisted slice updated) never
+    // triggers a redundant write — including right after rehydration.
+    let lastSerialized = JSON.stringify(pickPersistableState(store.getState(), persistence));
+    const flush = () => {
+        timer = null;
+        const slice = pickPersistableState(store.getState(), persistence);
+        const serialized = JSON.stringify(slice);
+        // Skip redundant writes when the persisted slice did not actually change.
+        if (serialized === lastSerialized)
+            return;
+        lastSerialized = serialized;
+        void provider.save(key, slice);
+    };
+    const unsubscribe = store.subscribe(() => {
+        if (timer !== null)
+            clearTimeout(timer);
+        if (debounceMs <= 0) {
+            flush();
+        }
+        else {
+            timer = setTimeout(flush, debounceMs);
+        }
+    });
+    return () => {
+        if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        unsubscribe();
+    };
+}

package/dist/impl/persistence/web-storage-persistence-provider.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Web Storage Persistence Provider
+ *
+ * Concrete `IPersistenceProvider` backed by a Web Storage area
+ * (`localStorage` / `sessionStorage`). When the backing storage is
+ * unavailable — SSR, private-mode quota errors, disabled storage — it
+ * degrades gracefully to an in-memory map so callers never throw. This mirrors
+ * the `createLocalStorageActiveProjectStorage` fallback pattern used
+ * downstream. See amah/app-framework#30.
+ */
+import type { IPersistenceProvider } from '../../spi/index.js';
+/** Minimal structural subset of the Web Storage API we depend on. */
+export interface WebStorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+    key(index: number): string | null;
+    readonly length: number;
+}
+/** Default namespace every persisted key is prefixed with. */
+export declare const DEFAULT_PERSISTENCE_NAMESPACE = "@hamak/ui-store";
+export declare class WebStoragePersistenceProvider implements IPersistenceProvider {
+    private readonly storage;
+    private readonly namespace;
+    private readonly memory;
+    private readonly available;
+    /**
+     * @param storage   Backing web storage, or `null` to run in-memory only.
+     * @param namespace Key prefix; `clear()` only removes keys under this prefix
+     *                  so it never wipes unrelated app state.
+     */
+    constructor(storage: WebStorageLike | null, namespace?: string);
+    isAvailable(): boolean;
+    save(key: string, state: unknown): Promise<void>;
+    load(key: string): Promise<any | null>;
+    remove(key: string): Promise<void>;
+    clear(): Promise<void>;
+    private fullKey;
+    /** Verify the storage area is usable with a write/remove round-trip. */
+    private static probe;
+}
+/** Provider backed by `window.localStorage` (in-memory fallback when absent). */
+export declare function createLocalStoragePersistenceProvider(namespace?: string): WebStoragePersistenceProvider;
+/** Provider backed by `window.sessionStorage` (in-memory fallback when absent). */
+export declare function createSessionStoragePersistenceProvider(namespace?: string): WebStoragePersistenceProvider;
+//# sourceMappingURL=web-storage-persistence-provider.d.ts.map

package/dist/impl/persistence/web-storage-persistence-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-storage-persistence-provider.d.ts","sourceRoot":"","sources":["../../../src/impl/persistence/web-storage-persistence-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAEtD,qEAAqE;AACrE,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACpC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,8DAA8D;AAC9D,eAAO,MAAM,6BAA6B,oBAAoB,CAAC;AAI/D,qBAAa,6BAA8B,YAAW,oBAAoB;IAUtE,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAV5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IAEpC;;;;OAIG;gBAEgB,OAAO,EAAE,cAAc,GAAG,IAAI,EAC9B,SAAS,GAAE,MAAsC;IAKpE,WAAW,IAAI,OAAO;IAIhB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAchD,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC;IAsBtC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB5B,OAAO,CAAC,OAAO;IAIf,wEAAwE;IACxE,OAAO,CAAC,MAAM,CAAC,KAAK;CAUrB;AAcD,iFAAiF;AACjF,wBAAgB,qCAAqC,CACnD,SAAS,CAAC,EAAE,MAAM,GACjB,6BAA6B,CAK/B;AAED,mFAAmF;AACnF,wBAAgB,uCAAuC,CACrD,SAAS,CAAC,EAAE,MAAM,GACjB,6BAA6B,CAK/B"}

package/dist/impl/persistence/web-storage-persistence-provider.js

@@ -0,0 +1,155 @@
+/**
+ * Web Storage Persistence Provider
+ *
+ * Concrete `IPersistenceProvider` backed by a Web Storage area
+ * (`localStorage` / `sessionStorage`). When the backing storage is
+ * unavailable — SSR, private-mode quota errors, disabled storage — it
+ * degrades gracefully to an in-memory map so callers never throw. This mirrors
+ * the `createLocalStorageActiveProjectStorage` fallback pattern used
+ * downstream. See amah/app-framework#30.
+ */
+/** Default namespace every persisted key is prefixed with. */
+export const DEFAULT_PERSISTENCE_NAMESPACE = '@hamak/ui-store';
+const PROBE_KEY = '@hamak/ui-store:__persist_probe__';
+export class WebStoragePersistenceProvider {
+    /**
+     * @param storage   Backing web storage, or `null` to run in-memory only.
+     * @param namespace Key prefix; `clear()` only removes keys under this prefix
+     *                  so it never wipes unrelated app state.
+     */
+    constructor(storage, namespace = DEFAULT_PERSISTENCE_NAMESPACE) {
+        Object.defineProperty(this, "storage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: storage
+        });
+        Object.defineProperty(this, "namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: namespace
+        });
+        Object.defineProperty(this, "memory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "available", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.available = WebStoragePersistenceProvider.probe(storage);
+    }
+    isAvailable() {
+        return this.available;
+    }
+    async save(key, state) {
+        const serialized = JSON.stringify(state);
+        const fullKey = this.fullKey(key);
+        if (this.available && this.storage) {
+            try {
+                this.storage.setItem(fullKey, serialized);
+                return;
+            }
+            catch (e) {
+                console.warn('[persistence] save failed, falling back to memory:', e);
+            }
+        }
+        this.memory.set(fullKey, serialized);
+    }
+    async load(key) {
+        const fullKey = this.fullKey(key);
+        let raw = null;
+        if (this.available && this.storage) {
+            try {
+                raw = this.storage.getItem(fullKey);
+            }
+            catch (e) {
+                console.warn('[persistence] load failed:', e);
+            }
+        }
+        if (raw == null) {
+            raw = this.memory.get(fullKey) ?? null;
+        }
+        if (raw == null)
+            return null;
+        try {
+            return JSON.parse(raw);
+        }
+        catch (e) {
+            console.warn('[persistence] could not parse persisted state:', e);
+            return null;
+        }
+    }
+    async remove(key) {
+        const fullKey = this.fullKey(key);
+        this.memory.delete(fullKey);
+        if (this.available && this.storage) {
+            try {
+                this.storage.removeItem(fullKey);
+            }
+            catch (e) {
+                console.warn('[persistence] remove failed:', e);
+            }
+        }
+    }
+    async clear() {
+        // Only remove keys under our namespace — never the whole storage area.
+        for (const memKey of [...this.memory.keys()]) {
+            if (memKey.startsWith(this.namespace))
+                this.memory.delete(memKey);
+        }
+        if (this.available && this.storage) {
+            try {
+                const toRemove = [];
+                for (let i = 0; i < this.storage.length; i++) {
+                    const k = this.storage.key(i);
+                    if (k && k.startsWith(this.namespace))
+                        toRemove.push(k);
+                }
+                toRemove.forEach((k) => this.storage.removeItem(k));
+            }
+            catch (e) {
+                console.warn('[persistence] clear failed:', e);
+            }
+        }
+    }
+    fullKey(key) {
+        return `${this.namespace}:${key}`;
+    }
+    /** Verify the storage area is usable with a write/remove round-trip. */
+    static probe(storage) {
+        if (!storage)
+            return false;
+        try {
+            storage.setItem(PROBE_KEY, '1');
+            storage.removeItem(PROBE_KEY);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function getWindowStorage(kind) {
+    try {
+        const g = globalThis;
+        return g[kind] ?? null;
+    }
+    catch {
+        // Accessing storage can throw in some sandboxed environments.
+        return null;
+    }
+}
+/** Provider backed by `window.localStorage` (in-memory fallback when absent). */
+export function createLocalStoragePersistenceProvider(namespace) {
+    return new WebStoragePersistenceProvider(getWindowStorage('localStorage'), namespace);
+}
+/** Provider backed by `window.sessionStorage` (in-memory fallback when absent). */
+export function createSessionStoragePersistenceProvider(namespace) {
+    return new WebStoragePersistenceProvider(getWindowStorage('sessionStorage'), namespace);
+}

package/dist/impl/plugin/store-plugin-factory.d.ts

@@ -3,13 +3,25 @@
  * Creates a microkernel plugin for Redux store management
  */
 import type { PluginModule } from '@hamak/microkernel-spi';
-import { type StorePluginExtensions } from '../../api/index.js';
+import { type StorePluginExtensions, type StorePersistenceConfig } from '../../api/index.js';
+import type { IPersistenceProvider } from '../../spi/index.js';
 export declare const FILESYSTEM_ADAPTER_TOKEN = "FILESYSTEM_ADAPTER";
 export interface StorePluginConfig extends StorePluginExtensions {
     /** Enable Redux DevTools integration */
     devTools?: boolean;
     /** Enable logger middleware in development */
     logger?: boolean;
+    /**
+     * State persistence configuration. When `enabled`, the whitelisted slice is
+     * rehydrated on boot and saved (debounced) on change. See #30.
+     */
+    persistence?: StorePersistenceConfig;
+    /**
+     * Custom persistence provider to mount instead of the default web-storage
+     * one. Takes precedence over any DI-registered provider and over the
+     * `persistence.storage` default. See #30.
+     */
+    persistenceProvider?: IPersistenceProvider;
 }
 export declare function createStorePlugin(config?: StorePluginConfig): PluginModule;
 //# sourceMappingURL=store-plugin-factory.d.ts.map

package/dist/impl/plugin/store-plugin-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-plugin-factory.d.ts","sourceRoot":"","sources":["../../../src/impl/plugin/store-plugin-factory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAML,KAAK,qBAAqB,EAC3B,MAAM,WAAW,CAAC;AAanB,eAAO,MAAM,wBAAwB,uBAAuB,CAAC;AAE7D,MAAM,WAAW,iBAAkB,SAAQ,qBAAqB;IAC9D,wCAAwC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,GAAE,iBAAsB,GAC7B,YAAY,CAqId"}
+{"version":3,"file":"store-plugin-factory.d.ts","sourceRoot":"","sources":["../../../src/impl/plugin/store-plugin-factory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAQL,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC5B,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AActD,eAAO,MAAM,wBAAwB,uBAAuB,CAAC;AAE7D,MAAM,WAAW,iBAAkB,SAAQ,qBAAqB;IAC9D,wCAAwC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,8CAA8C;IAC9C,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB;;;OAGG;IACH,WAAW,CAAC,EAAE,sBAAsB,CAAC;IAErC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,oBAAoB,CAAC;CAC5C;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,GAAE,iBAAsB,GAC7B,YAAY,CAmMd"}

package/dist/impl/plugin/store-plugin-factory.js

@@ -2,11 +2,12 @@
  * Store Plugin Factory
  * Creates a microkernel plugin for Redux store management
  */
-import { STORE_MANAGER_TOKEN, MIDDLEWARE_REGISTRY_TOKEN, REDUCER_REGISTRY_TOKEN, STORE_EXTENSIONS_TOKEN, } from '../../api/index.js';
+import { STORE_MANAGER_TOKEN, MIDDLEWARE_REGISTRY_TOKEN, REDUCER_REGISTRY_TOKEN, STORE_EXTENSIONS_TOKEN, PERSISTENCE_PROVIDER_TOKEN, PERSISTENCE_PROVIDER_GLOBAL_TOKEN, } from '../../api/index.js';
 import { StoreManager } from '../core/store-manager.js';
 import { createEventBridgeMiddleware, createLoggerMiddleware, } from '../middleware/index.js';
 import { applyStoreExtensions, createStoreExtensionsCollector, } from '../extensions/store-extensions.js';
 import { createFileSystemAdapter } from '../fs/core/fs-adapter.js';
+import { resolvePersistenceProvider, loadPersistedState } from '../persistence/index.js';
 // DI token for filesystem adapter
 export const FILESYSTEM_ADAPTER_TOKEN = 'FILESYSTEM_ADAPTER';
 export function createStorePlugin(config = {}) {
@@ -14,6 +15,8 @@ export function createStorePlugin(config = {}) {
     const middlewareRegistry = storeManager.getMiddlewareRegistry();
     const reducerRegistry = storeManager.getReducerRegistry();
     const extensionsCollector = createStoreExtensionsCollector();
+    // Resolved once in initialize(), reused in activate() for rehydrate + save.
+    let persistenceProvider;
     // Create filesystem adapter with 'fs' slice name
     const fileSystemAdapter = createFileSystemAdapter('fs');
     const registerDefaultMiddleware = (hooks) => {
@@ -95,15 +98,67 @@ export function createStorePlugin(config = {}) {
                 provide: FILESYSTEM_ADAPTER_TOKEN,
                 useValue: fileSystemAdapter,
             });
+            // Back-compat aliases (global symbol registry). The unique-symbol tokens
+            // above only resolve for consumers that import them from
+            // `@hamak/ui-store-api`. Several sibling plugins (ui-navigation, auth,
+            // notification, event-channel) deliberately stay decoupled and look the
+            // store services up via `Symbol.for(...)` keys instead. Register the same
+            // instances under those global keys so those lookups succeed instead of
+            // silently no-opping. See amah/app-framework#28 and #5.
+            ctx.provide({
+                provide: Symbol.for('StoreManager'),
+                useValue: storeManager,
+            });
+            ctx.provide({
+                provide: Symbol.for('@hamak/ui-store:StoreExtensionsRegistry'),
+                useValue: extensionsCollector,
+            });
+            // Resolve the persistence provider (Option B, #30). Precedence:
+            //   1. explicit mount-time provider (config.persistenceProvider)
+            //   2. a provider another plugin already registered under the token
+            //   3. a default built from `persistence.storage`
+            // The resolved instance is re-provided under both the unique and global
+            // tokens so sibling plugins can look it up the same way they do the store.
+            persistenceProvider = config.persistenceProvider;
+            if (!persistenceProvider) {
+                try {
+                    persistenceProvider = ctx.resolve(PERSISTENCE_PROVIDER_TOKEN);
+                }
+                catch {
+                    // No provider registered yet — fall through to the default.
+                }
+            }
+            if (!persistenceProvider && config.persistence?.enabled) {
+                persistenceProvider = resolvePersistenceProvider(config.persistence);
+            }
+            if (persistenceProvider) {
+                ctx.provide({
+                    provide: PERSISTENCE_PROVIDER_TOKEN,
+                    useValue: persistenceProvider,
+                });
+                ctx.provide({
+                    provide: PERSISTENCE_PROVIDER_GLOBAL_TOKEN,
+                    useValue: persistenceProvider,
+                });
+            }
             registerDefaultMiddleware(ctx.hooks);
             registerConfigExtensions();
             console.log('[ui-store] Plugin initialized with filesystem support');
         },
         async activate(ctx) {
             applyStoreExtensions(extensionsCollector, middlewareRegistry, reducerRegistry);
+            // Rehydrate the persisted slice before store creation (load() is async,
+            // but preloadedState must be supplied synchronously). See #30.
+            let preloadedState;
+            if (persistenceProvider && config.persistence?.enabled) {
+                preloadedState = await loadPersistedState(persistenceProvider, config.persistence);
+            }
             // Initialize the store after all plugins have registered middleware/reducers
             const store = storeManager.initialize({
                 devTools: config.devTools,
+                preloadedState,
+                persistence: config.persistence,
+                persistenceProvider,
             });
             // Bridge Redux state changes to microkernel events
             store.subscribe(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamak/ui-store",
-  "version": "0.5.9",
+  "version": "0.7.1",
   "private": false,
   "type": "module",
   "description": "Redux store management for microkernel-based applications",