@plyaz/core 1.10.1 → 1.11.1

package/dist/index.js

@@ -4708,18 +4708,18 @@ var require_logger_service = __commonJS({
       static getTimestamp() {
         return dateTimeFormatter.format(Date.now());
       }
-      static overrideLogger(logger7) {
-        if (Array.isArray(logger7)) {
-          Logger_1.logLevels = logger7;
-          return this.staticInstanceRef?.setLogLevels?.(logger7);
+      static overrideLogger(logger9) {
+        if (Array.isArray(logger9)) {
+          Logger_1.logLevels = logger9;
+          return this.staticInstanceRef?.setLogLevels?.(logger9);
         }
-        if ((0, shared_utils_1.isObject)(logger7)) {
-          if (logger7 instanceof Logger_1 && logger7.constructor !== Logger_1) {
+        if ((0, shared_utils_1.isObject)(logger9)) {
+          if (logger9 instanceof Logger_1 && logger9.constructor !== Logger_1) {
             const errorMessage = `Using the "extends Logger" instruction is not allowed in Nest v9. Please, use "extends ConsoleLogger" instead.`;
             this.staticInstanceRef?.error(errorMessage);
             throw new Error(errorMessage);
           }
-          this.staticInstanceRef = logger7;
+          this.staticInstanceRef = logger9;
         } else {
           this.staticInstanceRef = void 0;
         }
@@ -5760,7 +5760,7 @@ var require_file_type_validator = __commonJS({
     var logger_service_1 = require_logger_service();
     var file_validator_interface_1 = require_file_validator_interface();
     var load_esm_1 = require_load_esm();
-    var logger7 = new logger_service_1.Logger("FileTypeValidator");
+    var logger9 = new logger_service_1.Logger("FileTypeValidator");
     var FileTypeValidator = class extends file_validator_interface_1.FileValidator {
       static {
         __name(this, "FileTypeValidator");
@@ -5814,7 +5814,7 @@ var require_file_type_validator = __commonJS({
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
           if (errorMessage.includes("ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING") || errorMessage.includes("Cannot find module") || errorMessage.includes("ERR_MODULE_NOT_FOUND")) {
-            logger7.warn(`Failed to load the "file-type" package for magic number validation. If you are using Jest, run it with NODE_OPTIONS="--experimental-vm-modules". Error: ${errorMessage}`);
+            logger9.warn(`Failed to load the "file-type" package for magic number validation. If you are using Jest, run it with NODE_OPTIONS="--experimental-vm-modules". Error: ${errorMessage}`);
           }
           if (this.validationOptions.fallbackToMimetype) {
             return !!file.mimetype.match(this.validationOptions.fileType);
@@ -6461,12 +6461,12 @@ var require_load_package_util = __commonJS({
     exports$1.loadPackage = loadPackage;
     var logger_service_1 = require_logger_service();
     var MISSING_REQUIRED_DEPENDENCY = /* @__PURE__ */ __name((name, reason) => `The "${name}" package is missing. Please, make sure to install it to take advantage of ${reason}.`, "MISSING_REQUIRED_DEPENDENCY");
-    var logger7 = new logger_service_1.Logger("PackageLoader");
+    var logger9 = new logger_service_1.Logger("PackageLoader");
     function loadPackage(packageName, context, loaderFn) {
       try {
         return loaderFn ? loaderFn() : __require(packageName);
       } catch (e) {
-        logger7.error(MISSING_REQUIRED_DEPENDENCY(packageName, context));
+        logger9.error(MISSING_REQUIRED_DEPENDENCY(packageName, context));
         logger_service_1.Logger.flush();
         process.exit(1);
       }
@@ -33950,7 +33950,7 @@ var LoggerAdapter = class extends BaseAdapter {
     let status = "unset";
     let statusMessage;
     const logSpans = this.logSpans;
-    const logger7 = this.observabilityLogger;
+    const logger9 = this.observabilityLogger;
     return {
       context,
       setAttribute: /* @__PURE__ */ __name((key, value) => {
@@ -33962,7 +33962,7 @@ var LoggerAdapter = class extends BaseAdapter {
       addEvent: /* @__PURE__ */ __name((event) => {
         events.push(event);
         if (logSpans) {
-          logger7.debug(`[SPAN EVENT] ${options.name}: ${event.name}`, {
+          logger9.debug(`[SPAN EVENT] ${options.name}: ${event.name}`, {
             traceId: context.traceId,
             spanId: context.spanId,
             eventAttributes: event.attributes
@@ -33977,7 +33977,7 @@ var LoggerAdapter = class extends BaseAdapter {
         const duration = (endTime ?? Date.now()) - startTime;
         if (logSpans) {
           const logMethod = status === "error" ? "warn" : "debug";
-          logger7[logMethod](`[SPAN END] ${options.name}`, {
+          logger9[logMethod](`[SPAN END] ${options.name}`, {
             traceId: context.traceId,
             spanId: context.spanId,
             durationMs: duration,
@@ -33990,7 +33990,7 @@ var LoggerAdapter = class extends BaseAdapter {
       }, "end"),
       recordException: /* @__PURE__ */ __name((error) => {
         if (logSpans) {
-          logger7.error(`[SPAN ERROR] ${options.name}`, {
+          logger9.error(`[SPAN ERROR] ${options.name}`, {
             traceId: context.traceId,
             spanId: context.spanId,
             error: error.message,
@@ -35497,6 +35497,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
    */
@@ -36407,8 +36425,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 = store.useRootStore;
+      if (!_Core._injectedStoreHook) {
+        throw new errors.CorePackageError(
+          "Root store hook not set. Call Core.setRootStoreHook(useRootStore) before Core.initialize(), or use PlyazProvider with the store prop: <PlyazProvider store={useRootStore} ...>",
+          types.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");
@@ -36517,26 +36541,76 @@ var Core = class _Core {
       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 = types.BACKEND_RUNTIMES.includes(_Core._coreServices.runtime);
     const errorEventCleanup = CoreEventManager.on(
       core.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 = !types.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.
@@ -38490,7 +38564,7 @@ var BaseFrontendDomainService = class _BaseFrontendDomainService extends BaseDom
   }
 };
 var logger2 = new logger$1.PackageLogger({ packageName: "core", service: "EventPersistence" });
-var BackendEventPersistenceHandler = class {
+(class {
   static {
     __name(this, "BackendEventPersistenceHandler");
   }
@@ -38664,7 +38738,7 @@ var BackendEventPersistenceHandler = class {
   static getRegisteredDomains() {
     return Array.from(this.registeredDomains.keys());
   }
-};
+});
 var logger3 = new logger$1.PackageLogger({ packageName: "core", service: "FrontendEventPersistence" });
 var FrontendEventPersistenceHandler = class {
   static {
@@ -43341,6 +43415,7 @@ var ApiFeatureFlagProvider = class extends FeatureFlagProvider {
     return this.engine.getRules();
   }
 };
+var logger4 = new logger$1.PackageLogger({ packageName: "core", service: "DbService" });
 var DEFAULT_ENCRYPTION_FIELDS = {
   // User PII
   users: ["password_hash", "phone_number", "date_of_birth"],
@@ -43434,6 +43509,41 @@ var DbService = class _DbService {
     };
     CoreEventManager.emit(core.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) => {
+        logger4.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) => {
+        logger4.debug("Database read completed", {
+          table: event.table,
+          duration: event.duration
+        });
+        if (userHandlers?.onAfterRead) {
+          await userHandlers.onAfterRead(event);
+        }
+      }, "onAfterRead")
+    };
+  }
   /**
    * Gets the singleton instance of DbService
    *
@@ -43638,6 +43748,8 @@ var DbService = class _DbService {
     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;
   }
   /**
@@ -44879,8 +44991,9 @@ function buildDatabaseProviderConfig(config) {
 __name(buildDatabaseProviderConfig, "buildDatabaseProviderConfig");
 function buildRedisProviderConfig(config) {
   if (!config.redis?.url) {
-    throw new Error(
-      'Redis URL is required when using redis provider. Provide redis: { url: "redis://..." }'
+    throw new errors.CorePackageError(
+      'Redis URL is required when using redis provider. Provide redis: { url: "redis://..." }',
+      types.ERROR_CODES.CORE_CONFIGURATION_INVALID
     );
   }
   return {
@@ -46203,7 +46316,7 @@ var FrontendExampleDomainService = class _FrontendExampleDomainService extends B
   // Constructor
   // ─────────────────────────────────────────────────────────────────────────
   constructor(config = {}, options) {
-    const apiBasePath = config.apiBasePath || "/api/examples";
+    const apiBasePath = config.apiBasePath || "";
     super({
       serviceName: "ExampleFrontendService",
       supportedRuntimes: ["frontend"],
@@ -46228,20 +46341,20 @@ var FrontendExampleDomainService = class _FrontendExampleDomainService extends B
         // 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
@@ -46309,7 +46422,7 @@ var FrontendExampleDomainService = class _FrontendExampleDomainService extends B
       // 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) {
@@ -46470,7 +46583,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 errors.CorePackageError(
+          `Failed to send email: ${JSON.stringify(error)}`,
+          types.ERROR_CODES.CORE_OPERATION_FAILED
+        );
       }
       const result2 = this.unwrapResponseData(response.data);
       CoreEventManager.emit(`${this.eventPrefix}:email:sent`, { result: result2 });
@@ -46690,337 +46806,712 @@ var CacheService = class _CacheService {
   }
 };
 var getCacheService = /* @__PURE__ */ __name(() => CacheService.getInstance(), "getCacheService");
-var StorageService = class _StorageService {
-  constructor() {
-    this.storageService = null;
-    this.config = null;
-    this.initialized = false;
-  }
+var TABLE_NAME = "media";
+var DEFAULT_LIMIT2 = 100;
+var FilesRepository = class _FilesRepository extends db.BaseRepository {
   static {
-    __name(this, "StorageService");
+    __name(this, "FilesRepository");
   }
-  static {
-    this.instance = null;
+  constructor(db) {
+    super(db, TABLE_NAME);
   }
-  // ─────────────────────────────────────────────────────────────────
-  // Error Handling
-  // ─────────────────────────────────────────────────────────────────
+  // ─────────────────────────────────────────────────────────────────────────
+  // Static Factory
+  // ─────────────────────────────────────────────────────────────────────────
   /**
-   * Emits a storage error event via CoreEventManager.
-   * Called when storage operations fail to integrate with global error handling.
+   * Create repository instance.
+   * Uses DbService if initialized.
    */
-  emitStorageError(error, operation, options) {
-    const payload = {
-      error,
-      operation,
-      fileId: options?.fileId,
-      filename: options?.filename,
-      recoverable: options?.recoverable ?? false
+  static create() {
+    if (!DbService.isInitialized()) {
+      throw new errors.DatabasePackageError(
+        "DbService not initialized. Call DbService.initialize() first.",
+        errors$1.DATABASE_ERROR_CODES.CONNECTION_FAILED
+      );
+    }
+    const db = DbService.getInstance().getDatabase();
+    return new _FilesRepository(db);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Overridden Methods (with domain-specific logic)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Find multiple entities with default sorting
+   */
+  // eslint-disable-next-line complexity
+  async findMany(options, config) {
+    const mergedOptions = {
+      sort: options?.sort ?? [{ field: "created_at", direction: "desc" }],
+      pagination: {
+        limit: options?.pagination?.limit ?? DEFAULT_LIMIT2,
+        offset: options?.pagination?.offset ?? 0
+      },
+      filter: options?.filter
     };
-    CoreEventManager.emit(core.CORE_EVENTS.STORAGE.ERROR, payload);
+    return super.findMany(mergedOptions, config);
   }
-  // ─────────────────────────────────────────────────────────────────
-  // Singleton Management
-  // ─────────────────────────────────────────────────────────────────
   /**
-   * Gets the singleton instance of StorageService
+   * Create new file record with auto-generated ID and timestamps
    */
-  static getInstance() {
-    _StorageService.instance ??= new _StorageService();
-    return _StorageService.instance;
+  // eslint-disable-next-line complexity
+  async create(data, config) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = data.id ?? generateId();
+    const row = {
+      id,
+      user_id: data.user_id ?? "",
+      type: data.type ?? "OTHER",
+      filename: data.filename ?? "",
+      original_filename: data.original_filename ?? data.filename ?? "",
+      mime_type: data.mime_type ?? "application/octet-stream",
+      file_size: data.file_size ?? 0,
+      storage_path: data.storage_path ?? "",
+      cdn_url: data.cdn_url ?? null,
+      width: data.width ?? null,
+      height: data.height ?? null,
+      duration: data.duration ?? null,
+      is_virus_scanned: data.is_virus_scanned ?? false,
+      virus_scan_result: data.virus_scan_result ?? null,
+      metadata: data.metadata ?? null,
+      variants: data.variants ?? null,
+      entity_type: data.entity_type ?? null,
+      entity_id: data.entity_id ?? null,
+      access_level: data.access_level ?? null,
+      created_at: now,
+      updated_at: now,
+      deleted_at: null
+    };
+    return super.create(row, config);
   }
   /**
-   * Checks if the storage service has been initialized
+   * Get the table name for this repository
    */
-  static isInitialized() {
-    return _StorageService.instance?.initialized ?? false;
+  getTableName() {
+    return TABLE_NAME;
   }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Domain-Specific Methods
+  // ─────────────────────────────────────────────────────────────────────────
   /**
-   * Resets the storage service by clearing the singleton instance
+   * Find all files for a user
    */
-  static async reset() {
-    if (_StorageService.instance) {
-      _StorageService.instance.storageService = null;
-      _StorageService.instance.config = null;
-      _StorageService.instance.initialized = false;
-      _StorageService.instance = null;
-    }
+  async findByUserId(userId, options) {
+    return this.findMany({
+      filter: { field: "user_id", operator: "eq", value: userId },
+      pagination: {
+        limit: options?.limit ?? DEFAULT_LIMIT2,
+        offset: options?.offset ?? 0
+      }
+    });
   }
   /**
-   * Initializes the storage service
-   *
-   * @param config - Storage service configuration
-   * @returns The initialized StorageService instance
+   * Find files for a specific entity (polymorphic association)
    */
-  static async initialize(config) {
-    const instance = _StorageService.getInstance();
-    if (instance.initialized) {
-      return instance;
-    }
-    instance.config = config;
-    instance.storageService = new storage$1.StorageService(config);
-    instance.initialized = true;
-    return instance;
+  async findByEntityId(entityType, entityId, options) {
+    return this.query().where("entity_type", "eq", entityType).andWhere("entity_id", "eq", entityId).whereNull("deleted_at").orderByDesc("created_at").paginate(
+      Math.floor((options?.offset ?? 0) / (options?.limit ?? DEFAULT_LIMIT2)) + 1,
+      options?.limit ?? DEFAULT_LIMIT2
+    ).execute();
   }
   /**
-   * Gets the raw underlying storage service instance without error handling wrapper.
-   * Use this only if you need direct access to the underlying service.
-   *
-   * @returns The raw StorageService instance from @plyaz/storage
-   * @throws {StoragePackageError} When storage is not initialized
+   * Find file by storage path (for deduplication checks)
    */
-  getRawStorage() {
-    if (!this.storageService) {
-      throw new errors.StoragePackageError(
-        "Storage not initialized. Call StorageService.initialize() first or use Core.initialize() with storage config.",
-        errors$1.STORAGE_ERROR_CODES.INITIALIZATION_FAILED
-      );
-    }
-    return this.storageService;
+  async findByStoragePath(storagePath) {
+    return this.findOne({ field: "storage_path", operator: "eq", value: storagePath });
   }
-  // ─────────────────────────────────────────────────────────────────
-  // Service Access
-  // ─────────────────────────────────────────────────────────────────
   /**
-   * Gets the storage service with automatic error handling.
-   * All method calls are wrapped with try/catch and emit error events on failure.
-   * Any method added to @plyaz/storage will be automatically available.
-   *
-   * @example
-   * ```typescript
-   * const storage = StorageService.getInstance().getStorage();
-   * await storage.uploadFile({ file, filename: 'doc.pdf' });
-   * await storage.deleteFile({ fileId: '123' });
-   * ```
-   *
-   * @returns StorageServiceImpl with automatic error handling
+   * Count files for a user
    */
-  getStorage() {
-    const self2 = this;
-    return new Proxy({}, {
-      get(_, prop) {
-        if (typeof prop === "symbol") {
-          return void 0;
-        }
-        const storage = self2.getRawStorage();
-        const value = storage[prop];
-        if (typeof value !== "function") {
-          return value;
-        }
-        return (...args) => {
-          try {
-            const result2 = value.apply(storage, args);
-            if (result2 instanceof Promise) {
-              return result2.catch((error) => {
-                self2.emitStorageError(error, prop, { recoverable: true });
-                throw error;
-              });
-            }
-            return result2;
-          } catch (error) {
-            self2.emitStorageError(error, prop, { recoverable: true });
-            throw error;
-          }
-        };
-      }
-    });
+  async countByUserId(userId) {
+    return this.count({ field: "user_id", operator: "eq", value: userId });
   }
-  // ─────────────────────────────────────────────────────────────────
-  // Health Check (special handling for response transformation)
-  // ─────────────────────────────────────────────────────────────────
   /**
-   * Performs a health check on the storage service by checking all adapter health.
-   * This method has special handling to transform the response format.
+   * Find files by MIME type
    */
-  async healthCheck() {
-    const startTime = Date.now();
-    try {
-      const storage = this.getRawStorage();
-      if (typeof storage.checkAllAdaptersHealth === "function") {
-        await storage.checkAllAdaptersHealth();
+  async findByMimeType(mimeType, options) {
+    return this.findMany({
+      filter: { field: "mime_type", operator: "eq", value: mimeType },
+      pagination: {
+        limit: options?.limit ?? DEFAULT_LIMIT2,
+        offset: options?.offset ?? 0
       }
-      const summary = typeof storage.getHealthSummary === "function" ? storage.getHealthSummary() : null;
-      const responseTime = Date.now() - startTime;
-      return {
-        // Check if all adapters are healthy (healthy count equals total count)
-        isHealthy: summary ? summary.healthy === summary.total : true,
-        responseTime,
-        error: void 0
-      };
-    } catch (error) {
-      this.emitStorageError(error, "healthCheck", { recoverable: true });
-      return {
-        isHealthy: false,
-        responseTime: Date.now() - startTime,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
+    });
   }
-  // ─────────────────────────────────────────────────────────────────
-  // Lifecycle
-  // ─────────────────────────────────────────────────────────────────
   /**
-   * Gets the current configuration
+   * Find files by type (IMAGE, VIDEO, DOCUMENT, AUDIO)
    */
-  getConfig() {
-    return this.config;
+  async findByType(type, options) {
+    return this.findMany({
+      filter: { field: "type", operator: "eq", value: type },
+      pagination: {
+        limit: options?.limit ?? DEFAULT_LIMIT2,
+        offset: options?.offset ?? 0
+      }
+    });
+  }
+};
+
+// src/domain/files/mappers/FilesMapper.ts
+var FilesMapperClass = class _FilesMapperClass extends BaseMapper {
+  static {
+    __name(this, "FilesMapperClass");
   }
   /**
-   * Closes the storage service and cleans up resources
+   * Type guard for UploadResult from event payloads
+   * Validates that the value has the required structure for DB mapping
    */
-  async close() {
-    if (this.storageService) {
-      await this.storageService.destroy();
-    }
-    this.storageService = null;
-    this.initialized = false;
-    this.config = null;
+  static isUploadResult(value) {
+    if (!isObject(value)) return false;
+    const obj = value;
+    if (!isObject(obj.metadata)) return false;
+    const metadata = obj.metadata;
+    return typeof metadata.fileId === "string" && typeof metadata.filename === "string" && typeof metadata.mimeType === "string" && typeof metadata.size === "number" && typeof metadata.path === "string";
   }
   /**
-   * Creates a dedicated storage service instance (NOT the singleton)
-   *
-   * Use this when you need an isolated storage connection with its own configuration.
-   *
-   * @param config - Storage service configuration
-   * @returns Promise that resolves to a new dedicated StorageService instance
+   * Infer file type from MIME type
    */
-  static async createInstance(config) {
-    const dedicatedInstance = new _StorageService();
-    dedicatedInstance.config = config;
-    dedicatedInstance.storageService = new storage$1.StorageService(config);
-    dedicatedInstance.initialized = true;
-    return dedicatedInstance;
-  }
-};
-var NotificationService = class _NotificationService {
-  constructor() {
-    this.notificationService = null;
-    this.config = null;
-    this.initialized = false;
-  }
-  static {
-    __name(this, "NotificationService");
-  }
-  static {
-    this.instance = null;
+  static inferFileType(mimeType) {
+    if (mimeType.startsWith("image/")) return "IMAGE";
+    if (mimeType.startsWith("video/")) return "VIDEO";
+    if (mimeType.startsWith("audio/")) return "AUDIO";
+    if (mimeType.includes("pdf") || mimeType.includes("document") || mimeType.includes("text/")) {
+      return "DOCUMENT";
+    }
+    return "OTHER";
   }
-  // ─────────────────────────────────────────────────────────────────
-  // Error Handling
-  // ─────────────────────────────────────────────────────────────────
   /**
-   * Emits a notification error event via CoreEventManager.
-   * Called when notification operations fail to integrate with global error handling.
+   * API Response → Domain Entity
    */
-  emitNotificationError(error, operation, options) {
-    const payload = {
-      error,
-      operation,
-      recipientId: options?.recipientId,
-      channel: options?.channel,
-      recoverable: options?.recoverable ?? false
+  toDomain(dto) {
+    const type = _FilesMapperClass.inferFileType(dto.mimeType);
+    return {
+      id: dto.id,
+      key: dto.key,
+      filename: dto.filename,
+      mimeType: dto.mimeType,
+      size: dto.size,
+      checksum: dto.checksum,
+      url: dto.url,
+      publicUrl: dto.publicUrl,
+      signedUrl: dto.signedUrl,
+      bucket: dto.bucket,
+      entityType: dto.entityType,
+      entityId: dto.entityId,
+      category: dto.category,
+      uploadedAt: new Date(dto.uploadedAt),
+      expiresAt: dto.expiresAt ? new Date(dto.expiresAt) : void 0,
+      variants: dto.variants,
+      type,
+      isImage: type === "IMAGE",
+      isVideo: type === "VIDEO",
+      isDocument: type === "DOCUMENT",
+      isAudio: type === "AUDIO"
     };
-    CoreEventManager.emit(core.CORE_EVENTS.NOTIFICATION.ERROR, payload);
   }
-  // ─────────────────────────────────────────────────────────────────
-  // Singleton Management
-  // ─────────────────────────────────────────────────────────────────
   /**
-   * Gets the singleton instance of NotificationService
+   * Domain Entity → Store State (serializable)
    */
-  static getInstance() {
-    _NotificationService.instance ??= new _NotificationService();
-    return _NotificationService.instance;
+  toStoreState(entity) {
+    return {
+      id: entity.id,
+      key: entity.key,
+      filename: entity.filename,
+      mimeType: entity.mimeType,
+      size: entity.size,
+      url: entity.url,
+      publicUrl: entity.publicUrl,
+      bucket: entity.bucket,
+      entityType: entity.entityType,
+      entityId: entity.entityId,
+      category: entity.category,
+      uploadedAt: entity.uploadedAt.toISOString(),
+      type: entity.type,
+      isImage: entity.isImage,
+      isVideo: entity.isVideo,
+      isDocument: entity.isDocument,
+      isAudio: entity.isAudio
+    };
   }
   /**
-   * Checks if the notification service has been initialized
+   * Store State → Domain Entity
    */
-  static isInitialized() {
-    return _NotificationService.instance?.initialized ?? false;
+  fromStoreState(state) {
+    return {
+      id: state.id,
+      key: state.key,
+      filename: state.filename,
+      mimeType: state.mimeType,
+      size: state.size,
+      url: state.url,
+      publicUrl: state.publicUrl,
+      bucket: state.bucket,
+      entityType: state.entityType,
+      entityId: state.entityId,
+      category: state.category,
+      uploadedAt: new Date(state.uploadedAt),
+      type: state.type,
+      isImage: state.isImage,
+      isVideo: state.isVideo,
+      isDocument: state.isDocument,
+      isAudio: state.isAudio
+    };
   }
   /**
-   * Resets the notification service by clearing the singleton instance
+   * Database Row → API Response (for backend)
    */
-  static async reset() {
-    if (_NotificationService.instance) {
-      _NotificationService.instance.notificationService = null;
-      _NotificationService.instance.config = null;
-      _NotificationService.instance.initialized = false;
-      _NotificationService.instance = null;
-    }
+  toResponseDTO(row) {
+    return {
+      id: row.id,
+      key: row.storage_path,
+      filename: row.filename,
+      mimeType: row.mime_type,
+      size: toNumber(row.file_size),
+      checksum: void 0,
+      url: row.cdn_url ?? void 0,
+      publicUrl: row.cdn_url ?? void 0,
+      signedUrl: void 0,
+      bucket: "media",
+      entityType: row.entity_type ?? void 0,
+      entityId: row.entity_id ?? void 0,
+      category: void 0,
+      uploadedAt: row.created_at,
+      expiresAt: void 0
+    };
   }
   /**
-   * Initializes the notification service
-   *
-   * @param config - Notification service configuration
-   * @returns The initialized NotificationService instance
+   * Create GeneratedFileItem from generation result
    */
-  static async initialize(config) {
-    const instance = _NotificationService.getInstance();
-    if (instance.initialized) {
-      return instance;
-    }
-    instance.config = config;
-    instance.notificationService = new notifications.NotificationService(config);
-    instance.initialized = true;
-    return instance;
+  toGeneratedFileItem(templateId, buffer, size, outputFormat = "pdf") {
+    return {
+      id: crypto.randomUUID(),
+      templateId,
+      buffer,
+      size,
+      mimeType: `application/${outputFormat}`,
+      filename: `${templateId}.${outputFormat}`,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
   }
   /**
-   * Gets the raw underlying notification service instance without error handling wrapper.
-   * Use this only if you need direct access to the underlying service.
+   * Convert upload result to database row format
+   * Used by event handlers to persist upload results to DB
    *
-   * @returns The raw NotificationService instance from @plyaz/notifications
-   * @throws {NotificationsPackageError} When notifications is not initialized
+   * @param uploadResult - Result from storage upload
+   * @param userId - User ID who uploaded the file (from auth context)
+   * @returns Partial database row ready for repository.create()
    */
-  getRawNotifications() {
-    if (!this.notificationService) {
-      throw new errors.NotificationPackageError(
-        "Notifications not initialized. Call NotificationService.initialize() first or use Core.initialize() with notifications config.",
-        errors$1.NOTIFICATION_ERROR_CODES.INITIALIZATION_FAILED
+  // eslint-disable-next-line complexity
+  toDbRow(uploadResult, userId) {
+    const { metadata, variants } = uploadResult;
+    return {
+      id: metadata.fileId,
+      user_id: userId ?? "system",
+      type: _FilesMapperClass.inferFileType(metadata.mimeType),
+      filename: metadata.filename,
+      original_filename: metadata.filename,
+      mime_type: metadata.mimeType,
+      file_size: metadata.size,
+      storage_path: metadata.path,
+      cdn_url: metadata.url ?? null,
+      width: metadata.extractedMetadata?.width ?? null,
+      height: metadata.extractedMetadata?.height ?? null,
+      duration: metadata.extractedMetadata?.duration ?? null,
+      entity_type: metadata.entityType,
+      entity_id: metadata.entityId,
+      access_level: metadata.accessLevel,
+      is_virus_scanned: false,
+      virus_scan_result: null,
+      metadata: metadata.customMetadata ?? null,
+      variants: variants ?? null
+    };
+  }
+};
+var FilesMapper = new FilesMapperClass();
+
+// src/domain/files/validators/FilesValidator.ts
+var FilesValidatorClass = class extends BaseValidator {
+  static {
+    __name(this, "FilesValidatorClass");
+  }
+  constructor() {
+    super({});
+  }
+  /**
+   * Check if user has permission to access file
+   */
+  validateUserAccess(userId, fileOwnerId, accessLevel, isAdmin = false) {
+    if (isAdmin) return true;
+    if (userId === fileOwnerId) return true;
+    if (accessLevel === "public") return true;
+    if (accessLevel === "protected" && userId) return true;
+    return false;
+  }
+};
+new FilesValidatorClass();
+
+// src/domain/files/BackendFilesDomainService.ts
+var BackendFilesDomainService = class _BackendFilesDomainService extends BaseBackendDomainService {
+  constructor(config = {}, injected) {
+    super({
+      serviceName: "BackendFilesDomainService",
+      supportedRuntimes: ["backend"],
+      serviceConfig: {
+        enabled: true,
+        throwOnValidationError: true,
+        throwOnRepositoryError: true,
+        emitEvents: true,
+        ...config
+      },
+      mapperClass: FilesMapperClass,
+      validatorClass: FilesValidatorClass,
+      injected
+    });
+    this.eventPrefix = "files";
+    this.cachePrefix = "files";
+  }
+  static {
+    __name(this, "BackendFilesDomainService");
+  }
+  static {
+    this.serviceKey = "files";
+  }
+  /**
+   * Lazy repository getter - creates repository on first access.
+   * Throws if DbService is not initialized.
+   */
+  get repository() {
+    this._repository ??= FilesRepository.create();
+    return this._repository;
+  }
+  /**
+   * Create service instance
+   */
+  // eslint-disable-next-line complexity
+  static async create(config = {}, options) {
+    const injected = {
+      cache: options?.cache?.instance,
+      db: options?.db?.instance,
+      api: options?.apiClient?.instance,
+      storage: options?.storage?.instance,
+      notifications: options?.notifications?.instance
+    };
+    return new _BackendFilesDomainService(config, injected);
+  }
+  isAvailable() {
+    return this.isServiceEnabled;
+  }
+  dispose() {
+    this.logInfo("Service disposed");
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Storage operations (via @plyaz/storage)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Download file content
+   * GET /files/:id/download
+   *
+   * Follows same pattern as base class CRUD methods:
+   * 1. assertReady
+   * 2. Record start time
+   * 3. Log debug info
+   * 4. Emit starting event
+   * 5. Execute operation
+   * 6. Emit success event
+   * 7. Record metrics
+   *
+   * @param params - Download parameters (fileId required)
+   * @returns Download result with buffer, filename, mimeType
+   */
+  // eslint-disable-next-line complexity
+  async downloadFile(params) {
+    this.assertReady();
+    const startTime = Date.now();
+    this.logDebug("Downloading file", { fileId: params.fileId });
+    this.emitEvent("download:downloading", { request: params });
+    try {
+      await this.beforeDownloadFile?.(params);
+      if (!this.storageService) {
+        throw new errors.CorePackageError(
+          "Storage service not available. Ensure storage is configured in Core.initialize().",
+          types.ERROR_CODES.CORE_PROVIDER_INITIALIZATION_FAILED
+        );
+      }
+      const storage = this.storageService.getStorage();
+      const result2 = await storage.downloadFile({
+        fileId: params.fileId
+      });
+      const response = {
+        buffer: result2?.file?.toString("base64") ?? "",
+        filename: result2?.metadata?.filename ?? "download",
+        mimeType: result2?.metadata?.mimeType ?? "application/octet-stream"
+      };
+      await this.afterDownloadFile?.(response);
+      this.emitEvent("download:downloaded", { result: response });
+      this.emitEvent("complete", { success: true, operation: "downloadFile" });
+      await this.recordOperationMetrics("downloadFile", Date.now() - startTime, true);
+      return response;
+    } catch (error) {
+      await this.recordOperationMetrics("downloadFile", Date.now() - startTime, false);
+      this.emitEvent("download:error", { error });
+      throw error;
+    }
+  }
+  /**
+   * Get signed URL for file
+   * GET /files/:id/signed-url
+   *
+   * Follows same pattern as base class CRUD methods.
+   *
+   * @param params - Signed URL parameters (fileId required)
+   * @returns Signed URL result with url and expiresAt
+   */
+  // eslint-disable-next-line complexity
+  async getSignedUrl(params) {
+    this.assertReady();
+    const startTime = Date.now();
+    this.logDebug("Getting signed URL", { fileId: params.fileId, expiresIn: params.expiresIn });
+    this.emitEvent("signedUrl:requesting", { request: params });
+    try {
+      await this.beforeGetSignedUrl?.(params);
+      if (!this.storageService) {
+        throw new errors.CorePackageError(
+          "Storage service not available. Ensure storage is configured in Core.initialize().",
+          types.ERROR_CODES.CORE_PROVIDER_INITIALIZATION_FAILED
+        );
+      }
+      const storage = this.storageService.getStorage();
+      const result2 = await storage.getSignedUrl({
+        fileId: params.fileId,
+        expiresIn: params.expiresIn ?? config.DOWNLOAD_CONFIG.DEFAULT_SIGNED_URL_EXPIRY_SECONDS,
+        operation: "get"
+      });
+      const response = {
+        url: result2?.url ?? "",
+        expiresAt: result2?.expiresAt?.toISOString() ?? new Date(Date.now() + config.TIME_CONSTANTS.HOUR).toISOString()
+      };
+      await this.afterGetSignedUrl?.(response);
+      this.emitEvent("signedUrl:received", { result: response });
+      this.emitEvent("complete", { success: true, operation: "getSignedUrl" });
+      await this.recordOperationMetrics("getSignedUrl", Date.now() - startTime, true);
+      return response;
+    } catch (error) {
+      await this.recordOperationMetrics("getSignedUrl", Date.now() - startTime, false);
+      this.emitEvent("signedUrl:error", { error });
+      throw error;
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // 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
+  // ─────────────────────────────────────────────────────────────────────────
+  //
+  // CRUD methods:
+  // - getById(id) - for GET /files/:id
+  // - getAll(query) - for listing files
+  // - delete(id) - for DELETE /files/:id
+  // - exists(id) - check if file exists
+  //
+  // Storage methods (inherited):
+  // - uploadFile(params) - for POST /files/upload
+  // - generateFile(params) - for POST /files/generate-document
+  // ─────────────────────────────────────────────────────────────────────────
+};
+var backendFilesDomainService = new BackendFilesDomainService();
+var _instance = null;
+async function getBackendFilesDomainService(config, options) {
+  _instance ??= await BackendFilesDomainService.create(config, options);
+  return _instance;
+}
+__name(getBackendFilesDomainService, "getBackendFilesDomainService");
+
+// src/services/StorageService.ts
+var logger5 = new logger$1.PackageLogger({ packageName: "core", service: "StorageService" });
+var StorageService = class _StorageService {
+  constructor() {
+    this.storageService = null;
+    this.config = null;
+    this.initialized = false;
+  }
+  static {
+    __name(this, "StorageService");
+  }
+  static {
+    this.instance = null;
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Error Handling
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Emits a storage error event via CoreEventManager.
+   * Called when storage operations fail to integrate with global error handling.
+   */
+  emitStorageError(error, operation, options) {
+    const payload = {
+      error,
+      operation,
+      fileId: options?.fileId,
+      filename: options?.filename,
+      recoverable: options?.recoverable ?? false
+    };
+    CoreEventManager.emit(core.CORE_EVENTS.STORAGE.ERROR, payload);
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Singleton Management
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Gets the singleton instance of StorageService
+   */
+  static getInstance() {
+    _StorageService.instance ??= new _StorageService();
+    return _StorageService.instance;
+  }
+  /**
+   * Checks if the storage service has been initialized
+   */
+  static isInitialized() {
+    return _StorageService.instance?.initialized ?? false;
+  }
+  /**
+   * Resets the storage service by clearing the singleton instance
+   */
+  static async reset() {
+    if (_StorageService.instance) {
+      _StorageService.instance.storageService = null;
+      _StorageService.instance.config = null;
+      _StorageService.instance.initialized = false;
+      _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
+   *
+   * @param config - Storage service configuration
+   * @returns The initialized StorageService instance
+   */
+  static async initialize(config) {
+    const instance = _StorageService.getInstance();
+    if (instance.initialized) {
+      return instance;
+    }
+    instance.config = config;
+    const mergedHandlers = _StorageService.createMergedEventHandlers(config.handlers);
+    const mergedConfig = {
+      ...config,
+      handlers: mergedHandlers
+    };
+    logger5.info("[StorageService] Initializing with merged event handlers for DB persistence");
+    instance.storageService = new storage$1.StorageService(mergedConfig);
+    instance.initialized = true;
+    return instance;
+  }
+  /**
+   * Gets the raw underlying storage service instance without error handling wrapper.
+   * Use this only if you need direct access to the underlying service.
+   *
+   * @returns The raw StorageService instance from @plyaz/storage
+   * @throws {StoragePackageError} When storage is not initialized
+   */
+  getRawStorage() {
+    if (!this.storageService) {
+      throw new errors.StoragePackageError(
+        "Storage not initialized. Call StorageService.initialize() first or use Core.initialize() with storage config.",
+        errors$1.STORAGE_ERROR_CODES.INITIALIZATION_FAILED
       );
     }
-    return this.notificationService;
+    return this.storageService;
   }
   // ─────────────────────────────────────────────────────────────────
   // Service Access
   // ─────────────────────────────────────────────────────────────────
   /**
-   * Gets the notification service with automatic error handling.
+   * Gets the storage service with automatic error handling.
    * All method calls are wrapped with try/catch and emit error events on failure.
-   * Any method added to @plyaz/notifications will be automatically available.
+   * Any method added to @plyaz/storage will be automatically available.
    *
    * @example
    * ```typescript
-   * const notifications = NotificationService.getInstance().getNotifications();
-   * await notifications.sendEmail({ to: 'user@example.com', templateId: 'welcome' });
-   * await notifications.sendSMS({ to: '+1234567890', message: 'Hello!' });
+   * const storage = StorageService.getInstance().getStorage();
+   * await storage.uploadFile({ file, filename: 'doc.pdf' });
+   * await storage.deleteFile({ fileId: '123' });
    * ```
    *
-   * @returns NotificationServiceImpl with automatic error handling
+   * @returns StorageServiceImpl with automatic error handling
    */
-  getNotifications() {
+  getStorage() {
     const self2 = this;
     return new Proxy({}, {
       get(_, prop) {
         if (typeof prop === "symbol") {
           return void 0;
         }
-        const notifications = self2.getRawNotifications();
-        const value = notifications[prop];
+        const storage = self2.getRawStorage();
+        const value = storage[prop];
         if (typeof value !== "function") {
           return value;
         }
         return (...args) => {
           try {
-            const result2 = value.apply(notifications, args);
+            const result2 = value.apply(storage, args);
             if (result2 instanceof Promise) {
               return result2.catch((error) => {
-                self2.emitNotificationError(error, prop, { recoverable: true });
+                self2.emitStorageError(error, prop, { recoverable: true });
                 throw error;
               });
             }
             return result2;
           } catch (error) {
-            self2.emitNotificationError(error, prop, { recoverable: true });
+            self2.emitStorageError(error, prop, { recoverable: true });
             throw error;
           }
         };
@@ -47031,23 +47522,29 @@ var NotificationService = class _NotificationService {
   // Health Check (special handling for response transformation)
   // ─────────────────────────────────────────────────────────────────
   /**
-   * Performs a health check on the notification service.
+   * Performs a health check on the storage service by checking all adapter health.
    * This method has special handling to transform the response format.
    */
   async healthCheck() {
+    const startTime = Date.now();
     try {
-      const notifications = this.getRawNotifications();
-      const result2 = await notifications.healthCheck();
+      const storage = this.getRawStorage();
+      if (typeof storage.checkAllAdaptersHealth === "function") {
+        await storage.checkAllAdaptersHealth();
+      }
+      const summary = typeof storage.getHealthSummary === "function" ? storage.getHealthSummary() : null;
+      const responseTime = Date.now() - startTime;
       return {
-        isHealthy: result2.healthy,
-        providers: result2.providers,
-        // Use optional chaining since error may not exist on all health check results
-        error: "error" in result2 ? result2.error : void 0
+        // Check if all adapters are healthy (healthy count equals total count)
+        isHealthy: summary ? summary.healthy === summary.total : true,
+        responseTime,
+        error: void 0
       };
     } catch (error) {
-      this.emitNotificationError(error, "healthCheck", { recoverable: true });
+      this.emitStorageError(error, "healthCheck", { recoverable: true });
       return {
         isHealthy: false,
+        responseTime: Date.now() - startTime,
         error: error instanceof Error ? error.message : "Unknown error"
       };
     }
@@ -47062,844 +47559,539 @@ var NotificationService = class _NotificationService {
     return this.config;
   }
   /**
-   * Closes the notification service and cleans up resources
+   * Closes the storage service and cleans up resources
    */
   async close() {
-    this.notificationService = null;
+    if (this.storageService) {
+      await this.storageService.destroy();
+    }
+    this.storageService = null;
     this.initialized = false;
     this.config = null;
   }
   /**
-   * Creates a dedicated notification service instance (NOT the singleton)
+   * Creates a dedicated storage service instance (NOT the singleton)
    *
-   * Use this when you need an isolated notification service with its own configuration.
+   * Use this when you need an isolated storage connection with its own configuration.
    *
-   * @param config - Notification service configuration
-   * @returns Promise that resolves to a new dedicated NotificationService instance
+   * @param config - Storage service configuration
+   * @returns Promise that resolves to a new dedicated StorageService instance
    */
   static async createInstance(config) {
-    const dedicatedInstance = new _NotificationService();
+    const dedicatedInstance = new _StorageService();
     dedicatedInstance.config = config;
-    dedicatedInstance.notificationService = new notifications.NotificationService(config);
+    dedicatedInstance.storageService = new storage$1.StorageService(config);
     dedicatedInstance.initialized = true;
     return dedicatedInstance;
   }
 };
-var cachedVersion = "";
-function getPackageVersion() {
-  if (cachedVersion) return cachedVersion;
-  try {
-    const require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
-    const pkg = require2("../package.json");
-    cachedVersion = pkg.version ?? "0.0.0";
-  } catch {
-    try {
-      const currentFile = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
-      const currentDir = path.dirname(currentFile);
-      const pkgPath = path.join(currentDir, "..", "package.json");
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-      cachedVersion = pkg.version ?? "0.0.0";
-    } catch {
-      cachedVersion = "0.0.0";
-    }
-  }
-  return cachedVersion;
-}
-__name(getPackageVersion, "getPackageVersion");
-var VERSION = getPackageVersion();
-var PACKAGE_NAME = "@plyaz/core";
-
-// src/backend/index.ts
-var backend_exports = {};
-__export(backend_exports, {
-  BACKEND_EXAMPLE_DOMAIN_SERVICE: () => BACKEND_EXAMPLE_DOMAIN_SERVICE,
-  BACKEND_FILES_DOMAIN_SERVICE: () => BACKEND_FILES_DOMAIN_SERVICE,
-  BackendExampleDomainService: () => BackendExampleDomainService,
-  Caching: () => Caching,
-  ErrorHandlingInterceptor: () => ErrorHandlingInterceptor,
-  ExampleController: () => ExampleController,
-  ExampleModule: () => ExampleModule,
-  FeatureDisabled: () => FeatureDisabled,
-  FeatureEnabled: () => FeatureEnabled,
-  FeatureFlagConfigFactory: () => FeatureFlagConfigFactory,
-  FeatureFlagConfigValidator: () => FeatureFlagConfigValidator,
-  FeatureFlagController: () => FeatureFlagController,
-  FeatureFlagDatabaseRepository: () => FeatureFlagDatabaseRepository,
-  FeatureFlagDomainService: () => FeatureFlagDomainService,
-  FeatureFlagGuard: () => FeatureFlagGuard,
-  FeatureFlagLoggingInterceptor: () => FeatureFlagLoggingInterceptor,
-  FeatureFlagMiddleware: () => FeatureFlagMiddleware,
-  FeatureFlagModule: () => FeatureFlagModule,
-  FeatureFlagService: () => FeatureFlagService,
-  FeatureFlagServiceFactory: () => FeatureFlagServiceFactory,
-  FilesController: () => FilesController,
-  FilesModule: () => FilesModule
-});
-
-// src/backend/example/example.module.ts
-var import_common11 = __toESM(require_common(), 1);
-
-// src/backend/example/example.controller.ts
-var import_common10 = __toESM(require_common(), 1);
-var BACKEND_EXAMPLE_DOMAIN_SERVICE = "BACKEND_EXAMPLE_DOMAIN_SERVICE";
-var ExampleController = class {
-  constructor(exampleService) {
-    this.exampleService = exampleService;
-  }
-  health() {
-    return errors.SuccessResponseStandard("Service is healthy", {
-      service: this.exampleService.isAvailable(),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  async getEntity(id) {
-    const entity = await this.exampleService.getById(id);
-    return errors.SuccessResponseStandard("Entity retrieved successfully", entity);
-  }
-  async createEntity(dto) {
-    const entity = await this.exampleService.create(dto);
-    return errors.SuccessResponseStandard("Entity created successfully", entity, types.HTTP_STATUS.CREATED);
-  }
-  async updateEntity(id, dto) {
-    const entity = await this.exampleService.patch(id, dto);
-    return errors.SuccessResponseStandard("Entity updated successfully", entity);
-  }
-  async deleteEntity(id) {
-    await this.exampleService.delete(id);
-    return errors.SuccessResponseStandard("Entity deleted successfully", null);
-  }
-  async createEntityWithValidation(dto) {
-    const entity = await this.exampleService.create(dto);
-    return errors.SuccessResponseStandard("Entity created successfully", entity, types.HTTP_STATUS.CREATED);
-  }
-  async demoSingleError() {
-    return await this.exampleService.demoSingleValidationError();
-  }
-  async demoArrayErrors() {
-    return await this.exampleService.demoMultipleValidationErrors();
-  }
-  async sendEmail(dto) {
-    const result2 = await this.exampleService.sendEmail(dto);
-    return errors.SuccessResponseStandard("Email sent successfully", result2);
-  }
-};
-__name(ExampleController, "ExampleController");
-__decorateClass([
-  (0, import_common10.Get)("health")
-], ExampleController.prototype, "health", 1);
-__decorateClass([
-  (0, import_common10.Get)("entities/:id"),
-  __decorateParam(0, (0, import_common10.Param)("id"))
-], ExampleController.prototype, "getEntity", 1);
-__decorateClass([
-  (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_common10.Patch)("entities/:id"),
-  __decorateParam(0, (0, import_common10.Param)("id")),
-  __decorateParam(1, (0, import_common10.Body)())
-], ExampleController.prototype, "updateEntity", 1);
-__decorateClass([
-  (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_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_common10.Get)("errors/single")
-], ExampleController.prototype, "demoSingleError", 1);
-__decorateClass([
-  (0, import_common10.Get)("errors/array")
-], ExampleController.prototype, "demoArrayErrors", 1);
-__decorateClass([
-  (0, import_common10.Post)("email"),
-  (0, import_common10.HttpCode)(import_common10.HttpStatus.OK),
-  __decorateParam(0, (0, import_common10.Body)())
-], ExampleController.prototype, "sendEmail", 1);
-ExampleController = __decorateClass([
-  (0, import_common10.Controller)("example"),
-  __decorateParam(0, (0, import_common10.Inject)(BACKEND_EXAMPLE_DOMAIN_SERVICE))
-], ExampleController);
-
-// src/backend/example/example.module.ts
-var ExampleModule = class {
-};
-__name(ExampleModule, "ExampleModule");
-ExampleModule = __decorateClass([
-  (0, import_common11.Module)({
-    controllers: [ExampleController],
-    providers: [
-      // Provide BackendExampleDomainService via factory using the singleton instance
-      // This ensures the service is shared across the application
-      {
-        provide: BACKEND_EXAMPLE_DOMAIN_SERVICE,
-        useFactory: /* @__PURE__ */ __name(() => backendExampleDomainService, "useFactory")
-      }
-    ],
-    exports: [BACKEND_EXAMPLE_DOMAIN_SERVICE]
-  })
-], ExampleModule);
-
-// src/backend/files/files.module.ts
-var import_common17 = __toESM(require_common(), 1);
-
-// src/backend/files/files.controller.ts
-var import_common12 = __toESM(require_common(), 1);
-var BACKEND_FILES_DOMAIN_SERVICE = "BACKEND_FILES_DOMAIN_SERVICE";
-var FilesController = class {
-  constructor(filesService) {
-    this.filesService = filesService;
-  }
-  health() {
-    return errors.SuccessResponseStandard("Files service is healthy", {
-      service: this.filesService.isAvailable(),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  async uploadFile(dto) {
-    const result2 = await this.filesService.uploadFile(dto);
-    return errors.SuccessResponseStandard("File uploaded successfully", result2);
-  }
-  async uploadFiles(dto) {
-    const results = await this.filesService.uploadFiles(dto.files);
-    return errors.SuccessResponseStandard("Files uploaded successfully", results);
-  }
-  async generateDocument(dto) {
-    const buffer = await this.filesService.generateFile(dto);
-    return errors.SuccessResponseStandard("Document generated successfully", {
-      buffer: buffer.toString("base64"),
-      size: buffer.length
-    });
-  }
-  async getFile(id) {
-    const entity = await this.filesService.getById(id);
-    return errors.SuccessResponseStandard("File retrieved", entity);
-  }
-  async downloadFile(id) {
-    const result2 = await this.filesService.downloadFile({ fileId: id });
-    return errors.SuccessResponseStandard("File downloaded", result2);
-  }
-  async getSignedUrl(id) {
-    const result2 = await this.filesService.getSignedUrl({ fileId: id });
-    return errors.SuccessResponseStandard("Signed URL generated", result2);
-  }
-  async deleteFile(id) {
-    await this.filesService.delete(id);
-    return errors.SuccessResponseStandard("File deleted", null);
-  }
-};
-__name(FilesController, "FilesController");
-__decorateClass([
-  (0, import_common12.Get)("health")
-], FilesController.prototype, "health", 1);
-__decorateClass([
-  (0, import_common12.Post)("upload"),
-  (0, import_common12.HttpCode)(import_common12.HttpStatus.OK),
-  __decorateParam(0, (0, import_common12.Body)())
-], FilesController.prototype, "uploadFile", 1);
-__decorateClass([
-  (0, import_common12.Post)("upload/bulk"),
-  (0, import_common12.HttpCode)(import_common12.HttpStatus.OK),
-  __decorateParam(0, (0, import_common12.Body)())
-], FilesController.prototype, "uploadFiles", 1);
-__decorateClass([
-  (0, import_common12.Post)("generate-document"),
-  (0, import_common12.HttpCode)(import_common12.HttpStatus.OK),
-  __decorateParam(0, (0, import_common12.Body)())
-], FilesController.prototype, "generateDocument", 1);
-__decorateClass([
-  (0, import_common12.Get)(":id"),
-  __decorateParam(0, (0, import_common12.Param)("id"))
-], FilesController.prototype, "getFile", 1);
-__decorateClass([
-  (0, import_common12.Get)(":id/download"),
-  __decorateParam(0, (0, import_common12.Param)("id"))
-], FilesController.prototype, "downloadFile", 1);
-__decorateClass([
-  (0, import_common12.Get)(":id/signed-url"),
-  __decorateParam(0, (0, import_common12.Param)("id"))
-], FilesController.prototype, "getSignedUrl", 1);
-__decorateClass([
-  (0, import_common12.Delete)(":id"),
-  (0, import_common12.HttpCode)(import_common12.HttpStatus.OK),
-  __decorateParam(0, (0, import_common12.Param)("id"))
-], FilesController.prototype, "deleteFile", 1);
-FilesController = __decorateClass([
-  (0, import_common12.Controller)("files"),
-  __decorateParam(0, (0, import_common12.Inject)(BACKEND_FILES_DOMAIN_SERVICE))
-], FilesController);
-var TABLE_NAME = "media";
-var DEFAULT_LIMIT2 = 100;
-var FilesRepository = class _FilesRepository extends db.BaseRepository {
-  static {
-    __name(this, "FilesRepository");
-  }
-  constructor(db) {
-    super(db, TABLE_NAME);
-  }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Static Factory
-  // ─────────────────────────────────────────────────────────────────────────
-  /**
-   * Create repository instance.
-   * Uses DbService if initialized.
-   */
-  static create() {
-    if (!DbService.isInitialized()) {
-      throw new errors.DatabasePackageError(
-        "DbService not initialized. Call DbService.initialize() first.",
-        errors$1.DATABASE_ERROR_CODES.CONNECTION_FAILED
-      );
-    }
-    const db = DbService.getInstance().getDatabase();
-    return new _FilesRepository(db);
-  }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Overridden Methods (with domain-specific logic)
-  // ─────────────────────────────────────────────────────────────────────────
-  /**
-   * Find multiple entities with default sorting
-   */
-  // eslint-disable-next-line complexity
-  async findMany(options, config) {
-    const mergedOptions = {
-      sort: options?.sort ?? [{ field: "created_at", direction: "desc" }],
-      pagination: {
-        limit: options?.pagination?.limit ?? DEFAULT_LIMIT2,
-        offset: options?.pagination?.offset ?? 0
-      },
-      filter: options?.filter
-    };
-    return super.findMany(mergedOptions, config);
-  }
-  /**
-   * Create new file record with auto-generated ID and timestamps
-   */
-  // eslint-disable-next-line complexity
-  async create(data, config) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const id = data.id ?? generateId();
-    const row = {
-      id,
-      user_id: data.user_id ?? "",
-      type: data.type ?? "OTHER",
-      filename: data.filename ?? "",
-      original_filename: data.original_filename ?? data.filename ?? "",
-      mime_type: data.mime_type ?? "application/octet-stream",
-      file_size: data.file_size ?? 0,
-      storage_path: data.storage_path ?? "",
-      cdn_url: data.cdn_url ?? null,
-      width: data.width ?? null,
-      height: data.height ?? null,
-      duration: data.duration ?? null,
-      is_virus_scanned: data.is_virus_scanned ?? false,
-      virus_scan_result: data.virus_scan_result ?? null,
-      metadata: data.metadata ?? null,
-      variants: data.variants ?? null,
-      entity_type: data.entity_type ?? null,
-      entity_id: data.entity_id ?? null,
-      access_level: data.access_level ?? null,
-      created_at: now,
-      updated_at: now,
-      deleted_at: null
-    };
-    return super.create(row, config);
-  }
-  /**
-   * Get the table name for this repository
-   */
-  getTableName() {
-    return TABLE_NAME;
-  }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Domain-Specific Methods
-  // ─────────────────────────────────────────────────────────────────────────
-  /**
-   * Find all files for a user
-   */
-  async findByUserId(userId, options) {
-    return this.findMany({
-      filter: { field: "user_id", operator: "eq", value: userId },
-      pagination: {
-        limit: options?.limit ?? DEFAULT_LIMIT2,
-        offset: options?.offset ?? 0
-      }
-    });
-  }
-  /**
-   * Find files for a specific entity (polymorphic association)
-   */
-  async findByEntityId(entityType, entityId, options) {
-    return this.query().where("entity_type", "eq", entityType).andWhere("entity_id", "eq", entityId).whereNull("deleted_at").orderByDesc("created_at").paginate(
-      Math.floor((options?.offset ?? 0) / (options?.limit ?? DEFAULT_LIMIT2)) + 1,
-      options?.limit ?? DEFAULT_LIMIT2
-    ).execute();
-  }
-  /**
-   * Find file by storage path (for deduplication checks)
-   */
-  async findByStoragePath(storagePath) {
-    return this.findOne({ field: "storage_path", operator: "eq", value: storagePath });
-  }
-  /**
-   * Count files for a user
-   */
-  async countByUserId(userId) {
-    return this.count({ field: "user_id", operator: "eq", value: userId });
-  }
-  /**
-   * Find files by MIME type
-   */
-  async findByMimeType(mimeType, options) {
-    return this.findMany({
-      filter: { field: "mime_type", operator: "eq", value: mimeType },
-      pagination: {
-        limit: options?.limit ?? DEFAULT_LIMIT2,
-        offset: options?.offset ?? 0
-      }
-    });
-  }
-  /**
-   * Find files by type (IMAGE, VIDEO, DOCUMENT, AUDIO)
-   */
-  async findByType(type, options) {
-    return this.findMany({
-      filter: { field: "type", operator: "eq", value: type },
-      pagination: {
-        limit: options?.limit ?? DEFAULT_LIMIT2,
-        offset: options?.offset ?? 0
-      }
-    });
+var MAX_FAIL_ATTEMPTS = 3;
+var NotificationService = class _NotificationService {
+  constructor() {
+    this.notificationService = null;
+    this.config = null;
+    this.initialized = false;
   }
-};
-
-// src/domain/files/mappers/FilesMapper.ts
-var FilesMapperClass = class _FilesMapperClass extends BaseMapper {
   static {
-    __name(this, "FilesMapperClass");
-  }
-  /**
-   * Type guard for UploadResult from event payloads
-   * Validates that the value has the required structure for DB mapping
-   */
-  static isUploadResult(value) {
-    if (!isObject(value)) return false;
-    const obj = value;
-    if (!isObject(obj.metadata)) return false;
-    const metadata = obj.metadata;
-    return typeof metadata.fileId === "string" && typeof metadata.filename === "string" && typeof metadata.mimeType === "string" && typeof metadata.size === "number" && typeof metadata.path === "string";
-  }
-  /**
-   * Infer file type from MIME type
-   */
-  static inferFileType(mimeType) {
-    if (mimeType.startsWith("image/")) return "IMAGE";
-    if (mimeType.startsWith("video/")) return "VIDEO";
-    if (mimeType.startsWith("audio/")) return "AUDIO";
-    if (mimeType.includes("pdf") || mimeType.includes("document") || mimeType.includes("text/")) {
-      return "DOCUMENT";
-    }
-    return "OTHER";
-  }
-  /**
-   * API Response → Domain Entity
-   */
-  toDomain(dto) {
-    const type = _FilesMapperClass.inferFileType(dto.mimeType);
-    return {
-      id: dto.id,
-      key: dto.key,
-      filename: dto.filename,
-      mimeType: dto.mimeType,
-      size: dto.size,
-      checksum: dto.checksum,
-      url: dto.url,
-      publicUrl: dto.publicUrl,
-      signedUrl: dto.signedUrl,
-      bucket: dto.bucket,
-      entityType: dto.entityType,
-      entityId: dto.entityId,
-      category: dto.category,
-      uploadedAt: new Date(dto.uploadedAt),
-      expiresAt: dto.expiresAt ? new Date(dto.expiresAt) : void 0,
-      variants: dto.variants,
-      type,
-      isImage: type === "IMAGE",
-      isVideo: type === "VIDEO",
-      isDocument: type === "DOCUMENT",
-      isAudio: type === "AUDIO"
-    };
-  }
-  /**
-   * Domain Entity → Store State (serializable)
-   */
-  toStoreState(entity) {
-    return {
-      id: entity.id,
-      key: entity.key,
-      filename: entity.filename,
-      mimeType: entity.mimeType,
-      size: entity.size,
-      url: entity.url,
-      publicUrl: entity.publicUrl,
-      bucket: entity.bucket,
-      entityType: entity.entityType,
-      entityId: entity.entityId,
-      category: entity.category,
-      uploadedAt: entity.uploadedAt.toISOString(),
-      type: entity.type,
-      isImage: entity.isImage,
-      isVideo: entity.isVideo,
-      isDocument: entity.isDocument,
-      isAudio: entity.isAudio
-    };
-  }
-  /**
-   * Store State → Domain Entity
-   */
-  fromStoreState(state) {
-    return {
-      id: state.id,
-      key: state.key,
-      filename: state.filename,
-      mimeType: state.mimeType,
-      size: state.size,
-      url: state.url,
-      publicUrl: state.publicUrl,
-      bucket: state.bucket,
-      entityType: state.entityType,
-      entityId: state.entityId,
-      category: state.category,
-      uploadedAt: new Date(state.uploadedAt),
-      type: state.type,
-      isImage: state.isImage,
-      isVideo: state.isVideo,
-      isDocument: state.isDocument,
-      isAudio: state.isAudio
-    };
-  }
-  /**
-   * Database Row → API Response (for backend)
-   */
-  toResponseDTO(row) {
-    return {
-      id: row.id,
-      key: row.storage_path,
-      filename: row.filename,
-      mimeType: row.mime_type,
-      size: toNumber(row.file_size),
-      checksum: void 0,
-      url: row.cdn_url ?? void 0,
-      publicUrl: row.cdn_url ?? void 0,
-      signedUrl: void 0,
-      bucket: "media",
-      entityType: row.entity_type ?? void 0,
-      entityId: row.entity_id ?? void 0,
-      category: void 0,
-      uploadedAt: row.created_at,
-      expiresAt: void 0
-    };
-  }
-  /**
-   * Create GeneratedFileItem from generation result
-   */
-  toGeneratedFileItem(templateId, buffer, size, outputFormat = "pdf") {
-    return {
-      id: crypto.randomUUID(),
-      templateId,
-      buffer,
-      size,
-      mimeType: `application/${outputFormat}`,
-      filename: `${templateId}.${outputFormat}`,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  /**
-   * Convert upload result to database row format
-   * Used by event handlers to persist upload results to DB
-   *
-   * @param uploadResult - Result from storage upload
-   * @param userId - User ID who uploaded the file (from auth context)
-   * @returns Partial database row ready for repository.create()
-   */
-  // eslint-disable-next-line complexity
-  toDbRow(uploadResult, userId) {
-    const { metadata, variants } = uploadResult;
-    return {
-      id: metadata.fileId,
-      user_id: userId ?? "system",
-      type: _FilesMapperClass.inferFileType(metadata.mimeType),
-      filename: metadata.filename,
-      original_filename: metadata.filename,
-      mime_type: metadata.mimeType,
-      file_size: metadata.size,
-      storage_path: metadata.path,
-      cdn_url: metadata.url ?? null,
-      width: metadata.extractedMetadata?.width ?? null,
-      height: metadata.extractedMetadata?.height ?? null,
-      duration: metadata.extractedMetadata?.duration ?? null,
-      entity_type: metadata.entityType,
-      entity_id: metadata.entityId,
-      access_level: metadata.accessLevel,
-      is_virus_scanned: false,
-      virus_scan_result: null,
-      metadata: metadata.customMetadata ?? null,
-      variants: variants ?? null
-    };
+    __name(this, "NotificationService");
   }
-};
-var FilesMapper = new FilesMapperClass();
-
-// src/domain/files/validators/FilesValidator.ts
-var FilesValidatorClass = class extends BaseValidator {
   static {
-    __name(this, "FilesValidatorClass");
-  }
-  constructor() {
-    super({});
+    this.instance = null;
   }
+  // ─────────────────────────────────────────────────────────────────
+  // Error Handling
+  // ─────────────────────────────────────────────────────────────────
   /**
-   * Check if user has permission to access file
+   * Emits a notification error event via CoreEventManager.
+   * Called when notification operations fail to integrate with global error handling.
    */
-  validateUserAccess(userId, fileOwnerId, accessLevel, isAdmin = false) {
-    if (isAdmin) return true;
-    if (userId === fileOwnerId) return true;
-    if (accessLevel === "public") return true;
-    if (accessLevel === "protected" && userId) return true;
-    return false;
-  }
-};
-new FilesValidatorClass();
-
-// src/domain/files/BackendFilesDomainService.ts
-var BackendFilesDomainService = class _BackendFilesDomainService extends BaseBackendDomainService {
-  constructor(config = {}, injected) {
-    super({
-      serviceName: "BackendFilesDomainService",
-      supportedRuntimes: ["backend"],
-      serviceConfig: {
-        enabled: true,
-        throwOnValidationError: true,
-        throwOnRepositoryError: true,
-        emitEvents: true,
-        ...config
-      },
-      mapperClass: FilesMapperClass,
-      validatorClass: FilesValidatorClass,
-      injected
-    });
-    this.eventPrefix = "files";
-    this.cachePrefix = "files";
+  emitNotificationError(error, operation, options) {
+    const payload = {
+      error,
+      operation,
+      recipientId: options?.recipientId,
+      channel: options?.channel,
+      recoverable: options?.recoverable ?? false
+    };
+    CoreEventManager.emit(core.CORE_EVENTS.NOTIFICATION.ERROR, payload);
   }
-  static {
-    __name(this, "BackendFilesDomainService");
+  // ─────────────────────────────────────────────────────────────────
+  // 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.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.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.CORE_EVENTS.NOTIFICATION.DELIVERED, {
+          notificationId: payload.notificationId,
+          recipientId: payload.recipientId,
+          channel: payload.channel,
+          deliveredAt: payload.deliveredAt
+        });
+        if (userHandlers?.onDelivered) {
+          await userHandlers.onDelivered(payload);
+        }
+      }, "onDelivered")
+    };
   }
-  static {
-    this.serviceKey = "files";
+  // ─────────────────────────────────────────────────────────────────
+  // Singleton Management
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Gets the singleton instance of NotificationService
+   */
+  static getInstance() {
+    _NotificationService.instance ??= new _NotificationService();
+    return _NotificationService.instance;
   }
   /**
-   * Lazy repository getter - creates repository on first access.
-   * Throws if DbService is not initialized.
+   * Checks if the notification service has been initialized
    */
-  get repository() {
-    this._repository ??= FilesRepository.create();
-    return this._repository;
+  static isInitialized() {
+    return _NotificationService.instance?.initialized ?? false;
   }
   /**
-   * Create service instance
+   * Resets the notification service by clearing the singleton instance
    */
-  // eslint-disable-next-line complexity
-  static async create(config = {}, options) {
-    this.registerEventHandlers();
-    const injected = {
-      cache: options?.cache?.instance,
-      db: options?.db?.instance,
-      api: options?.apiClient?.instance,
-      storage: options?.storage?.instance,
-      notifications: options?.notifications?.instance
-    };
-    return new _BackendFilesDomainService(config, injected);
+  static async reset() {
+    if (_NotificationService.instance) {
+      _NotificationService.instance.notificationService = null;
+      _NotificationService.instance.config = null;
+      _NotificationService.instance.initialized = false;
+      _NotificationService.instance = null;
+    }
   }
   /**
-   * 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.
+   * Initializes the notification service
    *
-   * @param verbose - Enable verbose logging
+   * @param config - Notification service configuration
+   * @returns The initialized NotificationService instance
    */
-  static registerEventHandlers(verbose) {
-    if (BackendEventPersistenceHandler.isRegistered("files")) {
-      return;
+  static async initialize(config) {
+    const instance = _NotificationService.getInstance();
+    if (instance.initialized) {
+      return instance;
     }
-    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
+    const mergedEvents = _NotificationService.createMergedEventHandlers(config.events);
+    instance.config = config;
+    instance.notificationService = new notifications.NotificationService({
+      ...config,
+      events: mergedEvents
     });
+    instance.initialized = true;
+    return instance;
   }
-  isAvailable() {
-    return this.isServiceEnabled;
-  }
-  dispose() {
-    this.logInfo("Service disposed");
+  /**
+   * Gets the raw underlying notification service instance without error handling wrapper.
+   * Use this only if you need direct access to the underlying service.
+   *
+   * @returns The raw NotificationService instance from @plyaz/notifications
+   * @throws {NotificationsPackageError} When notifications is not initialized
+   */
+  getRawNotifications() {
+    if (!this.notificationService) {
+      throw new errors.NotificationPackageError(
+        "Notifications not initialized. Call NotificationService.initialize() first or use Core.initialize() with notifications config.",
+        errors$1.NOTIFICATION_ERROR_CODES.INITIALIZATION_FAILED
+      );
+    }
+    return this.notificationService;
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Storage operations (via @plyaz/storage)
-  // ─────────────────────────────────────────────────────────────────────────
+  // ─────────────────────────────────────────────────────────────────
+  // Service Access
+  // ─────────────────────────────────────────────────────────────────
   /**
-   * Download file content
-   * GET /files/:id/download
+   * Gets the notification service with automatic error handling.
+   * All method calls are wrapped with try/catch and emit error events on failure.
+   * Any method added to @plyaz/notifications will be automatically available.
    *
-   * Follows same pattern as base class CRUD methods:
-   * 1. assertReady
-   * 2. Record start time
-   * 3. Log debug info
-   * 4. Emit starting event
-   * 5. Execute operation
-   * 6. Emit success event
-   * 7. Record metrics
+   * @example
+   * ```typescript
+   * const notifications = NotificationService.getInstance().getNotifications();
+   * await notifications.sendEmail({ to: 'user@example.com', templateId: 'welcome' });
+   * await notifications.sendSMS({ to: '+1234567890', message: 'Hello!' });
+   * ```
    *
-   * @param params - Download parameters (fileId required)
-   * @returns Download result with buffer, filename, mimeType
+   * @returns NotificationServiceImpl with automatic error handling
    */
-  // eslint-disable-next-line complexity
-  async downloadFile(params) {
-    this.assertReady();
-    const startTime = Date.now();
-    this.logDebug("Downloading file", { fileId: params.fileId });
-    this.emitEvent("download:downloading", { request: params });
-    try {
-      await this.beforeDownloadFile?.(params);
-      if (!this.storageService) {
-        throw new Error(
-          "Storage service not available. Ensure storage is configured in Core.initialize()."
-        );
+  getNotifications() {
+    const self2 = this;
+    return new Proxy({}, {
+      get(_, prop) {
+        if (typeof prop === "symbol") {
+          return void 0;
+        }
+        const notifications = self2.getRawNotifications();
+        const value = notifications[prop];
+        if (typeof value !== "function") {
+          return value;
+        }
+        return (...args) => {
+          try {
+            const result2 = value.apply(notifications, args);
+            if (result2 instanceof Promise) {
+              return result2.catch((error) => {
+                self2.emitNotificationError(error, prop, { recoverable: true });
+                throw error;
+              });
+            }
+            return result2;
+          } catch (error) {
+            self2.emitNotificationError(error, prop, { recoverable: true });
+            throw error;
+          }
+        };
       }
-      const storage = this.storageService.getStorage();
-      const result2 = await storage.downloadFile({
-        fileId: params.fileId
-      });
-      const response = {
-        buffer: result2?.file?.toString("base64") ?? "",
-        filename: result2?.metadata?.filename ?? "download",
-        mimeType: result2?.metadata?.mimeType ?? "application/octet-stream"
+    });
+  }
+  // ─────────────────────────────────────────────────────────────────
+  // Health Check (special handling for response transformation)
+  // ─────────────────────────────────────────────────────────────────
+  /**
+   * Performs a health check on the notification service.
+   * This method has special handling to transform the response format.
+   */
+  async healthCheck() {
+    try {
+      const notifications = this.getRawNotifications();
+      const result2 = await notifications.healthCheck();
+      return {
+        isHealthy: result2.healthy,
+        providers: result2.providers,
+        // Use optional chaining since error may not exist on all health check results
+        error: "error" in result2 ? result2.error : void 0
       };
-      await this.afterDownloadFile?.(response);
-      this.emitEvent("download:downloaded", { result: response });
-      this.emitEvent("complete", { success: true, operation: "downloadFile" });
-      await this.recordOperationMetrics("downloadFile", Date.now() - startTime, true);
-      return response;
     } catch (error) {
-      await this.recordOperationMetrics("downloadFile", Date.now() - startTime, false);
-      this.emitEvent("download:error", { error });
-      throw error;
+      this.emitNotificationError(error, "healthCheck", { recoverable: true });
+      return {
+        isHealthy: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
     }
   }
+  // ─────────────────────────────────────────────────────────────────
+  // Lifecycle
+  // ─────────────────────────────────────────────────────────────────
   /**
-   * Get signed URL for file
-   * GET /files/:id/signed-url
+   * Gets the current configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Closes the notification service and cleans up resources
+   */
+  async close() {
+    this.notificationService = null;
+    this.initialized = false;
+    this.config = null;
+  }
+  /**
+   * Creates a dedicated notification service instance (NOT the singleton)
    *
-   * Follows same pattern as base class CRUD methods.
+   * Use this when you need an isolated notification service with its own configuration.
    *
-   * @param params - Signed URL parameters (fileId required)
-   * @returns Signed URL result with url and expiresAt
+   * @param config - Notification service configuration
+   * @returns Promise that resolves to a new dedicated NotificationService instance
    */
-  // eslint-disable-next-line complexity
-  async getSignedUrl(params) {
-    this.assertReady();
-    const startTime = Date.now();
-    this.logDebug("Getting signed URL", { fileId: params.fileId, expiresIn: params.expiresIn });
-    this.emitEvent("signedUrl:requesting", { request: params });
+  static async createInstance(config) {
+    const mergedEvents = _NotificationService.createMergedEventHandlers(config.events);
+    const dedicatedInstance = new _NotificationService();
+    dedicatedInstance.config = config;
+    dedicatedInstance.notificationService = new notifications.NotificationService({
+      ...config,
+      events: mergedEvents
+    });
+    dedicatedInstance.initialized = true;
+    return dedicatedInstance;
+  }
+};
+var cachedVersion = "";
+function getPackageVersion() {
+  if (cachedVersion) return cachedVersion;
+  try {
+    const require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
+    const pkg = require2("../package.json");
+    cachedVersion = pkg.version ?? "0.0.0";
+  } catch {
     try {
-      await this.beforeGetSignedUrl?.(params);
-      if (!this.storageService) {
-        throw new Error(
-          "Storage service not available. Ensure storage is configured in Core.initialize()."
-        );
-      }
-      const storage = this.storageService.getStorage();
-      const result2 = await storage.getSignedUrl({
-        fileId: params.fileId,
-        expiresIn: params.expiresIn ?? config.DOWNLOAD_CONFIG.DEFAULT_SIGNED_URL_EXPIRY_SECONDS,
-        operation: "get"
-      });
-      const response = {
-        url: result2?.url ?? "",
-        expiresAt: result2?.expiresAt?.toISOString() ?? new Date(Date.now() + config.TIME_CONSTANTS.HOUR).toISOString()
-      };
-      await this.afterGetSignedUrl?.(response);
-      this.emitEvent("signedUrl:received", { result: response });
-      this.emitEvent("complete", { success: true, operation: "getSignedUrl" });
-      await this.recordOperationMetrics("getSignedUrl", Date.now() - startTime, true);
-      return response;
-    } catch (error) {
-      await this.recordOperationMetrics("getSignedUrl", Date.now() - startTime, false);
-      this.emitEvent("signedUrl:error", { error });
-      throw error;
+      const currentFile = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
+      const currentDir = path.dirname(currentFile);
+      const pkgPath = path.join(currentDir, "..", "package.json");
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      cachedVersion = pkg.version ?? "0.0.0";
+    } catch {
+      cachedVersion = "0.0.0";
     }
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // NOTE: CRUD and Storage Methods Are Inherited from BaseBackendDomainService
-  // ─────────────────────────────────────────────────────────────────────────
-  //
-  // CRUD methods:
-  // - getById(id) - for GET /files/:id
-  // - getAll(query) - for listing files
-  // - delete(id) - for DELETE /files/:id
-  // - exists(id) - check if file exists
-  //
-  // Storage methods (inherited):
-  // - uploadFile(params) - for POST /files/upload
-  // - generateFile(params) - for POST /files/generate-document
-  // ─────────────────────────────────────────────────────────────────────────
+  return cachedVersion;
+}
+__name(getPackageVersion, "getPackageVersion");
+var VERSION = getPackageVersion();
+var PACKAGE_NAME = "@plyaz/core";
+
+// src/backend/index.ts
+var backend_exports = {};
+__export(backend_exports, {
+  BACKEND_EXAMPLE_DOMAIN_SERVICE: () => BACKEND_EXAMPLE_DOMAIN_SERVICE,
+  BACKEND_FILES_DOMAIN_SERVICE: () => BACKEND_FILES_DOMAIN_SERVICE,
+  BackendExampleDomainService: () => BackendExampleDomainService,
+  Caching: () => Caching,
+  ErrorHandlingInterceptor: () => ErrorHandlingInterceptor,
+  ExampleController: () => ExampleController,
+  ExampleModule: () => ExampleModule,
+  FeatureDisabled: () => FeatureDisabled,
+  FeatureEnabled: () => FeatureEnabled,
+  FeatureFlagConfigFactory: () => FeatureFlagConfigFactory,
+  FeatureFlagConfigValidator: () => FeatureFlagConfigValidator,
+  FeatureFlagController: () => FeatureFlagController,
+  FeatureFlagDatabaseRepository: () => FeatureFlagDatabaseRepository,
+  FeatureFlagDomainService: () => FeatureFlagDomainService,
+  FeatureFlagGuard: () => FeatureFlagGuard,
+  FeatureFlagLoggingInterceptor: () => FeatureFlagLoggingInterceptor,
+  FeatureFlagMiddleware: () => FeatureFlagMiddleware,
+  FeatureFlagModule: () => FeatureFlagModule,
+  FeatureFlagService: () => FeatureFlagService,
+  FeatureFlagServiceFactory: () => FeatureFlagServiceFactory,
+  FilesController: () => FilesController,
+  FilesModule: () => FilesModule
+});
+
+// src/backend/example/example.module.ts
+var import_common14 = __toESM(require_common(), 1);
+
+// src/backend/example/example.controller.ts
+var import_common13 = __toESM(require_common(), 1);
+var BACKEND_EXAMPLE_DOMAIN_SERVICE = "BACKEND_EXAMPLE_DOMAIN_SERVICE";
+var ExampleController = class {
+  constructor(exampleService) {
+    this.exampleService = exampleService;
+  }
+  health() {
+    return errors.SuccessResponseStandard("Service is healthy", {
+      service: this.exampleService.isAvailable(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async getEntity(id) {
+    const entity = await this.exampleService.getById(id);
+    return errors.SuccessResponseStandard("Entity retrieved successfully", entity);
+  }
+  async createEntity(dto) {
+    const entity = await this.exampleService.create(dto);
+    return errors.SuccessResponseStandard("Entity created successfully", entity, types.HTTP_STATUS.CREATED);
+  }
+  async updateEntity(id, dto) {
+    const entity = await this.exampleService.patch(id, dto);
+    return errors.SuccessResponseStandard("Entity updated successfully", entity);
+  }
+  async deleteEntity(id) {
+    await this.exampleService.delete(id);
+    return errors.SuccessResponseStandard("Entity deleted successfully", null);
+  }
+  async createEntityWithValidation(dto) {
+    const entity = await this.exampleService.create(dto);
+    return errors.SuccessResponseStandard("Entity created successfully", entity, types.HTTP_STATUS.CREATED);
+  }
+  async demoSingleError() {
+    return await this.exampleService.demoSingleValidationError();
+  }
+  async demoArrayErrors() {
+    return await this.exampleService.demoMultipleValidationErrors();
+  }
+  async sendEmail(dto) {
+    const result2 = await this.exampleService.sendEmail(dto);
+    return errors.SuccessResponseStandard("Email sent successfully", result2);
+  }
 };
-var backendFilesDomainService = new BackendFilesDomainService();
-var logger4 = new logger$1.PackageLogger({ packageName: "core", service: "FrontendFilesDomainService" });
+__name(ExampleController, "ExampleController");
+__decorateClass([
+  (0, import_common13.Get)("health")
+], ExampleController.prototype, "health", 1);
+__decorateClass([
+  (0, import_common13.Get)("entities/:id"),
+  __decorateParam(0, (0, import_common13.Param)("id"))
+], ExampleController.prototype, "getEntity", 1);
+__decorateClass([
+  (0, import_common13.Post)("entities"),
+  (0, import_common13.HttpCode)(import_common13.HttpStatus.CREATED),
+  __decorateParam(0, (0, import_common13.Body)())
+], ExampleController.prototype, "createEntity", 1);
+__decorateClass([
+  (0, import_common13.Patch)("entities/:id"),
+  __decorateParam(0, (0, import_common13.Param)("id")),
+  __decorateParam(1, (0, import_common13.Body)())
+], ExampleController.prototype, "updateEntity", 1);
+__decorateClass([
+  (0, import_common13.Delete)("entities/:id"),
+  (0, import_common13.HttpCode)(import_common13.HttpStatus.OK),
+  __decorateParam(0, (0, import_common13.Param)("id"))
+], ExampleController.prototype, "deleteEntity", 1);
+__decorateClass([
+  (0, import_common13.Post)("entities/validated"),
+  (0, import_common13.HttpCode)(import_common13.HttpStatus.CREATED),
+  __decorateParam(0, (0, import_common13.Body)())
+], ExampleController.prototype, "createEntityWithValidation", 1);
+__decorateClass([
+  (0, import_common13.Get)("errors/single")
+], ExampleController.prototype, "demoSingleError", 1);
+__decorateClass([
+  (0, import_common13.Get)("errors/array")
+], ExampleController.prototype, "demoArrayErrors", 1);
+__decorateClass([
+  (0, import_common13.Post)("email"),
+  (0, import_common13.HttpCode)(import_common13.HttpStatus.OK),
+  __decorateParam(0, (0, import_common13.Body)())
+], ExampleController.prototype, "sendEmail", 1);
+ExampleController = __decorateClass([
+  (0, import_common13.Controller)("example"),
+  __decorateParam(0, (0, import_common13.Inject)(BACKEND_EXAMPLE_DOMAIN_SERVICE))
+], ExampleController);
+
+// src/backend/example/example.module.ts
+var ExampleModule = class {
+};
+__name(ExampleModule, "ExampleModule");
+ExampleModule = __decorateClass([
+  (0, import_common14.Module)({
+    controllers: [ExampleController],
+    providers: [
+      // Provide BackendExampleDomainService via factory using the singleton instance
+      // This ensures the service is shared across the application
+      {
+        provide: BACKEND_EXAMPLE_DOMAIN_SERVICE,
+        useFactory: /* @__PURE__ */ __name(() => backendExampleDomainService, "useFactory")
+      }
+    ],
+    exports: [BACKEND_EXAMPLE_DOMAIN_SERVICE]
+  })
+], ExampleModule);
+
+// src/backend/files/files.module.ts
+var import_common16 = __toESM(require_common(), 1);
+
+// src/backend/files/files.controller.ts
+var import_common15 = __toESM(require_common(), 1);
+var BACKEND_FILES_DOMAIN_SERVICE = "BACKEND_FILES_DOMAIN_SERVICE";
+var FilesController = class {
+  constructor(filesService) {
+    this.filesService = filesService;
+  }
+  health() {
+    return errors.SuccessResponseStandard("Files service is healthy", {
+      service: this.filesService.isAvailable(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async uploadFile(dto) {
+    const result2 = await this.filesService.uploadFile(dto);
+    return errors.SuccessResponseStandard("File uploaded successfully", result2);
+  }
+  async uploadFiles(dto) {
+    const results = await this.filesService.uploadFiles(dto.files);
+    return errors.SuccessResponseStandard("Files uploaded successfully", results);
+  }
+  async generateDocument(dto) {
+    const buffer = await this.filesService.generateFile(dto);
+    return errors.SuccessResponseStandard("Document generated successfully", {
+      buffer: buffer.toString("base64"),
+      size: buffer.length
+    });
+  }
+  async getFile(id) {
+    const entity = await this.filesService.getById(id);
+    return errors.SuccessResponseStandard("File retrieved", entity);
+  }
+  async downloadFile(id) {
+    const result2 = await this.filesService.downloadFile({ fileId: id });
+    return errors.SuccessResponseStandard("File downloaded", result2);
+  }
+  async getSignedUrl(id) {
+    const result2 = await this.filesService.getSignedUrl({ fileId: id });
+    return errors.SuccessResponseStandard("Signed URL generated", result2);
+  }
+  async deleteFile(id) {
+    await this.filesService.delete(id);
+    return errors.SuccessResponseStandard("File deleted", null);
+  }
+};
+__name(FilesController, "FilesController");
+__decorateClass([
+  (0, import_common15.Get)("health")
+], FilesController.prototype, "health", 1);
+__decorateClass([
+  (0, import_common15.Post)("upload"),
+  (0, import_common15.HttpCode)(import_common15.HttpStatus.OK),
+  __decorateParam(0, (0, import_common15.Body)())
+], FilesController.prototype, "uploadFile", 1);
+__decorateClass([
+  (0, import_common15.Post)("upload/bulk"),
+  (0, import_common15.HttpCode)(import_common15.HttpStatus.OK),
+  __decorateParam(0, (0, import_common15.Body)())
+], FilesController.prototype, "uploadFiles", 1);
+__decorateClass([
+  (0, import_common15.Post)("generate-document"),
+  (0, import_common15.HttpCode)(import_common15.HttpStatus.OK),
+  __decorateParam(0, (0, import_common15.Body)())
+], FilesController.prototype, "generateDocument", 1);
+__decorateClass([
+  (0, import_common15.Get)(":id"),
+  __decorateParam(0, (0, import_common15.Param)("id"))
+], FilesController.prototype, "getFile", 1);
+__decorateClass([
+  (0, import_common15.Get)(":id/download"),
+  __decorateParam(0, (0, import_common15.Param)("id"))
+], FilesController.prototype, "downloadFile", 1);
+__decorateClass([
+  (0, import_common15.Get)(":id/signed-url"),
+  __decorateParam(0, (0, import_common15.Param)("id"))
+], FilesController.prototype, "getSignedUrl", 1);
+__decorateClass([
+  (0, import_common15.Delete)(":id"),
+  (0, import_common15.HttpCode)(import_common15.HttpStatus.OK),
+  __decorateParam(0, (0, import_common15.Param)("id"))
+], FilesController.prototype, "deleteFile", 1);
+FilesController = __decorateClass([
+  (0, import_common15.Controller)("files"),
+  __decorateParam(0, (0, import_common15.Inject)(BACKEND_FILES_DOMAIN_SERVICE))
+], FilesController);
+var logger6 = new logger$1.PackageLogger({ packageName: "core", service: "FrontendFilesDomainService" });
 var FrontendFilesDomainService = class _FrontendFilesDomainService extends BaseFrontendDomainService {
   constructor(config = {}, options) {
-    const apiBasePath = config.apiBasePath || "/api";
+    const apiBasePath = config.apiBasePath || "";
     super({
       serviceName: "FrontendFilesDomainService",
       supportedRuntimes: ["frontend"],
@@ -47962,7 +48154,7 @@ var FrontendFilesDomainService = class _FrontendFilesDomainService extends BaseF
       // 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);
   }
@@ -47999,7 +48191,7 @@ var FrontendFilesDomainService = class _FrontendFilesDomainService extends BaseF
    */
   static registerEventHandlers(verbose) {
     if (this._eventHandlersRegistered) {
-      logger4.debug("Files frontend event handlers already registered");
+      logger6.debug("Files frontend event handlers already registered");
       return () => {
       };
     }
@@ -48061,7 +48253,7 @@ var FrontendFilesDomainService = class _FrontendFilesDomainService extends BaseF
       verbose
     });
     this._eventHandlersRegistered = true;
-    logger4.info("Files frontend event handlers registered");
+    logger6.info("Files frontend event handlers registered");
     return () => {
       FrontendEventPersistenceHandler.unregisterAll();
       this._eventHandlersRegistered = false;
@@ -48139,7 +48331,7 @@ var FilesModule = class {
 };
 __name(FilesModule, "FilesModule");
 FilesModule = __decorateClass([
-  (0, import_common17.Module)({
+  (0, import_common16.Module)({
     controllers: [FilesController],
     providers: [
       // Provide BackendFilesDomainService via factory using the singleton instance
@@ -48430,10 +48622,10 @@ var FeatureFlagDomainService = class extends BaseDomainService {
 };
 
 // src/backend/featureFlags/feature-flag.module.ts
-var import_common19 = __toESM(require_common(), 1);
+var import_common18 = __toESM(require_common(), 1);
 
 // src/backend/featureFlags/feature-flag.controller.ts
-var import_common18 = __toESM(require_common(), 1);
+var import_common17 = __toESM(require_common(), 1);
 var FeatureFlagController = class {
   constructor(featureFlagService) {
     this.featureFlagService = featureFlagService;
@@ -48562,54 +48754,54 @@ var FeatureFlagController = class {
 };
 __name(FeatureFlagController, "FeatureFlagController");
 __decorateClass([
-  (0, import_common18.Post)(":key/evaluate"),
-  __decorateParam(0, (0, import_common18.Param)("key")),
-  __decorateParam(1, (0, import_common18.Body)())
+  (0, import_common17.Post)(":key/evaluate"),
+  __decorateParam(0, (0, import_common17.Param)("key")),
+  __decorateParam(1, (0, import_common17.Body)())
 ], FeatureFlagController.prototype, "evaluateFlag", 1);
 __decorateClass([
-  (0, import_common18.Post)(":key/enabled"),
-  __decorateParam(0, (0, import_common18.Param)("key")),
-  __decorateParam(1, (0, import_common18.Body)())
+  (0, import_common17.Post)(":key/enabled"),
+  __decorateParam(0, (0, import_common17.Param)("key")),
+  __decorateParam(1, (0, import_common17.Body)())
 ], FeatureFlagController.prototype, "isEnabled", 1);
 __decorateClass([
-  (0, import_common18.Post)("evaluate-all"),
-  __decorateParam(0, (0, import_common18.Body)())
+  (0, import_common17.Post)("evaluate-all"),
+  __decorateParam(0, (0, import_common17.Body)())
 ], FeatureFlagController.prototype, "evaluateAllFlags", 1);
 __decorateClass([
-  (0, import_common18.Post)(),
-  __decorateParam(0, (0, import_common18.Body)())
+  (0, import_common17.Post)(),
+  __decorateParam(0, (0, import_common17.Body)())
 ], FeatureFlagController.prototype, "createFlag", 1);
 __decorateClass([
-  (0, import_common18.Put)(":key"),
-  __decorateParam(0, (0, import_common18.Param)("key")),
-  __decorateParam(1, (0, import_common18.Body)())
+  (0, import_common17.Put)(":key"),
+  __decorateParam(0, (0, import_common17.Param)("key")),
+  __decorateParam(1, (0, import_common17.Body)())
 ], FeatureFlagController.prototype, "updateFlag", 1);
 __decorateClass([
-  (0, import_common18.Delete)(":key"),
-  __decorateParam(0, (0, import_common18.Param)("key"))
+  (0, import_common17.Delete)(":key"),
+  __decorateParam(0, (0, import_common17.Param)("key"))
 ], FeatureFlagController.prototype, "deleteFlag", 1);
 __decorateClass([
-  (0, import_common18.Post)(":key/override"),
-  __decorateParam(0, (0, import_common18.Param)("key")),
-  __decorateParam(1, (0, import_common18.Body)("value"))
+  (0, import_common17.Post)(":key/override"),
+  __decorateParam(0, (0, import_common17.Param)("key")),
+  __decorateParam(1, (0, import_common17.Body)("value"))
 ], FeatureFlagController.prototype, "setOverride", 1);
 __decorateClass([
-  (0, import_common18.Delete)(":key/override"),
-  __decorateParam(0, (0, import_common18.Param)("key"))
+  (0, import_common17.Delete)(":key/override"),
+  __decorateParam(0, (0, import_common17.Param)("key"))
 ], FeatureFlagController.prototype, "removeOverride", 1);
 __decorateClass([
-  (0, import_common18.Get)(":key/rules"),
-  __decorateParam(0, (0, import_common18.Param)("key"))
+  (0, import_common17.Get)(":key/rules"),
+  __decorateParam(0, (0, import_common17.Param)("key"))
 ], FeatureFlagController.prototype, "getFlagRules", 1);
 __decorateClass([
-  (0, import_common18.Post)("refresh")
+  (0, import_common17.Post)("refresh")
 ], FeatureFlagController.prototype, "refreshCache", 1);
 __decorateClass([
-  (0, import_common18.Get)("health")
+  (0, import_common17.Get)("health")
 ], FeatureFlagController.prototype, "getHealth", 1);
 FeatureFlagController = __decorateClass([
-  (0, import_common18.Controller)("feature-flags"),
-  __decorateParam(0, (0, import_common18.Inject)(FEATURE_FLAG_SERVICE))
+  (0, import_common17.Controller)("feature-flags"),
+  __decorateParam(0, (0, import_common17.Inject)(FEATURE_FLAG_SERVICE))
 ], FeatureFlagController);
 
 // src/backend/featureFlags/feature-flag.module.ts
@@ -48701,16 +48893,16 @@ var FeatureFlagModule = class {
 __name(FeatureFlagModule, "FeatureFlagModule");
 FeatureFlagModule.serviceInstance = null;
 FeatureFlagModule = __decorateClass([
-  (0, import_common19.Global)(),
-  (0, import_common19.Module)({
+  (0, import_common18.Global)(),
+  (0, import_common18.Module)({
     controllers: [FeatureFlagController]
   })
 ], FeatureFlagModule);
 
 // src/backend/featureFlags/decorators/feature-flag.decorator.ts
-var import_common20 = __toESM(require_common(), 1);
+var import_common19 = __toESM(require_common(), 1);
 function FeatureFlag(key, expected = true) {
-  return (0, import_common20.SetMetadata)(types.FEATURE_FLAG_METADATA.FLAG_CHECK, { key, expected });
+  return (0, import_common19.SetMetadata)(types.FEATURE_FLAG_METADATA.FLAG_CHECK, { key, expected });
 }
 __name(FeatureFlag, "FeatureFlag");
 
@@ -48727,7 +48919,7 @@ function FeatureEnabled(key) {
 __name(FeatureEnabled, "FeatureEnabled");
 
 // src/backend/featureFlags/guards/feature-flag.guard.ts
-var import_common21 = __toESM(require_common(), 1);
+var import_common20 = __toESM(require_common(), 1);
 var FeatureFlagGuard = class {
   constructor(reflector, featureFlagService) {
     this.reflector = reflector;
@@ -48771,12 +48963,12 @@ var FeatureFlagGuard = class {
 };
 __name(FeatureFlagGuard, "FeatureFlagGuard");
 FeatureFlagGuard = __decorateClass([
-  (0, import_common21.Injectable)(),
-  __decorateParam(1, (0, import_common21.Inject)(FEATURE_FLAG_SERVICE))
+  (0, import_common20.Injectable)(),
+  __decorateParam(1, (0, import_common20.Inject)(FEATURE_FLAG_SERVICE))
 ], FeatureFlagGuard);
 
 // src/backend/featureFlags/middleware/feature-flag-middleware.ts
-var import_common22 = __toESM(require_common(), 1);
+var import_common21 = __toESM(require_common(), 1);
 function isFeatureFlagKey(value) {
   return Object.keys(config.FEATURES).includes(value);
 }
@@ -48854,12 +49046,12 @@ var FeatureFlagMiddleware = class {
 };
 __name(FeatureFlagMiddleware, "FeatureFlagMiddleware");
 FeatureFlagMiddleware = __decorateClass([
-  (0, import_common22.Injectable)(),
-  __decorateParam(0, (0, import_common22.Inject)(FEATURE_FLAG_SERVICE))
+  (0, import_common21.Injectable)(),
+  __decorateParam(0, (0, import_common21.Inject)(FEATURE_FLAG_SERVICE))
 ], FeatureFlagMiddleware);
 
 // src/backend/featureFlags/interceptors/feature-flag-logging-interceptor.ts
-var import_common23 = __toESM(require_common(), 1);
+var import_common22 = __toESM(require_common(), 1);
 var import_rxjs = __toESM(require_cjs(), 1);
 var FeatureFlagLoggingInterceptor = class {
   constructor() {
@@ -48892,11 +49084,11 @@ var FeatureFlagLoggingInterceptor = class {
 };
 __name(FeatureFlagLoggingInterceptor, "FeatureFlagLoggingInterceptor");
 FeatureFlagLoggingInterceptor = __decorateClass([
-  (0, import_common23.Injectable)()
+  (0, import_common22.Injectable)()
 ], FeatureFlagLoggingInterceptor);
 
 // src/backend/featureFlags/interceptors/error-handling-interceptor.ts
-var import_common24 = __toESM(require_common(), 1);
+var import_common23 = __toESM(require_common(), 1);
 var import_operators = __toESM(require_operators(), 1);
 var ErrorHandlingInterceptor = class {
   constructor() {
@@ -48925,9 +49117,9 @@ var ErrorHandlingInterceptor = class {
 };
 __name(ErrorHandlingInterceptor, "ErrorHandlingInterceptor");
 ErrorHandlingInterceptor = __decorateClass([
-  (0, import_common24.Injectable)()
+  (0, import_common23.Injectable)()
 ], ErrorHandlingInterceptor);
-var logger5 = new logger$1.PackageLogger({
+var logger7 = new logger$1.PackageLogger({
   packageName: "core",
   service: "FeatureFlagConfigValidator"
 });
@@ -49113,7 +49305,7 @@ var FeatureFlagConfigValidator = class {
   static getWarnings(config$1, environment) {
     const env = environment ?? (config$1.isLoggingEnabled ? types.NODE_ENVIRONMENTS.DEVELOPMENT : types.NODE_ENVIRONMENTS.PRODUCTION);
     if (config$1.cacheTtl > config.NUMERIC_CONSTANTS.ONE_HOUR_SECONDS) {
-      logger5.warn(
+      logger7.warn(
         "Cache TTL is very high (>1 hour). Consider reducing for better responsiveness.",
         {
           field: "cacheTtl",
@@ -49123,13 +49315,13 @@ var FeatureFlagConfigValidator = class {
       );
     }
     if (env === types.NODE_ENVIRONMENTS.PRODUCTION && config$1.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 === types.NODE_ENVIRONMENTS.DEVELOPMENT && !config$1.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"
       });
@@ -49272,7 +49464,7 @@ var FeatureFlagConfigFactory = class {
 };
 
 // src/base/cache/feature/caching.ts
-var import_common25 = __toESM(require_common(), 1);
+var import_common24 = __toESM(require_common(), 1);
 var import_rxjs2 = __toESM(require_cjs(), 1);
 var Caching = class {
   constructor() {
@@ -49295,7 +49487,7 @@ var Caching = class {
 };
 __name(Caching, "Caching");
 Caching = __decorateClass([
-  (0, import_common25.Injectable)()
+  (0, import_common24.Injectable)()
 ], Caching);
 
 // src/frontend/index.ts
@@ -49331,7 +49523,6 @@ __export(frontend_exports, {
   useHasService: () => useHasService,
   usePlyaz: () => usePlyaz,
   usePlyazReady: () => usePlyazReady,
-  useRootStore: () => store.useRootStore,
   useService: () => useService,
   useServiceAsync: () => useServiceAsync,
   useServiceKeys: () => useServiceKeys,
@@ -49422,7 +49613,7 @@ function ApiProvider({
   return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
 }
 __name(ApiProvider, "ApiProvider");
-var logger6 = new logger$1.PackageLogger({ packageName: "core", service: "PlyazProvider" });
+var logger8 = new logger$1.PackageLogger({ packageName: "core", service: "PlyazProvider" });
 var PlyazContext = react.createContext(null);
 var FeatureFlagStore = class {
   constructor(config = {}) {
@@ -49512,22 +49703,27 @@ async function initializeCore(config) {
   });
 }
 __name(initializeCore, "initializeCore");
-function createStoreRegistry() {
+function createStoreRegistry(store) {
   return {
     getStore(key) {
-      const state = store.useRootStore.getState();
+      const state = store.getState();
       if (!state) {
-        logger6.warn(
+        logger8.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];
+      logger8.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...");
@@ -49539,7 +49735,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(
@@ -49576,6 +49772,7 @@ function createServicesObject(config, featureFlagStore) {
 __name(createServicesObject, "createServicesObject");
 function PlyazProvider({
   children,
+  store,
   config,
   loading,
   error: errorComponent,
@@ -49589,8 +49786,9 @@ function PlyazProvider({
   const initialize = react.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));
@@ -49600,7 +49798,7 @@ function PlyazProvider({
       onError?.(initError);
       globalThis.console.error("[PlyazProvider] Initialization failed:", initError);
     }
-  }, [config, featureFlagStore, onReady, onError]);
+  }, [config, store, featureFlagStore, onReady, onError]);
   const reinitialize = react.useCallback(async () => {
     setIsReady(false);
     ServiceRegistry.disposeAll();
@@ -49649,8 +49847,9 @@ __name(PlyazProvider, "PlyazProvider");
 function usePlyaz() {
   const context = react.useContext(PlyazContext);
   if (!context) {
-    throw new Error(
-      "usePlyaz must be used within a PlyazProvider. Wrap your app with <PlyazProvider config={...}>...</PlyazProvider>"
+    throw new errors.CorePackageError(
+      "usePlyaz must be used within a PlyazProvider. Wrap your app with <PlyazProvider config={...}>...</PlyazProvider>",
+      types.ERROR_CODES.CORE_PROVIDER_NOT_FOUND
     );
   }
   return context;
@@ -49659,7 +49858,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 errors.CorePackageError(
+      "API client is not ready. Make sure PlyazProvider has finished initializing.",
+      types.ERROR_CODES.CORE_PROVIDER_INITIALIZATION_FAILED
+    );
   }
   return api;
 }
@@ -49702,7 +49904,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 errors.CorePackageError(
+      `PlyazProvider not ready. Cannot get service '${key}'.`,
+      types.ERROR_CODES.CORE_PROVIDER_INITIALIZATION_FAILED
+    );
   }
   return react.useMemo(() => getService(key), [getService, key]);
 }