@zintrust/core 0.1.27 → 0.1.28

package/src/config/features.js

@@ -1,49 +0,0 @@
-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

@@ -1,241 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,41 +0,0 @@
-/**
- * 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

@@ -1,19 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,338 +0,0 @@
-/**
- * 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;