@plyaz/core 1.11.0 → 1.11.1

package/dist/entry-frontend-browser.mjs

@@ -7,8 +7,7 @@ import { EventEmitter } from 'events';
 import { ERROR_CODES as ERROR_CODES$1, ERROR_CATEGORY as ERROR_CATEGORY$1, API_ERROR_CODES as API_ERROR_CODES$1 } from '@plyaz/types/errors';
 import { OBSERVABILITY_METRICS } from '@plyaz/types/observability';
 import { clearEventEmitter, setEventEmitter, initializeGlobalErrorHandler } from '@plyaz/errors/middleware';
-import { STORE_KEYS, useRootStore, createStandaloneFeatureFlagStore } from '@plyaz/store';
-export { useRootStore } from '@plyaz/store';
+import { STORE_KEYS, createStandaloneFeatureFlagStore } from '@plyaz/store';
 import { CORE_EVENTS as CORE_EVENTS$1, SERVICE_KEYS } from '@plyaz/types/core';
 import { uploadFile, uploadFiles, generateDocument, downloadFile, getSignedUrl, deleteFile, getFile } from '@plyaz/api';
 import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
@@ -2773,6 +2772,24 @@ var Core = class _Core {
      */
     this._rootStore = null;
   }
+  static {
+    /**
+     * Injected store hook for frontend (set via setRootStoreHook before initialize).
+     * This is used instead of directly importing from @plyaz/store to prevent
+     * duplicate store instances when bundlers create multiple module copies.
+     */
+    this._injectedStoreHook = null;
+  }
+  /**
+   * Set the root store hook for frontend use.
+   * Must be called before Core.initialize() when running in browser.
+   * PlyazProvider calls this automatically with the store prop.
+   *
+   * @param store - The useRootStore hook from @plyaz/store
+   */
+  static setRootStoreHook(store) {
+    _Core._injectedStoreHook = store;
+  }
   /**
    * Setup environment and context
    */
@@ -3683,8 +3700,14 @@ var Core = class _Core {
   static async initializeRootStore(config, verbose) {
     const isFrontend = typeof window !== "undefined";
     if (isFrontend) {
-      _Core.log("Using frontend root store (Zustand)", verbose);
-      _Core._rootStore = useRootStore;
+      if (!_Core._injectedStoreHook) {
+        throw new CorePackageError(
+          "Root store hook not set. Call Core.setRootStoreHook(useRootStore) before Core.initialize(), or use PlyazProvider with the store prop: <PlyazProvider store={useRootStore} ...>",
+          ERROR_CODES.CLIENT_INITIALIZATION_FAILED
+        );
+      }
+      _Core.log("Using frontend root store (Zustand) - injected via setRootStoreHook", verbose);
+      _Core._rootStore = _Core._injectedStoreHook;
     } else {
       _Core.log("Creating backend composite store (in-memory)", verbose);
       const ServerErrorMiddleware = getCoreDependency("ServerErrorMiddleware");
@@ -7136,7 +7159,10 @@ var FrontendExampleDomainService = class _FrontendExampleDomainService extends B
       const response = await this.apiClient.post(endpoint, data);
       if (!this.isResponseSuccess(response)) {
         const error = this.extractResponseError(response);
-        throw new Error(`Failed to send email: ${JSON.stringify(error)}`);
+        throw new CorePackageError(
+          `Failed to send email: ${JSON.stringify(error)}`,
+          ERROR_CODES.CORE_OPERATION_FAILED
+        );
       }
       const result = this.unwrapResponseData(response.data);
       CoreEventManager.emit(`${this.eventPrefix}:email:sent`, { result });
@@ -8678,22 +8704,27 @@ async function initializeCore(config) {
   });
 }
 __name(initializeCore, "initializeCore");
-function createStoreRegistry() {
+function createStoreRegistry(store) {
   return {
     getStore(key) {
-      const state = useRootStore.getState();
+      const state = store.getState();
       if (!state) {
         logger4.warn(
           "Store state is undefined - store may not be hydrated yet. This can cause side effects if called during SSR or before initialization."
         );
         return void 0;
       }
-      return state[key];
+      const slice = state[key];
+      logger4.debug(`[StoreRegistry] getStore('${key}')`, {
+        hasSlice: !!slice,
+        sliceKeys: slice ? Object.keys(slice) : []
+      });
+      return slice;
     }
   };
 }
 __name(createStoreRegistry, "createStoreRegistry");
-async function initializeServices(config) {
+async function initializeServices(config, store) {
   if (!config.services || config.services.length === 0) return;
   if (config.verbose) {
     globalThis.console.log("[PlyazProvider] Initializing domain services...");
@@ -8705,7 +8736,7 @@ async function initializeServices(config) {
     observability: config.observability,
     services: config.services,
     // Provide store registry for injecting stores into services
-    stores: createStoreRegistry()
+    stores: createStoreRegistry(store)
   });
   if (config.verbose) {
     globalThis.console.log(
@@ -8742,6 +8773,7 @@ function createServicesObject(config, featureFlagStore) {
 __name(createServicesObject, "createServicesObject");
 function PlyazProvider({
   children,
+  store,
   config,
   loading,
   error: errorComponent,
@@ -8755,8 +8787,9 @@ function PlyazProvider({
   const initialize = useCallback(async () => {
     try {
       setError(null);
+      Core.setRootStoreHook(store);
       await initializeCore(config);
-      await initializeServices(config);
+      await initializeServices(config, store);
       await initializeFeatureFlags(featureFlagStore);
       setIsReady(true);
       onReady?.(createServicesObject(config, featureFlagStore));
@@ -8766,7 +8799,7 @@ function PlyazProvider({
       onError?.(initError);
       globalThis.console.error("[PlyazProvider] Initialization failed:", initError);
     }
-  }, [config, featureFlagStore, onReady, onError]);
+  }, [config, store, featureFlagStore, onReady, onError]);
   const reinitialize = useCallback(async () => {
     setIsReady(false);
     ServiceRegistry.disposeAll();
@@ -8815,8 +8848,9 @@ __name(PlyazProvider, "PlyazProvider");
 function usePlyaz() {
   const context = useContext(PlyazContext);
   if (!context) {
-    throw new Error(
-      "usePlyaz must be used within a PlyazProvider. Wrap your app with <PlyazProvider config={...}>...</PlyazProvider>"
+    throw new CorePackageError(
+      "usePlyaz must be used within a PlyazProvider. Wrap your app with <PlyazProvider config={...}>...</PlyazProvider>",
+      ERROR_CODES.CORE_PROVIDER_NOT_FOUND
     );
   }
   return context;
@@ -8825,7 +8859,10 @@ __name(usePlyaz, "usePlyaz");
 function useApi() {
   const { api, isReady } = usePlyaz();
   if (!isReady || !api) {
-    throw new Error("API client is not ready. Make sure PlyazProvider has finished initializing.");
+    throw new CorePackageError(
+      "API client is not ready. Make sure PlyazProvider has finished initializing.",
+      ERROR_CODES.CORE_PROVIDER_INITIALIZATION_FAILED
+    );
   }
   return api;
 }
@@ -8868,7 +8905,10 @@ __name(useEnvironment, "useEnvironment");
 function useService(key) {
   const { getService, isReady } = usePlyaz();
   if (!isReady) {
-    throw new Error(`PlyazProvider not ready. Cannot get service '${key}'.`);
+    throw new CorePackageError(
+      `PlyazProvider not ready. Cannot get service '${key}'.`,
+      ERROR_CODES.CORE_PROVIDER_INITIALIZATION_FAILED
+    );
   }
   return useMemo(() => getService(key), [getService, key]);
 }