@open-core/framework 0.1.0-alpha.1 → 0.2.0-beta.1

package/dist/{shared → kernel/shared}/logger/index.js

@@ -1,26 +1,35 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BufferedTransport = exports.ConsoleTransport = exports.loggers = exports.coreLogger = exports.ChildLogger = exports.LoggerService = exports.DEFAULT_LOGGER_CONFIG = exports.createLoggerConfig = exports.parseLogLevel = exports.LogDomainLabels = exports.LogDomain = exports.LogLevelLabels = exports.LogLevel = void 0;
 // Types
-var logger_types_1 = require("./logger.types");
-Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_types_1.LogLevel; } });
-Object.defineProperty(exports, "LogLevelLabels", { enumerable: true, get: function () { return logger_types_1.LogLevelLabels; } });
-Object.defineProperty(exports, "LogDomain", { enumerable: true, get: function () { return logger_types_1.LogDomain; } });
-Object.defineProperty(exports, "LogDomainLabels", { enumerable: true, get: function () { return logger_types_1.LogDomainLabels; } });
-Object.defineProperty(exports, "parseLogLevel", { enumerable: true, get: function () { return logger_types_1.parseLogLevel; } });
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleConsoleTransport = exports.ConsoleTransport = exports.BufferedTransport = exports.parseLogLevel = exports.LogLevelLabels = exports.LogLevel = exports.LogDomainLabels = exports.LogDomain = exports.LoggerService = exports.ChildLogger = exports.isServerEnvironment = exports.isFiveMEnvironment = exports.isDebugMode = exports.isClientEnvironment = exports.getLogLevel = exports.DEFAULT_LOGGER_CONFIG = exports.createLoggerConfig = exports.loggers = exports.coreLogger = void 0;
+// Core Logger (internal framework use)
+var core_logger_1 = require("./core-logger");
+Object.defineProperty(exports, "coreLogger", { enumerable: true, get: function () { return core_logger_1.coreLogger; } });
+Object.defineProperty(exports, "loggers", { enumerable: true, get: function () { return core_logger_1.loggers; } });
 // Config
 var logger_config_1 = require("./logger.config");
 Object.defineProperty(exports, "createLoggerConfig", { enumerable: true, get: function () { return logger_config_1.createLoggerConfig; } });
 Object.defineProperty(exports, "DEFAULT_LOGGER_CONFIG", { enumerable: true, get: function () { return logger_config_1.DEFAULT_LOGGER_CONFIG; } });
+// Environment utilities
+var logger_env_1 = require("./logger.env");
+Object.defineProperty(exports, "getLogLevel", { enumerable: true, get: function () { return logger_env_1.getLogLevel; } });
+Object.defineProperty(exports, "isClientEnvironment", { enumerable: true, get: function () { return logger_env_1.isClientEnvironment; } });
+Object.defineProperty(exports, "isDebugMode", { enumerable: true, get: function () { return logger_env_1.isDebugMode; } });
+Object.defineProperty(exports, "isFiveMEnvironment", { enumerable: true, get: function () { return logger_env_1.isFiveMEnvironment; } });
+Object.defineProperty(exports, "isServerEnvironment", { enumerable: true, get: function () { return logger_env_1.isServerEnvironment; } });
 // Service
 var logger_service_1 = require("./logger.service");
-Object.defineProperty(exports, "LoggerService", { enumerable: true, get: function () { return logger_service_1.LoggerService; } });
 Object.defineProperty(exports, "ChildLogger", { enumerable: true, get: function () { return logger_service_1.ChildLogger; } });
