@chromahq/store 0.0.3 → 0.0.4

package/dist/index.cjs.js

@@ -0,0 +1,405 @@
+'use strict';
+
+var React = require('react');
+var vanilla = require('zustand/vanilla');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+function chromeStoragePersist(options) {
+  return (config) => (set, get, store) => {
+    const key = options.name;
+    let isInitialized = false;
+    let persistenceSetup = false;
+    const initialState = config(set, get, store);
+    const loadPersistedState = async () => {
+      try {
+        if (!chrome?.storage?.local) {
+          console.warn(`Chrome storage not available for "${key}", using memory only`);
+          isInitialized = true;
+          setupPersistence();
+          return;
+        }
+        const result = await new Promise((resolve, reject) => {
+          chrome.storage.local.get([key], (result2) => {
+            if (chrome.runtime.lastError) {
+              reject(chrome.runtime.lastError);
+            } else {
+              resolve(result2);
+            }
+          });
+        });
+        if (result[key]) {
+          const mergedState = { ...initialState, ...result[key] };
+          set(mergedState);
+        } else {
+          await persistState(initialState);
+        }
+      } catch (error) {
+        console.error(`Failed to load persisted state for "${key}":`, error);
+      } finally {
+        isInitialized = true;
+        setupPersistence();
+      }
+    };
+    const persistState = async (state) => {
+      if (!chrome?.storage?.local) {
+        return;
+      }
+      return new Promise((resolve) => {
+        chrome.storage.local.set({ [key]: state }, () => {
+          if (chrome.runtime.lastError) {
+            console.error(`Failed to persist state for "${key}":`, chrome.runtime.lastError);
+          }
+          resolve();
+        });
+      });
+    };
+    const setupPersistence = () => {
+      if (persistenceSetup) return;
+      persistenceSetup = true;
+      store.subscribe((state) => {
+        if (!isInitialized) return;
+        persistState(state);
+      });
+    };
+    loadPersistedState();
+    return initialState;
+  };
+}
+
+function useCentralStore(store, selector) {
+  return React.useSyncExternalStore(
+    store.subscribe,
+    () => selector(store.getState()),
+    () => selector(store.getState())
+  );
+}
+function useCentralDispatch(store) {
+  return store.setState;
+}
+
+class BridgeStore {
+  constructor(bridge, initialState, storeName = "default") {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.currentState = null;
+    this.previousState = null;
+    this.ready = false;
+    this.initialize = async () => {
+      try {
+        console.log("Initializing bridge store:", this.storeName, this.bridge);
+        const state = await this.bridge.send(`store:${this.storeName}:getState`);
+        this.previousState = this.currentState;
+        this.currentState = state;
+        this.notifyListeners();
+        this.ready = true;
+      } catch (error) {
+        console.warn("Failed to initialize bridge store:", error);
+      }
+    };
+    this.notifyListeners = () => {
+      if (!this.listeners) {
+        console.warn("BridgeStore: listeners not initialized");
+        return;
+      }
+      if (this.currentState && this.previousState) {
+        this.listeners.forEach((listener) => listener(this.currentState, this.previousState));
+      }
+    };
+    this.getState = () => {
+      return this.currentState;
+    };
+    this.subscribe = (listener) => {
+      if (!this.listeners) {
+        console.error("BridgeStore: Cannot subscribe, listeners not initialized");
+        return () => {
+        };
+      }
+      this.listeners.add(listener);
+      if (this.currentState && this.previousState) {
+        listener(this.currentState, this.previousState);
+      }
+      return () => {
+        if (this.listeners) {
+          this.listeners.delete(listener);
+        }
+      };
+    };
+    // Additional StoreApi methods
+    this.destroy = () => {
+      if (this.listeners) {
+        this.listeners.clear();
+      }
+    };
+    this.getInitialState = () => {
+      return this.getState();
+    };
+    this.bridge = bridge;
+    this.currentState = initialState || null;
+    this.previousState = initialState || null;
+    this.storeName = storeName;
+    this.setupStateSync();
+    this.initialize();
+  }
+  setupStateSync() {
+    if (this.bridge.on) {
+      this.bridge.on(`store:${this.storeName}:stateChanged`, (newState) => {
+        this.previousState = this.currentState;
+        this.currentState = newState;
+        this.notifyListeners();
+      });
+    }
+  }
+  setState(partial, replace) {
+    let actualUpdate;
+    if (typeof partial === "function") {
+      if (this.currentState === null) {
+        console.warn("BridgeStore: Cannot execute function update, state not initialized");
+        return;
+      }
+      actualUpdate = partial(this.currentState);
+    } else {
+      actualUpdate = partial;
+    }
+    const payload = { partial: actualUpdate, replace };
+    this.bridge.send(`store:${this.storeName}:setState`, payload).catch((error) => {
+      console.error("Failed to update state via bridge:", error);
+    });
+    if (this.currentState) {
+      this.previousState = this.currentState;
+      if (replace) {
+        this.currentState = actualUpdate;
+      } else {
+        this.currentState = { ...this.currentState, ...actualUpdate };
+      }
+      this.notifyListeners();
+    }
+  }
+}
+function createBridgeStore(bridge, initialState, storeName = "default") {
+  return new BridgeStore(bridge, initialState, storeName);
+}
+
+class StoreBuilder {
+  constructor(name = "default") {
+    this.config = {
+      name,
+      slices: []
+    };
+  }
+  /**
+   * Add state slices to the store
+   */
+  withSlices(...slices) {
+    this.config.slices = [...this.config.slices, ...slices];
+    return this;
+  }
+  /**
+   * Attach a bridge for cross-context communication
+   */
+  withBridge(bridge) {
+    this.config.bridge = bridge;
+    return this;
+  }
+  /**
+   * Create the store
+   */
+  async create() {
+    if (this.config.slices.length === 0) {
+      throw new Error("Store must have at least one slice. Use withSlices() to add state.");
+    }
+    return await this.createBaseStore();
+  }
+  async createBaseStore() {
+    const bridge = this.config.bridge || globalThis.bridge;
+    if (bridge) {
+      createBridgeStore(bridge, void 0, this.config.name);
+    }
+    return this.createServiceWorkerStore();
+  }
+  createServiceWorkerStore() {
+    const creator = (set, get, store2) => {
+      let state = {};
+      for (const slice of this.config.slices) {
+        const sliceState = slice(set, get, store2);
+        state = { ...state, ...sliceState };
+      }
+      return state;
+    };
+    const persistOptions = { name: this.config.name };
+    const persistedCreator = chromeStoragePersist(persistOptions)(creator);
+    const store = vanilla.createStore(persistedCreator);
+    const centralStore = store;
+    return centralStore;
+  }
+}
+function createStore(name) {
+  return new StoreBuilder(name);
+}
+
+function useStoreActions(store) {
+  return React.useMemo(
+    () => ({
+      // Update state with partial data
+      update: (partial) => {
+        store.setState((state) => ({ ...state, ...partial }));
+      },
+      // Update state with a function
+      updateWith: (updater) => {
+        store.setState((state) => ({ ...state, ...updater(state) }));
+      },
+      // Replace entire state
+      replace: (newState) => {
+        store.setState(newState, true);
+      },
+      // Direct access to setState
+      setState: store.setState.bind(store)
+    }),
+    [store]
+  );
+}
+function createStoreHooks() {
+  const StoreContext = React.createContext(null);
+  function StoreProvider({ store, children }) {
+    const storeRef = React.useRef(store);
+    return React__namespace.createElement(StoreContext.Provider, { value: storeRef.current }, children);
+  }
+  function useStore(selector) {
+    const store = React.useContext(StoreContext);
+    if (!store) throw new Error("useStore must be used within a StoreProvider");
+    return useCentralStore(store, selector);
+  }
+  function useStoreInstance() {
+    const store = React.useContext(StoreContext);
+    if (!store) throw new Error("useStoreInstance must be used within a StoreProvider");
+    return store;
+  }
+  function useActions() {
+    const store = useStoreInstance();
+    return useStoreActions(store);
+  }
+  function createActionHook(actionsFactory) {
+    return function useCustomActions() {
+      const store = useStoreInstance();
+      const baseActions = useStoreActions(store);
+      return React.useMemo(() => actionsFactory(baseActions), [baseActions]);
+    };
+  }
+  return {
+    StoreProvider,
+    useStore,
+    useStoreInstance,
+    useActions,
+    createActionHook
+  };
+}
+
+function autoRegisterStoreHandlers(store) {
+  if (!store) {
+    throw new Error("autoRegisterStoreHandlers: store parameter is required");
+  }
+  class AutoGetStoreStateMessage {
+    handle() {
+      if (!store) {
+        throw new Error("Store instance not available");
+      }
+      return store.getState();
+    }
+  }
+  class AutoSetStoreStateMessage {
+    handle(...args) {
+      if (!store) {
+        throw new Error("Store instance not available");
+      }
+      let partial;
+      let replace = false;
+      if (args.length === 1 && args[0] && typeof args[0] === "object") {
+        const payload = args[0];
+        if ("partial" in payload && "replace" in payload) {
+          ({ partial, replace } = payload);
+        } else {
+          partial = payload;
+          replace = false;
+        }
+      } else if (args.length >= 2) {
+        partial = args[0];
+        replace = args[1] || false;
+      } else if (args.length === 1) {
+        partial = args[0];
+        replace = false;
+      } else {
+        return store.getState();
+      }
+      if (partial === void 0) {
+        return store.getState();
+      }
+      if (replace) {
+        store.setState(partial, true);
+      } else {
+        store.setState(partial);
+      }
+      return store.getState();
+    }
+  }
+  class AutoSubscribeToStoreMessage {
+    handle() {
+      if (!store) {
+        throw new Error("Store instance not available");
+      }
+      store.subscribe((state, prevState) => {
+      });
+    }
+  }
+  return {
+    GetStoreStateMessage: AutoGetStoreStateMessage,
+    SetStoreStateMessage: AutoSetStoreStateMessage,
+    SubscribeToStoreMessage: AutoSubscribeToStoreMessage
+  };
+}
+
+async function init(storeDefinition) {
+  try {
+    let builder = createStore(storeDefinition.name);
+    if (storeDefinition.slices) {
+      builder = builder.withSlices(...storeDefinition.slices);
+    }
+    const store = await builder.create();
+    return {
+      store,
+      classes: autoRegisterStoreHandlers(store)
+    };
+  } catch (error) {
+    console.error(`Failed to initialize store "${storeDefinition.name}":`, error);
+    throw error;
+  }
+}
+if (typeof globalThis !== "undefined") {
+  globalThis.__CHROMA__ = globalThis.__CHROMA__ || {};
+  globalThis.__CHROMA__.initStores = init;
+  globalThis.initStores = init;
+}
+
+exports.BridgeStore = BridgeStore;
+exports.StoreBuilder = StoreBuilder;
+exports.chromeStoragePersist = chromeStoragePersist;
+exports.createBridgeStore = createBridgeStore;
+exports.createStore = createStore;
+exports.createStoreHooks = createStoreHooks;
+exports.useCentralDispatch = useCentralDispatch;
+exports.useCentralStore = useCentralStore;

