@zintrust/core 0.1.28 → 0.1.30

package/src/config/features.js

@@ -0,0 +1,49 @@
+import { Env } from './env.js';
+import { Logger } from './logger.js';
+/**
+ * Feature Flags State
+ * Internal state managed by the module
+ */
+let _rawQueryEnabled = false;
+/**
+ * Feature Flags - Controls access to advanced/experimental features
+ * Sealed namespace for immutability
+ */
+export const FeatureFlags = Object.freeze({
+    /**
+     * Initialize all feature flags from environment
+     * Called once during application bootstrap
+     */
+    initialize() {
+        _rawQueryEnabled = Env.get('USE_RAW_QRY') === 'true';
+        if (_rawQueryEnabled) {
+            Logger.warn('⚠️  FEATURE FLAG ENABLED: Raw SQL Queries are now available via adapter.rawQuery()');
+            Logger.warn('⚠️  This bypasses QueryBuilder safety - use only when necessary');
+            Logger.warn('⚠️  Ensure parameters are properly bound to prevent SQL injection');
+        }
+        else {
+            Logger.info('🔒 Raw SQL Queries are DISABLED (default, recommended for production)');
+        }
+    },
+    /**
+     * Check if raw queries are enabled
+     * Returns cached flag value (no environment lookup)
+     */
+    isRawQueryEnabled() {
+        return _rawQueryEnabled;
+    },
+    /**
+     * Reset flags (primarily for testing)
+     */
+    reset() {
+        _rawQueryEnabled = false;
+    },
+    /**
+     * Set raw query enabled state
+     * Primarily for testing to avoid 'as any' type casting
+     */
+    setRawQueryEnabled(enabled) {
+        _rawQueryEnabled = enabled;
+    },
+});
+export default FeatureFlags;

package/src/config/index.d.ts