-// Core Logger (internal framework use)
-var core_logger_1 = require("./core-logger");
-Object.defineProperty(exports, "coreLogger", { enumerable: true, get: function () { return core_logger_1.coreLogger; } });
-Object.defineProperty(exports, "loggers", { enumerable: true, get: function () { return core_logger_1.loggers; } });
-var console_transport_1 = require("./transports/console.transport");
-Object.defineProperty(exports, "ConsoleTransport", { enumerable: true, get: function () { return console_transport_1.ConsoleTransport; } });
+Object.defineProperty(exports, "LoggerService", { enumerable: true, get: function () { return logger_service_1.LoggerService; } });
+var logger_types_1 = require("./logger.types");
+Object.defineProperty(exports, "LogDomain", { enumerable: true, get: function () { return logger_types_1.LogDomain; } });
+Object.defineProperty(exports, "LogDomainLabels", { enumerable: true, get: function () { return logger_types_1.LogDomainLabels; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_types_1.LogLevel; } });
+Object.defineProperty(exports, "LogLevelLabels", { enumerable: true, get: function () { return logger_types_1.LogLevelLabels; } });
+Object.defineProperty(exports, "parseLogLevel", { enumerable: true, get: function () { return logger_types_1.parseLogLevel; } });
 var buffered_transport_1 = require("./transports/buffered.transport");
 Object.defineProperty(exports, "BufferedTransport", { enumerable: true, get: function () { return buffered_transport_1.BufferedTransport; } });
+var console_transport_1 = require("./transports/console.transport");
+Object.defineProperty(exports, "ConsoleTransport", { enumerable: true, get: function () { return console_transport_1.ConsoleTransport; } });
+var simple_console_transport_1 = require("./transports/simple-console.transport");
+Object.defineProperty(exports, "SimpleConsoleTransport", { enumerable: true, get: function () { return simple_console_transport_1.SimpleConsoleTransport; } });

package/dist/{shared → kernel/shared}/logger/logger.config.d.ts

@@ -1,5 +1,5 @@
 import { LogDomain, LogLevel } from './logger.types';
-import type { LogTransport } from './transports/transport.interface';
+import { LogTransport } from './transports/transport.interface';
 /**
  * Global configuration options for the LoggerService.
  */

package/dist/kernel/shared/logger/logger.env.d.ts

@@ -0,0 +1,28 @@
+import { LogLevel } from './logger.types';
+/**
+ * Detects if we're running in a FiveM client environment.
+ * Client has GetPlayerPed but not GetNumPlayerIndices (server-only native).
+ */
+export declare function isClientEnvironment(): boolean;
+/**
+ * Detects if we're running in a FiveM server environment.
+ */
+export declare function isServerEnvironment(): boolean;
+/**
+ * Detects if we're running in a FiveM environment (client or server).
+ */
+export declare function isFiveMEnvironment(): boolean;
+/**
+ * Gets the configured log level.
+ *
+ * The log level is determined at build-time from opencore.config.ts via the CLI.
+ * If not configured, defaults to INFO.
+ *
+ * @returns The configured LogLevel
+ */
+export declare function getLogLevel(): LogLevel;
+/**
+ * Checks if debug mode is enabled based on log level.
+ * Debug mode is enabled when log level is DEBUG or TRACE.
+ */
+export declare function isDebugMode(): boolean;

package/dist/kernel/shared/logger/logger.env.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClientEnvironment = isClientEnvironment;
+exports.isServerEnvironment = isServerEnvironment;
+exports.isFiveMEnvironment = isFiveMEnvironment;
+exports.getLogLevel = getLogLevel;
+exports.isDebugMode = isDebugMode;
+const logger_types_1 = require("./logger.types");
+/**
+ * Detects if we're running in a FiveM client environment.
+ * Client has GetPlayerPed but not GetNumPlayerIndices (server-only native).
+ */
+function isClientEnvironment() {
+    if (typeof __OPENCORE_TARGET__ !== 'undefined') {
+        return __OPENCORE_TARGET__ === 'client';
+    }
+    return (typeof globalThis.GetPlayerPed === 'function' &&
+        typeof globalThis.GetNumPlayerIndices !== 'function');
+}
+/**
+ * Detects if we're running in a FiveM server environment.
+ */
+function isServerEnvironment() {
+    return typeof globalThis.GetNumPlayerIndices === 'function';
+}
+/**
+ * Detects if we're running in a FiveM environment (client or server).
+ */
+function isFiveMEnvironment() {
+    return isClientEnvironment() || isServerEnvironment();
+}
+/**
+ * Gets the configured log level.
+ *
+ * The log level is determined at build-time from opencore.config.ts via the CLI.
+ * If not configured, defaults to INFO.
+ *
+ * @returns The configured LogLevel
+ */
+function getLogLevel() {
+    // Use build-time injected value, fallback to INFO
+    const level = typeof __OPENCORE_LOG_LEVEL__ !== 'undefined' ? __OPENCORE_LOG_LEVEL__ : 'INFO';
+    return (0, logger_types_1.parseLogLevel)(level);
+}
+/**
+ * Checks if debug mode is enabled based on log level.
+ * Debug mode is enabled when log level is DEBUG or TRACE.
+ */
+function isDebugMode() {
+    return getLogLevel() <= logger_types_1.LogLevel.DEBUG;
+}

