@plyaz/core 1.8.4 → 1.9.0

package/dist/index.js

@@ -33261,6 +33261,80 @@ var ApiClientService = class _ApiClientService {
   static {
     this.initPromise = null;
   }
+  /**
+   * Build the core error handler for API clients.
+   * This handler emits errors to CoreEventManager for global error handling.
+   *
+   * Handles:
+   * - Single errors (network, timeout)
+   * - Array of errors from API responses (validation, business logic)
+   * - Serialization to unified SerializedError format
+   * - Event emission to CORE_EVENTS.SYSTEM.ERROR and CORE_EVENTS.API.REQUEST_ERROR
+   *
+   * @returns Error handler function compatible with ApiClientOptions.onError
+   */
+  static buildCoreErrorHandler() {
+    return async (error) => {
+      const requestId = errors.generateRequestId();
+      const method = error.config?.method ?? "UNKNOWN";
+      const url = error.config?.url ?? "unknown";
+      try {
+        const errorDetails = Array.isArray(error.response?.data) ? error.response.data : [];
+        if (errorDetails.length === 0) {
+          const serializedError = {
+            id: requestId,
+            code: types.ERROR_CODES.CORE_API_CLIENT_REQUEST_FAILED,
+            message: error.message ?? "API request failed",
+            status: error.status,
+            category: types.ERROR_CATEGORY.Network,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            isRetryable: error.status ? error.status >= types.HTTP_STATUS.INTERNAL_SERVER_ERROR : false,
+            source: "api-client",
+            dismissed: false,
+            context: {
+              method,
+              url,
+              requestId
+            }
+          };
+          CoreEventManager.emit(types.CORE_EVENTS.SYSTEM.ERROR, { errors: [serializedError] });
+        } else {
+          const serializedErrors = errorDetails.map(
+            (detail, index) => ({
+              id: `${requestId}-${index}`,
+              code: detail.errorCode ?? types.ERROR_CODES.CORE_API_CLIENT_REQUEST_FAILED,
+              message: detail.message ?? error.message ?? "API request failed",
+              status: error.status,
+              category: types.ERROR_CATEGORY.Network,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              isRetryable: error.status ? error.status >= types.HTTP_STATUS.INTERNAL_SERVER_ERROR : false,
+              source: "api-client",
+              dismissed: false,
+              context: {
+                method,
+                url,
+                requestId,
+                field: detail.field,
+                valueGiven: detail.valueGiven,
+                allowedValues: detail.allowedValues,
+                constraints: detail.constraints
+              }
+            })
+          );
+          CoreEventManager.emit(types.CORE_EVENTS.SYSTEM.ERROR, { errors: serializedErrors });
+        }
+      } catch (e) {
+        console.error("[ApiClientService] Failed to emit error event:", e);
+      }
+      _ApiClientService.emitApiError(error, {
+        method,
+        url,
+        requestId,
+        status: error.status,
+        duration: 0
+      });
+    };
+  }
   /**
    * Initialize the API client with environment config and API options
    *
@@ -33298,71 +33372,12 @@ var ApiClientService = class _ApiClientService {
    * 2. Environment metadata (envConfig - apiKey)
    * 3. API configuration (apiConfig - baseURL, encryption, timeout, etc.)
    */
-  // eslint-disable-next-line max-lines-per-function, complexity
+  // eslint-disable-next-line complexity
   static async createClient(envConfig, apiConfig) {
     try {
       const envDefaults = getConfigForEnvironment(envConfig.env);
       const envMetadataMapped = mapEnvironmentMetadata(envConfig, envDefaults);
-      const coreErrorHandler = /* @__PURE__ */ __name(async (error) => {
-        const requestId = errors.generateRequestId();
-        const method = error.config?.method ?? "UNKNOWN";
-        const url = error.config?.url ?? "unknown";
-        try {
-          const errorDetails = Array.isArray(error.response?.data) ? error.response.data : [];
-          if (errorDetails.length === 0) {
-            const serializedError = {
-              id: requestId,
-              code: types.ERROR_CODES.CORE_API_CLIENT_REQUEST_FAILED,
-              message: error.message ?? "API request failed",
-              status: error.status,
-              category: types.ERROR_CATEGORY.Network,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-              isRetryable: error.status ? error.status >= types.HTTP_STATUS.INTERNAL_SERVER_ERROR : false,
-              source: "api-client",
-              dismissed: false,
-              context: {
-                method,
-                url,
-                requestId
-              }
-            };
-            CoreEventManager.emit(types.CORE_EVENTS.SYSTEM.ERROR, { errors: [serializedError] });
-          } else {
-            const serializedErrors = errorDetails.map(
-              (detail, index) => ({
-                id: `${requestId}-${index}`,
-                code: detail.errorCode ?? types.ERROR_CODES.CORE_API_CLIENT_REQUEST_FAILED,
-                message: detail.message ?? error.message ?? "API request failed",
-                status: error.status,
-                category: types.ERROR_CATEGORY.Network,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-                isRetryable: error.status ? error.status >= types.HTTP_STATUS.INTERNAL_SERVER_ERROR : false,
-                source: "api-client",
-                dismissed: false,
-                context: {
-                  method,
-                  url,
-                  requestId,
-                  field: detail.field,
-                  valueGiven: detail.valueGiven,
-                  allowedValues: detail.allowedValues,
-                  constraints: detail.constraints
-                }
-              })
-            );
-            CoreEventManager.emit(types.CORE_EVENTS.SYSTEM.ERROR, { errors: serializedErrors });
-          }
-        } catch (e) {
-          console.error("[ApiClientService] Failed to emit error event:", e);
-        }
-        _ApiClientService.emitApiError(error, {
-          method,
-          url,
-          requestId,
-          status: error.status,
-          duration: 0
-        });
-      }, "coreErrorHandler");
+      const coreErrorHandler = _ApiClientService.buildCoreErrorHandler();
       const userOnError = apiConfig?.onError;
       const combinedOnError = userOnError ? Array.isArray(userOnError) ? [...userOnError, coreErrorHandler] : [userOnError, coreErrorHandler] : coreErrorHandler;
       const mergedOptions = frontend.mergeConfigs(
@@ -33537,11 +33552,13 @@ var ApiClientService = class _ApiClientService {
     try {
       const envDefaults = getConfigForEnvironment(envConfig.env);
       const envMetadataMapped = mapEnvironmentMetadata(envConfig, envDefaults);
-      const mergedOptions = frontend.mergeConfigs(
-        envDefaults,
-        envMetadataMapped,
-        apiConfig ?? {}
-      );
+      const coreErrorHandler = _ApiClientService.buildCoreErrorHandler();
+      const userOnError = apiConfig?.onError;
+      const combinedOnError = userOnError ? Array.isArray(userOnError) ? [...userOnError, coreErrorHandler] : [userOnError, coreErrorHandler] : coreErrorHandler;
+      const mergedOptions = frontend.mergeConfigs(envDefaults, envMetadataMapped, {
+        ...apiConfig ?? {},
+        onError: combinedOnError
+      });
       validateEnvironmentConfig(envConfig, mergedOptions);
       const dedicatedClient = await frontend.createApiClient(mergedOptions);
       return dedicatedClient;
@@ -33563,10 +33580,66 @@ var ApiClientService = class _ApiClientService {
       );
     }
   }
+  /**
+   * Create a standalone API client with Core error handling.
+   *
+   * This is a simpler alternative to `createInstance()` that doesn't require
+   * environment config. Use this when you just need the error handling without
+   * environment-specific defaults (production validation, etc.).
+   *
+   * **Use cases:**
+   * - Domain services that need their own API client
+   * - Testing with isolated API clients
+   * - Simple client creation without environment setup
+   *
+   * @param apiConfig - API configuration (baseURL, timeout, etc.)
+   * @returns Promise that resolves to a client with Core error handling
+   *
+   * @example
+   * ```typescript
+   * // In BaseDomainService or any service
+   * const client = await ApiClientService.createStandaloneClient({
+   *   baseURL: '/api/examples',
+   *   timeout: 10000,
+   * });
+   *
+   * // Errors are automatically emitted to CoreEventManager
+   * const response = await client.get('/items');
+   * ```
+   */
+  static async createStandaloneClient(apiConfig) {
+    try {
+      const coreErrorHandler = _ApiClientService.buildCoreErrorHandler();
+      const userOnError = apiConfig.onError;
+      const combinedOnError = userOnError ? Array.isArray(userOnError) ? [...userOnError, coreErrorHandler] : [userOnError, coreErrorHandler] : coreErrorHandler;
+      const client = await frontend.createApiClient({
+        ...apiConfig,
+        onError: combinedOnError
+      });
+      return client;
+    } catch (error) {
+      throw new frontend.ApiPackageError(
+        "service.standalone_client_creation.failed",
+        types.PACKAGE_STATUS_CODES.INITIALIZATION_FAILED,
+        types.API_ERROR_CODES.CLIENT_INITIALIZATION_FAILED,
+        {
+          cause: error instanceof Error ? error : void 0,
+          context: {
+            operation: types.OPERATIONS.INITIALIZATION,
+            originalError: error instanceof Error ? error.message : String(error),
+            i18n: {
+              error: error instanceof Error ? error.message : String(error)
+            }
+          }
+        }
+      );
+    }
+  }
 };
 var getApiClient = /* @__PURE__ */ __name(() => ApiClientService.getClient(), "getApiClient");
 var initApiClient = /* @__PURE__ */ __name((envConfig, apiConfig) => ApiClientService.init(envConfig, apiConfig), "initApiClient");
 var createApiClientInstance = /* @__PURE__ */ __name((envConfig, apiConfig) => ApiClientService.createInstance(envConfig, apiConfig), "createApiClientInstance");
+var createStandaloneApiClient = /* @__PURE__ */ __name((apiConfig) => ApiClientService.createStandaloneClient(apiConfig), "createStandaloneApiClient");
 var BaseAdapter = class {
   constructor() {
     this._isInitialized = false;
@@ -36138,6 +36211,7 @@ var Core = class _Core {
       _Core._errorHandler.destroy();
       _Core._errorHandler = null;
       middleware.clearEventEmitter();
+      errors.BaseError.clearEventEmitter();
     }
     _Core._errorConfig = {};
     _Core._httpErrorHandler = null;
@@ -36326,6 +36400,28 @@ var Core = class _Core {
       };
     }
   }
+  /**
+   * Serialize a PackageErrorLike to SerializedError format.
+   * Used by BaseError.setEventEmitter() to convert errors for the store.
+   */
+  static serializePackageError(error) {
+    const serviceName = typeof error.context?.service === "string" ? error.context.service : "core";
+    return {
+      id: generateId(),
+      code: error.errorCode ?? types.ERROR_CODES.UNKNOWN_ERROR,
+      message: error.message,
+      status: error.statusCode,
+      category: error.category ?? errors$1.ERROR_CATEGORY.Server,
+      timestamp: error.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      isRetryable: error.retryable ?? false,
+      source: serviceName,
+      dismissed: false,
+      context: {
+        correlationId: error.correlationId,
+        ...error.context
+      }
+    };
+  }
   /** Get error store actions from root store */
   static getErrorStoreActions() {
     if (!_Core._rootStore) {
@@ -36337,12 +36433,17 @@ var Core = class _Core {
     return _Core._rootStore.getState().errors;
   }
   /** Build global error handler config */
-  // eslint-disable-next-line complexity
   static buildErrorHandlerConfig(config) {
+    const baseErrorFilter = /* @__PURE__ */ __name((error) => {
+      if (error instanceof errors.BaseError) {
+        return false;
+      }
+      return config?.filter ? config.filter(error) : true;
+    }, "baseErrorFilter");
     return {
       source: config?.source ?? "global",
       maxErrors: config?.maxErrors ?? DEFAULT_MAX_ERRORS,
-      filter: config?.filter,
+      filter: baseErrorFilter,
       onError: config?.onError,
       logToConsole: config?.logToConsole ?? false
     };
@@ -36363,6 +36464,15 @@ var Core = class _Core {
     });
     await _Core.initializeRootStore(_Core._errorConfig, verbose);
     middleware.setEventEmitter(CoreEventManager.emit.bind(CoreEventManager));
+    errors.BaseError.setEventEmitter((error) => {
+      const serializedError = _Core.serializePackageError(error);
+      const serviceName = serializedError.source ?? "core";
+      CoreEventManager.emit(core.CORE_EVENTS.SYSTEM.ERROR, {
+        errors: [serializedError],
+        context: serviceName,
+        recoverable: error.retryable ?? false
+      });
+    });
     const errorStore = _Core.getErrorStoreActions();
     _Core._errorHandler = middleware.initializeGlobalErrorHandler(
       errorStore,
@@ -36458,9 +36568,15 @@ var Core = class _Core {
   }
   /**
    * Subscribe to CoreEventManager error events
-   * Forwards system, entity, API, validation, database, and auth errors to the global error handler.
+   * Forwards entity, API, validation, database, and auth errors to the global error handler.
+   *
+   * NOTE: SYSTEM.ERROR is NOT subscribed here - it's handled in initializeErrorHandler()
+   * via the BaseError.setEventEmitter() + addErrors() pattern to avoid duplicate subscriptions.
+   *
+   * For non-BaseError errors, domain-specific events (ENTITY.ERROR, API.REQUEST_ERROR, etc.)
+   * are captured here. BaseError instances are skipped (they already auto-emit via SYSTEM.ERROR).
    *
-   * Note: Database errors (DATABASE.ERROR) are only subscribed on backend runtimes since
+   * Database errors (DATABASE.ERROR) are only subscribed on backend runtimes since
    * DbService is backend-only (skipDb: true on frontend).
    */
   static subscribeToErrorEvents(verbose) {
@@ -36468,78 +36584,36 @@ var Core = class _Core {
       return;
     }
     _Core.log("Subscribing to error events...", verbose);
-    const cleanupSystemError = CoreEventManager.on(core.CORE_EVENTS.SYSTEM.ERROR, (event) => {
-      if (_Core._errorHandler && event.data?.errors?.length) {
-        for (const err of event.data.errors) {
-          _Core._errorHandler.captureError(err, "system");
+    const subscribeError = /* @__PURE__ */ __name((event, source) => {
+      return CoreEventManager.on(event, (e) => {
+        if (_Core._errorHandler && e.data?.error && !(e.data.error instanceof errors.BaseError)) {
+          _Core._errorHandler.captureError(e.data.error, source);
         }
-      }
-    });
-    const cleanupEntityError = CoreEventManager.on(core.CORE_EVENTS.ENTITY.ERROR, (event) => {
-      if (_Core._errorHandler && event.data) {
-        _Core._errorHandler.captureError(event.data.error, "entity");
-      }
-    });
-    const cleanupApiError = CoreEventManager.on(core.CORE_EVENTS.API.REQUEST_ERROR, (event) => {
-      if (_Core._errorHandler && event.data) {
-        _Core._errorHandler.captureError(event.data.error, "api");
-      }
-    });
-    const cleanupValidationError = CoreEventManager.on(core.CORE_EVENTS.VALIDATION.FAILED, (event) => {
-      if (_Core._errorHandler && event.data) {
-        _Core._errorHandler.captureError(event.data.error, "validation");
-      }
-    });
-    const cleanupAuthUnauthorized = CoreEventManager.on(core.CORE_EVENTS.AUTH.UNAUTHORIZED, (event) => {
-      if (_Core._errorHandler && event.data?.error) {
-        _Core._errorHandler.captureError(event.data.error, "auth");
-      }
-    });
-    const cleanupAuthSessionExpired = CoreEventManager.on(
-      core.CORE_EVENTS.AUTH.SESSION_EXPIRED,
-      (event) => {
-        if (_Core._errorHandler && event.data?.error) {
-          _Core._errorHandler.captureError(event.data.error, "auth");
-        }
-      }
-    );
+      });
+    }, "subscribeError");
     _Core._eventCleanupFns.push(
-      cleanupSystemError,
-      cleanupEntityError,
-      cleanupApiError,
-      cleanupValidationError,
-      cleanupAuthUnauthorized,
-      cleanupAuthSessionExpired
+      subscribeError(core.CORE_EVENTS.ENTITY.ERROR, "entity"),
+      subscribeError(core.CORE_EVENTS.API.REQUEST_ERROR, "api"),
+      subscribeError(core.CORE_EVENTS.VALIDATION.FAILED, "validation"),
+      subscribeError(core.CORE_EVENTS.AUTH.UNAUTHORIZED, "auth"),
+      subscribeError(core.CORE_EVENTS.AUTH.SESSION_EXPIRED, "auth")
     );
     if (_Core.isRuntimeCompatible("backend")) {
-      const cleanupDatabaseError = CoreEventManager.on(core.CORE_EVENTS.DATABASE.ERROR, (event) => {
-        if (_Core._errorHandler && event.data) {
-          _Core._errorHandler.captureError(event.data.error, "database");
-        }
-      });
-      _Core._eventCleanupFns.push(cleanupDatabaseError);
-      const cleanupStorageError = CoreEventManager.on(core.CORE_EVENTS.STORAGE.ERROR, (event) => {
-        if (_Core._errorHandler && event.data) {
-          _Core._errorHandler.captureError(event.data.error, "storage");
-        }
-      });
-      _Core._eventCleanupFns.push(cleanupStorageError);
-      const cleanupNotificationError = CoreEventManager.on(
-        core.CORE_EVENTS.NOTIFICATION.ERROR,
-        (event) => {
-          if (_Core._errorHandler && event.data) {
-            _Core._errorHandler.captureError(event.data.error, "notification");
-          }
-        }
+      _Core._eventCleanupFns.push(
+        subscribeError(core.CORE_EVENTS.DATABASE.ERROR, "database"),
+        subscribeError(core.CORE_EVENTS.STORAGE.ERROR, "storage"),
+        subscribeError(core.CORE_EVENTS.NOTIFICATION.ERROR, "notification"),
+        subscribeError(core.CORE_EVENTS.CACHE.ERROR, "cache")
+      );
+      _Core.log(
+        "Subscribed to backend error events (database, storage, notification, cache)",
+        verbose
       );
-      _Core._eventCleanupFns.push(cleanupNotificationError);
-      _Core.log("Subscribed to backend error events (database, storage, notification)", verbose);
-    }
-    const eventTypes = ["system", "entity", "api", "validation", "auth"];
-    if (_Core.isRuntimeCompatible("backend")) {
-      eventTypes.push("database", "storage", "notification");
     }
-    _Core.log(`Subscribed to error events: ${eventTypes.join(", ")}`, verbose);
+    const eventTypes = ["entity", "api", "validation", "auth"];
+    if (_Core.isRuntimeCompatible("backend"))
+      eventTypes.push("database", "storage", "notification", "cache");
+    _Core.log(`Subscribed to domain error events: ${eventTypes.join(", ")}`, verbose);
   }
   /** Handle fetch flags error and return empty flags */
   static handleFetchFlagsError(error, config, verbose) {
@@ -36786,6 +36860,11 @@ var BaseDomainService = class {
   /**
    * Initialize API client asynchronously
    * Called from constructor if apiClientConfig is provided
+   *
+   * Uses ApiClientService.createStandaloneClient() which includes:
+   * - Automatic error handling (single errors and arrays)
+   * - Event emission to CORE_EVENTS.SYSTEM.ERROR and CORE_EVENTS.API.REQUEST_ERROR
+   * - Serialization to unified SerializedError format
    */
   initializeApiClient() {
     if (this._clientInitPromise || !this._apiClientConfig) {
@@ -36793,7 +36872,7 @@ var BaseDomainService = class {
     }
     this._clientInitPromise = (async () => {
       try {
-        this._apiClient = await frontend.createApiClient(this._apiClientConfig);
+        this._apiClient = await ApiClientService.createStandaloneClient(this._apiClientConfig);
         if (this._setAsDefaultClient) {
           frontend.setDefaultApiClient(this._apiClient);
         }
@@ -45617,6 +45696,22 @@ var CacheService = class _CacheService {
     /** Singleton instance */
     this.instance = null;
   }
+  // ─────────────────────────────────────────────────────────────────
+  // Error Handling
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Emits a cache error event via CoreEventManager.
+   * Called when cache operations fail to integrate with global error handling.
+   */
+  emitCacheError(error, operation, options) {
+    const payload = {
+      error,
+      operation,
+      key: options?.key,
+      recoverable: options?.recoverable ?? true
+    };
+    CoreEventManager.emit(core.CORE_EVENTS.CACHE.ERROR, payload);
+  }
   /**
    * Initialize the cache service with configuration
    *
@@ -45661,6 +45756,7 @@ var CacheService = class _CacheService {
       });
     } catch (error) {
       service.logger.error("[CacheService] Failed to initialize cache", { error });
+      service.emitCacheError(error, "initialize", { recoverable: false });
       throw new errors.CorePackageError(
         `Failed to initialize cache: ${error instanceof Error ? error.message : String(error)}`,
         errors$1.ERROR_CODES.VALIDATION_ERROR,
@@ -46218,10 +46314,10 @@ __export(backend_exports, {
 });
 
 // src/backend/example/example.module.ts
-var import_common10 = __toESM(require_common(), 1);
+var import_common11 = __toESM(require_common(), 1);
 
 // src/backend/example/example.controller.ts
-var import_common9 = __toESM(require_common(), 1);
+var import_common10 = __toESM(require_common(), 1);
 var BACKEND_EXAMPLE_DOMAIN_SERVICE = "BACKEND_EXAMPLE_DOMAIN_SERVICE";
 var ExampleController = class {
   constructor(exampleService) {
@@ -46262,41 +46358,41 @@ var ExampleController = class {
 };
 __name(ExampleController, "ExampleController");
 __decorateClass([
-  (0, import_common9.Get)("health")
+  (0, import_common10.Get)("health")
 ], ExampleController.prototype, "health", 1);
 __decorateClass([
-  (0, import_common9.Get)("entities/:id"),
-  __decorateParam(0, (0, import_common9.Param)("id"))
+  (0, import_common10.Get)("entities/:id"),
+  __decorateParam(0, (0, import_common10.Param)("id"))
 ], ExampleController.prototype, "getEntity", 1);
 __decorateClass([
-  (0, import_common9.Post)("entities"),
-  (0, import_common9.HttpCode)(import_common9.HttpStatus.CREATED),
-  __decorateParam(0, (0, import_common9.Body)())
+  (0, import_common10.Post)("entities"),
+  (0, import_common10.HttpCode)(import_common10.HttpStatus.CREATED),
+  __decorateParam(0, (0, import_common10.Body)())
 ], ExampleController.prototype, "createEntity", 1);
 __decorateClass([
-  (0, import_common9.Patch)("entities/:id"),
-  __decorateParam(0, (0, import_common9.Param)("id")),
-  __decorateParam(1, (0, import_common9.Body)())
+  (0, import_common10.Patch)("entities/:id"),
+  __decorateParam(0, (0, import_common10.Param)("id")),
+  __decorateParam(1, (0, import_common10.Body)())
 ], ExampleController.prototype, "updateEntity", 1);
 __decorateClass([
-  (0, import_common9.Delete)("entities/:id"),
-  (0, import_common9.HttpCode)(import_common9.HttpStatus.OK),
-  __decorateParam(0, (0, import_common9.Param)("id"))
+  (0, import_common10.Delete)("entities/:id"),
+  (0, import_common10.HttpCode)(import_common10.HttpStatus.OK),
+  __decorateParam(0, (0, import_common10.Param)("id"))
 ], ExampleController.prototype, "deleteEntity", 1);
 __decorateClass([
-  (0, import_common9.Post)("entities/validated"),
-  (0, import_common9.HttpCode)(import_common9.HttpStatus.CREATED),
-  __decorateParam(0, (0, import_common9.Body)())
+  (0, import_common10.Post)("entities/validated"),
+  (0, import_common10.HttpCode)(import_common10.HttpStatus.CREATED),
+  __decorateParam(0, (0, import_common10.Body)())
 ], ExampleController.prototype, "createEntityWithValidation", 1);
 __decorateClass([
-  (0, import_common9.Get)("errors/single")
+  (0, import_common10.Get)("errors/single")
 ], ExampleController.prototype, "demoSingleError", 1);
 __decorateClass([
-  (0, import_common9.Get)("errors/array")
+  (0, import_common10.Get)("errors/array")
 ], ExampleController.prototype, "demoArrayErrors", 1);
 ExampleController = __decorateClass([
-  (0, import_common9.Controller)("example"),
-  __decorateParam(0, (0, import_common9.Inject)(BACKEND_EXAMPLE_DOMAIN_SERVICE))
+  (0, import_common10.Controller)("example"),
+  __decorateParam(0, (0, import_common10.Inject)(BACKEND_EXAMPLE_DOMAIN_SERVICE))
 ], ExampleController);
 
 // src/backend/example/example.module.ts
@@ -46304,7 +46400,7 @@ var ExampleModule = class {
 };
 __name(ExampleModule, "ExampleModule");
 ExampleModule = __decorateClass([
-  (0, import_common10.Module)({
+  (0, import_common11.Module)({
     controllers: [ExampleController],
     providers: [
       // Provide BackendExampleDomainService via factory using the singleton instance
@@ -46596,10 +46692,10 @@ var FeatureFlagDomainService = class extends BaseDomainService {
 };
 
 // src/backend/featureFlags/feature-flag.module.ts
-var import_common12 = __toESM(require_common(), 1);
+var import_common13 = __toESM(require_common(), 1);
 
 // src/backend/featureFlags/feature-flag.controller.ts
-var import_common11 = __toESM(require_common(), 1);
+var import_common12 = __toESM(require_common(), 1);
 var FeatureFlagController = class {
   constructor(featureFlagService) {
     this.featureFlagService = featureFlagService;
@@ -46728,54 +46824,54 @@ var FeatureFlagController = class {
 };
 __name(FeatureFlagController, "FeatureFlagController");
 __decorateClass([
-  (0, import_common11.Post)(":key/evaluate"),
-  __decorateParam(0, (0, import_common11.Param)("key")),
-  __decorateParam(1, (0, import_common11.Body)())
+  (0, import_common12.Post)(":key/evaluate"),
+  __decorateParam(0, (0, import_common12.Param)("key")),
+  __decorateParam(1, (0, import_common12.Body)())
 ], FeatureFlagController.prototype, "evaluateFlag", 1);
 __decorateClass([
-  (0, import_common11.Post)(":key/enabled"),
-  __decorateParam(0, (0, import_common11.Param)("key")),
-  __decorateParam(1, (0, import_common11.Body)())
+  (0, import_common12.Post)(":key/enabled"),
+  __decorateParam(0, (0, import_common12.Param)("key")),
+  __decorateParam(1, (0, import_common12.Body)())
 ], FeatureFlagController.prototype, "isEnabled", 1);
 __decorateClass([
-  (0, import_common11.Post)("evaluate-all"),
-  __decorateParam(0, (0, import_common11.Body)())
+  (0, import_common12.Post)("evaluate-all"),
+  __decorateParam(0, (0, import_common12.Body)())
 ], FeatureFlagController.prototype, "evaluateAllFlags", 1);
 __decorateClass([
-  (0, import_common11.Post)(),
-  __decorateParam(0, (0, import_common11.Body)())
+  (0, import_common12.Post)(),
+  __decorateParam(0, (0, import_common12.Body)())
 ], FeatureFlagController.prototype, "createFlag", 1);
 __decorateClass([
-  (0, import_common11.Put)(":key"),
-  __decorateParam(0, (0, import_common11.Param)("key")),
-  __decorateParam(1, (0, import_common11.Body)())
+  (0, import_common12.Put)(":key"),
+  __decorateParam(0, (0, import_common12.Param)("key")),
+  __decorateParam(1, (0, import_common12.Body)())
 ], FeatureFlagController.prototype, "updateFlag", 1);
 __decorateClass([
-  (0, import_common11.Delete)(":key"),
-  __decorateParam(0, (0, import_common11.Param)("key"))
+  (0, import_common12.Delete)(":key"),
+  __decorateParam(0, (0, import_common12.Param)("key"))
 ], FeatureFlagController.prototype, "deleteFlag", 1);
 __decorateClass([
-  (0, import_common11.Post)(":key/override"),
-  __decorateParam(0, (0, import_common11.Param)("key")),
-  __decorateParam(1, (0, import_common11.Body)("value"))
+  (0, import_common12.Post)(":key/override"),
+  __decorateParam(0, (0, import_common12.Param)("key")),
+  __decorateParam(1, (0, import_common12.Body)("value"))
 ], FeatureFlagController.prototype, "setOverride", 1);
 __decorateClass([
-  (0, import_common11.Delete)(":key/override"),
-  __decorateParam(0, (0, import_common11.Param)("key"))
+  (0, import_common12.Delete)(":key/override"),
+  __decorateParam(0, (0, import_common12.Param)("key"))
 ], FeatureFlagController.prototype, "removeOverride", 1);
 __decorateClass([
-  (0, import_common11.Get)(":key/rules"),
-  __decorateParam(0, (0, import_common11.Param)("key"))
+  (0, import_common12.Get)(":key/rules"),
+  __decorateParam(0, (0, import_common12.Param)("key"))
 ], FeatureFlagController.prototype, "getFlagRules", 1);
 __decorateClass([
-  (0, import_common11.Post)("refresh")
+  (0, import_common12.Post)("refresh")
 ], FeatureFlagController.prototype, "refreshCache", 1);
 __decorateClass([
-  (0, import_common11.Get)("health")
+  (0, import_common12.Get)("health")
 ], FeatureFlagController.prototype, "getHealth", 1);
 FeatureFlagController = __decorateClass([
-  (0, import_common11.Controller)("feature-flags"),
-  __decorateParam(0, (0, import_common11.Inject)(FEATURE_FLAG_SERVICE))
+  (0, import_common12.Controller)("feature-flags"),
+  __decorateParam(0, (0, import_common12.Inject)(FEATURE_FLAG_SERVICE))
 ], FeatureFlagController);
 
 // src/backend/featureFlags/feature-flag.module.ts
@@ -46867,16 +46963,16 @@ var FeatureFlagModule = class {
 __name(FeatureFlagModule, "FeatureFlagModule");
 FeatureFlagModule.serviceInstance = null;
 FeatureFlagModule = __decorateClass([
-  (0, import_common12.Global)(),
-  (0, import_common12.Module)({
+  (0, import_common13.Global)(),
+  (0, import_common13.Module)({
     controllers: [FeatureFlagController]
   })
 ], FeatureFlagModule);
 
 // src/backend/featureFlags/decorators/feature-flag.decorator.ts
-var import_common13 = __toESM(require_common(), 1);
+var import_common14 = __toESM(require_common(), 1);
 function FeatureFlag(key, expected = true) {
-  return (0, import_common13.SetMetadata)(types.FEATURE_FLAG_METADATA.FLAG_CHECK, { key, expected });
+  return (0, import_common14.SetMetadata)(types.FEATURE_FLAG_METADATA.FLAG_CHECK, { key, expected });
 }
 __name(FeatureFlag, "FeatureFlag");
 
@@ -46893,7 +46989,7 @@ function FeatureEnabled(key) {
 __name(FeatureEnabled, "FeatureEnabled");
 
 // src/backend/featureFlags/guards/feature-flag.guard.ts
-var import_common14 = __toESM(require_common(), 1);
+var import_common15 = __toESM(require_common(), 1);
 var FeatureFlagGuard = class {
   constructor(reflector, featureFlagService) {
     this.reflector = reflector;
@@ -46937,12 +47033,12 @@ var FeatureFlagGuard = class {
 };
 __name(FeatureFlagGuard, "FeatureFlagGuard");
 FeatureFlagGuard = __decorateClass([
-  (0, import_common14.Injectable)(),
-  __decorateParam(1, (0, import_common14.Inject)(FEATURE_FLAG_SERVICE))
+  (0, import_common15.Injectable)(),
+  __decorateParam(1, (0, import_common15.Inject)(FEATURE_FLAG_SERVICE))
 ], FeatureFlagGuard);
 
 // src/backend/featureFlags/middleware/feature-flag-middleware.ts
-var import_common15 = __toESM(require_common(), 1);
+var import_common16 = __toESM(require_common(), 1);
 function isFeatureFlagKey(value) {
   return Object.keys(config.FEATURES).includes(value);
 }
@@ -47020,12 +47116,12 @@ var FeatureFlagMiddleware = class {
 };
 __name(FeatureFlagMiddleware, "FeatureFlagMiddleware");
 FeatureFlagMiddleware = __decorateClass([
-  (0, import_common15.Injectable)(),
-  __decorateParam(0, (0, import_common15.Inject)(FEATURE_FLAG_SERVICE))
+  (0, import_common16.Injectable)(),
+  __decorateParam(0, (0, import_common16.Inject)(FEATURE_FLAG_SERVICE))
 ], FeatureFlagMiddleware);
 
 // src/backend/featureFlags/interceptors/feature-flag-logging-interceptor.ts
-var import_common16 = __toESM(require_common(), 1);
+var import_common17 = __toESM(require_common(), 1);
 var import_rxjs = __toESM(require_cjs(), 1);
 var FeatureFlagLoggingInterceptor = class {
   constructor() {
@@ -47058,11 +47154,11 @@ var FeatureFlagLoggingInterceptor = class {
 };
 __name(FeatureFlagLoggingInterceptor, "FeatureFlagLoggingInterceptor");
 FeatureFlagLoggingInterceptor = __decorateClass([
-  (0, import_common16.Injectable)()
+  (0, import_common17.Injectable)()
 ], FeatureFlagLoggingInterceptor);
 
 // src/backend/featureFlags/interceptors/error-handling-interceptor.ts
-var import_common17 = __toESM(require_common(), 1);
+var import_common18 = __toESM(require_common(), 1);
 var import_operators = __toESM(require_operators(), 1);
 var ErrorHandlingInterceptor = class {
   constructor() {
@@ -47091,7 +47187,7 @@ var ErrorHandlingInterceptor = class {
 };
 __name(ErrorHandlingInterceptor, "ErrorHandlingInterceptor");
 ErrorHandlingInterceptor = __decorateClass([
-  (0, import_common17.Injectable)()
+  (0, import_common18.Injectable)()
 ], ErrorHandlingInterceptor);
 var logger2 = new logger$1.PackageLogger({
   packageName: "core",
@@ -47438,7 +47534,7 @@ var FeatureFlagConfigFactory = class {
 };
 
 // src/base/cache/feature/caching.ts
-var import_common18 = __toESM(require_common(), 1);
+var import_common19 = __toESM(require_common(), 1);
 var import_rxjs2 = __toESM(require_cjs(), 1);
 var Caching = class {
   constructor() {
@@ -47461,7 +47557,7 @@ var Caching = class {
 };
 __name(Caching, "Caching");
 Caching = __decorateClass([
-  (0, import_common18.Injectable)()
+  (0, import_common19.Injectable)()
 ], Caching);
 
 // src/frontend/index.ts
@@ -47660,7 +47756,11 @@ async function initializeCore(config) {
       apiKey: config.api.apiKey,
       setAsDefault: true,
       ...apiConfig
-    }
+    },
+    // Feature flags config (passed to Core for memory provider setup)
+    featureFlags: config.featureFlags
+    // Error handler is auto-initialized by Core.initialize()
+    // Store (Zustand) is auto-connected via useRootStore in Core.initializeRootStore()
   });
 }
 __name(initializeCore, "initializeCore");
@@ -48023,6 +48123,7 @@ exports.createBackendContext = createBackendContext;
 exports.createFeatureFlagService = createFeatureFlagService;
 exports.createFrontendContext = createFrontendContext;
 exports.createRolloutIdentifier = createRolloutIdentifier;
+exports.createStandaloneApiClient = createStandaloneApiClient;
 exports.detectRuntime = detectRuntime;
 exports.evaluateArrayOperator = evaluateArrayOperator;
 exports.evaluateConditionOperator = evaluateConditionOperator;