@@ -0,0 +1,241 @@
+/**
+ * Configuration Exports
+ * Central export point for all configuration
+ */
+export { appConfig, type AppConfig } from './app';
+export { default as broadcastConfig } from './broadcast';
+export { cacheConfig, type CacheConfig } from './cache';
+export { databaseConfig, type DatabaseConfig } from './database';
+export { microservicesConfig, type MicroservicesConfig } from './microservices';
+export { middlewareConfig } from './middleware';
+export { notificationConfig, type NotificationConfig } from './notification';
+export { queueConfig, type QueueConfig } from './queue';
+export { securityConfig } from './security';
+export { storageConfig, type StorageConfig } from './storage';
+export { createRedisConnection } from './workers';
+/**
+ * Combined configuration object
+ * Sealed namespace for immutability
+ */
+export declare const config: Readonly<{
+    readonly app: Readonly<{
+        readonly name: string;
+        readonly prefix: string;
+        readonly environment: import("./type").StartMode;
+        readonly port: number;
+        readonly host: string;
+        readonly isDevelopment: () => boolean;
+        readonly isProduction: () => boolean;
+        readonly isTesting: () => boolean;
+        readonly debug: boolean;
+        readonly timezone: string;
+        readonly requestTimeout: number;
+        readonly maxBodySize: number;
+        readonly getSafeEnv: () => NodeJS.ProcessEnv;
+        readonly detectRuntime: () => string;
+    }>;
+    readonly broadcast: {
+        default: string;
+        drivers: import("./type").BroadcastDrivers;
+        getDriverName: () => string;
+        getDriverConfig: (name?: string) => import("./type").KnownBroadcastDriverConfig;
+    };
+    readonly database: {
+        default: string;
+        connections: import("./type").DatabaseConnections;
+        getConnection: (this: import("./type").DatabaseConfigShape) => import("./type").DatabaseConnectionConfig;
+        logging: {
+            enabled: boolean;
+            level: string;
+        };
+        migrations: {
+            directory: string;
+            extension: string;
+        };
+        seeders: {
+            directory: string;
+        };
+    };
+    readonly storage: import("./type").StorageConfigRuntime & {
+        getDriver: (this: import("./type").StorageConfigRuntime) => import("./type").StorageDriverConfig;
+        getDriverConfig: (this: import("./type").StorageConfigRuntime, name?: string) => import("./type").StorageDriverConfig;
+        temp: {
+            path: string;
+            maxAge: number;
+        };
+        uploads: {
+            maxSize: string;
+            allowedMimes: string;
+            path: string;
+        };
+        backups: {
+            path: string;
+            driver: string;
+        };
+    };
+    readonly notification: {
+        default: string;
+        drivers: import("./type").NotificationDrivers;
+        providers: import("./type").NotificationProviders;
+        getDriverName: () => string;
+        getDriverConfig: (name?: string) => import("./type").KnownNotificationDriverConfig;
+    };
+    readonly security: Readonly<{
+        readonly jwt: {
+            readonly enabled: boolean;
+            readonly secret: string;
+            readonly algorithm: "HS256" | "HS512" | "RS256";
+            readonly expiresIn: number;
+            readonly refreshExpiresIn: string;
+            readonly issuer: string;
+            readonly audience: string;
+        };
+        readonly csrf: {
+            readonly enabled: boolean;
+            readonly headerName: string;
+            readonly tokenName: string;
+            readonly cookieName: string;
+            readonly cookieHttpOnly: boolean;
+            readonly cookieSecure: boolean;
+            readonly cookieSameSite: "strict" | "lax" | "none";
+        };
+        readonly encryption: {
+            readonly cipher: string;
+            readonly appKey: string;
+            readonly appPreviousKeys: string;
+            readonly algorithm: string;
+            readonly key: string;
+        };
+        readonly apiKey: {
+            readonly enabled: boolean;
+            readonly headerName: string;
+            readonly secret: string;
+        };
+        readonly cors: {
+            readonly enabled: boolean;
+            readonly origins: string[];
+            readonly methods: string[];
+            readonly allowedHeaders: string[];
+            readonly exposedHeaders: string[];
+            readonly credentials: boolean;
+            readonly maxAge: number;
+        };
+        readonly rateLimit: {
+            readonly enabled: boolean;
+            readonly windowMs: number;
+            readonly maxRequests: number;
+            readonly message: string;
+        };
+        readonly xss: {
+            readonly enabled: boolean;
+            readonly reportUri: string;
+        };
+        readonly helmet: {
+            readonly enabled: boolean;
+            readonly contentSecurityPolicy: boolean;
+            readonly hsts: {
+                readonly enabled: boolean;
+                readonly maxAge: number;
+                readonly includeSubDomains: boolean;
+            };
+        };
+        readonly session: {
+            readonly name: string;
+            readonly secret: string;
+            readonly expiresIn: number;
+            readonly secure: boolean;
+            readonly httpOnly: boolean;
+            readonly sameSite: "strict" | "lax" | "none";
+        };
+        readonly password: {
+            readonly minLength: number;
+            readonly requireUppercase: boolean;
+            readonly requireNumbers: boolean;
+            readonly requireSpecialChars: boolean;
+            readonly bcryptRounds: number;
+        };
+    }>;
+    readonly middleware: import("./type").MiddlewareConfigType;
+    readonly microservices: Readonly<{
+        readonly enabled: boolean;
+        readonly services: string[];
+        readonly discovery: {
+            readonly type: "filesystem" | "consul" | "etcd";
+            readonly servicesPath: string;
+            readonly refreshInterval: number;
+        };
+        readonly registry: {
+            readonly host: string;
+            readonly port: number;
+            readonly deregisterCriticalServiceAfter: string;
+        };
+        readonly auth: {
+            readonly strategy: "api-key" | "jwt" | "none" | "custom";
+            readonly apiKey: string;
+            readonly jwtSecret: string;
+        };
+        readonly tracing: {
+            readonly enabled: boolean;
+            readonly samplingRate: number;
+            readonly exportInterval: number;
+            readonly jaegerEndpoint: string;
+        };
+        readonly database: {
+            readonly isolation: "shared" | "isolated";
+            readonly schema: string;
+        };
+        readonly healthCheck: {
+            readonly enabled: boolean;
+            readonly interval: number;
+            readonly timeout: number;
+            readonly unhealthyThreshold: number;
+            readonly healthyThreshold: number;
+        };
+        readonly communication: {
+            readonly timeout: number;
+            readonly retries: number;
+            readonly retryDelay: number;
+            readonly circuitBreaker: {
+                readonly enabled: boolean;
+                readonly threshold: number;
+                readonly timeout: number;
+            };
+        };
+        readonly mesh: {
+            readonly enabled: boolean;
+            readonly type: "istio" | "linkerd";
+            readonly namespace: string;
+        };
+    }>;
+    readonly cache: {
+        default: string;
+        drivers: import("./type").CacheConfigInput["drivers"];
+        getDriver: (name?: string) => import("./type").CacheDriverConfig;
+        keyPrefix: string;
+        ttl: number;
+    };
+    readonly queue: {
+        default: import("./type").QueueDriverName;
+        drivers: import("./type").QueueDriversConfig;
+        getDriver: (this: import("./type").QueueConfigWithDrivers) => import("./type").QueueDriversConfig[import("./type").QueueDriverName];
+        failed: {
+            database: string;
+            table: string;
+        };
+        processing: {
+            timeout: number;
+            retries: number;
+            backoff: number;
+            workers: number;
+        };
+        monitor: {
+            enabled: boolean;
+            basePath: string;
+            middleware: ReadonlyArray<string>;
+            autoRefresh: boolean;
+            refreshIntervalMs: number;
+        };
+    };
+}>;
+export type Config = typeof config;
+//# sourceMappingURL=index.d.ts.map