package/dist/{shared → kernel/shared}/logger/logger.service.d.ts

@@ -1,6 +1,6 @@
 import { type LoggerConfig } from './logger.config';
-import { LogDomain, LogLevel, type LogContext } from './logger.types';
-import type { LogTransport } from './transports/transport.interface';
+import { type LogContext, LogDomain, LogLevel } from './logger.types';
+import { LogTransport } from './transports/transport.interface';
 /**
  * Central logging service for the framework.
  *

package/dist/{shared → kernel/shared}/logger/transports/buffered.transport.d.ts

@@ -1,5 +1,5 @@
-import { LogLevel, type LogEntry } from '../logger.types';
-import type { LogTransport } from './transport.interface';
+import { type LogEntry, LogLevel } from '../logger.types';
+import { LogTransport } from './transport.interface';
 /**
  * Output format for exported logs.
  */

package/dist/{shared → kernel/shared}/logger/transports/buffered.transport.js

@@ -91,7 +91,6 @@ class BufferedTransport {
                 return this.exportJson();
             case 'csv':
                 return this.exportCsv();
-            case 'text':
             default:
                 return this.exportText();
         }
@@ -164,6 +163,7 @@ class BufferedTransport {
     cleanContext(context) {
         if (!context)
             return {};
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         const { source, domain } = context, rest = __rest(context, ["source", "domain"]);
         return rest;
     }

package/dist/{shared → kernel/shared}/logger/transports/console.transport.d.ts

@@ -1,5 +1,5 @@
-import { LogLevel, type LogEntry } from '../logger.types';
-import type { LogTransport } from './transport.interface';
+import { type LogEntry, LogLevel } from '../logger.types';
+import { LogTransport } from './transport.interface';
 export interface ConsoleTransportOptions {
     /**
      * Minimum log level to output. Defaults to DEBUG.

package/dist/{shared → kernel/shared}/logger/transports/console.transport.js

@@ -120,6 +120,7 @@ class ConsoleTransport {
         }
         // Output context if present (excluding source and domain which are already shown)
         if (context) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
             const { source, domain: _ } = context, rest = __rest(context, ["source", "domain"]);
             if (Object.keys(rest).length > 0) {
                 console.debug(`${dim}  └─ context:${reset}`, rest);

package/dist/kernel/shared/logger/transports/dev-transport.factory.d.ts

@@ -0,0 +1,75 @@
+import { LogLevel } from '../logger.types';
+import { HttpLogTransport, type HttpTransportOptions } from './http.transport';
+import { LogTransport } from './transport.interface';
+import { WebSocketLogTransport, type WebSocketTransportOptions } from './websocket.transport';
+/**
+ * Runtime environment detection.
+ */
+export type RuntimeEnvironment = 'fivem' | 'node';
+/**
+ * Options for creating a dev transport.
+ */
+export interface DevTransportOptions {
+    /** HTTP endpoint URL for FiveM mode */
+    httpUrl: string;
+    /** WebSocket URL for Node.js mode */
+    wsUrl?: string;
+    /** Force a specific transport type */
+    forceTransport?: 'http' | 'websocket';
+    /** Minimum log level */
+    minLevel?: LogLevel;
+    /** HTTP transport specific options */
+    httpOptions?: Partial<Omit<HttpTransportOptions, 'url'>>;
+    /** WebSocket transport specific options */
+    wsOptions?: Partial<Omit<WebSocketTransportOptions, 'url'>>;
+}
+/**
+ * Detects the current runtime environment.
+ *
+ * @returns 'fivem' if running in FiveM, 'node' otherwise
+ */
+export declare function detectEnvironment(): RuntimeEnvironment;
+/**
+ * Checks if WebSocket is available in the current environment.
+ */
+export declare function isWebSocketAvailable(): boolean;
+/**
+ * Creates the appropriate log transport based on the runtime environment.
+ *
+ * - In FiveM: Uses HttpLogTransport (Node.js http module)
+ * - In Node.js: Uses WebSocketLogTransport if available, otherwise HttpLogTransport
+ *
+ * @param options - Transport configuration
+ * @returns Configured log transport
+ *
+ * @example
+ * ```typescript
+ * const transport = createDevTransport({
+ *   httpUrl: 'http://localhost:3847/logs',
+ *   wsUrl: 'ws://localhost:3848',
+ * })
+ *
+ * if ('start' in transport) {
+ *   transport.start() // HTTP transport
+ * } else if ('connect' in transport) {
+ *   await transport.connect() // WebSocket transport
+ * }
+ * ```
+ */
+export declare function createDevTransport(options: DevTransportOptions): LogTransport;
+/**
+ * Type guard to check if transport is HttpLogTransport.
+ */
+export declare function isHttpTransport(transport: LogTransport): transport is HttpLogTransport;
+/**
+ * Type guard to check if transport is WebSocketLogTransport.
+ */
+export declare function isWebSocketTransport(transport: LogTransport): transport is WebSocketLogTransport;
+/**
+ * Starts the transport (handles both HTTP and WebSocket).
+ */
+export declare function startDevTransport(transport: LogTransport): Promise<void>;
+/**
+ * Stops the transport (handles both HTTP and WebSocket).
+ */
+export declare function stopDevTransport(transport: LogTransport): Promise<void>;

package/dist/kernel/shared/logger/transports/dev-transport.factory.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectEnvironment = detectEnvironment;
+exports.isWebSocketAvailable = isWebSocketAvailable;
+exports.createDevTransport = createDevTransport;
+exports.isHttpTransport = isHttpTransport;
+exports.isWebSocketTransport = isWebSocketTransport;
+exports.startDevTransport = startDevTransport;
+exports.stopDevTransport = stopDevTransport;
+const logger_types_1 = require("../logger.types");
+const http_transport_1 = require("./http.transport");
+const websocket_transport_1 = require("./websocket.transport");
+/**
+ * Detects the current runtime environment.
+ *
+ * @returns 'fivem' if running in FiveM, 'node' otherwise
+ */
+function detectEnvironment() {
+    // Check for FiveM-specific globals
+    if (typeof GetCurrentResourceName === 'function') {
+        return 'fivem';
+    }
+    return 'node';
+}
+/**
+ * Checks if WebSocket is available in the current environment.
+ */
+function isWebSocketAvailable() {
+    return typeof WebSocket !== 'undefined';
+}
+/**
+ * Creates the appropriate log transport based on the runtime environment.
+ *
+ * - In FiveM: Uses HttpLogTransport (Node.js http module)
+ * - In Node.js: Uses WebSocketLogTransport if available, otherwise HttpLogTransport
+ *
+ * @param options - Transport configuration
+ * @returns Configured log transport
+ *
+ * @example
+ * ```typescript
+ * const transport = createDevTransport({
+ *   httpUrl: 'http://localhost:3847/logs',
+ *   wsUrl: 'ws://localhost:3848',
+ * })
+ *
+ * if ('start' in transport) {
+ *   transport.start() // HTTP transport
+ * } else if ('connect' in transport) {
+ *   await transport.connect() // WebSocket transport
+ * }
+ * ```
+ */
+function createDevTransport(options) {
+    var _a, _b;
+    const env = detectEnvironment();
+    const minLevel = (_a = options.minLevel) !== null && _a !== void 0 ? _a : logger_types_1.LogLevel.DEBUG;
+    // If forced transport type is specified, use it
+    if (options.forceTransport === 'http') {
+        return new http_transport_1.HttpLogTransport(Object.assign({ url: options.httpUrl }, options.httpOptions), minLevel);
+    }
+    if (options.forceTransport === 'websocket') {
+        const wsUrl = (_b = options.wsUrl) !== null && _b !== void 0 ? _b : options.httpUrl.replace('http', 'ws');
+        return new websocket_transport_1.WebSocketLogTransport(Object.assign({ url: wsUrl }, options.wsOptions), minLevel);
+    }
+    // Auto-detect based on environment
+    if (env === 'fivem') {
+        // FiveM: Always use HTTP (WebSocket not available in FiveM runtime)
+        return new http_transport_1.HttpLogTransport(Object.assign({ url: options.httpUrl }, options.httpOptions), minLevel);
+    }
+    // Node.js: Prefer WebSocket if available, otherwise use HTTP
+    if (isWebSocketAvailable() && options.wsUrl) {
+        return new websocket_transport_1.WebSocketLogTransport(Object.assign({ url: options.wsUrl }, options.wsOptions), minLevel);
+    }
+    // Fallback to HTTP
+    return new http_transport_1.HttpLogTransport(Object.assign({ url: options.httpUrl }, options.httpOptions), minLevel);
+}
+/**
+ * Type guard to check if transport is HttpLogTransport.
+ */
+function isHttpTransport(transport) {
+    return transport.name === 'http';
+}
+/**
+ * Type guard to check if transport is WebSocketLogTransport.
+ */
+function isWebSocketTransport(transport) {
+    return transport.name === 'websocket';
+}
+/**
+ * Starts the transport (handles both HTTP and WebSocket).
+ */
+async function startDevTransport(transport) {
+    if (isHttpTransport(transport)) {
+        transport.start();
+    }
+    else if (isWebSocketTransport(transport)) {
+        await transport.connect();
+    }
+}
+/**
+ * Stops the transport (handles both HTTP and WebSocket).
+ */
+async function stopDevTransport(transport) {
+    if (isHttpTransport(transport)) {
+        await transport.stop();
+    }
+    else if (isWebSocketTransport(transport)) {
+        transport.destroy();
+    }
+}

package/dist/kernel/shared/logger/transports/http.transport.d.ts

@@ -0,0 +1,67 @@
+import { type LogEntry, LogLevel } from '../logger.types';
+import { LogTransport } from './transport.interface';
+/**
+ * Configuration for HTTP log transport.
+ */
+export interface HttpTransportOptions {
+    /** HTTP endpoint URL (e.g., 'http://localhost:3847/logs') */
+    url: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Batch size - number of logs to send per request */
+    batchSize?: number;
+    /** Flush interval in milliseconds */
+    flushInterval?: number;
+    /** Maximum buffer size */
+    maxBufferSize?: number;
+}
+/**
+ * HTTP-based log transport for streaming logs to external tools.
+ *
+ * Compatible with FiveM's Node.js runtime. Uses batched HTTP POST requests
+ * instead of WebSocket for environments where WebSocket is unavailable.
+ *
+ * @example
+ * ```typescript
+ * const transport = new HttpLogTransport({
+ *   url: 'http://localhost:3847/logs',
+ *   batchSize: 10,
+ *   flushInterval: 1000,
+ * })
+ * transport.start()
+ * ```
+ */
+export declare class HttpLogTransport implements LogTransport {
+    readonly name = "http";
+    minLevel: LogLevel;
+    private buffer;
+    private options;
+    private flushTimer;
+    private isSending;
+    private parsedUrl;
+    constructor(options: HttpTransportOptions, minLevel?: LogLevel);
+    /**
+     * Starts the flush timer for periodic log sending.
+     */
+    start(): void;
+    /**
+     * Stops the transport and flushes remaining logs.
+     */
+    stop(): Promise<void>;
+    /**
+     * Writes a log entry to the buffer.
+     */
+    write(entry: LogEntry): void;
+    /**
+     * Flushes buffered logs to the server.
+     */
+    flush(): Promise<void>;
+    /**
+     * Sends logs via HTTP POST.
+     */
+    private sendLogs;
+    /**
+     * Destroys the transport and clears resources.
+     */
+    destroy(): void;
+}

package/dist/kernel/shared/logger/transports/http.transport.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpLogTransport = void 0;
+const logger_types_1 = require("../logger.types");
+// Lazy-loaded http module (only loaded at runtime, not bundled)
+let httpModule = null;
+// Use variable to prevent esbuild from statically analyzing the require
+const HTTP_MODULE = 'http';
+function getHttpSync() {
+    if (!httpModule) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        httpModule = require(HTTP_MODULE);
+    }
+    return httpModule;
+}
+/**
+ * HTTP-based log transport for streaming logs to external tools.
+ *
+ * Compatible with FiveM's Node.js runtime. Uses batched HTTP POST requests
+ * instead of WebSocket for environments where WebSocket is unavailable.
+ *
+ * @example
+ * ```typescript
+ * const transport = new HttpLogTransport({
+ *   url: 'http://localhost:3847/logs',
+ *   batchSize: 10,
+ *   flushInterval: 1000,
+ * })
+ * transport.start()
+ * ```
+ */
+class HttpLogTransport {
+    constructor(options, minLevel = logger_types_1.LogLevel.DEBUG) {
+        var _a, _b, _c, _d;
+        this.name = 'http';
+        this.buffer = [];
+        this.flushTimer = null;
+        this.isSending = false;
+        this.minLevel = minLevel;
+        this.options = {
+            url: options.url,
+            timeout: (_a = options.timeout) !== null && _a !== void 0 ? _a : 5000,
+            batchSize: (_b = options.batchSize) !== null && _b !== void 0 ? _b : 20,
+            flushInterval: (_c = options.flushInterval) !== null && _c !== void 0 ? _c : 500,
+            maxBufferSize: (_d = options.maxBufferSize) !== null && _d !== void 0 ? _d : 500,
+        };
+        this.parsedUrl = new URL(this.options.url);
+    }
+    /**
+     * Starts the flush timer for periodic log sending.
+     */
+    start() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setInterval(() => {
+            void this.flush();
+        }, this.options.flushInterval);
+    }
+    /**
+     * Stops the transport and flushes remaining logs.
+     */
+    async stop() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.flush();
+    }
+    /**
+     * Writes a log entry to the buffer.
+     */
+    write(entry) {
+        this.buffer.push(entry);
+        // Prevent buffer overflow
+        if (this.buffer.length > this.options.maxBufferSize) {
+            this.buffer.shift();
+        }
+        // Flush immediately if batch size reached
+        if (this.buffer.length >= this.options.batchSize) {
+            void this.flush();
+        }
+    }
+    /**
+     * Flushes buffered logs to the server.
+     */
+    async flush() {
+        if (this.isSending || this.buffer.length === 0)
+            return;
+        this.isSending = true;
+        const logsToSend = this.buffer.splice(0, this.options.batchSize);
+        try {
+            await this.sendLogs(logsToSend);
+        }
+        catch (_a) {
+            // On error, put logs back at the front of the buffer
+            this.buffer.unshift(...logsToSend);
+            // But limit buffer size
+            if (this.buffer.length > this.options.maxBufferSize) {
+                this.buffer.length = this.options.maxBufferSize;
+            }
+        }
+        finally {
+            this.isSending = false;
+        }
+    }
+    /**
+     * Sends logs via HTTP POST.
+     */
+    sendLogs(logs) {
+        return new Promise((resolve, reject) => {
+            const http = getHttpSync();
+            const payload = JSON.stringify({
+                type: 'logs',
+                payload: logs.map((entry) => ({
+                    level: entry.level,
+                    domain: entry.domain,
+                    message: entry.message,
+                    timestamp: entry.timestamp,
+                    context: entry.context,
+                    error: entry.error
+                        ? {
+                            name: entry.error.name,
+                            message: entry.error.message,
+                            stack: entry.error.stack,
+                        }
+                        : undefined,
+                })),
+            });
+            const options = {
+                hostname: this.parsedUrl.hostname,
+                port: this.parsedUrl.port || 80,
+                path: this.parsedUrl.pathname,
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(payload),
+                },
+                timeout: this.options.timeout,
+            };
+            const req = http.request(options, (res) => {
+                // Consume response to free up memory
+                res.resume();
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`HTTP ${res.statusCode}`));
+                }
+            });
+            req.on('error', reject);
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+            req.write(payload);
+            req.end();
+        });
+    }
+    /**
+     * Destroys the transport and clears resources.
+     */
+    destroy() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.buffer = [];
+    }
+}
+exports.HttpLogTransport = HttpLogTransport;