package/dist/index.d.ts

@@ -0,0 +1,129 @@
+import { StoreApi, StateCreator } from 'zustand';
+import { StateCreator as StateCreator$1 } from 'zustand/vanilla';
+import * as React from 'react';
+import { ReactNode } from 'react';
+
+type PersistOptions = {
+    name: string;
+    version?: number;
+    migrate?: (state: any, version: number) => any;
+};
+interface StoreDefinition {
+    name: string;
+    slices?: StateCreator<any, [], [], any>[];
+    persistence?: PersistOptions;
+    config?: Record<string, any>;
+}
+type ExtractSliceState<T> = T extends StateCreator<infer State, any, any, any> ? State : never;
+type SliceCreator<T> = StateCreator<T, [], [], T>;
+interface StoreConfig<T> {
+    slices: readonly StateCreator<any, [], [], any>[];
+    persist?: PersistOptions;
+}
+type MergeSlices<Slices extends readonly StateCreator<any, [], [], any>[]> = Slices extends readonly [infer First, ...infer Rest] ? First extends StateCreator<any, [], [], infer FirstState> ? Rest extends readonly StateCreator<any, [], [], any>[] ? FirstState & MergeSlices<Rest> : FirstState : {} : {};
+interface CentralStore<T> extends StoreApi<T> {
+}
+
+declare function chromeStoragePersist<S>(options: PersistOptions): (config: StateCreator<S>) => StateCreator<S>;
+
+declare function useCentralStore<T, U = T>(store: CentralStore<T>, selector: (state: T) => U): U;
+declare function useCentralDispatch<T>(store: CentralStore<T>): {
+    (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: false): void;
+    (state: T | ((state: T) => T), replace: true): void;
+};
+
+interface Bridge {
+    send: <Req = unknown, Res = unknown>(key: string, payload?: Req) => Promise<Res>;
+    isConnected: boolean;
+}
+interface BridgeWithEvents extends Bridge {
+    on?: (key: string, handler: (payload: any) => void) => void;
+}
+interface BridgeWithHandlers extends Bridge {
+    register: (key: string, handler: (payload?: any) => any) => void;
+    broadcast: (key: string, payload: any) => void;
+    on?: (key: string, handler: (payload: any) => void) => void;
+}
+declare class BridgeStore<T> implements CentralStore<T> {
+    private bridge;
+    private listeners;
+    private currentState;
+    private previousState;
+    private storeName;
+    private ready;
+    constructor(bridge: BridgeWithEvents, initialState?: T, storeName?: string);
+    initialize: () => Promise<void>;
+    private setupStateSync;
+    private notifyListeners;
+    getState: () => T;
+    setState(partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: false): void;
+    setState(state: T | ((state: T) => T), replace: true): void;
+    subscribe: (listener: (state: T, prevState: T) => void) => (() => void);
+    destroy: () => void;
+    getInitialState: () => T;
+}
+declare function createBridgeStore<T>(bridge: BridgeWithEvents, initialState?: T, storeName?: string): CentralStore<T>;
+
+/**
+ * Core store builder with fluent API
+ */
+declare class StoreBuilder<T = any> {
+    private config;
+    constructor(name?: string);
+    /**
+     * Add state slices to the store
+     */
+    withSlices(...slices: StateCreator$1<any, [], [], any>[]): this;
+    /**
+     * Attach a bridge for cross-context communication
+     */
+    withBridge(bridge?: BridgeWithEvents): this;
+    /**
+     * Create the store
+     */
+    create(): Promise<CentralStore<T>>;
+    private createBaseStore;
+    private createServiceWorkerStore;
+}
+/**
+ * Create a new store builder
+ */
+declare function createStore<T = any>(name?: string): StoreBuilder<T>;
+
+/**
+ * Store actions helper (inlined from actions.ts)
+ */
+declare function useStoreActions<T extends Record<string, any>>(store: CentralStore<T>): {
+    update: (partial: Partial<T>) => void;
+    updateWith: (updater: (state: T) => Partial<T>) => void;
+    replace: (newState: T) => void;
+    setState: {
+        (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: false): void;
+        (state: T | ((state: T) => T), replace: true): void;
+    };
+};
+/**
+ * Create a complete store hook factory with typed providers and action creators
+ * This prevents confusion by providing only the hooks you need, not global ones
+ */
+declare function createStoreHooks<T extends Record<string, any>>(): {
+    StoreProvider: ({ store, children }: {
+        store: CentralStore<T>;
+        children: ReactNode;
+    }) => React.FunctionComponentElement<React.ProviderProps<CentralStore<T> | null>>;
+    useStore: <U>(selector: (state: T) => U) => U;
+    useStoreInstance: () => CentralStore<T>;
+    useActions: () => {
+        update: (partial: Partial<T>) => void;
+        updateWith: (updater: (state: T) => Partial<T>) => void;
+        replace: (newState: T) => void;
+        setState: {
+            (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: false): void;
+            (state: T | ((state: T) => T), replace: true): void;
+        };
+    };
+    createActionHook: <ActionMap extends Record<string, (...args: any[]) => void>>(actionsFactory: (actions: ReturnType<typeof useStoreActions<T>>) => ActionMap) => () => ActionMap;
+};
+
+export { BridgeStore, StoreBuilder, chromeStoragePersist, createBridgeStore, createStore, createStoreHooks, useCentralDispatch, useCentralStore };
+export type { Bridge, BridgeWithEvents, BridgeWithHandlers, CentralStore, ExtractSliceState, MergeSlices, PersistOptions, SliceCreator, StoreConfig, StoreDefinition };