package/src/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAaH,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AACnF,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;8BAZc,CAAC;;;;;;;;;;;;;;;;;;;;2EAAC,CAAA;;;;;;;;;;;;;;;;;;;;8BAD2B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAmBrD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;EAKA,CAAC;AAEZ,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC"}

package/src/config/index.js

@@ -0,0 +1,41 @@
+/**
+ * Configuration Exports
+ * Central export point for all configuration
+ */
+import { appConfig } from './app.js';
+import broadcastConfig from './broadcast.js';
+import { cacheConfig } from './cache.js';
+import { databaseConfig } from './database.js';
+import { microservicesConfig } from './microservices.js';
+import { middlewareConfig } from './middleware.js';
+import notificationConfig from './notification.js';
+import { queueConfig } from './queue.js';
+import { securityConfig } from './security.js';
+import { storageConfig } from './storage.js';
+export { appConfig } from './app.js';
+export { default as broadcastConfig } from './broadcast.js';
+export { cacheConfig } from './cache.js';
+export { databaseConfig } from './database.js';
+export { microservicesConfig } from './microservices.js';
+export { middlewareConfig } from './middleware.js';
+export { notificationConfig } from './notification.js';
+export { queueConfig } from './queue.js';
+export { securityConfig } from './security.js';
+export { storageConfig } from './storage.js';
+export { createRedisConnection } from './workers.js';
+/**
+ * Combined configuration object
+ * Sealed namespace for immutability
+ */
+export const config = Object.freeze({
+    app: appConfig,
+    broadcast: broadcastConfig,
+    database: databaseConfig,
+    storage: storageConfig,
+    notification: notificationConfig,
+    security: securityConfig,
+    middleware: middlewareConfig,
+    microservices: microservicesConfig,
+    cache: cacheConfig,
+    queue: queueConfig,
+});

package/src/config/logger.d.ts