package/dist/kernel/shared/logger/transports/index.d.ts

@@ -0,0 +1,7 @@
+export * from './buffered.transport';
+export { ConsoleTransport } from './console.transport';
+export { createDevTransport, type DevTransportOptions, detectEnvironment, isHttpTransport, isWebSocketTransport, type RuntimeEnvironment, startDevTransport, stopDevTransport, } from './dev-transport.factory';
+export { HttpLogTransport, type HttpTransportOptions } from './http.transport';
+export { SimpleConsoleTransport } from './simple-console.transport';
+export * from './transport.interface';
+export { WebSocketLogTransport, type WebSocketTransportOptions } from './websocket.transport';

package/dist/kernel/shared/logger/transports/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketLogTransport = exports.SimpleConsoleTransport = exports.HttpLogTransport = exports.stopDevTransport = exports.startDevTransport = exports.isWebSocketTransport = exports.isHttpTransport = exports.detectEnvironment = exports.createDevTransport = exports.ConsoleTransport = void 0;
+__exportStar(require("./buffered.transport"), exports);
+var console_transport_1 = require("./console.transport");
+Object.defineProperty(exports, "ConsoleTransport", { enumerable: true, get: function () { return console_transport_1.ConsoleTransport; } });
+var dev_transport_factory_1 = require("./dev-transport.factory");
+Object.defineProperty(exports, "createDevTransport", { enumerable: true, get: function () { return dev_transport_factory_1.createDevTransport; } });
+Object.defineProperty(exports, "detectEnvironment", { enumerable: true, get: function () { return dev_transport_factory_1.detectEnvironment; } });
+Object.defineProperty(exports, "isHttpTransport", { enumerable: true, get: function () { return dev_transport_factory_1.isHttpTransport; } });
+Object.defineProperty(exports, "isWebSocketTransport", { enumerable: true, get: function () { return dev_transport_factory_1.isWebSocketTransport; } });
+Object.defineProperty(exports, "startDevTransport", { enumerable: true, get: function () { return dev_transport_factory_1.startDevTransport; } });
+Object.defineProperty(exports, "stopDevTransport", { enumerable: true, get: function () { return dev_transport_factory_1.stopDevTransport; } });
+var http_transport_1 = require("./http.transport");
+Object.defineProperty(exports, "HttpLogTransport", { enumerable: true, get: function () { return http_transport_1.HttpLogTransport; } });
+var simple_console_transport_1 = require("./simple-console.transport");
+Object.defineProperty(exports, "SimpleConsoleTransport", { enumerable: true, get: function () { return simple_console_transport_1.SimpleConsoleTransport; } });
+__exportStar(require("./transport.interface"), exports);
+var websocket_transport_1 = require("./websocket.transport");
+Object.defineProperty(exports, "WebSocketLogTransport", { enumerable: true, get: function () { return websocket_transport_1.WebSocketLogTransport; } });