@plyaz/core 1.2.1 → 1.3.0

package/dist/init/nestjs/index.mjs

@@ -1,17 +1,17 @@
-import { CoreLogger, PackageLogger } from '@plyaz/logger';
-import { createDatabaseService, BaseRepository } from '@plyaz/db';
-import { DatabasePackageError, generateRequestId, CorePackageError, StoragePackageError, NotificationPackageError, BaseError, ValidateAndFormatErrors, ValidationError, initializeErrorSystem } from '@plyaz/errors';
-import { DATABASE_ERROR_CODES, ERROR_CODES as ERROR_CODES$1, STORAGE_ERROR_CODES, NOTIFICATION_ERROR_CODES, API_ERROR_CODES as API_ERROR_CODES$1 } from '@plyaz/types/errors';
-import { CORE_EVENTS, SERVICE_KEYS } from '@plyaz/types/core';
-import { EventEmitter } from 'events';
 import { CACHE_MAX_SIZE_DEFAULT, CACHE_CLEANUP_INTERVAL_DEFAULT, TIME_CONSTANTS, HTTP_STATUS as HTTP_STATUS$1, DEVELOPMENT_CONFIG, STAGING_CONFIG, PRODUCTION_CONFIG } from '@plyaz/config';
-import { HTTP_STATUS, ERROR_CATEGORY, ERROR_CODES, CORE_EVENTS as CORE_EVENTS$1, PACKAGE_STATUS_CODES, API_ERROR_CODES, OPERATIONS, BACKEND_RUNTIMES, FRONTEND_RUNTIMES } from '@plyaz/types';
+import { HTTP_STATUS, ERROR_CATEGORY, ERROR_CODES, CORE_EVENTS, PACKAGE_STATUS_CODES, API_ERROR_CODES, OPERATIONS, BACKEND_RUNTIMES, FRONTEND_RUNTIMES } from '@plyaz/types';
+import { EventEmitter } from 'events';
+import { BaseRepository, createDatabaseService } from '@plyaz/db';
+import { generateRequestId, CorePackageError, BaseError, ValidateAndFormatErrors, ValidationError, DatabasePackageError, initializeErrorSystem, StoragePackageError, NotificationPackageError } from '@plyaz/errors';
+import { ERROR_CODES as ERROR_CODES$1, API_ERROR_CODES as API_ERROR_CODES$1, DATABASE_ERROR_CODES, STORAGE_ERROR_CODES, NOTIFICATION_ERROR_CODES } from '@plyaz/types/errors';
+import { SERVICE_KEYS, CORE_EVENTS as CORE_EVENTS$1 } from '@plyaz/types/core';
+import { StorageService as StorageService$1 } from '@plyaz/storage';
+import { NotificationService as NotificationService$1 } from '@plyaz/notifications';
+import { CoreLogger, PackageLogger } from '@plyaz/logger';
 import { mergeConfigs, createApiClient, ApiPackageError, setDefaultApiClient } from '@plyaz/api';
 import { Injectable } from '@nestjs/common';
 import { of, tap } from 'rxjs';
 import { CACHE_STRATEGIES } from '@plyaz/types/features';
-import { StorageService as StorageService$1 } from '@plyaz/storage';
-import { NotificationService as NotificationService$1 } from '@plyaz/notifications';
 import { STORE_KEYS, useRootStore, createStandaloneFeatureFlagStore } from '@plyaz/store';
 import { OBSERVABILITY_METRICS } from '@plyaz/types/observability';
 import { QueryExampleSchema, DeleteExampleSchema, PatchExampleSchema, UpdateExampleSchema, CreateExampleSchema } from '@plyaz/types/examples';
