@plyaz/core 1.10.0 → 1.11.0

package/dist/entry-backend.mjs

@@ -1,4 +1,4 @@
-import { TIME_CONSTANTS, FORMAT_CONSTANTS, FILE_CHECK_INTERVAL_DEFAULT, FEATURE_FLAG_CACHE_TTL_DEFAULT, FEATURE_FLAG_FILE_PATHS, FEATURE_FLAG_PROVIDERS, NUMERIC_CONSTANTS, HTTP_STATUS as HTTP_STATUS$1, DOWNLOAD_CONFIG, MATH_CONSTANTS, ISO_STANDARDS, CACHE_MAX_SIZE_DEFAULT, CACHE_CLEANUP_INTERVAL_DEFAULT, DEVELOPMENT_CONFIG, STAGING_CONFIG, PRODUCTION_CONFIG, FNV_CONSTANTS, FEATURES, HASH_SEED_CONSTANTS } from '@plyaz/config';
+import { TIME_CONSTANTS, FORMAT_CONSTANTS, FILE_CHECK_INTERVAL_DEFAULT, FEATURE_FLAG_CACHE_TTL_DEFAULT, FEATURE_FLAG_FILE_PATHS, FEATURE_FLAG_PROVIDERS, NUMERIC_CONSTANTS, DOWNLOAD_CONFIG, HTTP_STATUS as HTTP_STATUS$1, MATH_CONSTANTS, ISO_STANDARDS, CACHE_MAX_SIZE_DEFAULT, CACHE_CLEANUP_INTERVAL_DEFAULT, DEVELOPMENT_CONFIG, STAGING_CONFIG, PRODUCTION_CONFIG, FNV_CONSTANTS, FEATURES, HASH_SEED_CONSTANTS } from '@plyaz/config';
 import { ERROR_CODES as ERROR_CODES$1, HTTP_STATUS, NODE_ENVIRONMENTS, BACKEND_RUNTIMES, FRONTEND_RUNTIMES, UNIVERSAL_RUNTIMES, ERROR_CATEGORY as ERROR_CATEGORY$1, CORE_EVENTS as CORE_EVENTS$1, PACKAGE_STATUS_CODES, API_ERROR_CODES, OPERATIONS, FEATURE_FLAG_PROVIDERS as FEATURE_FLAG_PROVIDERS$2, FEATURE_FLAG_METADATA } from '@plyaz/types';
 import { EventEmitter } from 'events';
 import { evaluateAllFeatureFlags, createFeatureFlag, updateFeatureFlag, deleteFeatureFlag, fetchFeatureFlagRules, createApiClient, mergeConfigs, ApiPackageError, setDefaultApiClient } from '@plyaz/api/frontend';