@@ -0,0 +1,19 @@
+interface ILogger {
+    debug(message: string, data?: unknown, category?: string): void;
+    info(message: string, data?: unknown, category?: string): void;
+    warn(message: string, data?: unknown, category?: string): void;
+    error(message: string, error?: unknown, category?: string): void;
+    fatal(message: string, error?: unknown, category?: string): void;
+}
+export declare const cleanLogsOnce: () => Promise<string[]>;
+export declare const Logger: Readonly<{
+    debug: (message: string, data?: unknown, category?: string) => void;
+    info: (message: string, data?: unknown, category?: string) => void;
+    warn: (message: string, data?: unknown, category?: string) => void;
+    error: (message: string, error?: unknown, category?: string) => void;
+    fatal: (message: string, error?: unknown, category?: string) => void;
+    cleanLogsOnce: () => Promise<string[]>;
+    scope: (scope: string) => ILogger;
+}>;
+export default Logger;
+//# sourceMappingURL=logger.d.ts.map

package/src/config/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/config/logger.ts"],"names":[],"mappings":"AAQA,UAAU,OAAO;IACf,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClE;AA4VD,eAAO,MAAM,aAAa,QAAa,OAAO,CAAC,MAAM,EAAE,CAYtD,CAAC;AAEF,eAAO,MAAM,MAAM;qBAzJQ,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;oBAsBjD,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;oBAoBhD,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;qBAoB/C,MAAM,UAAU,OAAO,aAAa,MAAM,KAAG,IAAI;qBA0BjD,MAAM,UAAU,OAAO,aAAa,MAAM,KAAG,IAAI;yBAmDrC,OAAO,CAAC,MAAM,EAAE,CAAC;mBArBtB,MAAM,KAAG,OAAO;EA2ChD,CAAC;AAEH,eAAe,MAAM,CAAC"}

package/src/config/logger.js