@@ -20,7 +20,15 @@ import { clearEventEmitter, ServerErrorMiddleware, setEventEmitter, initializeGl
 // @plyaz package - Built with tsup
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __decorateClass = (decorators, target, key, kind) => {
   var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
@@ -28,15 +36,12 @@ var __decorateClass = (decorators, target, key, kind) => {
       result = (decorator(result)) || result;
   return result;
 };
+var init_hash = __esm({
+  "src/utils/common/hash.ts"() {
+  }
+});
 
 // src/utils/common/id.ts
-var RANDOM_ID_RADIX = 36;
-var RANDOM_ID_SLICE_START = 2;
-var SHORT_ID_LENGTH = 8;
-var HEX_RADIX = 16;
-var HEX_SLICE_START = 2;
-var HEX_SLICE_END = 18;
-var SPAN_ID_LENGTH = 16;
 function generateId() {
   const cryptoApi = globalThis.crypto;
   if (cryptoApi?.randomUUID) {
@@ -44,7 +49,6 @@ function generateId() {
   }
   return `${Date.now()}-${Math.random().toString(RANDOM_ID_RADIX).slice(RANDOM_ID_SLICE_START)}`;
 }
-__name(generateId, "generateId");
 function generateShortId() {
   const cryptoApi = globalThis.crypto;
   if (cryptoApi?.randomUUID) {
@@ -52,11 +56,9 @@ function generateShortId() {
   }
   return Math.random().toString(RANDOM_ID_RADIX).slice(RANDOM_ID_SLICE_START, RANDOM_ID_SLICE_START + SHORT_ID_LENGTH);
 }
-__name(generateShortId, "generateShortId");
 function generateCorrelationId() {
   return `${Date.now()}-${generateShortId()}`;
 }
-__name(generateCorrelationId, "generateCorrelationId");
 function generateTraceId() {
   const cryptoApi = globalThis.crypto;
   if (cryptoApi?.randomUUID) {
@@ -64,7 +66,6 @@ function generateTraceId() {
   }
   return Math.random().toString(HEX_RADIX).substring(HEX_SLICE_START, HEX_SLICE_END) + Math.random().toString(HEX_RADIX).substring(HEX_SLICE_START, HEX_SLICE_END);
 }
-__name(generateTraceId, "generateTraceId");
 function generateSpanId() {
   const cryptoApi = globalThis.crypto;
   if (cryptoApi?.randomUUID) {
@@ -72,747 +73,1229 @@ function generateSpanId() {
   }
   return Math.random().toString(HEX_RADIX).substring(HEX_SLICE_START, HEX_SLICE_END);
 }
-__name(generateSpanId, "generateSpanId");
+var RANDOM_ID_RADIX, RANDOM_ID_SLICE_START, SHORT_ID_LENGTH, HEX_RADIX, HEX_SLICE_START, HEX_SLICE_END, SPAN_ID_LENGTH;
+var init_id = __esm({
+  "src/utils/common/id.ts"() {
+    RANDOM_ID_RADIX = 36;
+    RANDOM_ID_SLICE_START = 2;
+    SHORT_ID_LENGTH = 8;
+    HEX_RADIX = 16;
+    HEX_SLICE_START = 2;
+    HEX_SLICE_END = 18;
+    SPAN_ID_LENGTH = 16;
+    __name(generateId, "generateId");
+    __name(generateShortId, "generateShortId");
+    __name(generateCorrelationId, "generateCorrelationId");
+    __name(generateTraceId, "generateTraceId");
+    __name(generateSpanId, "generateSpanId");
+  }
+});
+var init_values = __esm({
+  "src/utils/common/values.ts"() {
+  }
+});
 
-// src/events/CoreEventManager.ts
-var MAX_EVENT_LISTENERS = 100;
-var CoreEventManagerClass = class {
-  constructor() {
-    this.emitter = new EventEmitter();
-    this.subscriptions = /* @__PURE__ */ new Map();
-    this.emitter.setMaxListeners(MAX_EVENT_LISTENERS);
-  }
-  static {
-    __name(this, "CoreEventManagerClass");
-  }
-  emit(eventType, data) {
-    const [scope] = eventType.split(":");
-    const event = {
-      type: eventType,
-      scope: scope ?? "system",
-      timestamp: Date.now(),
-      correlationId: this.getCorrelationId(),
-      data
-    };
-    this.emitter.emit(eventType, event);
-    this.emitter.emit("*", event);
-    return true;
-  }
-  on(eventType, handler) {
-    this.emitter.on(eventType, handler);
-    if (!this.subscriptions.has(eventType)) {
-      this.subscriptions.set(eventType, /* @__PURE__ */ new Set());
-    }
-    this.subscriptions.get(eventType).add(handler);
-    return () => {
-      this.emitter.off(eventType, handler);
-      this.subscriptions.get(eventType)?.delete(handler);
-    };
+// src/utils/common/object.ts
+var init_object = __esm({
+  "src/utils/common/object.ts"() {
   }
-  once(eventType, handler) {
-    const wrappedHandler = /* @__PURE__ */ __name((event) => {
-      handler(event);
-      this.emitter.off(eventType, wrappedHandler);
-      this.subscriptions.get(eventType)?.delete(wrappedHandler);
-    }, "wrappedHandler");
-    this.emitter.on(eventType, wrappedHandler);
-    if (!this.subscriptions.has(eventType)) {
-      this.subscriptions.set(eventType, /* @__PURE__ */ new Set());
-    }
-    this.subscriptions.get(eventType).add(wrappedHandler);
-    return () => {
-      this.emitter.off(eventType, wrappedHandler);
-      this.subscriptions.get(eventType)?.delete(wrappedHandler);
-    };
+});
+var init_validation = __esm({
+  "src/utils/common/validation.ts"() {
   }
-  /**
-   * Subscribe to all events in a scope
-   *
-   * @param scope - Event scope to listen to (e.g., CoreEventScope.AUTH)
-   * @param handler - Event handler
-   * @returns Unsubscribe function
-   *
-   * @example
-   * ```typescript
-   * CoreEventManager.onScope(CoreEventScope.AUTH, (event) => {
-   *   // Handles auth:login, auth:logout, auth:tokenRefresh, etc.
-   *   console.log(`Auth event: ${event.type}`, event.data);
-   * });
-   * ```
-   */
-  onScope(scope, handler) {
-    const wrappedHandler = /* @__PURE__ */ __name((event) => {
-      if (event.scope === scope) {
-        handler(event);
+});
+
+// src/utils/common/index.ts
+var init_common = __esm({
+  "src/utils/common/index.ts"() {
+    init_hash();
+    init_id();
+    init_values();
+    init_object();
+    init_validation();
+  }
+});
+var MAX_EVENT_LISTENERS, CoreEventManagerClass, CoreEventManager;
+var init_CoreEventManager = __esm({
+  "src/events/CoreEventManager.ts"() {
+    init_common();
+    MAX_EVENT_LISTENERS = 100;
+    CoreEventManagerClass = class {
+      constructor() {
+        this.emitter = new EventEmitter();
+        this.subscriptions = /* @__PURE__ */ new Map();
+        this.emitter.setMaxListeners(MAX_EVENT_LISTENERS);
       }
-    }, "wrappedHandler");
-    return this.on("*", wrappedHandler);
-  }
-  /**
-   * Remove a specific handler from an event
-   *
-   * @param eventType - Event type
-   * @param handler - Handler to remove
-   */
-  off(eventType, handler) {
-    this.emitter.off(eventType, handler);
-    this.subscriptions.get(eventType)?.delete(handler);
-  }
-  /**
-   * Dispose all subscriptions
-   */
-  dispose() {
-    this.subscriptions.forEach((handlers, eventType) => {
-      handlers.forEach((handler) => this.emitter.off(eventType, handler));
-    });
-    this.subscriptions.clear();
-    this.emitter.removeAllListeners();
-  }
-  /**
-   * Generate correlation ID for event tracing
-   */
-  getCorrelationId() {
-    return generateCorrelationId();
+      static {
+        __name(this, "CoreEventManagerClass");
+      }
+      emit(eventType, data) {
+        const [scope] = eventType.split(":");
+        const event = {
+          type: eventType,
+          scope: scope ?? "system",
+          timestamp: Date.now(),
+          correlationId: this.getCorrelationId(),
+          data
+        };
+        this.emitter.emit(eventType, event);
+        this.emitter.emit("*", event);
+        return true;
+      }
+      on(eventType, handler) {
+        this.emitter.on(eventType, handler);
+        if (!this.subscriptions.has(eventType)) {
+          this.subscriptions.set(eventType, /* @__PURE__ */ new Set());
+        }
+        this.subscriptions.get(eventType).add(handler);
+        return () => {
+          this.emitter.off(eventType, handler);
+          this.subscriptions.get(eventType)?.delete(handler);
+        };
+      }
+      once(eventType, handler) {
+        const wrappedHandler = /* @__PURE__ */ __name((event) => {
+          handler(event);
+          this.emitter.off(eventType, wrappedHandler);
+          this.subscriptions.get(eventType)?.delete(wrappedHandler);
+        }, "wrappedHandler");
+        this.emitter.on(eventType, wrappedHandler);
+        if (!this.subscriptions.has(eventType)) {
+          this.subscriptions.set(eventType, /* @__PURE__ */ new Set());
+        }
+        this.subscriptions.get(eventType).add(wrappedHandler);
+        return () => {
+          this.emitter.off(eventType, wrappedHandler);
+          this.subscriptions.get(eventType)?.delete(wrappedHandler);
+        };
+      }
+      /**
+       * Subscribe to all events in a scope
+       *
+       * @param scope - Event scope to listen to (e.g., CoreEventScope.AUTH)
+       * @param handler - Event handler
+       * @returns Unsubscribe function
+       *
+       * @example
+       * ```typescript
+       * CoreEventManager.onScope(CoreEventScope.AUTH, (event) => {
+       *   // Handles auth:login, auth:logout, auth:tokenRefresh, etc.
+       *   console.log(`Auth event: ${event.type}`, event.data);
+       * });
+       * ```
+       */
+      onScope(scope, handler) {
+        const wrappedHandler = /* @__PURE__ */ __name((event) => {
+          if (event.scope === scope) {
+            handler(event);
+          }
+        }, "wrappedHandler");
+        return this.on("*", wrappedHandler);
+      }
+      /**
+       * Remove a specific handler from an event
+       *
+       * @param eventType - Event type
+       * @param handler - Handler to remove
+       */
+      off(eventType, handler) {
+        this.emitter.off(eventType, handler);
+        this.subscriptions.get(eventType)?.delete(handler);
+      }
+      /**
+       * Dispose all subscriptions
+       */
+      dispose() {
+        this.subscriptions.forEach((handlers, eventType) => {
+          handlers.forEach((handler) => this.emitter.off(eventType, handler));
+        });
+        this.subscriptions.clear();
+        this.emitter.removeAllListeners();
+      }
+      /**
+       * Generate correlation ID for event tracing
+       */
+      getCorrelationId() {
+        return generateCorrelationId();
+      }
+    };
+    CoreEventManager = new CoreEventManagerClass();
   }
-};
-var CoreEventManager = new CoreEventManagerClass();
+});
 
 // src/services/DbService.ts
-var DEFAULT_ENCRYPTION_FIELDS = {
-  // User PII
-  users: ["password_hash", "phone_number", "date_of_birth"],
-  // KYC sensitive data
-  "backoffice.kyc_submissions": ["tax_id", "address_line1", "address_line2"],
-  // Connected accounts OAuth tokens
-  connected_accounts: ["access_token_encrypted", "refresh_token_encrypted", "wallet_address"],
-  // Payment payout accounts
-  user_payout_accounts: ["provider_account_id", "account_holder_name"],
-  // Sessions
-  sessions: ["token"]
-};
-var DEFAULT_CACHE_TTL_SECONDS = 300;
-var DEFAULT_AUDIT_RETENTION_DAYS = 180;
-var DEFAULT_POOL_SIZE = 10;
-var DEFAULT_CONFIG = {
-  adapter: "sql",
-  cache: {
-    enabled: true,
-    provider: "memory",
-    ttl: DEFAULT_CACHE_TTL_SECONDS
-  },
-  softDelete: {
-    enabled: true,
-    field: "deleted_at",
-    excludeTables: [
-      "audit_logs",
-      "audit.audit_logs",
-      "audit.feature_flag_evaluations",
-      "feature_flag_evaluations",
-      "notification_events",
-      "payments_activity",
-      "campaign_analytics",
-      "admin_actions",
-      "backoffice.admin_actions"
-    ]
-  },
-  audit: {
-    enabled: true,
-    // Enabled by default for compliance
-    retentionDays: DEFAULT_AUDIT_RETENTION_DAYS,
-    excludeFields: ["password_hash", "api_key_hash", "token_hash"],
-    excludeTables: ["audit_logs", "audit.audit_logs"],
-    // Don't audit the audit table itself
-    schema: "audit",
-    // Use dedicated audit schema
-    usePartitionedTables: true
-    // Use daily partitioned tables (audit_log_yyyy_mm_dd)
-  }
-  // NOTE: Encryption requires key from environment or DbService.initialize()
-  // Enable via: DbService.initialize({ encryption: { enabled: true, key: process.env.ENCRYPTION_KEY!, fields: DEFAULT_ENCRYPTION_FIELDS } })
-};
-var TABLE_REGISTRY = {
-  // Migration 008: Feature Flags (custom ID column 'key')
-  feature_flags: { idColumn: "key" },
-  // Test Feature Flags (custom ID column 'key')
-  test_feature_flags: { idColumn: "key" },
-  // Migration 010: Universal Analytics (custom ID column 'user_id')
-  user_analytics_summary: { idColumn: "user_id" }
-};
-var DbService = class _DbService {
-  constructor() {
-    this.databaseService = null;
-    this.namedAdapters = /* @__PURE__ */ new Map();
-    this.config = null;
-    this.initialized = false;
-  }
-  static {
-    __name(this, "DbService");
-  }
-  static {
-    this.instance = null;
-  }
-  /**
-   * Emits a database error event via CoreEventManager.
-   * Called when database operations fail to integrate with global error handling.
-   *
-   * @param error - The error that occurred
-   * @param operation - The operation that failed (e.g., 'transaction', 'query', 'healthCheck')
-   * @param table - Optional table name involved in the operation
-   * @param query - Optional query string that failed
-   * @param recoverable - Whether the error is recoverable (default: false)
-   */
-  emitDatabaseError(error, operation, options) {
-    const payload = {
-      error,
-      operation,
-      table: options?.table,
-      query: options?.query,
-      recoverable: options?.recoverable ?? false
+var DbService_exports = {};
+__export(DbService_exports, {
+  DEFAULT_ENCRYPTION_FIELDS: () => DEFAULT_ENCRYPTION_FIELDS,
+  DbService: () => DbService,
+  TABLE_REGISTRY: () => TABLE_REGISTRY
+});
+var DEFAULT_ENCRYPTION_FIELDS, DEFAULT_CACHE_TTL_SECONDS, DEFAULT_AUDIT_RETENTION_DAYS, DEFAULT_POOL_SIZE, DEFAULT_CONFIG, TABLE_REGISTRY, DbService;
+var init_DbService = __esm({
+  "src/services/DbService.ts"() {
+    init_CoreEventManager();
+    DEFAULT_ENCRYPTION_FIELDS = {
+      // User PII
+      users: ["password_hash", "phone_number", "date_of_birth"],
+      // KYC sensitive data
+      "backoffice.kyc_submissions": ["tax_id", "address_line1", "address_line2"],
+      // Connected accounts OAuth tokens
+      connected_accounts: ["access_token_encrypted", "refresh_token_encrypted", "wallet_address"],
+      // Payment payout accounts
+      user_payout_accounts: ["provider_account_id", "account_holder_name"],
+      // Sessions
+      sessions: ["token"]
     };
-    CoreEventManager.emit(CORE_EVENTS.DATABASE.ERROR, payload);
-  }
-  /**
-   * Gets the singleton instance of DbService
-   *
-   * @returns {DbService} The singleton instance
-   */
-  static getInstance() {
-    _DbService.instance ??= new _DbService();
-    return _DbService.instance;
-  }
-  /**
-   * Checks if the database service has been initialized
-   *
-   * @returns {boolean} True if initialized
-   */
-  static isInitialized() {
-    return _DbService.instance?.initialized ?? false;
-  }
-  /**
-   * Resets the database service by closing connections and clearing the singleton instance
-   *
-   * @description Properly closes the database connection and clears the singleton.
-   * Useful for testing or when you need to reinitialize with different configuration.
-   *
-   * @example
-   * ```typescript
-   * await DbService.reset();
-   * await DbService.initialize({ adapter: 'sql', ... });
-   * ```
-   */
-  static async reset() {
-    if (_DbService.instance) {
-      try {
-        await _DbService.instance.databaseService?.close?.();
-      } catch {
+    DEFAULT_CACHE_TTL_SECONDS = 300;
+    DEFAULT_AUDIT_RETENTION_DAYS = 180;
+    DEFAULT_POOL_SIZE = 10;
+    DEFAULT_CONFIG = {
+      adapter: "sql",
+      cache: {
+        enabled: true,
+        provider: "memory",
+        ttl: DEFAULT_CACHE_TTL_SECONDS
+      },
+      softDelete: {
+        enabled: true,
+        field: "deleted_at",
+        excludeTables: [
+          "audit_logs",
+          "audit.audit_logs",
+          "audit.feature_flag_evaluations",
+          "feature_flag_evaluations",
+          "notification_events",
+          "payments_activity",
+          "campaign_analytics",
+          "admin_actions",
+          "backoffice.admin_actions"
+        ]
+      },
+      audit: {
+        enabled: true,
+        // Enabled by default for compliance
+        retentionDays: DEFAULT_AUDIT_RETENTION_DAYS,
+        excludeFields: ["password_hash", "api_key_hash", "token_hash"],
+        excludeTables: ["audit_logs", "audit.audit_logs"],
+        // Don't audit the audit table itself
+        schema: "audit",
+        // Use dedicated audit schema
+        usePartitionedTables: true
+        // Use daily partitioned tables (audit_log_yyyy_mm_dd)
       }
-      _DbService.instance = null;
-    }
-  }
-  /**
-   * Initializes the database connection
-   *
-   * @description Sets up the database connection using the provided configuration
-   * or environment variables. This method is idempotent - calling it multiple
-   * times won't create additional connections.
-   *
-   * **Environment Variables:**
-   * - `DATABASE_URL` - PostgreSQL connection string (for sql/drizzle adapters)
-   * - `ENCRYPTION_KEY` - 32-byte encryption key for field encryption (optional)
-   * - `SUPABASE_URL`, `SUPABASE_SERVICE_ROLE_KEY`, `SUPABASE_ANON_PUBLIC_KEY` - For supabase adapter
-   *
-   * **Encryption:** If `ENCRYPTION_KEY` env is set, encryption is auto-enabled
-   * using `DEFAULT_ENCRYPTION_FIELDS`. Override via config.encryption.
-   *
-   * @param {DbServiceConfig} [config] - Optional configuration
-   * @returns {Promise<DbService>} The initialized DbService instance
-   * @throws {DatabasePackageError} When configuration is invalid or connection fails
-   *
-   * @example
-   * ```typescript
-   * // Minimal - uses DATABASE_URL env, auto-enables encryption if ENCRYPTION_KEY set
-   * await DbService.initialize();
-   *
-   * // With explicit encryption
-   * await DbService.initialize({
-   *   adapter: 'sql',
-   *   encryption: {
-   *     enabled: true,
-   *     key: 'your-32-byte-encryption-key-here!!',
-   *     fields: DEFAULT_ENCRYPTION_FIELDS,
-   *   },
-   * });
-   *
-   * // Or via Core.initialize() with env:
-   * await Core.initialize({
-   *   env: { ENCRYPTION_KEY: '...' },
-   *   db: { adapter: 'sql' },
-   * });
-   * ```
-   */
-  /** Build encryption config from user config */
-  static buildEncryptionConfig(config) {
-    const encryption = config?.encryption;
-    if (!encryption?.key) return void 0;
-    return {
-      enabled: encryption.enabled ?? true,
-      key: encryption.key,
-      fields: encryption.fields ?? DEFAULT_ENCRYPTION_FIELDS,
-      algorithm: encryption.algorithm ?? "aes-256-gcm"
-    };
-  }
-  /** Merge user config with defaults */
-  static mergeConfig(config) {
-    return {
-      ...DEFAULT_CONFIG,
-      ...config,
-      softDelete: { ...DEFAULT_CONFIG.softDelete, ...config?.softDelete },
-      cache: { ...DEFAULT_CONFIG.cache, ...config?.cache },
-      audit: { ...DEFAULT_CONFIG.audit, ...config?.audit },
-      encryption: _DbService.buildEncryptionConfig(config)
-    };
-  }
-  /** Initialize named adapters */
-  async initializeNamedAdapters(mergedConfig) {
-    if (!mergedConfig.adapters) return;
-    for (const [name, adapterConfig] of Object.entries(mergedConfig.adapters)) {
-      const namedDbConfig = this.buildDatabaseConfig({
-        ...mergedConfig,
-        adapter: adapterConfig.adapter,
-        drizzle: adapterConfig.drizzle,
-        supabase: adapterConfig.supabase,
-        sql: adapterConfig.sql
-      });
-      const namedService = await createDatabaseService(namedDbConfig);
-      this.namedAdapters.set(name, namedService);
-    }
-  }
-  static async initialize(config) {
-    const instance = _DbService.getInstance();
-    if (instance.initialized) {
-      return instance;
-    }
-    const mergedConfig = _DbService.mergeConfig(config);
-    instance.config = mergedConfig;
-    const dbConfig = instance.buildDatabaseConfig(mergedConfig);
-    instance.databaseService = await createDatabaseService(dbConfig);
-    await instance.initializeNamedAdapters(mergedConfig);
-    instance.initialized = true;
-    return instance;
-  }
-  /**
-   * Builds the DatabaseServiceConfig based on the adapter type
-   * @private
-   */
-  /** Builds adapter-specific config based on adapter type */
-  buildAdapterConfig(adapter, config) {
-    const builders = {
-      drizzle: /* @__PURE__ */ __name(() => this.buildDrizzleConfig(config), "drizzle"),
-      supabase: /* @__PURE__ */ __name(() => this.buildSupabaseConfig(config), "supabase"),
-      sql: /* @__PURE__ */ __name(() => this.buildSqlConfig(config), "sql")
-    };
-    const builder = builders[adapter];
-    if (!builder) {
-      throw new DatabasePackageError(
-        `Unsupported adapter type: ${adapter}`,
-        DATABASE_ERROR_CODES.CONFIG_REQUIRED
-      );
-    }
-    return builder();
-  }
-  /** Builds soft delete extension config */
-  buildSoftDeleteExtension(config) {
-    if (!config.softDelete?.enabled) return void 0;
-    return {
-      enabled: true,
-      field: config.softDelete.field ?? "deleted_at",
-      excludeTables: config.softDelete.excludeTables
-    };
-  }
-  /** Builds cache extension config */
-  buildCacheExtension(config) {
-    if (!config.cache?.enabled) return void 0;
-    return {
-      enabled: true,
-      ttl: config.cache.ttl ?? DEFAULT_CACHE_TTL_SECONDS,
-      provider: config.cache.provider ?? "memory",
-      invalidation: config.cache.invalidation ?? "write"
-    };
-  }
-  /** Builds audit extension config */
-  buildAuditExtension(config) {
-    if (!config.audit?.enabled) return void 0;
-    return {
-      enabled: true,
-      retentionDays: config.audit.retentionDays ?? DEFAULT_AUDIT_RETENTION_DAYS,
-      excludeFields: config.audit.excludeFields,
-      excludeTables: config.audit.excludeTables,
-      schema: config.audit.schema ?? "audit",
-      usePartitionedTables: config.audit.usePartitionedTables ?? true
-    };
-  }
-  /** Builds encryption extension config */
-  buildEncryptionExtension(config) {
-    if (!config.encryption?.enabled || !config.encryption.key) return void 0;
-    return {
-      enabled: true,
-      key: config.encryption.key,
-      fields: config.encryption.fields ?? {},
-      algorithm: config.encryption.algorithm
-    };
-  }
-  buildDatabaseConfig(config) {
-    const adapter = config.adapter ?? "drizzle";
-    const dbConfig = {
-      adapter,
-      config: this.buildAdapterConfig(adapter, config)
-    };
-    const softDelete = this.buildSoftDeleteExtension(config);
-    const cache = this.buildCacheExtension(config);
-    const audit = this.buildAuditExtension(config);
-    const encryption = this.buildEncryptionExtension(config);
-    if (softDelete) dbConfig.softDelete = softDelete;
-    if (cache) dbConfig.cache = cache;
-    if (audit) dbConfig.audit = audit;
-    if (encryption) dbConfig.encryption = encryption;
-    return dbConfig;
-  }
-  /**
-   * Builds Drizzle adapter configuration
-   * @private
-   */
-  buildDrizzleConfig(config) {
-    const connectionString = config.drizzle?.connectionString;
-    if (!connectionString) {
-      throw new DatabasePackageError(
-        "Drizzle adapter requires a PostgreSQL connection string. Provide `drizzle.connectionString` in config or use Core.initialize() with DATABASE_URL in env. For Supabase, find this in Dashboard > Database > Connection string (URI).",
-        DATABASE_ERROR_CODES.CONFIG_REQUIRED
-      );
-    }
-    const tableIdColumns = this.buildTableIdColumns();
-    return {
-      connectionString,
-      poolSize: config.drizzle?.poolSize ?? DEFAULT_POOL_SIZE,
-      ssl: config.drizzle?.ssl,
-      schema: config.drizzle?.schema,
-      // Pass through schema configuration
-      tableIdColumns
-    };
-  }
-  /**
-   * Builds Supabase adapter configuration
-   * @private
-   */
-  // eslint-disable-next-line complexity
-  buildSupabaseConfig(config) {
-    const supabaseUrl = config.supabase?.supabaseUrl;
-    const supabaseServiceKey = config.supabase?.supabaseServiceKey;
-    const supabaseAnonKey = config.supabase?.supabaseAnonKey;
-    if (!supabaseUrl || !supabaseServiceKey) {
-      throw new DatabasePackageError(
-        "Supabase adapter requires supabaseUrl and supabaseServiceKey. Provide in config or use Core.initialize() with SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY in env.",
-        DATABASE_ERROR_CODES.CONFIG_REQUIRED
-      );
-    }
-    if (!supabaseAnonKey) {
-      throw new DatabasePackageError(
-        "Supabase adapter requires supabaseAnonKey. Provide in config or use Core.initialize() with SUPABASE_ANON_PUBLIC_KEY in env.",
-        DATABASE_ERROR_CODES.CONFIG_REQUIRED
-      );
-    }
-    const tableIdColumns = this.buildTableIdColumns();
-    return {
-      supabaseUrl,
-      supabaseServiceKey,
-      supabaseAnonKey,
-      schema: config.supabase?.schema ?? "public",
-      tableIdColumns
+      // NOTE: Encryption requires key from environment or DbService.initialize()
+      // Enable via: DbService.initialize({ encryption: { enabled: true, key: process.env.ENCRYPTION_KEY!, fields: DEFAULT_ENCRYPTION_FIELDS } })
     };
-  }
-  /**
-   * Builds SQL adapter configuration
-   * @private
-   */
-  buildSqlConfig(config) {
-    const connectionString = config.sql?.connectionString;
-    if (!connectionString) {
-      throw new DatabasePackageError(
-        "SQL adapter requires a connection string. Provide `sql.connectionString` in config or use Core.initialize() with DATABASE_URL in env.",
-        DATABASE_ERROR_CODES.CONFIG_REQUIRED
-      );
-    }
-    const tableIdColumns = this.buildTableIdColumns();
-    return {
-      connectionString,
-      dialect: config.sql?.dialect ?? "postgresql",
-      schema: config.sql?.schema,
-      // Pass through schema configuration
-      tableIdColumns
+    TABLE_REGISTRY = {
+      // Migration 008: Feature Flags (custom ID column 'key')
+      feature_flags: { idColumn: "key" },
+      // Test Feature Flags (custom ID column 'key')
+      test_feature_flags: { idColumn: "key" },
+      // Migration 010: Universal Analytics (custom ID column 'user_id')
+      user_analytics_summary: { idColumn: "user_id" }
     };
-  }
-  /**
-   * Builds table ID column mappings from TABLE_REGISTRY
-   * @private
-   * @returns Record of table names to ID column names
-   */
-  // eslint-disable-next-line complexity
-  buildTableIdColumns() {
-    const tableIdColumns = {};
-    const baseNameConflicts = /* @__PURE__ */ new Set();
-    const baseNameMappings = /* @__PURE__ */ new Map();
-    for (const tableName of Object.keys(TABLE_REGISTRY)) {
-      if (tableName.includes(".")) {
-        const baseName = tableName.split(".").pop();
-        if (baseNameMappings.has(baseName) || TABLE_REGISTRY[baseName]) {
-          baseNameConflicts.add(baseName);
-        } else {
-          baseNameMappings.set(baseName, tableName);
+    DbService = class _DbService {
+      constructor() {
+        this.databaseService = null;
+        this.namedAdapters = /* @__PURE__ */ new Map();
+        this.config = null;
+        this.initialized = false;
+      }
+      static {
+        __name(this, "DbService");
+      }
+      static {
+        this.instance = null;
+      }
+      /**
+       * Emits a database error event via CoreEventManager.
+       * Called when database operations fail to integrate with global error handling.
+       *
+       * @param error - The error that occurred
+       * @param operation - The operation that failed (e.g., 'transaction', 'query', 'healthCheck')
+       * @param table - Optional table name involved in the operation
+       * @param query - Optional query string that failed
+       * @param recoverable - Whether the error is recoverable (default: false)
+       */
+      emitDatabaseError(error, operation, options) {
+        const payload = {
+          error,
+          operation,
+          table: options?.table,
+          query: options?.query,
+          recoverable: options?.recoverable ?? false
+        };
+        CoreEventManager.emit(CORE_EVENTS$1.DATABASE.ERROR, payload);
+      }
+      /**
+       * Gets the singleton instance of DbService
+       *
+       * @returns {DbService} The singleton instance
+       */
+      static getInstance() {
+        _DbService.instance ??= new _DbService();
+        return _DbService.instance;
+      }
+      /**
+       * Checks if the database service has been initialized
+       *
+       * @returns {boolean} True if initialized
+       */
+      static isInitialized() {
+        return _DbService.instance?.initialized ?? false;
+      }
+      /**
+       * Resets the database service by closing connections and clearing the singleton instance
+       *
+       * @description Properly closes the database connection and clears the singleton.
+       * Useful for testing or when you need to reinitialize with different configuration.
+       *
+       * @example
+       * ```typescript
+       * await DbService.reset();
+       * await DbService.initialize({ adapter: 'sql', ... });
+       * ```
+       */
+      static async reset() {
+        if (_DbService.instance) {
+          try {
+            await _DbService.instance.databaseService?.close?.();
+          } catch {
+          }
+          _DbService.instance = null;
         }
       }
-    }
-    for (const [tableName, config] of Object.entries(TABLE_REGISTRY)) {
-      const idColumn = config.idColumn ?? "id";
-      if (idColumn === "id") continue;
-      tableIdColumns[tableName] = idColumn;
-      if (!tableName.includes(".")) continue;
-      const baseName = tableName.split(".").pop();
-      if (!baseNameConflicts.has(baseName)) {
-        tableIdColumns[baseName] = idColumn;
+      /**
+       * Initializes the database connection
+       *
+       * @description Sets up the database connection using the provided configuration
+       * or environment variables. This method is idempotent - calling it multiple
+       * times won't create additional connections.
+       *
+       * **Environment Variables:**
+       * - `DATABASE_URL` - PostgreSQL connection string (for sql/drizzle adapters)
+       * - `ENCRYPTION_KEY` - 32-byte encryption key for field encryption (optional)
+       * - `SUPABASE_URL`, `SUPABASE_SERVICE_ROLE_KEY`, `SUPABASE_ANON_PUBLIC_KEY` - For supabase adapter
+       *
+       * **Encryption:** If `ENCRYPTION_KEY` env is set, encryption is auto-enabled
+       * using `DEFAULT_ENCRYPTION_FIELDS`. Override via config.encryption.
+       *
+       * @param {DbServiceConfig} [config] - Optional configuration
+       * @returns {Promise<DbService>} The initialized DbService instance
+       * @throws {DatabasePackageError} When configuration is invalid or connection fails
+       *
+       * @example
+       * ```typescript
+       * // Minimal - uses DATABASE_URL env, auto-enables encryption if ENCRYPTION_KEY set
+       * await DbService.initialize();
+       *
+       * // With explicit encryption
+       * await DbService.initialize({
+       *   adapter: 'sql',
+       *   encryption: {
+       *     enabled: true,
+       *     key: 'your-32-byte-encryption-key-here!!',
+       *     fields: DEFAULT_ENCRYPTION_FIELDS,
+       *   },
+       * });
+       *
+       * // Or via Core.initialize() with env:
+       * await Core.initialize({
+       *   env: { ENCRYPTION_KEY: '...' },
+       *   db: { adapter: 'sql' },
+       * });
+       * ```
+       */
+      /** Build encryption config from user config */
+      static buildEncryptionConfig(config) {
+        const encryption = config?.encryption;
+        if (!encryption?.key) return void 0;
+        return {
+          enabled: encryption.enabled ?? true,
+          key: encryption.key,
+          fields: encryption.fields ?? DEFAULT_ENCRYPTION_FIELDS,
+          algorithm: encryption.algorithm ?? "aes-256-gcm"
+        };
       }
-    }
-    return tableIdColumns;
-  }
-  /**
-   * Gets the initialized database service instance
-   *
-   * @param {string} [adapterName] - Optional named adapter to use instead of default
-   * @returns {DatabaseServiceInterface} The database service instance
-   * @throws {DatabasePackageError} When database is not initialized or named adapter not found
-   */
-  getDatabase(adapterName) {
-    if (adapterName) {
-      const namedAdapter = this.namedAdapters.get(adapterName);
-      if (!namedAdapter) {
-        throw new DatabasePackageError(
-          `Named adapter '${adapterName}' not found. Available adapters: ${Array.from(this.namedAdapters.keys()).join(", ")}`,
-          DATABASE_ERROR_CODES.INIT_FAILED
-        );
+      /** Merge user config with defaults */
+      static mergeConfig(config) {
+        return {
+          ...DEFAULT_CONFIG,
+          ...config,
+          softDelete: { ...DEFAULT_CONFIG.softDelete, ...config?.softDelete },
+          cache: { ...DEFAULT_CONFIG.cache, ...config?.cache },
+          audit: { ...DEFAULT_CONFIG.audit, ...config?.audit },
+          encryption: _DbService.buildEncryptionConfig(config)
+        };
       }
-      return namedAdapter;
-    }
-    if (!this.databaseService) {
-      throw new DatabasePackageError(
-        "Database not initialized. Call DbService.initialize() first.",
-        DATABASE_ERROR_CODES.INIT_FAILED
-      );
-    }
-    return this.databaseService;
-  }
-  /**
-   * Gets a named adapter by name
-   *
-   * @param {string} name - The name of the adapter
-   * @returns {DatabaseServiceInterface} The named adapter instance
-   * @throws {DatabasePackageError} When adapter not found
-   */
-  getAdapter(name) {
-    return this.getDatabase(name);
-  }
-  /**
-   * Lists all available named adapters
-   *
-   * @returns {string[]} Array of adapter names
-   */
-  getAvailableAdapters() {
-    return ["default", ...Array.from(this.namedAdapters.keys())];
-  }
-  /**
-   * Executes a database transaction with automatic rollback on failure
-   *
-   * @template T The return type of the transaction callback
-   * @param {Function} callback - Function that receives transaction object
-   * @returns {Promise<T>} The result of the transaction callback
-   * @throws {DatabasePackageError} When transaction fails
-   */
-  async transaction(callback) {
-    const db = this.getDatabase();
-    const result = await db.transaction(callback);
-    if (!result.success) {
-      const errorMessage = result.error?.message ?? "Transaction failed";
-      const error = new DatabasePackageError(errorMessage, DATABASE_ERROR_CODES.TRANSACTION_FAILED);
-      this.emitDatabaseError(error, "transaction", { recoverable: true });
-      throw error;
-    }
-    if (result.value === void 0 || result.value === null) {
-      const error = new DatabasePackageError(
-        "Transaction returned no value",
-        DATABASE_ERROR_CODES.INVALID_RESULT
-      );
-      this.emitDatabaseError(error, "transaction", { recoverable: false });
-      throw error;
-    }
-    return result.value;
-  }
-  /**
-   * Sets audit context for subsequent operations
-   *
-   * @param context - Audit context (userId, requestId, etc.)
-   */
-  async setAuditContext(context) {
-    const db = this.getDatabase();
-    await db.setAuditContext(context);
-  }
-  /**
-   * Performs a health check on the database connection
-   *
-   * @returns Health check result
-   */
-  async healthCheck() {
-    try {
-      const db = this.getDatabase();
-      const result = await db.healthCheck();
-      if (result.success && result.value) {
+      /** Initialize named adapters */
+      async initializeNamedAdapters(mergedConfig) {
+        if (!mergedConfig.adapters) return;
+        for (const [name, adapterConfig] of Object.entries(mergedConfig.adapters)) {
+          const namedDbConfig = this.buildDatabaseConfig({
+            ...mergedConfig,
+            adapter: adapterConfig.adapter,
+            drizzle: adapterConfig.drizzle,
+            supabase: adapterConfig.supabase,
+            sql: adapterConfig.sql
+          });
+          const namedService = await createDatabaseService(namedDbConfig);
+          this.namedAdapters.set(name, namedService);
+        }
+      }
+      static async initialize(config) {
+        const instance = _DbService.getInstance();
+        if (instance.initialized) {
+          return instance;
+        }
+        const mergedConfig = _DbService.mergeConfig(config);
+        instance.config = mergedConfig;
+        const dbConfig = instance.buildDatabaseConfig(mergedConfig);
+        instance.databaseService = await createDatabaseService(dbConfig);
+        await instance.initializeNamedAdapters(mergedConfig);
+        instance.initialized = true;
+        return instance;
+      }
+      /**
+       * Builds the DatabaseServiceConfig based on the adapter type
+       * @private
+       */
+      /** Builds adapter-specific config based on adapter type */
+      buildAdapterConfig(adapter, config) {
+        const builders = {
+          drizzle: /* @__PURE__ */ __name(() => this.buildDrizzleConfig(config), "drizzle"),
+          supabase: /* @__PURE__ */ __name(() => this.buildSupabaseConfig(config), "supabase"),
+          sql: /* @__PURE__ */ __name(() => this.buildSqlConfig(config), "sql")
+        };
+        const builder = builders[adapter];
+        if (!builder) {
+          throw new DatabasePackageError(
+            `Unsupported adapter type: ${adapter}`,
+            DATABASE_ERROR_CODES.CONFIG_REQUIRED
+          );
+        }
+        return builder();
+      }
+      /** Builds soft delete extension config */
+      buildSoftDeleteExtension(config) {
+        if (!config.softDelete?.enabled) return void 0;
         return {
-          isHealthy: result.value.isHealthy,
-          responseTime: result.value.responseTime
+          enabled: true,
+          field: config.softDelete.field ?? "deleted_at",
+          excludeTables: config.softDelete.excludeTables
         };
       }
-      const errorMessage = result.error?.message ?? "Health check failed";
-      this.emitDatabaseError(
-        new DatabasePackageError(errorMessage, DATABASE_ERROR_CODES.CONNECTION_ERROR),
-        "healthCheck",
-        { recoverable: true }
-      );
-      return {
-        isHealthy: false,
-        error: errorMessage
-      };
-    } catch (error) {
-      this.emitDatabaseError(error, "healthCheck", { recoverable: true });
-      return {
-        isHealthy: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
-    }
-  }
-  /**
-   * Gets the table registry with all known tables and their ID columns
-   *
-   * @returns The complete table registry
-   */
-  static getTableRegistry() {
-    return TABLE_REGISTRY;
-  }
-  /**
-   * Gets ID column for a specific table
-   *
-   * @param tableName - Name of the table
-   * @returns ID column name or 'id' as default
-   */
-  static getTableIdColumn(tableName) {
-    return TABLE_REGISTRY[tableName]?.idColumn ?? "id";
-  }
-  /**
-   * Reinitializes the database connection with new config
-   *
-   * @param {DbServiceConfig} [config] - New configuration
-   * @returns {Promise<DbService>} The reinitialized DbService instance
-   */
-  static async reinitialize(config) {
-    const instance = _DbService.getInstance();
-    await instance.close();
-    instance.initialized = false;
-    return _DbService.initialize(config);
-  }
-  /**
-   * Closes the database connection and cleans up resources
-   */
-  async close() {
-    this.databaseService = null;
-    this.initialized = false;
-    this.config = null;
-  }
-  /**
-   * Gets the current configuration
-   *
-   * @returns {DbServiceConfig | null} Current config or null if not initialized
-   */
-  getConfig() {
-    return this.config;
-  }
-  /**
-   * Gets the current adapter type
-   *
-   * @returns The adapter type or null if not initialized
-   */
-  getAdapterType() {
-    return this.config?.adapter ?? null;
+      /** Builds cache extension config */
+      buildCacheExtension(config) {
+        if (!config.cache?.enabled) return void 0;
+        return {
+          enabled: true,
+          ttl: config.cache.ttl ?? DEFAULT_CACHE_TTL_SECONDS,
+          provider: config.cache.provider ?? "memory",
+          invalidation: config.cache.invalidation ?? "write"
+        };
+      }
+      /** Builds audit extension config */
+      buildAuditExtension(config) {
+        if (!config.audit?.enabled) return void 0;
+        return {
+          enabled: true,
+          retentionDays: config.audit.retentionDays ?? DEFAULT_AUDIT_RETENTION_DAYS,
+          excludeFields: config.audit.excludeFields,
+          excludeTables: config.audit.excludeTables,
+          schema: config.audit.schema ?? "audit",
+          usePartitionedTables: config.audit.usePartitionedTables ?? true
+        };
+      }
+      /** Builds encryption extension config */
+      buildEncryptionExtension(config) {
+        if (!config.encryption?.enabled || !config.encryption.key) return void 0;
+        return {
+          enabled: true,
+          key: config.encryption.key,
+          fields: config.encryption.fields ?? {},
+          algorithm: config.encryption.algorithm
+        };
+      }
+      buildDatabaseConfig(config) {
+        const adapter = config.adapter ?? "drizzle";
+        const dbConfig = {
+          adapter,
+          config: this.buildAdapterConfig(adapter, config)
+        };
+        const softDelete = this.buildSoftDeleteExtension(config);
+        const cache = this.buildCacheExtension(config);
+        const audit = this.buildAuditExtension(config);
+        const encryption = this.buildEncryptionExtension(config);
+        if (softDelete) dbConfig.softDelete = softDelete;
+        if (cache) dbConfig.cache = cache;
+        if (audit) dbConfig.audit = audit;
+        if (encryption) dbConfig.encryption = encryption;
+        return dbConfig;
+      }
+      /**
+       * Builds Drizzle adapter configuration
+       * @private
+       */
+      buildDrizzleConfig(config) {
+        const connectionString = config.drizzle?.connectionString;
+        if (!connectionString) {
+          throw new DatabasePackageError(
+            "Drizzle adapter requires a PostgreSQL connection string. Provide `drizzle.connectionString` in config or use Core.initialize() with DATABASE_URL in env. For Supabase, find this in Dashboard > Database > Connection string (URI).",
+            DATABASE_ERROR_CODES.CONFIG_REQUIRED
+          );
+        }
+        const tableIdColumns = this.buildTableIdColumns();
+        return {
+          connectionString,
+          poolSize: config.drizzle?.poolSize ?? DEFAULT_POOL_SIZE,
+          ssl: config.drizzle?.ssl,
+          schema: config.drizzle?.schema,
+          // Pass through schema configuration
+          tableIdColumns
+        };
+      }
+      /**
+       * Builds Supabase adapter configuration
+       * @private
+       */
+      // eslint-disable-next-line complexity
+      buildSupabaseConfig(config) {
+        const supabaseUrl = config.supabase?.supabaseUrl;
+        const supabaseServiceKey = config.supabase?.supabaseServiceKey;
+        const supabaseAnonKey = config.supabase?.supabaseAnonKey;
+        if (!supabaseUrl || !supabaseServiceKey) {
+          throw new DatabasePackageError(
+            "Supabase adapter requires supabaseUrl and supabaseServiceKey. Provide in config or use Core.initialize() with SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY in env.",
+            DATABASE_ERROR_CODES.CONFIG_REQUIRED
+          );
+        }
+        if (!supabaseAnonKey) {
+          throw new DatabasePackageError(
+            "Supabase adapter requires supabaseAnonKey. Provide in config or use Core.initialize() with SUPABASE_ANON_PUBLIC_KEY in env.",
+            DATABASE_ERROR_CODES.CONFIG_REQUIRED
+          );
+        }
+        const tableIdColumns = this.buildTableIdColumns();
+        return {
+          supabaseUrl,
+          supabaseServiceKey,
+          supabaseAnonKey,
+          schema: config.supabase?.schema ?? "public",
+          tableIdColumns
+        };
+      }
+      /**
+       * Builds SQL adapter configuration
+       * @private
+       */
+      buildSqlConfig(config) {
+        const connectionString = config.sql?.connectionString;
+        if (!connectionString) {
+          throw new DatabasePackageError(
+            "SQL adapter requires a connection string. Provide `sql.connectionString` in config or use Core.initialize() with DATABASE_URL in env.",
+            DATABASE_ERROR_CODES.CONFIG_REQUIRED
+          );
+        }
+        const tableIdColumns = this.buildTableIdColumns();
+        return {
+          connectionString,
+          dialect: config.sql?.dialect ?? "postgresql",
+          schema: config.sql?.schema,
+          // Pass through schema configuration
+          tableIdColumns
+        };
+      }
+      /**
+       * Builds table ID column mappings from TABLE_REGISTRY
+       * @private
+       * @returns Record of table names to ID column names
+       */
+      // eslint-disable-next-line complexity
+      buildTableIdColumns() {
+        const tableIdColumns = {};
+        const baseNameConflicts = /* @__PURE__ */ new Set();
+        const baseNameMappings = /* @__PURE__ */ new Map();
+        for (const tableName of Object.keys(TABLE_REGISTRY)) {
+          if (tableName.includes(".")) {
+            const baseName = tableName.split(".").pop();
+            if (baseNameMappings.has(baseName) || TABLE_REGISTRY[baseName]) {
+              baseNameConflicts.add(baseName);
+            } else {
+              baseNameMappings.set(baseName, tableName);
+            }
+          }
+        }
+        for (const [tableName, config] of Object.entries(TABLE_REGISTRY)) {
+          const idColumn = config.idColumn ?? "id";
+          if (idColumn === "id") continue;
+          tableIdColumns[tableName] = idColumn;
+          if (!tableName.includes(".")) continue;
+          const baseName = tableName.split(".").pop();
+          if (!baseNameConflicts.has(baseName)) {
+            tableIdColumns[baseName] = idColumn;
+          }
+        }
+        return tableIdColumns;
+      }
+      /**
+       * Gets the initialized database service instance
+       *
+       * @param {string} [adapterName] - Optional named adapter to use instead of default
+       * @returns {DatabaseServiceInterface} The database service instance
+       * @throws {DatabasePackageError} When database is not initialized or named adapter not found
+       */
+      getDatabase(adapterName) {
+        if (adapterName) {
+          const namedAdapter = this.namedAdapters.get(adapterName);
+          if (!namedAdapter) {
+            throw new DatabasePackageError(
+              `Named adapter '${adapterName}' not found. Available adapters: ${Array.from(this.namedAdapters.keys()).join(", ")}`,
+              DATABASE_ERROR_CODES.INIT_FAILED
+            );
+          }
+          return namedAdapter;
+        }
+        if (!this.databaseService) {
+          throw new DatabasePackageError(
+            "Database not initialized. Call DbService.initialize() first.",
+            DATABASE_ERROR_CODES.INIT_FAILED
+          );
+        }
+        return this.databaseService;
+      }
+      /**
+       * Gets a named adapter by name
+       *
+       * @param {string} name - The name of the adapter
+       * @returns {DatabaseServiceInterface} The named adapter instance
+       * @throws {DatabasePackageError} When adapter not found
+       */
+      getAdapter(name) {
+        return this.getDatabase(name);
+      }
+      /**
+       * Lists all available named adapters
+       *
+       * @returns {string[]} Array of adapter names
+       */
+      getAvailableAdapters() {
+        return ["default", ...Array.from(this.namedAdapters.keys())];
+      }
+      /**
+       * Executes a database transaction with automatic rollback on failure
+       *
+       * @template T The return type of the transaction callback
+       * @param {Function} callback - Function that receives transaction object
+       * @returns {Promise<T>} The result of the transaction callback
+       * @throws {DatabasePackageError} When transaction fails
+       */
+      async transaction(callback) {
+        const db = this.getDatabase();
+        const result = await db.transaction(callback);
+        if (!result.success) {
+          const errorMessage = result.error?.message ?? "Transaction failed";
+          const error = new DatabasePackageError(errorMessage, DATABASE_ERROR_CODES.TRANSACTION_FAILED);
+          this.emitDatabaseError(error, "transaction", { recoverable: true });
+          throw error;
+        }
+        if (result.value === void 0 || result.value === null) {
+          const error = new DatabasePackageError(
+            "Transaction returned no value",
+            DATABASE_ERROR_CODES.INVALID_RESULT
+          );
+          this.emitDatabaseError(error, "transaction", { recoverable: false });
+          throw error;
+        }
+        return result.value;
+      }
+      /**
+       * Sets audit context for subsequent operations
+       *
+       * @param context - Audit context (userId, requestId, etc.)
+       */
+      async setAuditContext(context) {
+        const db = this.getDatabase();
+        await db.setAuditContext(context);
+      }
+      /**
+       * Performs a health check on the database connection
+       *
+       * @returns Health check result
+       */
+      async healthCheck() {
+        try {
+          const db = this.getDatabase();
+          const result = await db.healthCheck();
+          if (result.success && result.value) {
+            return {
+              isHealthy: result.value.isHealthy,
+              responseTime: result.value.responseTime
+            };
+          }
+          const errorMessage = result.error?.message ?? "Health check failed";
+          this.emitDatabaseError(
+            new DatabasePackageError(errorMessage, DATABASE_ERROR_CODES.CONNECTION_ERROR),
+            "healthCheck",
+            { recoverable: true }
+          );
+          return {
+            isHealthy: false,
+            error: errorMessage
+          };
+        } catch (error) {
+          this.emitDatabaseError(error, "healthCheck", { recoverable: true });
+          return {
+            isHealthy: false,
+            error: error instanceof Error ? error.message : "Unknown error"
+          };
+        }
+      }
+      /**
+       * Gets the table registry with all known tables and their ID columns
+       *
+       * @returns The complete table registry
+       */
+      static getTableRegistry() {
+        return TABLE_REGISTRY;
+      }
+      /**
+       * Gets ID column for a specific table
+       *
+       * @param tableName - Name of the table
+       * @returns ID column name or 'id' as default
+       */
+      static getTableIdColumn(tableName) {
+        return TABLE_REGISTRY[tableName]?.idColumn ?? "id";
+      }
+      /**
+       * Reinitializes the database connection with new config
+       *
+       * @param {DbServiceConfig} [config] - New configuration
+       * @returns {Promise<DbService>} The reinitialized DbService instance
+       */
+      static async reinitialize(config) {
+        const instance = _DbService.getInstance();
+        await instance.close();
+        instance.initialized = false;
+        return _DbService.initialize(config);
+      }
+      /**
+       * Closes the database connection and cleans up resources
+       */
+      async close() {
+        this.databaseService = null;
+        this.initialized = false;
+        this.config = null;
+      }
+      /**
+       * Gets the current configuration
+       *
+       * @returns {DbServiceConfig | null} Current config or null if not initialized
+       */
+      getConfig() {
+        return this.config;
+      }
+      /**
+       * Gets the current adapter type
+       *
+       * @returns The adapter type or null if not initialized
+       */
+      getAdapterType() {
+        return this.config?.adapter ?? null;
+      }
+      /**
+       * Creates a dedicated database service instance (NOT the singleton)
+       *
+       * Use this when you need an isolated database connection with its own configuration
+       * that doesn't affect or get affected by the shared singleton instance.
+       *
+       * @param config - Database service configuration
+       * @returns Promise that resolves to a new dedicated DbService instance
+       *
+       * @example
+       * ```typescript
+       * // Create a dedicated instance for analytics database
+       * const analyticsDb = await DbService.createInstance({
+       *   adapter: 'sql',
+       *   sql: { connectionString: process.env.ANALYTICS_DB_URL },
+       *   cache: { enabled: false }, // No caching for analytics
+       * });
+       *
+       * // This instance is independent from DbService.getInstance()
+       * const data = await analyticsDb.getDatabase().list('events');
+       *
+       * // Clean up when done
+       * await analyticsDb.close();
+       * ```
+       */
+      // eslint-disable-next-line complexity
+      static async createInstance(config) {
+        const dedicatedInstance = new _DbService();
+        const encryptionKey = config.encryption?.key;
+        const encryptionConfig = encryptionKey ? {
+          enabled: config.encryption?.enabled ?? true,
+          key: encryptionKey,
+          fields: config.encryption?.fields ?? DEFAULT_ENCRYPTION_FIELDS,
+          algorithm: config.encryption?.algorithm ?? "aes-256-gcm"
+        } : void 0;
+        const mergedConfig = {
+          ...DEFAULT_CONFIG,
+          ...config,
+          // Deep merge extensions
+          softDelete: { ...DEFAULT_CONFIG.softDelete, ...config.softDelete },
+          cache: { ...DEFAULT_CONFIG.cache, ...config.cache },
+          audit: { ...DEFAULT_CONFIG.audit, ...config.audit },
+          // Encryption only if key is available
+          encryption: encryptionConfig
+        };
+        dedicatedInstance.config = mergedConfig;
+        const dbConfig = dedicatedInstance.buildDatabaseConfig(mergedConfig);
+        dedicatedInstance.databaseService = await createDatabaseService(dbConfig);
+        if (mergedConfig.adapters) {
+          for (const [name, adapterConfig] of Object.entries(mergedConfig.adapters)) {
+            const namedDbConfig = dedicatedInstance.buildDatabaseConfig({
+              ...mergedConfig,
+              adapter: adapterConfig.adapter,
+              drizzle: adapterConfig.drizzle,
+              supabase: adapterConfig.supabase,
+              sql: adapterConfig.sql
+            });
+            const namedService = await createDatabaseService(namedDbConfig);
+            dedicatedInstance.namedAdapters.set(name, namedService);
+          }
+        }
+        dedicatedInstance.initialized = true;
+        return dedicatedInstance;
+      }
+    };
   }
-  /**
-   * Creates a dedicated database service instance (NOT the singleton)
-   *
-   * Use this when you need an isolated database connection with its own configuration
-   * that doesn't affect or get affected by the shared singleton instance.
-   *
-   * @param config - Database service configuration
-   * @returns Promise that resolves to a new dedicated DbService instance
-   *
-   * @example
-   * ```typescript
-   * // Create a dedicated instance for analytics database
-   * const analyticsDb = await DbService.createInstance({
-   *   adapter: 'sql',
-   *   sql: { connectionString: process.env.ANALYTICS_DB_URL },
-   *   cache: { enabled: false }, // No caching for analytics
-   * });
-   *
-   * // This instance is independent from DbService.getInstance()
-   * const data = await analyticsDb.getDatabase().list('events');
-   *
-   * // Clean up when done
-   * await analyticsDb.close();
-   * ```
-   */
-  // eslint-disable-next-line complexity
-  static async createInstance(config) {
-    const dedicatedInstance = new _DbService();
-    const encryptionKey = config.encryption?.key;
-    const encryptionConfig = encryptionKey ? {
-      enabled: config.encryption?.enabled ?? true,
-      key: encryptionKey,
-      fields: config.encryption?.fields ?? DEFAULT_ENCRYPTION_FIELDS,
-      algorithm: config.encryption?.algorithm ?? "aes-256-gcm"
-    } : void 0;
-    const mergedConfig = {
-      ...DEFAULT_CONFIG,
-      ...config,
-      // Deep merge extensions
-      softDelete: { ...DEFAULT_CONFIG.softDelete, ...config.softDelete },
-      cache: { ...DEFAULT_CONFIG.cache, ...config.cache },
-      audit: { ...DEFAULT_CONFIG.audit, ...config.audit },
-      // Encryption only if key is available
-      encryption: encryptionConfig
+});
+
+// src/services/StorageService.ts
+var StorageService_exports = {};
+__export(StorageService_exports, {
+  StorageService: () => StorageService
+});
+var StorageService;
+var init_StorageService = __esm({
+  "src/services/StorageService.ts"() {
+    init_CoreEventManager();
+    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_EVENTS$1.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;
+        }
+      }
+      /**
+       * 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;
+        instance.storageService = new StorageService$1(config);
+        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 StoragePackageError(
+            "Storage not initialized. Call StorageService.initialize() first or use Core.initialize() with storage config.",
+            STORAGE_ERROR_CODES.INITIALIZATION_FAILED
+          );
+        }
+        return this.storageService;
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // 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
+       */
+      getStorage() {
+        const self = this;
+        return new Proxy({}, {
+          get(_, prop) {
+            if (typeof prop === "symbol") {
+              return void 0;
+            }
+            const storage = self.getRawStorage();
+            const value = storage[prop];
+            if (typeof value !== "function") {
+              return value;
+            }
+            return (...args) => {
+              try {
+                const result = value.apply(storage, args);
+                if (result instanceof Promise) {
+                  return result.catch((error) => {
+                    self.emitStorageError(error, prop, { recoverable: true });
+                    throw error;
+                  });
+                }
+                return result;
+              } catch (error) {
+                self.emitStorageError(error, prop, { recoverable: true });
+                throw error;
+              }
+            };
+          }
+        });
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // 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.
+       */
+      async healthCheck() {
+        const startTime = Date.now();
+        try {
+          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 {
+            // 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
+       */
+      getConfig() {
+        return this.config;
+      }
+      /**
+       * Closes the storage service and cleans up resources
+       */
+      async close() {
+        if (this.storageService) {
+          await this.storageService.destroy();
+        }
+        this.storageService = null;
+        this.initialized = false;
+        this.config = null;
+      }
+      /**
+       * 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
+       */
+      static async createInstance(config) {
+        const dedicatedInstance = new _StorageService();
+        dedicatedInstance.config = config;
+        dedicatedInstance.storageService = new StorageService$1(config);
+        dedicatedInstance.initialized = true;
+        return dedicatedInstance;
+      }
     };
-    dedicatedInstance.config = mergedConfig;
-    const dbConfig = dedicatedInstance.buildDatabaseConfig(mergedConfig);
-    dedicatedInstance.databaseService = await createDatabaseService(dbConfig);
-    if (mergedConfig.adapters) {
-      for (const [name, adapterConfig] of Object.entries(mergedConfig.adapters)) {
-        const namedDbConfig = dedicatedInstance.buildDatabaseConfig({
-          ...mergedConfig,
-          adapter: adapterConfig.adapter,
-          drizzle: adapterConfig.drizzle,
-          supabase: adapterConfig.supabase,
-          sql: adapterConfig.sql
+  }
+});
+
+// src/services/NotificationService.ts
+var NotificationService_exports = {};
+__export(NotificationService_exports, {
+  NotificationService: () => NotificationService
+});
+var NotificationService;
+var init_NotificationService = __esm({
+  "src/services/NotificationService.ts"() {
+    init_CoreEventManager();
+    NotificationService = class _NotificationService {
+      constructor() {
+        this.notificationService = null;
+        this.config = null;
+        this.initialized = false;
+      }
+      static {
+        __name(this, "NotificationService");
+      }
+      static {
+        this.instance = null;
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // Error Handling
+      // ─────────────────────────────────────────────────────────────────
+      /**
+       * Emits a notification error event via CoreEventManager.
+       * Called when notification operations fail to integrate with global error handling.
+       */
+      emitNotificationError(error, operation, options) {
+        const payload = {
+          error,
+          operation,
+          recipientId: options?.recipientId,
+          channel: options?.channel,
+          recoverable: options?.recoverable ?? false
+        };
+        CoreEventManager.emit(CORE_EVENTS$1.NOTIFICATION.ERROR, payload);
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // Singleton Management
+      // ─────────────────────────────────────────────────────────────────
+      /**
+       * Gets the singleton instance of NotificationService
+       */
+      static getInstance() {
+        _NotificationService.instance ??= new _NotificationService();
+        return _NotificationService.instance;
+      }
+      /**
+       * Checks if the notification service has been initialized
+       */
+      static isInitialized() {
+        return _NotificationService.instance?.initialized ?? false;
+      }
+      /**
+       * Resets the notification service by clearing the singleton instance
+       */
+      static async reset() {
+        if (_NotificationService.instance) {
+          _NotificationService.instance.notificationService = null;
+          _NotificationService.instance.config = null;
+          _NotificationService.instance.initialized = false;
+          _NotificationService.instance = null;
+        }
+      }
+      /**
+       * Initializes the notification service
+       *
+       * @param config - Notification service configuration
+       * @returns The initialized NotificationService instance
+       */
+      static async initialize(config) {
+        const instance = _NotificationService.getInstance();
+        if (instance.initialized) {
+          return instance;
+        }
+        instance.config = config;
+        instance.notificationService = new NotificationService$1(config);
+        instance.initialized = true;
+        return instance;
+      }
+      /**
+       * 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 NotificationPackageError(
+            "Notifications not initialized. Call NotificationService.initialize() first or use Core.initialize() with notifications config.",
+            NOTIFICATION_ERROR_CODES.INITIALIZATION_FAILED
+          );
+        }
+        return this.notificationService;
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // Service Access
+      // ─────────────────────────────────────────────────────────────────
+      /**
+       * 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.
+       *
+       * @example
+       * ```typescript
+       * const notifications = NotificationService.getInstance().getNotifications();
+       * await notifications.sendEmail({ to: 'user@example.com', templateId: 'welcome' });
+       * await notifications.sendSMS({ to: '+1234567890', message: 'Hello!' });
+       * ```
+       *
+       * @returns NotificationServiceImpl with automatic error handling
+       */
+      getNotifications() {
+        const self = this;
+        return new Proxy({}, {
+          get(_, prop) {
+            if (typeof prop === "symbol") {
+              return void 0;
+            }
+            const notifications = self.getRawNotifications();
+            const value = notifications[prop];
+            if (typeof value !== "function") {
+              return value;
+            }
+            return (...args) => {
+              try {
+                const result = value.apply(notifications, args);
+                if (result instanceof Promise) {
+                  return result.catch((error) => {
+                    self.emitNotificationError(error, prop, { recoverable: true });
+                    throw error;
+                  });
+                }
+                return result;
+              } catch (error) {
+                self.emitNotificationError(error, prop, { recoverable: true });
+                throw error;
+              }
+            };
+          }
         });
-        const namedService = await createDatabaseService(namedDbConfig);
-        dedicatedInstance.namedAdapters.set(name, namedService);
       }
-    }
-    dedicatedInstance.initialized = true;
-    return dedicatedInstance;
+      // ─────────────────────────────────────────────────────────────────
+      // 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 result = await notifications.healthCheck();
+          return {
+            isHealthy: result.healthy,
+            providers: result.providers,
+            // Use optional chaining since error may not exist on all health check results
+            error: "error" in result ? result.error : void 0
+          };
+        } catch (error) {
+          this.emitNotificationError(error, "healthCheck", { recoverable: true });
+          return {
+            isHealthy: false,
+            error: error instanceof Error ? error.message : "Unknown error"
+          };
+        }
+      }
+      // ─────────────────────────────────────────────────────────────────
+      // Lifecycle
+      // ─────────────────────────────────────────────────────────────────
+      /**
+       * 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)
+       *
+       * Use this when you need an isolated notification service with its own configuration.
+       *
+       * @param config - Notification service configuration
+       * @returns Promise that resolves to a new dedicated NotificationService instance
+       */
+      static async createInstance(config) {
+        const dedicatedInstance = new _NotificationService();
+        dedicatedInstance.config = config;
+        dedicatedInstance.notificationService = new NotificationService$1(config);
+        dedicatedInstance.initialized = true;
+        return dedicatedInstance;
+      }
+    };
   }
-};
+});
+
+// src/init/CoreInitializer.ts
+init_DbService();
+
+// src/services/ApiClientService.ts
+init_CoreEventManager();
 var MIN_RETRY_ATTEMPTS_PRODUCTION = 3;
 function getConfigForEnvironment(env) {
   switch (env) {
@@ -1027,7 +1510,7 @@ var ApiClientService = class _ApiClientService {
                 requestId
               }
             };
-            CoreEventManager.emit(CORE_EVENTS$1.SYSTEM.ERROR, { errors: [serializedError] });
+            CoreEventManager.emit(CORE_EVENTS.SYSTEM.ERROR, { errors: [serializedError] });
           } else {
             const serializedErrors = errorDetails.map(
               (detail, index) => ({
@@ -1051,7 +1534,7 @@ var ApiClientService = class _ApiClientService {
                 }
               })
             );
-            CoreEventManager.emit(CORE_EVENTS$1.SYSTEM.ERROR, { errors: serializedErrors });
+            CoreEventManager.emit(CORE_EVENTS.SYSTEM.ERROR, { errors: serializedErrors });
           }
         } catch (e) {
           console.error("[ApiClientService] Failed to emit error event:", e);
@@ -1204,7 +1687,7 @@ var ApiClientService = class _ApiClientService {
       error,
       duration: options.duration
     };
-    CoreEventManager.emit(CORE_EVENTS$1.API.REQUEST_ERROR, payload);
+    CoreEventManager.emit(CORE_EVENTS.API.REQUEST_ERROR, payload);
     if (options.rethrow && error instanceof Error) {
       throw error;
     }
@@ -1897,567 +2380,175 @@ var CacheService = class _CacheService {
     this.cacheManager = null;
     /** Configuration used to initialize cache */
     this.config = null;
-    /** Logger instance */
-    this.logger = new CoreLogger({ service: "CacheService" });
-  }
-  static {
-    __name(this, "CacheService");
-  }
-  static {
-    /** Singleton instance */
-    this.instance = null;
-  }
-  /**
-   * Initialize the cache service with configuration
-   *
-   * @param config - Cache configuration
-   * @throws {CorePackageError} If already initialized or config is invalid
-   *
-   * @example
-   * ```typescript
-   * await CacheService.initialize({
-   *   strategy: 'redis',
-   *   isEnabled: true,
-   *   ttl: 300,
-   *   prefix: 'app',
-   *   redis: { url: process.env.REDIS_URL },
-   * });
-   * ```
-   */
-  static async initialize(config) {
-    if (this.instance?.cacheManager) {
-      throw new CorePackageError(
-        "CacheService is already initialized. Call reset() first if you need to reinitialize.",
-        ERROR_CODES$1.VALIDATION_ERROR
-      );
-    }
-    const service = this.instance ?? new _CacheService();
-    this.instance = service;
-    try {
-      service.logger.info("[CacheService] Initializing cache...", {
-        strategy: config.strategy,
-        isEnabled: config.isEnabled,
-        ttl: config.ttl
-      });
-      service.validateConfig(config);
-      const cacheConfig = {
-        ...config,
-        ttl: config.ttl ?? TIME_CONSTANTS.DEFAULT_CACHE_TTL
-      };
-      service.cacheManager = new CacheManager(cacheConfig);
-      service.config = config;
-      service.logger.info("[CacheService] Cache initialized successfully", {
-        strategy: config.strategy
-      });
-    } catch (error) {
-      service.logger.error("[CacheService] Failed to initialize cache", { error });
-      throw new CorePackageError(
-        `Failed to initialize cache: ${error instanceof Error ? error.message : String(error)}`,
-        ERROR_CODES$1.VALIDATION_ERROR,
-        { cause: error instanceof Error ? error : void 0 }
-      );
-    }
-  }
-  /**
-   * Get the singleton instance
-   *
-   * @throws {CorePackageError} If not initialized
-   * @returns CacheService singleton instance
-   *
-   * @example
-   * ```typescript
-   * const cacheService = CacheService.getInstance();
-   * const cache = cacheService.getCacheManager();
-   * ```
-   */
-  static getInstance() {
-    if (!this.instance) {
-      throw new CorePackageError(
-        "CacheService not initialized. Call CacheService.initialize() first.",
-        ERROR_CODES$1.CLIENT_INITIALIZATION_FAILED
-      );
-    }
-    return this.instance;
-  }
-  /**
-   * Get the cache manager instance
-   *
-   * @throws {CorePackageError} If cache not initialized
-   * @returns CacheManager instance
-   *
-   * @example
-   * ```typescript
-   * const cache = CacheService.getInstance().getCacheManager();
-   * await cache.set('user:123', userData);
-   * const user = await cache.get('user:123');
-   * ```
-   */
-  getCacheManager() {
-    if (!this.cacheManager) {
-      throw new CorePackageError(
-        "Cache manager not initialized. Call CacheService.initialize() first.",
-        ERROR_CODES$1.CLIENT_INITIALIZATION_FAILED
-      );
-    }
-    return this.cacheManager;
-  }
-  /**
-   * Get current cache configuration
-   *
-   * @returns Current cache configuration or null if not initialized
-   */
-  getConfig() {
-    return this.config;
-  }
-  /**
-   * Check if cache is initialized and enabled
-   *
-   * @returns True if cache is ready to use
-   */
-  isInitialized() {
-    return this.cacheManager !== null && (this.config?.isEnabled ?? false);
-  }
-  /**
-   * Reset the cache service (useful for testing)
-   *
-   * @internal
-   */
-  static reset() {
-    if (this.instance?.cacheManager) {
-      this.instance.logger.info("[CacheService] Resetting cache service");
-      this.instance.cacheManager.clear().catch((error) => {
-        this.instance?.logger.error("[CacheService] Error clearing cache during reset", { error });
-      });
-    }
-    this.instance = null;
-  }
-  /**
-   * Validate cache configuration
-   *
-   * @param config - Configuration to validate
-   * @throws {CorePackageError} If configuration is invalid
-   * @private
-   */
-  // eslint-disable-next-line complexity
-  validateConfig(config) {
-    if (!CACHE_STRATEGIES.includes(config.strategy)) {
-      throw new CorePackageError(
-        `Invalid cache strategy: ${config.strategy}. Must be one of: ${CACHE_STRATEGIES.join(", ")}`,
-        ERROR_CODES$1.VALIDATION_ERROR
-      );
-    }
-    if (config.ttl !== void 0 && (config.ttl < 0 || !Number.isFinite(config.ttl))) {
-      throw new CorePackageError(
-        `Invalid TTL value: ${config.ttl}. Must be a positive number.`,
-        ERROR_CODES$1.VALIDATION_ERROR
-      );
-    }
-    if (config.strategy === "redis") {
-      if (!config.redis?.url && !config.redis?.host) {
-        throw new CorePackageError(
-          "Redis strategy requires either redis.url or redis.host configuration",
-          ERROR_CODES$1.VALIDATION_ERROR
-        );
-      }
-    }
-    this.logger.debug("[CacheService] Configuration validated successfully");
-  }
-};
-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_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;
-    }
-  }
-  /**
-   * 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;
-    instance.storageService = new StorageService$1(config);
-    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 StoragePackageError(
-        "Storage not initialized. Call StorageService.initialize() first or use Core.initialize() with storage config.",
-        STORAGE_ERROR_CODES.INITIALIZATION_FAILED
-      );
-    }
-    return this.storageService;
-  }
-  // ─────────────────────────────────────────────────────────────────
-  // 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
-   */
-  getStorage() {
-    const self = this;
-    return new Proxy({}, {
-      get(_, prop) {
-        if (typeof prop === "symbol") {
-          return void 0;
-        }
-        const storage = self.getRawStorage();
-        const value = storage[prop];
-        if (typeof value !== "function") {
-          return value;
-        }
-        return (...args) => {
-          try {
-            const result = value.apply(storage, args);
-            if (result instanceof Promise) {
-              return result.catch((error) => {
-                self.emitStorageError(error, prop, { recoverable: true });
-                throw error;
-              });
-            }
-            return result;
-          } catch (error) {
-            self.emitStorageError(error, prop, { recoverable: true });
-            throw error;
-          }
-        };
-      }
-    });
-  }
-  // ─────────────────────────────────────────────────────────────────
-  // 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.
-   */
-  async healthCheck() {
-    const startTime = Date.now();
-    try {
-      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 {
-        // 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
-   */
-  getConfig() {
-    return this.config;
-  }
-  /**
-   * Closes the storage service and cleans up resources
-   */
-  async close() {
-    if (this.storageService) {
-      await this.storageService.destroy();
-    }
-    this.storageService = null;
-    this.initialized = false;
-    this.config = null;
-  }
-  /**
-   * 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
-   */
-  static async createInstance(config) {
-    const dedicatedInstance = new _StorageService();
-    dedicatedInstance.config = config;
-    dedicatedInstance.storageService = new StorageService$1(config);
-    dedicatedInstance.initialized = true;
-    return dedicatedInstance;
-  }
-};
-var NotificationService = class _NotificationService {
-  constructor() {
-    this.notificationService = null;
-    this.config = null;
-    this.initialized = false;
+    /** Logger instance */
+    this.logger = new CoreLogger({ service: "CacheService" });
   }
   static {
-    __name(this, "NotificationService");
+    __name(this, "CacheService");
   }
   static {
+    /** Singleton instance */
     this.instance = null;
   }
-  // ─────────────────────────────────────────────────────────────────
-  // Error Handling
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Emits a notification error event via CoreEventManager.
-   * Called when notification operations fail to integrate with global error handling.
-   */
-  emitNotificationError(error, operation, options) {
-    const payload = {
-      error,
-      operation,
-      recipientId: options?.recipientId,
-      channel: options?.channel,
-      recoverable: options?.recoverable ?? false
-    };
-    CoreEventManager.emit(CORE_EVENTS.NOTIFICATION.ERROR, payload);
-  }
-  // ─────────────────────────────────────────────────────────────────
-  // Singleton Management
-  // ─────────────────────────────────────────────────────────────────
-  /**
-   * Gets the singleton instance of NotificationService
-   */
-  static getInstance() {
-    _NotificationService.instance ??= new _NotificationService();
-    return _NotificationService.instance;
-  }
-  /**
-   * Checks if the notification service has been initialized
-   */
-  static isInitialized() {
-    return _NotificationService.instance?.initialized ?? false;
-  }
   /**
-   * Resets the notification service by clearing the singleton instance
-   */
-  static async reset() {
-    if (_NotificationService.instance) {
-      _NotificationService.instance.notificationService = null;
-      _NotificationService.instance.config = null;
-      _NotificationService.instance.initialized = false;
-      _NotificationService.instance = null;
-    }
-  }
-  /**
-   * Initializes the notification service
+   * Initialize the cache service with configuration
+   *
+   * @param config - Cache configuration
+   * @throws {CorePackageError} If already initialized or config is invalid
    *
-   * @param config - Notification service configuration
-   * @returns The initialized NotificationService instance
+   * @example
+   * ```typescript
+   * await CacheService.initialize({
+   *   strategy: 'redis',
+   *   isEnabled: true,
+   *   ttl: 300,
+   *   prefix: 'app',
+   *   redis: { url: process.env.REDIS_URL },
+   * });
+   * ```
    */
   static async initialize(config) {
-    const instance = _NotificationService.getInstance();
-    if (instance.initialized) {
-      return instance;
+    if (this.instance?.cacheManager) {
+      throw new CorePackageError(
+        "CacheService is already initialized. Call reset() first if you need to reinitialize.",
+        ERROR_CODES$1.VALIDATION_ERROR
+      );
+    }
+    const service = this.instance ?? new _CacheService();
+    this.instance = service;
+    try {
+      service.logger.info("[CacheService] Initializing cache...", {
+        strategy: config.strategy,
+        isEnabled: config.isEnabled,
+        ttl: config.ttl
+      });
+      service.validateConfig(config);
+      const cacheConfig = {
+        ...config,
+        ttl: config.ttl ?? TIME_CONSTANTS.DEFAULT_CACHE_TTL
+      };
+      service.cacheManager = new CacheManager(cacheConfig);
+      service.config = config;
+      service.logger.info("[CacheService] Cache initialized successfully", {
+        strategy: config.strategy
+      });
+    } catch (error) {
+      service.logger.error("[CacheService] Failed to initialize cache", { error });
+      throw new CorePackageError(
+        `Failed to initialize cache: ${error instanceof Error ? error.message : String(error)}`,
+        ERROR_CODES$1.VALIDATION_ERROR,
+        { cause: error instanceof Error ? error : void 0 }
+      );
     }
-    instance.config = config;
-    instance.notificationService = new NotificationService$1(config);
-    instance.initialized = true;
-    return instance;
   }
   /**
-   * Gets the raw underlying notification service instance without error handling wrapper.
-   * Use this only if you need direct access to the underlying service.
+   * Get the singleton instance
    *
-   * @returns The raw NotificationService instance from @plyaz/notifications
-   * @throws {NotificationsPackageError} When notifications is not initialized
+   * @throws {CorePackageError} If not initialized
+   * @returns CacheService singleton instance
+   *
+   * @example
+   * ```typescript
+   * const cacheService = CacheService.getInstance();
+   * const cache = cacheService.getCacheManager();
+   * ```
    */
-  getRawNotifications() {
-    if (!this.notificationService) {
-      throw new NotificationPackageError(
-        "Notifications not initialized. Call NotificationService.initialize() first or use Core.initialize() with notifications config.",
-        NOTIFICATION_ERROR_CODES.INITIALIZATION_FAILED
+  static getInstance() {
+    if (!this.instance) {
+      throw new CorePackageError(
+        "CacheService not initialized. Call CacheService.initialize() first.",
+        ERROR_CODES$1.CLIENT_INITIALIZATION_FAILED
       );
     }
-    return this.notificationService;
+    return this.instance;
   }
-  // ─────────────────────────────────────────────────────────────────
-  // Service Access
-  // ─────────────────────────────────────────────────────────────────
   /**
-   * 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.
+   * Get the cache manager instance
+   *
+   * @throws {CorePackageError} If cache not initialized
+   * @returns CacheManager instance
    *
    * @example
    * ```typescript
-   * const notifications = NotificationService.getInstance().getNotifications();
-   * await notifications.sendEmail({ to: 'user@example.com', templateId: 'welcome' });
-   * await notifications.sendSMS({ to: '+1234567890', message: 'Hello!' });
+   * const cache = CacheService.getInstance().getCacheManager();
+   * await cache.set('user:123', userData);
+   * const user = await cache.get('user:123');
    * ```
-   *
-   * @returns NotificationServiceImpl with automatic error handling
-   */
-  getNotifications() {
-    const self = this;
-    return new Proxy({}, {
-      get(_, prop) {
-        if (typeof prop === "symbol") {
-          return void 0;
-        }
-        const notifications = self.getRawNotifications();
-        const value = notifications[prop];
-        if (typeof value !== "function") {
-          return value;
-        }
-        return (...args) => {
-          try {
-            const result = value.apply(notifications, args);
-            if (result instanceof Promise) {
-              return result.catch((error) => {
-                self.emitNotificationError(error, prop, { recoverable: true });
-                throw error;
-              });
-            }
-            return result;
-          } catch (error) {
-            self.emitNotificationError(error, prop, { recoverable: true });
-            throw error;
-          }
-        };
-      }
-    });
-  }
-  // ─────────────────────────────────────────────────────────────────
-  // 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 result = await notifications.healthCheck();
-      return {
-        isHealthy: result.healthy,
-        providers: result.providers,
-        // Use optional chaining since error may not exist on all health check results
-        error: "error" in result ? result.error : void 0
-      };
-    } catch (error) {
-      this.emitNotificationError(error, "healthCheck", { recoverable: true });
-      return {
-        isHealthy: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
+  getCacheManager() {
+    if (!this.cacheManager) {
+      throw new CorePackageError(
+        "Cache manager not initialized. Call CacheService.initialize() first.",
+        ERROR_CODES$1.CLIENT_INITIALIZATION_FAILED
+      );
     }
+    return this.cacheManager;
   }
-  // ─────────────────────────────────────────────────────────────────
-  // Lifecycle
-  // ─────────────────────────────────────────────────────────────────
   /**
-   * Gets the current configuration
+   * Get current cache configuration
+   *
+   * @returns Current cache configuration or null if not initialized
    */
   getConfig() {
     return this.config;
   }
   /**
-   * Closes the notification service and cleans up resources
+   * Check if cache is initialized and enabled
+   *
+   * @returns True if cache is ready to use
    */
-  async close() {
-    this.notificationService = null;
-    this.initialized = false;
-    this.config = null;
+  isInitialized() {
+    return this.cacheManager !== null && (this.config?.isEnabled ?? false);
   }
   /**
-   * Creates a dedicated notification service instance (NOT the singleton)
+   * Reset the cache service (useful for testing)
    *
-   * Use this when you need an isolated notification service with its own configuration.
+   * @internal
+   */
+  static reset() {
+    if (this.instance?.cacheManager) {
+      this.instance.logger.info("[CacheService] Resetting cache service");
+      this.instance.cacheManager.clear().catch((error) => {
+        this.instance?.logger.error("[CacheService] Error clearing cache during reset", { error });
+      });
+    }
+    this.instance = null;
+  }
+  /**
+   * Validate cache configuration
    *
-   * @param config - Notification service configuration
-   * @returns Promise that resolves to a new dedicated NotificationService instance
+   * @param config - Configuration to validate
+   * @throws {CorePackageError} If configuration is invalid
+   * @private
    */
-  static async createInstance(config) {
-    const dedicatedInstance = new _NotificationService();
-    dedicatedInstance.config = config;
-    dedicatedInstance.notificationService = new NotificationService$1(config);
-    dedicatedInstance.initialized = true;
-    return dedicatedInstance;
+  // eslint-disable-next-line complexity
+  validateConfig(config) {
+    if (!CACHE_STRATEGIES.includes(config.strategy)) {
+      throw new CorePackageError(
+        `Invalid cache strategy: ${config.strategy}. Must be one of: ${CACHE_STRATEGIES.join(", ")}`,
+        ERROR_CODES$1.VALIDATION_ERROR
+      );
+    }
+    if (config.ttl !== void 0 && (config.ttl < 0 || !Number.isFinite(config.ttl))) {
+      throw new CorePackageError(
+        `Invalid TTL value: ${config.ttl}. Must be a positive number.`,
+        ERROR_CODES$1.VALIDATION_ERROR
+      );
+    }
+    if (config.strategy === "redis") {
+      if (!config.redis?.url && !config.redis?.host) {
+        throw new CorePackageError(
+          "Redis strategy requires either redis.url or redis.host configuration",
+          ERROR_CODES$1.VALIDATION_ERROR
+        );
+      }
+    }
+    this.logger.debug("[CacheService] Configuration validated successfully");
   }
 };
+
+// src/init/CoreInitializer.ts
+init_CoreEventManager();
 var BaseDomainService = class {
   // ─────────────────────────────────────────────────────────────────────────
   // Constructor
@@ -2856,6 +2947,9 @@ var BaseDomainService = class {
     );
   }
 };
+
+// src/domain/base/BaseFrontendDomainService.ts
+init_CoreEventManager();
 var BaseFrontendDomainService = class extends BaseDomainService {
   // ─────────────────────────────────────────────────────────────────────────
   // Constructor
@@ -3753,6 +3847,9 @@ var BaseFrontendDomainService = class extends BaseDomainService {
     );
   }
 };
+
+// src/events/index.ts
+init_CoreEventManager();
 var BaseBackendDomainService = class extends BaseDomainService {
   static {
     __name(this, "BaseBackendDomainService");
@@ -5106,6 +5203,10 @@ function trimString(str) {
   return str?.trim();
 }
 __name(trimString, "trimString");
+
+// src/models/example/ExampleRepository.ts
+init_DbService();
+init_common();
 var EXAMPLE_TABLE = "examples";
 var DEFAULT_PAGINATION_LIMIT = 100;
 var DUMMY_DATA = [
@@ -5283,31 +5384,99 @@ var ExampleRepository = class _ExampleRepository extends BaseRepository {
     return super.delete(id, config);
   }
   // ─────────────────────────────────────────────────────────────────────────
-  // Domain-Specific Query Methods
+  // Domain-Specific Query Methods (using QueryBuilder fluent API)
   // ─────────────────────────────────────────────────────────────────────────
   /**
-   * Find entities by status
+   * Find entities by status using fluent QueryBuilder
+   *
+   * @example
+   * ```typescript
+   * const result = await repo.findByStatus('active');
+   * ```
    */
   async findByStatus(status) {
-    return this.findMany({
-      filter: { field: "status", operator: "eq", value: status }
-    });
+    if (this.useDummyData) {
+      return this.findMany({
+        filter: { field: "status", operator: "eq", value: status }
+      });
+    }
+    return this.query().where("status", "eq", status).execute();
   }
   /**
-   * Find entities by owner
+   * Find entities by owner using fluent QueryBuilder
+   *
+   * @example
+   * ```typescript
+   * const result = await repo.findByOwner('user-001');
+   * ```
    */
   async findByOwner(ownerId) {
-    return this.findMany({
-      filter: { field: "owner_id", operator: "eq", value: ownerId }
-    });
+    if (this.useDummyData) {
+      return this.findMany({
+        filter: { field: "owner_id", operator: "eq", value: ownerId }
+      });
+    }
+    return this.query().where("owner_id", "eq", ownerId).execute();
   }
   /**
-   * Find visible entities only
+   * Find visible entities only using fluent QueryBuilder
+   *
+   * @example
+   * ```typescript
+   * const result = await repo.findVisible();
+   * ```
    */
   async findVisible() {
-    return this.findMany({
-      filter: { field: "is_visible", operator: "eq", value: true }
-    });
+    if (this.useDummyData) {
+      return this.findMany({
+        filter: { field: "is_visible", operator: "eq", value: true }
+      });
+    }
+    return this.query().where("is_visible", "eq", true).execute();
+  }
+  /**
+   * Find active and visible entities using complex QueryBuilder
+   *
+   * @example
+   * ```typescript
+   * const items = await repo.findActiveAndVisible();
+   * ```
+   */
+  async findActiveAndVisible() {
+    if (this.useDummyData) {
+      return this.dummyStore.filter((r) => r.status === "active" && r.is_visible && !r.deleted_at);
+    }
+    return this.query().where("status", "eq", "active").andWhere("is_visible", "eq", true).whereNull("deleted_at").orderByDesc("created_at").getMany();
+  }
+  /**
+   * Find entities by owner with status filter using QueryBuilder
+   *
+   * @example
+   * ```typescript
+   * const items = await repo.findByOwnerWithStatus('user-001', 'active');
+   * ```
+   */
+  async findByOwnerWithStatus(ownerId, status) {
+    if (this.useDummyData) {
+      return this.dummyStore.filter(
+        (r) => r.owner_id === ownerId && r.status === status && !r.deleted_at
+      );
+    }
+    return this.query().where("owner_id", "eq", ownerId).andWhere("status", "eq", status).orderByDesc("updated_at").getMany();
+  }
+  /**
+   * Count entities by status using QueryBuilder
+   *
+   * @example
+   * ```typescript
+   * const count = await repo.countByStatus('active');
+   * ```
+   */
+  async countByStatus(status) {
+    if (this.useDummyData) {
+      return this.dummyStore.filter((r) => r.status === status && !r.deleted_at).length;
+    }
+    return this.query().where("status", "eq", status).count();
   }
   /**
    * Check if entity exists by ID
@@ -5778,6 +5947,7 @@ var BackendExampleDomainService = class _BackendExampleDomainService extends Bas
   // ─────────────────────────────────────────────────────────────────────────
 };
 new BackendExampleDomainService();
+init_CoreEventManager();
 var DEFAULT_POLLING_INTERVAL_MS = 3e4;
 var FrontendExampleDomainService = class _FrontendExampleDomainService extends BaseFrontendDomainService {
   // ─────────────────────────────────────────────────────────────────────────
@@ -5827,6 +5997,7 @@ var FrontendExampleDomainService = class _FrontendExampleDomainService extends B
         //     store.setData(data);
         //     // Can also call domain-specific methods or other stores
         //     // store.selectItem(data.selectedId);
+        //     // store.selectItem(data.selectedId);
         //   },
         //   updateData: (store, data) => store.updateData(data),
         //   setLoading: (store, isLoading) => store.setLoading(isLoading),
@@ -6042,6 +6213,9 @@ var FrontendExampleDomainService = class _FrontendExampleDomainService extends B
   // All events are emitted automatically with 'example:' prefix!
   // ─────────────────────────────────────────────────────────────────────────
 };
+
+// src/base/observability/BaseAdapter.ts
+init_common();
 var BaseAdapter = class {
   constructor() {
     this._isInitialized = false;
@@ -6264,6 +6438,9 @@ var NoopAdapter = class extends BaseAdapter {
   async doFlush() {
   }
 };
+
+// src/base/observability/LoggerAdapter.ts
+init_common();
 var LoggerAdapter = class extends BaseAdapter {
   constructor() {
     super(...arguments);
@@ -6413,6 +6590,12 @@ var LoggerAdapter = class extends BaseAdapter {
   async doFlush() {
   }
 };
+
+// src/base/observability/CompositeAdapter.ts
+init_common();
+
+// src/base/observability/DatadogAdapter.ts
+init_common();
 var DEFAULT_ADAPTER_TIMEOUT_MS = 5e3;
 var ObservabilityService = class {
   constructor() {
@@ -7165,10 +7348,11 @@ var ServiceRegistry = class _ServiceRegistry {
     if (!dbConfig) {
       return void 0;
     }
+    const { DbService: DbService2 } = await Promise.resolve().then(() => (init_DbService(), DbService_exports));
     let dbInstance;
     if (isDedicated && dbConfig) {
       try {
-        dbInstance = await DbService.createInstance(dbConfig);
+        dbInstance = await DbService2.createInstance(dbConfig);
         _ServiceRegistry.logger.debug(
           `Created dedicated database instance for service '${serviceKey}'`
         );
@@ -7182,7 +7366,7 @@ var ServiceRegistry = class _ServiceRegistry {
       }
     } else {
       try {
-        dbInstance = DbService.getInstance();
+        dbInstance = DbService2.getInstance();
       } catch {
         _ServiceRegistry.logger.debug(
           `Global DB not initialized, service '${serviceKey}' will not have DB`
@@ -7283,10 +7467,11 @@ var ServiceRegistry = class _ServiceRegistry {
     if (!storageConfig) {
       return void 0;
     }
+    const { StorageService: StorageService2 } = await Promise.resolve().then(() => (init_StorageService(), StorageService_exports));
     let storageInstance;
     if (isDedicated && storageConfig) {
       try {
-        storageInstance = await StorageService.createInstance(storageConfig);
+        storageInstance = await StorageService2.createInstance(storageConfig);
         _ServiceRegistry.logger.debug(
           `Created dedicated storage instance for service '${serviceKey}'`
         );
@@ -7298,7 +7483,7 @@ var ServiceRegistry = class _ServiceRegistry {
       }
     } else {
       try {
-        storageInstance = StorageService.getInstance();
+        storageInstance = StorageService2.getInstance();
       } catch {
         _ServiceRegistry.logger.debug(
           `Global storage not initialized, service '${serviceKey}' will not have storage`
@@ -7328,10 +7513,11 @@ var ServiceRegistry = class _ServiceRegistry {
     if (!notificationsConfig) {
       return void 0;
     }
+    const { NotificationService: NotificationService2 } = await Promise.resolve().then(() => (init_NotificationService(), NotificationService_exports));
     let notificationsInstance;
     if (isDedicated && notificationsConfig) {
       try {
-        notificationsInstance = await NotificationService.createInstance(notificationsConfig);
+        notificationsInstance = await NotificationService2.createInstance(notificationsConfig);
         _ServiceRegistry.logger.debug(
           `Created dedicated notifications instance for service '${serviceKey}'`
         );
@@ -7343,7 +7529,7 @@ var ServiceRegistry = class _ServiceRegistry {
       }
     } else {
       try {
-        notificationsInstance = NotificationService.getInstance();
+        notificationsInstance = NotificationService2.getInstance();
       } catch {
         _ServiceRegistry.logger.debug(
           `Global notifications not initialized, service '${serviceKey}' will not have notifications`
@@ -7921,8 +8107,9 @@ var Core = class _Core {
     await _Core.initService(
       "storage",
       async () => {
-        await StorageService.initialize(storageConfig);
-        _Core._coreServices.storage = StorageService.getInstance();
+        const { StorageService: StorageService2 } = await Promise.resolve().then(() => (init_StorageService(), StorageService_exports));
+        await StorageService2.initialize(storageConfig);
+        _Core._coreServices.storage = StorageService2.getInstance();
         _Core.log("Storage service initialized", verbose);
       },
       verbose
@@ -7946,8 +8133,9 @@ var Core = class _Core {
     await _Core.initService(
       "notifications",
       async () => {
-        await NotificationService.initialize(notificationsConfig);
-        _Core._coreServices.notifications = NotificationService.getInstance();
+        const { NotificationService: NotificationService2 } = await Promise.resolve().then(() => (init_NotificationService(), NotificationService_exports));
+        await NotificationService2.initialize(notificationsConfig);
+        _Core._coreServices.notifications = NotificationService2.getInstance();
         _Core.log("Notifications service initialized", verbose);
       },
       verbose
@@ -8512,11 +8700,13 @@ var Core = class _Core {
     _Core._observabilityConfig = {};
     if (_Core._coreServices.storage) {
       await _Core._coreServices.storage.close();
-      await StorageService.reset();
+      const { StorageService: StorageService2 } = await Promise.resolve().then(() => (init_StorageService(), StorageService_exports));
+      await StorageService2.reset();
     }
     if (_Core._coreServices.notifications) {
       await _Core._coreServices.notifications.close();
-      await NotificationService.reset();
+      const { NotificationService: NotificationService2 } = await Promise.resolve().then(() => (init_NotificationService(), NotificationService_exports));
+      await NotificationService2.reset();
     }
     if (_Core._errorHandler) {
       _Core._errorHandler.destroy();
@@ -8567,20 +8757,19 @@ var Core = class _Core {
    */
   static shouldSkipDbService(skipDb, verbose) {
     if (skipDb === true) {
-      if (verbose) {
-        console.log("[Core] Database service skipped (skipDb: true)");
-      }
+      _Core.log("Database service skipped (skipDb: true)", verbose);
       return true;
     }
     const isFrontend = _Core.isFrontend;
     if (isFrontend) {
       if (skipDb === false) {
-        console.warn(
-          "[Core] Warning: DbService cannot be initialized on frontend runtime. DbService is backend-only and requires Node.js. Use API calls from frontend instead. Skipping database initialization."
+        _Core.logger.warn(
+          "DbService cannot be initialized on frontend runtime. DbService is backend-only and requires Node.js. Use API calls from frontend instead. Skipping database initialization."
         );
       } else if (verbose) {
-        console.log(
-          "[Core] Database service skipped (frontend runtime detected). DbService is only available on backend."
+        _Core.log(
+          "Database service skipped (frontend runtime detected). DbService is only available on backend.",
+          verbose
         );
       }
       return true;
@@ -8592,10 +8781,9 @@ var Core = class _Core {
    * Config validation is handled by DbService
    */
   static async initializeDb(config, verbose) {
-    if (verbose) {
-      console.log(`[Core] Initializing database with adapter: ${config?.adapter ?? "drizzle"}`);
-    }
-    return DbService.initialize({
+    _Core.log(`Initializing database with adapter: ${config?.adapter ?? "drizzle"}`, verbose);
+    const { DbService: DbService2 } = await Promise.resolve().then(() => (init_DbService(), DbService_exports));
+    return DbService2.initialize({
       adapter: "drizzle",
       ...config
     });
@@ -8607,9 +8795,7 @@ var Core = class _Core {
   static async initializeApi(config, globalEnvironment, verbose) {
     const { env: apiEnv, setAsDefault, ...apiClientOptions } = config ?? {};
     const resolvedEnv = apiEnv ?? globalEnvironment ?? "development";
-    if (verbose) {
-      console.log(`[Core] Initializing API client for environment: ${resolvedEnv}`);
-    }
+    _Core.log(`Initializing API client for environment: ${resolvedEnv}`, verbose);
     await ApiClientService.init(
       {
         env: resolvedEnv,
@@ -8623,9 +8809,7 @@ var Core = class _Core {
    * Config validation is handled by CacheService
    */
   static async initializeCache(config, verbose) {
-    if (verbose) {
-      console.log(`[Core] Initializing cache with strategy: ${config.strategy}`);
-    }
+    _Core.log(`Initializing cache with strategy: ${config.strategy}`, verbose);
     await CacheService.initialize(config);
   }
   /**
@@ -8633,9 +8817,7 @@ var Core = class _Core {
    * Always includes LoggerAdapter as failover for console output.
    */
   static async initializeObservability(config, verbose, environment) {
-    if (verbose) {
-      console.log(`[Core] Initializing observability with provider: ${config.provider ?? "auto"}`);
-    }
+    _Core.log(`Initializing observability with provider: ${config.provider ?? "auto"}`, verbose);
     const env = config.environment ?? environment ?? "development";
     _Core._observabilityConfig = { ...config, environment: env };
     const adapters = [];
@@ -8659,11 +8841,10 @@ var Core = class _Core {
       flushInterval: config.flushInterval,
       adapterTimeout: config.flushInterval
     });
-    if (verbose) {
-      console.log(
-        `[Core] ObservabilityService initialized with ${adapters.length} adapters (env: ${env})`
-      );
-    }
+    _Core.log(
+      `ObservabilityService initialized with ${adapters.length} adapters (env: ${env})`,
+      verbose
+    );
     _Core._coreServices.observability = observability;
     ServiceRegistry.setObservabilityInstance(observability);
   }
@@ -8674,10 +8855,10 @@ var Core = class _Core {
   static initializeRootStore(config, verbose) {
     const isFrontend = typeof window !== "undefined";
     if (isFrontend) {
-      if (verbose) console.log("[Core] Using frontend root store (Zustand)");
+      _Core.log("Using frontend root store (Zustand)", verbose);
       _Core._rootStore = useRootStore;
     } else {
-      if (verbose) console.log("[Core] Creating backend composite store (in-memory)");
+      _Core.log("Creating backend composite store (in-memory)", verbose);
       const backendErrorStore = ServerErrorMiddleware.createErrorStore({
         maxErrors: config?.maxErrors ?? DEFAULT_MAX_ERRORS,
         onErrorAdded: config?.onError
@@ -8725,11 +8906,11 @@ var Core = class _Core {
   // eslint-disable-next-line complexity
   static async initializeErrorHandler(config, verbose) {
     if (config?.enabled === false) {
-      if (verbose) console.log("[Core] Error handler disabled by configuration");
+      _Core.log("Error handler disabled by configuration", verbose);
       return;
     }
     _Core._errorConfig = config ?? {};
-    if (verbose) console.log("[Core] Initializing global error handler...");
+    _Core.log("Initializing global error handler...", verbose);
     initializeErrorSystem({
       defaultLocale: _Core._errorConfig.localization?.defaultLocale,
       fallbackLocale: _Core._errorConfig.localization?.fallbackLocale,
@@ -8744,23 +8925,22 @@ var Core = class _Core {
       _Core.buildErrorHandlerConfig(_Core._errorConfig)
     );
     const errorEventCleanup = CoreEventManager.on(
-      CORE_EVENTS.SYSTEM.ERROR,
+      CORE_EVENTS$1.SYSTEM.ERROR,
       (event) => {
         if (!_Core._rootStore) return;
         try {
           const { errors } = event.data;
           if (errors && errors.length > 0) {
             _Core._rootStore.getState().errors.addErrors(errors);
-            if (verbose) console.log(`[Core] Added ${errors.length} error(s) to store`);
+            _Core.log(`Added ${errors.length} error(s) to store`, verbose);
           }
         } catch (e) {
-          console.error("[Core] Failed to handle error event:", e);
+          _Core.logger.error("Failed to handle error event", { error: e });
         }
       }
     );
     _Core._eventCleanupFns.push(errorEventCleanup);
-    if (verbose)
-      console.log("[Core] Global error handler initialized with CoreEventManager integration");
+    _Core.log("Global error handler initialized with CoreEventManager integration", verbose);
     if (_Core._errorConfig.httpHandler !== false) {
       _Core.createHttpErrorHandler(_Core._errorConfig, verbose);
     }
@@ -8782,11 +8962,11 @@ var Core = class _Core {
     switch (runtime) {
       case "express":
         _Core._httpErrorHandler = ServerErrorMiddleware.createHttpErrorHandler(httpConfig);
-        if (verbose) console.log("[Core] Created Express error handler middleware");
+        _Core.log("Created Express error handler middleware", verbose);
         break;
       case "nestjs":
         _Core._httpErrorHandler = ServerErrorMiddleware.createNestJsExceptionFilter(httpConfig);
-        if (verbose) console.log("[Core] Created NestJS exception filter");
+        _Core.log("Created NestJS exception filter", verbose);
         break;
       case "nextjs":
         _Core._httpErrorHandler = {
@@ -8798,7 +8978,7 @@ var Core = class _Core {
           /** For Pages Router: export default createNextApiErrorHandler()(handler) */
           createNextApiErrorHandler: /* @__PURE__ */ __name((overrideConfig = {}) => ServerErrorMiddleware.createNextApiErrorHandler({ ...httpConfig, ...overrideConfig }), "createNextApiErrorHandler")
         };
-        if (verbose) console.log("[Core] Created Next.js error handlers");
+        _Core.log("Created Next.js error handlers", verbose);
         break;
       case "node":
       case "bun":
@@ -8815,15 +8995,15 @@ var Core = class _Core {
           /** Create middleware for use with native http */
           createMiddleware: /* @__PURE__ */ __name(() => ServerErrorMiddleware.createHttpErrorHandler(httpConfig), "createMiddleware")
         };
-        if (verbose) console.log(`[Core] Created ${runtime} error handler`);
+        _Core.log(`Created ${runtime} error handler`, verbose);
         break;
       case "browser":
         _Core._httpErrorHandler = null;
-        if (verbose) console.log("[Core] Skipping HTTP handler for browser runtime");
+        _Core.log("Skipping HTTP handler for browser runtime", verbose);
         break;
       default:
         _Core._httpErrorHandler = ServerErrorMiddleware.createHttpErrorHandler(httpConfig);
-        if (verbose) console.log(`[Core] Created generic HTTP error handler for ${runtime}`);
+        _Core.log(`Created generic HTTP error handler for ${runtime}`, verbose);
     }
   }
   /**
@@ -8837,38 +9017,36 @@ var Core = class _Core {
     if (!_Core._errorHandler) {
       return;
     }
-    if (verbose) {
-      console.log("[Core] Subscribing to error events...");
-    }
-    const cleanupSystemError = CoreEventManager.on(CORE_EVENTS.SYSTEM.ERROR, (event) => {
+    _Core.log("Subscribing to error events...", verbose);
+    const cleanupSystemError = CoreEventManager.on(CORE_EVENTS$1.SYSTEM.ERROR, (event) => {
       if (_Core._errorHandler && event.data?.errors?.length) {
         for (const err of event.data.errors) {
           _Core._errorHandler.captureError(err, "system");
         }
       }
     });
-    const cleanupEntityError = CoreEventManager.on(CORE_EVENTS.ENTITY.ERROR, (event) => {
+    const cleanupEntityError = CoreEventManager.on(CORE_EVENTS$1.ENTITY.ERROR, (event) => {
       if (_Core._errorHandler && event.data) {
         _Core._errorHandler.captureError(event.data.error, "entity");
       }
     });
-    const cleanupApiError = CoreEventManager.on(CORE_EVENTS.API.REQUEST_ERROR, (event) => {
+    const cleanupApiError = CoreEventManager.on(CORE_EVENTS$1.API.REQUEST_ERROR, (event) => {
       if (_Core._errorHandler && event.data) {
         _Core._errorHandler.captureError(event.data.error, "api");
       }
     });
-    const cleanupValidationError = CoreEventManager.on(CORE_EVENTS.VALIDATION.FAILED, (event) => {
+    const cleanupValidationError = CoreEventManager.on(CORE_EVENTS$1.VALIDATION.FAILED, (event) => {
       if (_Core._errorHandler && event.data) {
         _Core._errorHandler.captureError(event.data.error, "validation");
       }
     });
-    const cleanupAuthUnauthorized = CoreEventManager.on(CORE_EVENTS.AUTH.UNAUTHORIZED, (event) => {
+    const cleanupAuthUnauthorized = CoreEventManager.on(CORE_EVENTS$1.AUTH.UNAUTHORIZED, (event) => {
       if (_Core._errorHandler && event.data?.error) {
         _Core._errorHandler.captureError(event.data.error, "auth");
       }
     });
     const cleanupAuthSessionExpired = CoreEventManager.on(
-      CORE_EVENTS.AUTH.SESSION_EXPIRED,
+      CORE_EVENTS$1.AUTH.SESSION_EXPIRED,
       (event) => {
         if (_Core._errorHandler && event.data?.error) {
           _Core._errorHandler.captureError(event.data.error, "auth");
@@ -8884,20 +9062,20 @@ var Core = class _Core {
       cleanupAuthSessionExpired
     );
     if (_Core.isRuntimeCompatible("backend")) {
-      const cleanupDatabaseError = CoreEventManager.on(CORE_EVENTS.DATABASE.ERROR, (event) => {
+      const cleanupDatabaseError = CoreEventManager.on(CORE_EVENTS$1.DATABASE.ERROR, (event) => {
         if (_Core._errorHandler && event.data) {
           _Core._errorHandler.captureError(event.data.error, "database");
         }
       });
       _Core._eventCleanupFns.push(cleanupDatabaseError);
-      const cleanupStorageError = CoreEventManager.on(CORE_EVENTS.STORAGE.ERROR, (event) => {
+      const cleanupStorageError = CoreEventManager.on(CORE_EVENTS$1.STORAGE.ERROR, (event) => {
         if (_Core._errorHandler && event.data) {
           _Core._errorHandler.captureError(event.data.error, "storage");
         }
       });
       _Core._eventCleanupFns.push(cleanupStorageError);
       const cleanupNotificationError = CoreEventManager.on(
-        CORE_EVENTS.NOTIFICATION.ERROR,
+        CORE_EVENTS$1.NOTIFICATION.ERROR,
         (event) => {
           if (_Core._errorHandler && event.data) {
             _Core._errorHandler.captureError(event.data.error, "notification");
@@ -8905,21 +9083,17 @@ var Core = class _Core {
         }
       );
       _Core._eventCleanupFns.push(cleanupNotificationError);
-      if (verbose) {
-        console.log("[Core] Subscribed to backend error events (database, storage, notification)");
-      }
+      _Core.log("Subscribed to backend error events (database, storage, notification)", verbose);
     }
-    if (verbose) {
-      const eventTypes = ["system", "entity", "api", "validation", "auth"];
-      if (_Core.isRuntimeCompatible("backend")) {
-        eventTypes.push("database", "storage", "notification");
-      }
-      console.log(`[Core] Subscribed to error events: ${eventTypes.join(", ")}`);
+    const eventTypes = ["system", "entity", "api", "validation", "auth"];
+    if (_Core.isRuntimeCompatible("backend")) {
+      eventTypes.push("database", "storage", "notification");
     }
+    _Core.log(`Subscribed to error events: ${eventTypes.join(", ")}`, verbose);
   }
   /** Handle fetch flags error and return empty flags */
   static handleFetchFlagsError(error, config, verbose) {
-    if (verbose) console.error("[Core] Failed to fetch feature flags:", error);
+    if (verbose) _Core.logger.error("Failed to fetch feature flags", { error });
     const packageError = error instanceof BaseError ? error : new CorePackageError(
       error instanceof Error ? error.message : String(error),
       ERROR_CODES.CORE_FEATURE_FLAG_PROVIDER_ERROR,
@@ -8952,7 +9126,7 @@ var Core = class _Core {
    */
   static async initializeFeatureFlags(config, verbose) {
     if (config?.enabled === false) {
-      if (verbose) console.log("[Core] Feature flags disabled by configuration");
+      _Core.log("Feature flags disabled by configuration", verbose);
       return;
     }
     if (!_Core._rootStore) {
@@ -8962,7 +9136,7 @@ var Core = class _Core {
       );
     }
     _Core._flagConfig = config ?? {};
-    if (verbose) console.log("[Core] Initializing feature flags from root store...");
+    _Core.log("Initializing feature flags from root store...", verbose);
     const state = _Core._rootStore.getState();
     await state.featureFlags.initialize({
       defaults: _Core._flagConfig.defaults,
@@ -8971,11 +9145,12 @@ var Core = class _Core {
       onFlagChange: _Core._flagConfig.onFlagChange,
       onError: _Core._flagConfig.onError
     });
-    if (verbose) console.log("[Core] Feature flags initialized");
+    _Core.log("Feature flags initialized", verbose);
   }
 };
 
 // src/init/nestjs/CoreModule.ts
+init_DbService();
 var CORE_OPTIONS = Symbol("CORE_OPTIONS");
 var DB_SERVICE = Symbol("DB_SERVICE");
 var CoreModule = class _CoreModule {