@@ -1356,7 +1356,7 @@ var init_LoggerAdapter = __esm({
         let status = "unset";
         let statusMessage;
         const logSpans = this.logSpans;
-        const logger6 = this.observabilityLogger;
+        const logger8 = this.observabilityLogger;
         return {
           context,
           setAttribute: /* @__PURE__ */ __name((key, value) => {
@@ -1368,7 +1368,7 @@ var init_LoggerAdapter = __esm({
           addEvent: /* @__PURE__ */ __name((event) => {
             events.push(event);
             if (logSpans) {
-              logger6.debug(`[SPAN EVENT] ${options.name}: ${event.name}`, {
+              logger8.debug(`[SPAN EVENT] ${options.name}: ${event.name}`, {
                 traceId: context.traceId,
                 spanId: context.spanId,
                 eventAttributes: event.attributes
@@ -1383,7 +1383,7 @@ var init_LoggerAdapter = __esm({
             const duration = (endTime ?? Date.now()) - startTime;
             if (logSpans) {
               const logMethod = status === "error" ? "warn" : "debug";
-              logger6[logMethod](`[SPAN END] ${options.name}`, {
+              logger8[logMethod](`[SPAN END] ${options.name}`, {
                 traceId: context.traceId,
                 spanId: context.spanId,
                 durationMs: duration,
@@ -1396,7 +1396,7 @@ var init_LoggerAdapter = __esm({
           }, "end"),
           recordException: /* @__PURE__ */ __name((error) => {
             if (logSpans) {
-              logger6.error(`[SPAN ERROR] ${options.name}`, {
+              logger8.error(`[SPAN ERROR] ${options.name}`, {
                 traceId: context.traceId,
                 spanId: context.spanId,
                 error: error.message,
@@ -3144,6 +3144,11 @@ var init_CoreInitializer = __esm({
               environment: globalEnvironment,
               runtime,
               apiClient: apiConfig ? { baseURL: apiConfig.baseURL, ...apiConfig } : void 0,
+              db: options.db,
+              cache: options.cache,
+              storage: options.storage,
+              notifications: options.notifications,
+              observability: options.observability,
               services: mergedServices,
               stores: {
                 // Returns specific slice from namespaced root store (type-safe)
@@ -3953,26 +3958,76 @@ var init_CoreInitializer = __esm({
           errorStore,
           _Core.buildErrorHandlerConfig(_Core._errorConfig)
         );
+        _Core.setupErrorEventSubscription(verbose);
+        _Core.setupErrorStoreSubscription(verbose);
+        _Core.log("Global error handler initialized with CoreEventManager integration", verbose);
+        if (_Core._errorConfig.httpHandler !== false) {
+          await _Core.createHttpErrorHandler(_Core._errorConfig, verbose);
+        }
+      }
+      /**
+       * Log serialized errors with full details.
+       */
+      static logErrors(errors, prefix = "ErrorStore") {
+        for (const err of errors) {
+          _Core.logger.error(`[${prefix}] ${err.code}: ${err.message}`, {
+            id: err.id,
+            code: err.code,
+            message: err.message,
+            category: err.category,
+            source: err.source,
+            status: err.status,
+            isRetryable: err.isRetryable,
+            context: err.context,
+            timestamp: err.timestamp
+          });
+        }
+      }
+      /**
+       * Setup SYSTEM.ERROR event subscription for error store updates.
+       * Backend: Also logs errors with full details.
+       * Frontend: Only updates store (logging handled by store subscription).
+       */
+      static setupErrorEventSubscription(verbose) {
+        const isBackend = BACKEND_RUNTIMES.includes(_Core._coreServices.runtime);
         const errorEventCleanup = CoreEventManager.on(
           CORE_EVENTS.SYSTEM.ERROR,
           (event) => {
             if (!_Core._rootStore) return;
             try {
               const { errors } = event.data;
-              if (errors && errors.length > 0) {
-                _Core._rootStore.getState().errors.addErrors(errors);
-                _Core.log(`Added ${errors.length} error(s) to store`, verbose);
-              }
+              if (!errors || errors.length === 0) return;
+              _Core._rootStore.getState().errors.addErrors(errors);
+              if (isBackend) _Core.logErrors(errors);
+              _Core.log(`Added ${errors.length} error(s) to store`, verbose);
             } catch (e) {
               _Core.logger.error("Failed to handle error event", { error: e });
             }
           }
         );
         _Core._eventCleanupFns.push(errorEventCleanup);
-        _Core.log("Global error handler initialized with CoreEventManager integration", verbose);
-        if (_Core._errorConfig.httpHandler !== false) {
-          await _Core.createHttpErrorHandler(_Core._errorConfig, verbose);
-        }
+      }
+      /**
+       * Setup error store subscription for frontend logging.
+       * Logs new errors when they're added to the store.
+       * Only active for non-backend runtimes (browser, nextjs, nuxt, edge).
+       */
+      static setupErrorStoreSubscription(verbose) {
+        const isFrontend = !BACKEND_RUNTIMES.includes(_Core._coreServices.runtime);
+        if (!isFrontend || !_Core._rootStore) return;
+        let prevErrorCount = 0;
+        const storeUnsubscribe = _Core._rootStore.subscribe((state) => {
+          const currentCount = state.errors.errorCount;
+          if (currentCount <= prevErrorCount) {
+            prevErrorCount = currentCount;
+            return;
+          }
+          const newErrors = state.errors.errors.slice(0, currentCount - prevErrorCount);
+          _Core.logErrors(newErrors, "ErrorStore:FE");
+          prevErrorCount = currentCount;
+        });
+        _Core._eventCleanupFns.push(storeUnsubscribe);
+        _Core.log("Error store subscription initialized for frontend", verbose);
       }
       /**
        * Create HTTP error handler based on detected runtime.
@@ -8690,7 +8745,7 @@ var init_FrontendExampleDomainService = __esm({
       // Constructor
       // ─────────────────────────────────────────────────────────────────────────
       constructor(config = {}, options) {
-        const apiBasePath = config.apiBasePath || "/api/examples";
+        const apiBasePath = config.apiBasePath || "";
         super({
           serviceName: "ExampleFrontendService",
           supportedRuntimes: ["frontend"],
@@ -8715,20 +8770,20 @@ var init_FrontendExampleDomainService = __esm({
             // Note: Use relative paths since apiClient.baseURL is already set to apiBasePath
             fetchers: {
               fetchAll: /* @__PURE__ */ __name(async (query) => {
-                return this.apiClient.get("", { params: query });
+                return this.apiClient.get("/examples", { params: query });
               }, "fetchAll"),
               fetchById: /* @__PURE__ */ __name(async (id) => {
-                return this.apiClient.get(`/${id}`);
+                return this.apiClient.get(`/examples/${id}`);
               }, "fetchById"),
               create: /* @__PURE__ */ __name(async (data) => {
-                return this.apiClient.post("", data);
+                return this.apiClient.post("/examples", data);
               }, "create"),
               update: /* @__PURE__ */ __name(async (payload) => {
                 const { id, data } = payload;
-                return this.apiClient.patch(`/${id}`, data);
+                return this.apiClient.patch(`/examples/${id}`, data);
               }, "update"),
               delete: /* @__PURE__ */ __name(async (id) => {
-                return this.apiClient.delete(`/${id}`);
+                return this.apiClient.delete(`/examples/${id}`);
               }, "delete")
             }
             // Store handlers - customize how data syncs to store
@@ -8796,7 +8851,7 @@ var init_FrontendExampleDomainService = __esm({
           // The ?? operator only falls through on null/undefined, not empty strings.
           // An empty string is not a valid API path, so we treat it as "not provided" and fall through to default.
           // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-          apiBasePath: config.apiBasePath || options?.apiClient?.options?.baseURL || "/api/examples"
+          apiBasePath: config.apiBasePath || options?.apiClient?.options?.baseURL || ""
         };
         const service = new _FrontendExampleDomainService(mergedConfig, options);
         if (mergedConfig.autoFetch) {
@@ -9200,7 +9255,7 @@ var init_FrontendFilesDomainService = __esm({
     logger4 = new PackageLogger({ packageName: "core", service: "FrontendFilesDomainService" });
     FrontendFilesDomainService = class _FrontendFilesDomainService extends BaseFrontendDomainService {
       constructor(config = {}, options) {
-        const apiBasePath = config.apiBasePath || "/api";
+        const apiBasePath = config.apiBasePath || "";
         super({
           serviceName: "FrontendFilesDomainService",
           supportedRuntimes: ["frontend"],
@@ -9263,7 +9318,7 @@ var init_FrontendFilesDomainService = __esm({
           // The ?? operator only falls through on null/undefined, not empty strings.
           // An empty string is not a valid API path, so we treat it as "not provided" and fall through to default.
           // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-          apiBasePath: config.apiBasePath || options?.apiClient?.options?.baseURL || "/api"
+          apiBasePath: config.apiBasePath || options?.apiClient?.options?.baseURL || ""
         };
         return new _FrontendFilesDomainService(mergedConfig, options);
       }
@@ -9439,10 +9494,11 @@ var init_FrontendFilesDomainService = __esm({
     __name(resetFilesFrontendService, "resetFilesFrontendService");
   }
 });
-var DEFAULT_ENCRYPTION_FIELDS, DEFAULT_CACHE_TTL_SECONDS, DEFAULT_AUDIT_RETENTION_DAYS, DEFAULT_POOL_SIZE, DEFAULT_CONFIG, TABLE_REGISTRY, DbService;
+var logger5, DEFAULT_ENCRYPTION_FIELDS, DEFAULT_CACHE_TTL_SECONDS, DEFAULT_AUDIT_RETENTION_DAYS, DEFAULT_POOL_SIZE, DEFAULT_CONFIG, TABLE_REGISTRY, DbService;
 var init_DbService = __esm({
   "src/services/DbService.ts"() {
     init_CoreEventManager();
+    logger5 = new PackageLogger({ packageName: "core", service: "DbService" });
     DEFAULT_ENCRYPTION_FIELDS = {
       // User PII
       users: ["password_hash", "phone_number", "date_of_birth"],
@@ -9536,6 +9592,41 @@ var init_DbService = __esm({
         };
         CoreEventManager.emit(CORE_EVENTS.DATABASE.ERROR, payload);
       }
+      /**
+       * Creates merged event handlers that wrap user-provided handlers.
+       * Adds Core-level logging and forwards to user handlers.
+       *
+       * Note: Unlike StorageService/NotificationService, DB events don't emit
+       * to CoreEventManager by default (too verbose). User handlers can emit
+       * if needed.
+       *
+       * @param userHandlers - User-provided event handlers from config
+       * @returns Merged handlers with Core logging + user handlers
+       */
+      static createMergedEventHandlers(userHandlers) {
+        return {
+          ...userHandlers,
+          onAfterWrite: /* @__PURE__ */ __name(async (event) => {
+            logger5.debug("Database write completed", {
+              operation: event.operation,
+              table: event.table,
+              duration: event.duration
+            });
+            if (userHandlers?.onAfterWrite) {
+              await userHandlers.onAfterWrite(event);
+            }
+          }, "onAfterWrite"),
+          onAfterRead: /* @__PURE__ */ __name(async (event) => {
+            logger5.debug("Database read completed", {
+              table: event.table,
+              duration: event.duration
+            });
+            if (userHandlers?.onAfterRead) {
+              await userHandlers.onAfterRead(event);
+            }
+          }, "onAfterRead")
+        };
+      }
       /**
        * Gets the singleton instance of DbService
        *
@@ -9740,6 +9831,8 @@ var init_DbService = __esm({
         if (cache) dbConfig.cache = cache;
         if (audit) dbConfig.audit = audit;
         if (encryption) dbConfig.encryption = encryption;
+        const events = _DbService.createMergedEventHandlers(config.events);
+        if (events) dbConfig.events = events;
         return dbConfig;
       }
       /**
@@ -10963,11 +11056,10 @@ var BackendFilesDomainService, backendFilesDomainService, _instance2;
 var init_BackendFilesDomainService = __esm({
   "src/domain/files/BackendFilesDomainService.ts"() {
     init_base();
-    init_events();
     init_files();
     init_FilesMapper();
     init_FilesValidator();
-    init_common();
+    init_FilesMapper();
     BackendFilesDomainService = class _BackendFilesDomainService extends BaseBackendDomainService {
       constructor(config = {}, injected) {
         super({
@@ -11006,7 +11098,6 @@ var init_BackendFilesDomainService = __esm({
        */
       // eslint-disable-next-line complexity
       static async create(config = {}, options) {
-        this.registerEventHandlers();
         const injected = {
           cache: options?.cache?.instance,
           db: options?.db?.instance,
@@ -11016,59 +11107,6 @@ var init_BackendFilesDomainService = __esm({
         };
         return new _BackendFilesDomainService(config, injected);
       }
-      /**
-       * Register event handlers for file upload persistence.
-       * Called by CoreInitializer after storage and DB are initialized.
-       *
-       * Events handled:
-       * - files:upload:uploaded - Persist single file to DB
-       * - files:upload:bulk:uploaded - Persist multiple files to DB
-       *
-       * Deduplication: Uses unique constraint on storage_path.
-       *
-       * @param verbose - Enable verbose logging
-       */
-      static registerEventHandlers(verbose) {
-        if (BackendEventPersistenceHandler.isRegistered("files")) {
-          return;
-        }
-        BackendEventPersistenceHandler.register({
-          domain: "files",
-          events: {
-            "files:upload:uploaded": {
-              extractPayload: /* @__PURE__ */ __name((payload) => {
-                if (!isObject(payload)) return void 0;
-                const p = payload;
-                if (!FilesMapperClass.isUploadResult(p.result)) return void 0;
-                return p.result;
-              }, "extractPayload"),
-              isBulk: false,
-              validate: /* @__PURE__ */ __name((item) => Boolean(item.metadata?.fileId), "validate")
-            },
-            "files:upload:bulk:uploaded": {
-              extractPayload: /* @__PURE__ */ __name((payload) => {
-                if (!isObject(payload)) return [];
-                const p = payload;
-                const results = p.result?.results;
-                if (!Array.isArray(results)) return [];
-                return results.filter(FilesMapperClass.isUploadResult);
-              }, "extractPayload"),
-              isBulk: true,
-              validate: /* @__PURE__ */ __name((item) => Boolean(item.metadata?.fileId), "validate")
-            }
-          },
-          loadDependencies: /* @__PURE__ */ __name(async () => ({
-            repository: FilesRepository.create(),
-            mapper: FilesMapper
-          }), "loadDependencies"),
-          mapToDbRow: /* @__PURE__ */ __name((mapper, item) => mapper.toDbRow(item), "mapToDbRow"),
-          createRecord: /* @__PURE__ */ __name(async (repository, dbRow) => {
-            return repository.create(dbRow);
-          }, "createRecord"),
-          getUniqueKey: /* @__PURE__ */ __name((item) => item.metadata.path ?? item.metadata.fileId, "getUniqueKey"),
-          verbose
-        });
-      }
       isAvailable() {
         return this.isServiceEnabled;
       }
@@ -11171,6 +11209,36 @@ var init_BackendFilesDomainService = __esm({
         }
       }
       // ─────────────────────────────────────────────────────────────────────────
+      // DB Persistence (called by StorageService on upload complete)
+      // ─────────────────────────────────────────────────────────────────────────
+      /**
+       * Persist uploaded file metadata to the media table.
+       * Called by StorageService.onFileUploaded event handler.
+       *
+       * @param metadata - File metadata from storage upload
+       * @param variants - Optional file variants (thumbnails, etc.)
+       * @param userId - Optional user ID who uploaded the file
+       */
+      async persistUploadedFile(metadata, variants, userId) {
+        const startTime = Date.now();
+        this.logDebug("Persisting uploaded file to DB", {
+          fileId: metadata.fileId,
+          filename: metadata.filename
+        });
+        try {
+          const dbRow = FilesMapper.toDbRow({ metadata, variants }, userId);
+          await this.repository.create(dbRow);
+          this.logDebug("File persisted to media table", {
+            fileId: metadata.fileId,
+            filename: metadata.filename
+          });
+          await this.recordOperationMetrics("persistUploadedFile", Date.now() - startTime, true);
+        } catch (error) {
+          await this.recordOperationMetrics("persistUploadedFile", Date.now() - startTime, false);
+          throw error;
+        }
+      }
+      // ─────────────────────────────────────────────────────────────────────────
       // NOTE: CRUD and Storage Methods Are Inherited from BaseBackendDomainService
       // ─────────────────────────────────────────────────────────────────────────
       //
@@ -11431,6 +11499,8 @@ var getCacheService = /* @__PURE__ */ __name(() => CacheService.getInstance(), "
 
 // src/services/StorageService.ts
 init_CoreEventManager();
+init_BackendFilesDomainService();
+var logger6 = new PackageLogger({ packageName: "core", service: "StorageService" });
 var StorageService = class _StorageService {
   constructor() {
     this.storageService = null;
@@ -11487,6 +11557,28 @@ var StorageService = class _StorageService {
       _StorageService.instance = null;
     }
   }
+  /**
+   * Creates merged event handlers that persist uploads to the media table.
+   * Merges Core's internal DB persistence handler with user-provided handlers.
+   *
+   * @param userHandlers - User-provided event handlers from config
+   * @returns Merged handlers with DB persistence + user handlers
+   */
+  static createMergedEventHandlers(userHandlers) {
+    return {
+      ...userHandlers,
+      // Persist uploaded files to media table, then call user handler
+      onFileUploaded: /* @__PURE__ */ __name(async (payload) => {
+        if (payload.metadata) {
+          const filesService = await getBackendFilesDomainService();
+          await filesService.persistUploadedFile(payload.metadata);
+        }
+        if (userHandlers?.onFileUploaded) {
+          await userHandlers.onFileUploaded(payload);
+        }
+      }, "onFileUploaded")
+    };
+  }
   /**
    * Initializes the storage service
    *
@@ -11499,7 +11591,13 @@ var StorageService = class _StorageService {
       return instance;
     }
     instance.config = config;
-    instance.storageService = new StorageService$1(config);
+    const mergedHandlers = _StorageService.createMergedEventHandlers(config.handlers);
+    const mergedConfig = {
+      ...config,
+      handlers: mergedHandlers
+    };
+    logger6.info("[StorageService] Initializing with merged event handlers for DB persistence");
+    instance.storageService = new StorageService$1(mergedConfig);
     instance.initialized = true;
     return instance;
   }
@@ -11636,6 +11734,7 @@ var StorageService = class _StorageService {
 
 // src/services/NotificationService.ts
 init_CoreEventManager();
+var MAX_FAIL_ATTEMPTS = 3;
 var NotificationService = class _NotificationService {
   constructor() {
     this.notificationService = null;
@@ -11666,6 +11765,58 @@ var NotificationService = class _NotificationService {
     CoreEventManager.emit(CORE_EVENTS.NOTIFICATION.ERROR, payload);
   }
   // ─────────────────────────────────────────────────────────────────
+  // Merged Event Handlers
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Creates merged event handlers that emit to CoreEventManager.
+   * Merges Core's internal handlers with user-provided handlers.
+   *
+   * @param userHandlers - User-provided event handlers from config
+   * @returns Merged handlers with Core event emission + user handlers
+   */
+  static createMergedEventHandlers(userHandlers) {
+    return {
+      ...userHandlers,
+      // Emit to CoreEventManager on sent, then call user handler
+      onSent: /* @__PURE__ */ __name(async (payload) => {
+        CoreEventManager.emit(CORE_EVENTS.NOTIFICATION.SENT, {
+          notificationId: payload.notificationId,
+          recipientId: payload.recipientId,
+          channel: payload.channel,
+          provider: payload.provider
+        });
+        if (userHandlers?.onSent) {
+          await userHandlers.onSent(payload);
+        }
+      }, "onSent"),
+      // Emit to CoreEventManager on failed, then call user handler
+      onFailed: /* @__PURE__ */ __name(async (payload) => {
+        CoreEventManager.emit(CORE_EVENTS.NOTIFICATION.FAILED, {
+          notificationId: payload.notificationId,
+          recipientId: payload.recipientId,
+          channel: payload.channel,
+          error: payload.error,
+          retryable: payload.retryCount < MAX_FAIL_ATTEMPTS
+        });
+        if (userHandlers?.onFailed) {
+          await userHandlers.onFailed(payload);
+        }
+      }, "onFailed"),
+      // Emit to CoreEventManager on delivered, then call user handler
+      onDelivered: /* @__PURE__ */ __name(async (payload) => {
+        CoreEventManager.emit(CORE_EVENTS.NOTIFICATION.DELIVERED, {
+          notificationId: payload.notificationId,
+          recipientId: payload.recipientId,
+          channel: payload.channel,
+          deliveredAt: payload.deliveredAt
+        });
+        if (userHandlers?.onDelivered) {
+          await userHandlers.onDelivered(payload);
+        }
+      }, "onDelivered")
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────
   // Singleton Management
   // ─────────────────────────────────────────────────────────────────
   /**
@@ -11703,8 +11854,12 @@ var NotificationService = class _NotificationService {
     if (instance.initialized) {
       return instance;
     }
+    const mergedEvents = _NotificationService.createMergedEventHandlers(config.events);
     instance.config = config;
-    instance.notificationService = new NotificationService$1(config);
+    instance.notificationService = new NotificationService$1({
+      ...config,
+      events: mergedEvents
+    });
     instance.initialized = true;
     return instance;
   }
@@ -11822,9 +11977,13 @@ var NotificationService = class _NotificationService {
    * @returns Promise that resolves to a new dedicated NotificationService instance
    */
   static async createInstance(config) {
+    const mergedEvents = _NotificationService.createMergedEventHandlers(config.events);
     const dedicatedInstance = new _NotificationService();
     dedicatedInstance.config = config;
-    dedicatedInstance.notificationService = new NotificationService$1(config);
+    dedicatedInstance.notificationService = new NotificationService$1({
+      ...config,
+      events: mergedEvents
+    });
     dedicatedInstance.initialized = true;
     return dedicatedInstance;
   }
@@ -16800,7 +16959,7 @@ ErrorHandlingInterceptor = __decorateClass([
 
 // src/backend/featureFlags/config/validation.ts
 init_validation();
-var logger5 = new PackageLogger({
+var logger7 = new PackageLogger({
   packageName: "core",
   service: "FeatureFlagConfigValidator"
 });
@@ -16986,7 +17145,7 @@ var FeatureFlagConfigValidator = class {
   static getWarnings(config, environment) {
     const env = environment ?? (config.isLoggingEnabled ? NODE_ENVIRONMENTS.DEVELOPMENT : NODE_ENVIRONMENTS.PRODUCTION);
     if (config.cacheTtl > NUMERIC_CONSTANTS.ONE_HOUR_SECONDS) {
-      logger5.warn(
+      logger7.warn(
         "Cache TTL is very high (>1 hour). Consider reducing for better responsiveness.",
         {
           field: "cacheTtl",
@@ -16996,13 +17155,13 @@ var FeatureFlagConfigValidator = class {
       );
     }
     if (env === NODE_ENVIRONMENTS.PRODUCTION && config.isLoggingEnabled) {
-      logger5.warn("Logging is enabled in production. Consider disabling for performance.", {
+      logger7.warn("Logging is enabled in production. Consider disabling for performance.", {
         field: "isLoggingEnabled",
         code: "PRODUCTION_LOGGING_ENABLED"
       });
     }
     if (env === NODE_ENVIRONMENTS.DEVELOPMENT && !config.isCacheEnabled) {
-      logger5.warn("Cache is disabled in development. This may impact performance testing.", {
+      logger7.warn("Cache is disabled in development. This may impact performance testing.", {
         field: "isCacheEnabled",
         code: "DEVELOPMENT_CACHE_DISABLED"
       });