@@ -0,0 +1,338 @@
+/**
+ * Logger utility - Central logging configuration
+ * Sealed namespace pattern - all exports through Logger namespace
+ * Replaces console.* calls throughout the codebase
+ */
+import { appConfig } from './app.js';
+import { Env } from './env.js';
+const isDevelopment = () => appConfig.isDevelopment();
+const isProduction = () => appConfig.isProduction();
+const getLogFormat = () => Env.get('LOG_FORMAT', 'text');
+const isJsonFormat = (value) => value === 'json';
+const SENSITIVE_FIELDS = new Set([
+    'password',
+    'token',
+    'authorization',
+    'secret',
+    'apikey',
+    'api_key',
+    'jwt',
+    'bearer',
+]);
+const redactSensitiveData = (data) => {
+    const seen = new WeakSet();
+    const walk = (value) => {
+        if (Array.isArray(value)) {
+            if (seen.has(value))
+                return '[Circular]';
+            seen.add(value);
+            return value.map((v) => walk(v));
+        }
+        if (typeof value === 'object' && value !== null) {
+            const asObj = value;
+            if (seen.has(asObj))
+                return '[Circular]';
+            seen.add(asObj);
+            const out = {};
+            for (const [key, inner] of Object.entries(asObj)) {
+                if (SENSITIVE_FIELDS.has(key.toLowerCase())) {
+                    out[key] = '[REDACTED]';
+                }
+                else {
+                    out[key] = walk(inner);
+                }
+            }
+            return out;
+        }
+        return value;
+    };
+    return walk(data);
+};
+const safeStringify = (obj, indent = false) => {
+    const seen = new WeakSet();
+    return JSON.stringify(obj, (_key, value) => {
+        if (typeof value === 'object' && value !== null) {
+            const asObj = value;
+            if (seen.has(asObj))
+                return '[Circular]';
+            seen.add(asObj);
+        }
+        return value;
+    }, indent ? 2 : 0);
+};
+let fileWriterPromise;
+let fileWriter;
+const getFileWriter = () => {
+    if (fileWriter !== undefined)
+        return;
+    if (fileWriterPromise !== undefined)
+        return;
+    fileWriterPromise = import('./FileLogWriter.js')
+        .then((mod) => {
+        fileWriter = mod.FileLogWriter;
+        return mod;
+    })
+        .catch(() => {
+        fileWriterPromise = undefined;
+        return { FileLogWriter: { write: (_line) => undefined } };
+    });
+};
+const shouldLogToFile = () => {
+    // Prefer dynamic lookup so late-bound env (tests, some runtimes) is respected.
+    const channel = Env.get('LOG_CHANNEL', '').trim().toLowerCase();
+    const channelWantsFile = channel === 'file' || channel === 'all';
+    if (!Env.getBool('LOG_TO_FILE', false) && !channelWantsFile)
+        return false;
+    if (typeof process === 'undefined')
+        return false;
+    return true;
+};
+const buildFileLine = (params) => {
+    if (isJsonFormat(getLogFormat()))
+        return params.formatted;
+    let line = params.formatted;
+    if (typeof params.errorMessage === 'string' && params.errorMessage.length > 0) {
+        line = `${line} ${params.errorMessage}`;
+    }
+    else if (params.data !== undefined && params.data !== '') {
+        line = `${line} ${safeStringify(redactSensitiveData(params.data))}`;
+    }
+    return line;
+};
+const writeToFile = (line) => {
+    if (!shouldLogToFile())
+        return;
+    if (fileWriter !== undefined) {
+        fileWriter.write(line);
+        return;
+    }
+    getFileWriter();
+    fileWriterPromise?.then((mod) => mod.FileLogWriter.write(line));
+};
+const formatLogMessage = (params) => {
+    if (isJsonFormat(getLogFormat())) {
+        return safeStringify({
+            timestamp: new Date().toISOString(),
+            level: params.level,
+            message: params.message,
+            category: params.category,
+            data: redactSensitiveData(params.data),
+            error: params.errorMessage,
+        });
+    }
+    // text format
+    return `[${params.level.toUpperCase()}] ${params.message}`;
+};
+/**
+ * Helper to extract error message from unknown error type
+ */
+const getErrorMessage = (error) => {
+    if (error === undefined) {
+        return '';
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string')
+        return error;
+    if (typeof error === 'number' || typeof error === 'bigint')
+        return error.toString();
+    if (typeof error === 'boolean')
+        return error ? 'true' : 'false';
+    if (typeof error === 'symbol')
+        return error.toString();
+    if (typeof error === 'function')
+        return '[Function]';
+    try {
+        return safeStringify(error);
+    }
+    catch {
+        return '[Unserializable error]';
+    }
+};
+const emitCloudLogs = (event) => {
+    // Lazy-load to avoid cycles and avoid cost when disabled.
+    void (async () => {
+        try {
+            if (event.level === 'error' || event.level === 'fatal') {
+                const mod = await import('./logging/KvLogger.js');
+                void mod.KvLogger.enqueue(event);
+            }
+        }
+        catch {
+            // best-effort
+        }
+        try {
+            if (event.level === 'warn' || event.level === 'error' || event.level === 'fatal') {
+                const mod = await import('./logging/SlackLogger.js');
+                void mod.SlackLogger.enqueue(event);
+            }
+        }
+        catch {
+            // best-effort
+        }
+        try {
+            const mod = await import('./logging/HttpLogger.js');
+            void mod.HttpLogger.enqueue(event);
+        }
+        catch {
+            // best-effort
+        }
+    })();
+};
+// Private helper functions
+const logDebug = (message, data, category) => {
+    String(category);
+    if (isDevelopment()) {
+        const timestamp = new Date().toISOString();
+        const out = formatLogMessage({ level: 'debug', message, data, category });
+        writeToFile(buildFileLine({ formatted: out, data }));
+        if (isJsonFormat(getLogFormat())) {
+            console.debug(out); // eslint-disable-line no-console
+            return;
+        }
+        console.debug(out, data ?? ''); // eslint-disable-line no-console
+        emitCloudLogs({
+            timestamp,
+            level: 'debug',
+            message,
+            category,
+            data: redactSensitiveData(data),
+        });
+    }
+};
+const logInfo = (message, data, category) => {
+    String(category);
+    const timestamp = new Date().toISOString();
+    const out = formatLogMessage({ level: 'info', message, data, category });
+    writeToFile(buildFileLine({ formatted: out, data }));
+    if (isJsonFormat(getLogFormat())) {
+        console.log(out); // eslint-disable-line no-console
+    }
+    else {
+        console.log(out, data ?? ''); // eslint-disable-line no-console
+    }
+    emitCloudLogs({
+        timestamp,
+        level: 'info',
+        message,
+        category,
+        data: redactSensitiveData(data),
+    });
+};
+const logWarn = (message, data, category) => {
+    String(category);
+    const timestamp = new Date().toISOString();
+    const out = formatLogMessage({ level: 'warn', message, data, category });
+    writeToFile(buildFileLine({ formatted: out, data }));
+    if (isJsonFormat(getLogFormat())) {
+        console.warn(out); // eslint-disable-line no-console
+    }
+    else {
+        console.warn(out, data ?? ''); // eslint-disable-line no-console
+    }
+    emitCloudLogs({
+        timestamp,
+        level: 'warn',
+        message,
+        category,
+        data: redactSensitiveData(data),
+    });
+};
+const logError = (message, error, category) => {
+    const errorMessage = getErrorMessage(error);
+    String(category);
+    const timestamp = new Date().toISOString();
+    const out = formatLogMessage({
+        level: 'error',
+        message,
+        category,
+        errorMessage,
+    });
+    writeToFile(buildFileLine({ formatted: out, errorMessage }));
+    if (isJsonFormat(getLogFormat())) {
+        console.error(out); // eslint-disable-line no-console
+    }
+    else {
+        console.error(out, errorMessage); // eslint-disable-line no-console
+    }
+    emitCloudLogs({
+        timestamp,
+        level: 'error',
+        message,
+        category,
+        error: errorMessage,
+    });
+};
+const logFatal = (message, error, category) => {
+    const errorMessage = getErrorMessage(error);
+    String(category);
+    const timestamp = new Date().toISOString();
+    const out = formatLogMessage({
+        level: 'fatal',
+        message,
+        category,
+        errorMessage,
+    });
+    writeToFile(buildFileLine({ formatted: out, errorMessage }));
+    if (isJsonFormat(getLogFormat())) {
+        console.error(out); // eslint-disable-line no-console
+    }
+    else {
+        console.error(out, errorMessage); // eslint-disable-line no-console
+    }
+    emitCloudLogs({
+        timestamp,
+        level: 'fatal',
+        message,
+        category,
+        error: errorMessage,
+    });
+    if (isProduction() && typeof process !== 'undefined') {
+        process.exit(1);
+    }
+};
+const createLoggerScope = (scope) => {
+    return {
+        debug(message, data) {
+            logDebug(`[${scope}] ${message}`, data, scope);
+        },
+        info(message, data) {
+            logInfo(`[${scope}] ${message}`, data, scope);
+        },
+        warn(message, data) {
+            logWarn(`[${scope}] ${message}`, data, scope);
+        },
+        error(message, error) {
+            logError(`[${scope}] ${message}`, error, scope);
+        },
+        fatal(message, error) {
+            logFatal(`[${scope}] ${message}`, error, scope);
+        },
+    };
+};
+// Expose log cleanup API and sealed namespace with all logger functionality
+export const cleanLogsOnce = async () => {
+    if (!shouldLogToFile())
+        return [];
+    try {
+        const mod = await import('./FileLogWriter.js');
+        const deleted = mod.cleanOnce();
+        logInfo('Log cleanup executed', { deletedCount: deleted.length });
+        return deleted;
+    }
+    catch (err) {
+        logError('Log cleanup failed', err);
+        return [];
+    }
+};
+export const Logger = Object.freeze({
+    debug: logDebug,
+    info: logInfo,
+    warn: logWarn,
+    error: logError,
+    fatal: logFatal,
+    cleanLogsOnce,
+    scope: createLoggerScope,
+});
+export default Logger;