package/dist/index.es.js

@@ -0,0 +1,378 @@
+import * as React from 'react';
+import { useSyncExternalStore, createContext, useMemo, useContext, useRef } from 'react';
+import { createStore as createStore$1 } from 'zustand/vanilla';
+
+function chromeStoragePersist(options) {
+  return (config) => (set, get, store) => {
+    const key = options.name;
+    let isInitialized = false;
+    let persistenceSetup = false;
+    const initialState = config(set, get, store);
+    const loadPersistedState = async () => {
+      try {
+        if (!chrome?.storage?.local) {
+          console.warn(`Chrome storage not available for "${key}", using memory only`);
+          isInitialized = true;
+          setupPersistence();
+          return;
+        }
+        const result = await new Promise((resolve, reject) => {
+          chrome.storage.local.get([key], (result2) => {
+            if (chrome.runtime.lastError) {
+              reject(chrome.runtime.lastError);
+            } else {
+              resolve(result2);
+            }
+          });
+        });
+        if (result[key]) {
+          const mergedState = { ...initialState, ...result[key] };
+          set(mergedState);
+        } else {
+          await persistState(initialState);
+        }
+      } catch (error) {
+        console.error(`Failed to load persisted state for "${key}":`, error);
+      } finally {
+        isInitialized = true;
+        setupPersistence();
+      }
+    };
+    const persistState = async (state) => {
+      if (!chrome?.storage?.local) {
+        return;
+      }
+      return new Promise((resolve) => {
+        chrome.storage.local.set({ [key]: state }, () => {
+          if (chrome.runtime.lastError) {
+            console.error(`Failed to persist state for "${key}":`, chrome.runtime.lastError);
+          }
+          resolve();
+        });
+      });
+    };
+    const setupPersistence = () => {
+      if (persistenceSetup) return;
+      persistenceSetup = true;
+      store.subscribe((state) => {
+        if (!isInitialized) return;
+        persistState(state);
+      });
+    };
+    loadPersistedState();
+    return initialState;
+  };
+}
+
+function useCentralStore(store, selector) {
+  return useSyncExternalStore(
+    store.subscribe,
+    () => selector(store.getState()),
+    () => selector(store.getState())
+  );
+}
+function useCentralDispatch(store) {
+  return store.setState;
+}
+
+class BridgeStore {
+  constructor(bridge, initialState, storeName = "default") {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.currentState = null;
+    this.previousState = null;
+    this.ready = false;
+    this.initialize = async () => {
+      try {
+        console.log("Initializing bridge store:", this.storeName, this.bridge);
+        const state = await this.bridge.send(`store:${this.storeName}:getState`);
+        this.previousState = this.currentState;
+        this.currentState = state;
+        this.notifyListeners();
+        this.ready = true;
+      } catch (error) {
+        console.warn("Failed to initialize bridge store:", error);
+      }
+    };
+    this.notifyListeners = () => {
+      if (!this.listeners) {
+        console.warn("BridgeStore: listeners not initialized");
+        return;
+      }
+      if (this.currentState && this.previousState) {
+        this.listeners.forEach((listener) => listener(this.currentState, this.previousState));
+      }
+    };
+    this.getState = () => {
+      return this.currentState;
+    };
+    this.subscribe = (listener) => {
+      if (!this.listeners) {
+        console.error("BridgeStore: Cannot subscribe, listeners not initialized");
+        return () => {
+        };
+      }
+      this.listeners.add(listener);
+      if (this.currentState && this.previousState) {
+        listener(this.currentState, this.previousState);
+      }
+      return () => {
+        if (this.listeners) {
+          this.listeners.delete(listener);
+        }
+      };
+    };
+    // Additional StoreApi methods
+    this.destroy = () => {
+      if (this.listeners) {
+        this.listeners.clear();
+      }
+    };
+    this.getInitialState = () => {
+      return this.getState();
+    };
+    this.bridge = bridge;
+    this.currentState = initialState || null;
+    this.previousState = initialState || null;
+    this.storeName = storeName;
+    this.setupStateSync();
+    this.initialize();
+  }
+  setupStateSync() {
+    if (this.bridge.on) {
+      this.bridge.on(`store:${this.storeName}:stateChanged`, (newState) => {
+        this.previousState = this.currentState;
+        this.currentState = newState;
+        this.notifyListeners();
+      });
+    }
+  }
+  setState(partial, replace) {
+    let actualUpdate;
+    if (typeof partial === "function") {
+      if (this.currentState === null) {
+        console.warn("BridgeStore: Cannot execute function update, state not initialized");
+        return;
+      }
+      actualUpdate = partial(this.currentState);
+    } else {
+      actualUpdate = partial;
+    }
+    const payload = { partial: actualUpdate, replace };
+    this.bridge.send(`store:${this.storeName}:setState`, payload).catch((error) => {
+      console.error("Failed to update state via bridge:", error);
+    });
+    if (this.currentState) {
+      this.previousState = this.currentState;
+      if (replace) {
+        this.currentState = actualUpdate;
+      } else {
+        this.currentState = { ...this.currentState, ...actualUpdate };
+      }
+      this.notifyListeners();
+    }
+  }
+}
+function createBridgeStore(bridge, initialState, storeName = "default") {
+  return new BridgeStore(bridge, initialState, storeName);
+}
+
+class StoreBuilder {
+  constructor(name = "default") {
+    this.config = {
+      name,
+      slices: []
+    };
+  }
+  /**
+   * Add state slices to the store
+   */
+  withSlices(...slices) {
+    this.config.slices = [...this.config.slices, ...slices];
+    return this;
+  }
+  /**
+   * Attach a bridge for cross-context communication
+   */
+  withBridge(bridge) {
+    this.config.bridge = bridge;
+    return this;
+  }
+  /**
+   * Create the store
+   */
+  async create() {
+    if (this.config.slices.length === 0) {
+      throw new Error("Store must have at least one slice. Use withSlices() to add state.");
+    }
+    return await this.createBaseStore();
+  }
+  async createBaseStore() {
+    const bridge = this.config.bridge || globalThis.bridge;
+    if (bridge) {
+      createBridgeStore(bridge, void 0, this.config.name);
+    }
+    return this.createServiceWorkerStore();
+  }
+  createServiceWorkerStore() {
+    const creator = (set, get, store2) => {
+      let state = {};
+      for (const slice of this.config.slices) {
+        const sliceState = slice(set, get, store2);
+        state = { ...state, ...sliceState };
+      }
+      return state;
+    };
+    const persistOptions = { name: this.config.name };
+    const persistedCreator = chromeStoragePersist(persistOptions)(creator);
+    const store = createStore$1(persistedCreator);
+    const centralStore = store;
+    return centralStore;
+  }
+}
+function createStore(name) {
+  return new StoreBuilder(name);
+}
+
+function useStoreActions(store) {
+  return useMemo(
+    () => ({
+      // Update state with partial data
+      update: (partial) => {
+        store.setState((state) => ({ ...state, ...partial }));
+      },
+      // Update state with a function
+      updateWith: (updater) => {
+        store.setState((state) => ({ ...state, ...updater(state) }));
+      },
+      // Replace entire state
+      replace: (newState) => {
+        store.setState(newState, true);
+      },
+      // Direct access to setState
+      setState: store.setState.bind(store)
+    }),
+    [store]
+  );
+}
+function createStoreHooks() {
+  const StoreContext = createContext(null);
+  function StoreProvider({ store, children }) {
+    const storeRef = useRef(store);
+    return React.createElement(StoreContext.Provider, { value: storeRef.current }, children);
+  }
+  function useStore(selector) {
+    const store = useContext(StoreContext);
+    if (!store) throw new Error("useStore must be used within a StoreProvider");
+    return useCentralStore(store, selector);
+  }
+  function useStoreInstance() {
+    const store = useContext(StoreContext);
+    if (!store) throw new Error("useStoreInstance must be used within a StoreProvider");
+    return store;
+  }
+  function useActions() {
+    const store = useStoreInstance();
+    return useStoreActions(store);
+  }
+  function createActionHook(actionsFactory) {
+    return function useCustomActions() {
+      const store = useStoreInstance();
+      const baseActions = useStoreActions(store);
+      return useMemo(() => actionsFactory(baseActions), [baseActions]);
+    };
+  }
+  return {
+    StoreProvider,
+    useStore,
+    useStoreInstance,
+    useActions,
+    createActionHook
+  };
+}
+
+function autoRegisterStoreHandlers(store) {
+  if (!store) {
+    throw new Error("autoRegisterStoreHandlers: store parameter is required");
+  }
+  class AutoGetStoreStateMessage {
+    handle() {
+      if (!store) {
+        throw new Error("Store instance not available");
+      }
+      return store.getState();
+    }
+  }
+  class AutoSetStoreStateMessage {
+    handle(...args) {
+      if (!store) {
+        throw new Error("Store instance not available");
+      }
+      let partial;
+      let replace = false;
+      if (args.length === 1 && args[0] && typeof args[0] === "object") {
+        const payload = args[0];
+        if ("partial" in payload && "replace" in payload) {
+          ({ partial, replace } = payload);
+        } else {
+          partial = payload;
+          replace = false;
+        }
+      } else if (args.length >= 2) {
+        partial = args[0];
+        replace = args[1] || false;
+      } else if (args.length === 1) {
+        partial = args[0];
+        replace = false;
+      } else {
+        return store.getState();
+      }
+      if (partial === void 0) {
+        return store.getState();
+      }
+      if (replace) {
+        store.setState(partial, true);
+      } else {
+        store.setState(partial);
+      }
+      return store.getState();
+    }
+  }
+  class AutoSubscribeToStoreMessage {
+    handle() {
+      if (!store) {
+        throw new Error("Store instance not available");
+      }
+      store.subscribe((state, prevState) => {
+      });
+    }
+  }
+  return {
+    GetStoreStateMessage: AutoGetStoreStateMessage,
+    SetStoreStateMessage: AutoSetStoreStateMessage,
+    SubscribeToStoreMessage: AutoSubscribeToStoreMessage
+  };
+}
+
+async function init(storeDefinition) {
+  try {
+    let builder = createStore(storeDefinition.name);
+    if (storeDefinition.slices) {
+      builder = builder.withSlices(...storeDefinition.slices);
+    }
+    const store = await builder.create();
+    return {
+      store,
+      classes: autoRegisterStoreHandlers(store)
+    };
+  } catch (error) {
+    console.error(`Failed to initialize store "${storeDefinition.name}":`, error);
+    throw error;
+  }
+}
+if (typeof globalThis !== "undefined") {
+  globalThis.__CHROMA__ = globalThis.__CHROMA__ || {};
+  globalThis.__CHROMA__.initStores = init;
+  globalThis.initStores = init;
+}
+
+export { BridgeStore, StoreBuilder, chromeStoragePersist, createBridgeStore, createStore, createStoreHooks, useCentralDispatch, useCentralStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chromahq/store",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Centralized, persistent store for Chrome extensions using zustand, accessible from service workers and React, with chrome.storage.local persistence.",
   "type": "module",
   "main": "dist/index.cjs.js",