lograil 0.1.0

package/dist/esm/runtime/electron-main.js

@@ -0,0 +1,99 @@
+import { ConsoleTransport } from '../transport/console.js';
+import { FileTransport } from '../transport/file.js';
+import { registerIpcReceiver, RENDERER_PROCESS_MARKER } from '../transport/electron-ipc.js';
+import { getElectronApp } from './electron-binding.js';
+import { createElectronLifecycle } from './electron-lifecycle.js';
+import { tmpdir } from '../shims/index.js';
+import { join } from '../shims/index.js';
+import { DEFAULT_FILE_CAPS } from './defaults.js';
+/**
+ * Log directory for the Electron main runtime. Prefers Electron's dedicated
+ * `logs` path (e.g. `<userData>/logs`, already namespaced by the app name so
+ * multiple apps never collide), falling back to `<appData>/Logs` and finally
+ * the OS temp dir if Electron is unavailable or `app` is not ready.
+ */
+function defaultElectronLogDir() {
+    const app = getElectronApp();
+    if (app?.getPath) {
+        try {
+            return app.getPath('logs');
+        }
+        catch {
+            /* app not ready yet — try the next fallback */
+        }
+        try {
+            return join(app.getPath('appData'), 'Logs');
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return tmpdir();
+}
+/**
+ * Electron **main process** runtime. Owns the filesystem, so by default it
+ * persists logs to a rotating file (unless `disableFile`) in addition to the
+ * console, and (by default) receives renderer entries over IPC so that all
+ * logs — including those produced in renderers — are written here.
+ */
+export function createElectronMainRuntime(options = {}) {
+    const pid = typeof process !== 'undefined' ? process.pid : undefined;
+    const receiveFromRenderer = options.receiveFromRenderer ?? true;
+    const runtime = {
+        name: 'electron',
+        processType: 'main',
+        now: () => Date.now(),
+        pid: () => pid,
+        hasFileSystem: () => true,
+        defaultTransports: () => {
+            const transports = [new ConsoleTransport()];
+            if (!options.disableFile) {
+                const dir = defaultElectronLogDir();
+                transports.push(new FileTransport({
+                    mode: 'rotate-time',
+                    unit: 'day',
+                    appName: 'main',
+                    dir,
+                    // Disk-safety defaults so a zero-config logger never eats the
+                    // disk; explicit `fileTransportOptions` values win.
+                    ...DEFAULT_FILE_CAPS,
+                    // Main-process entries only: renderer entries are routed to the
+                    // dedicated renderer log file below.
+                    filter: (entry) => entry.metadata?.[RENDERER_PROCESS_MARKER] !== 'renderer',
+                    ...options.fileTransportOptions,
+                }));
+                if (receiveFromRenderer) {
+                    transports.push(new FileTransport({
+                        mode: 'rotate-time',
+                        unit: 'day',
+                        appName: 'renderer',
+                        dir,
+                        // Disk-safety defaults so a zero-config logger never eats the
+                        // disk; explicit `fileTransportOptions` values win.
+                        ...DEFAULT_FILE_CAPS,
+                        // Renderer entries only.
+                        filter: (entry) => entry.metadata?.[RENDERER_PROCESS_MARKER] === 'renderer',
+                        ...options.fileTransportOptions,
+                    }));
+                }
+            }
+            return transports;
+        },
+        lifecycle: createElectronLifecycle(),
+    };
+    if (receiveFromRenderer) {
+        runtime.attachReceiver = (ingest) => {
+            try {
+                return registerIpcReceiver(ingest, {
+                    onLevelCommand: (level) => runtime.onLevelCommand?.(level),
+                });
+            }
+            catch {
+                // `electron` not available (e.g. tests) — degrade to a no-op.
+                return () => { };
+            }
+        };
+    }
+    return runtime;
+}
+//# sourceMappingURL=electron-main.js.map

package/dist/esm/runtime/electron-main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"electron-main.js","sourceRoot":"","sources":["../../../src/runtime/electron-main.ts"],"names":[],"mappings":"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"}

package/dist/esm/runtime/electron-renderer.d.ts

@@ -0,0 +1,26 @@
+import type { RuntimeAdapter } from './adapter.js';
+import type { IpcRenderer } from 'electron';
+export interface ElectronRendererRuntimeOptions {
+    /**
+     * Forward entries to the main process over IPC so they are written there
+     * (default `true`). Disable to keep renderer logs local only.
+     */
+    forwardToMain?: boolean;
+    /** Override the IPC channel used to reach the main process. */
+    channel?: string;
+    /**
+     * Injected IPC sender. Required when the renderer cannot reach
+     * `require('electron')` (e.g. `nodeIntegration: false` +
+     * `contextIsolation: true`) — pass the `ipcRenderer` obtained from a preload
+     * bridge. Without it the transport falls back to `require('electron')`, which
+     * is unavailable in that locked-down setup.
+     */
+    ipcRenderer?: Pick<IpcRenderer, 'send'>;
+}
+/**
+ * Electron **renderer process** runtime. Renderers have no filesystem access,
+ * so by default they forward entries to the main process (which persists
+ * them) while still logging to the local console for devtools visibility.
+ */
+export declare function createElectronRendererRuntime(options?: ElectronRendererRuntimeOptions): RuntimeAdapter;
+//# sourceMappingURL=electron-renderer.d.ts.map

package/dist/esm/runtime/electron-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"electron-renderer.d.ts","sourceRoot":"","sources":["../../../src/runtime/electron-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAK5C,MAAM,WAAW,8BAA8B;IAC7C;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;CACzC;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,GAAE,8BAAmC,GAC3C,cAAc,CAuBhB"}

package/dist/esm/runtime/electron-renderer.js

@@ -0,0 +1,30 @@
+import { ConsoleTransport } from '../transport/console.js';
+import { ElectronIpcTransport } from '../transport/electron-ipc.js';
+import { createWebLifecycle } from './web-lifecycle.js';
+/**
+ * Electron **renderer process** runtime. Renderers have no filesystem access,
+ * so by default they forward entries to the main process (which persists
+ * them) while still logging to the local console for devtools visibility.
+ */
+export function createElectronRendererRuntime(options = {}) {
+    const forwardToMain = options.forwardToMain ?? true;
+    return {
+        name: 'electron',
+        processType: 'renderer',
+        now: () => Date.now(),
+        pid: () => undefined,
+        hasFileSystem: () => false,
+        defaultTransports: () => {
+            const transports = [new ConsoleTransport()];
+            if (forwardToMain) {
+                transports.push(new ElectronIpcTransport({
+                    channel: options.channel,
+                    ipcRenderer: options.ipcRenderer,
+                }));
+            }
+            return transports;
+        },
+        lifecycle: createWebLifecycle(),
+    };
+}
+//# sourceMappingURL=electron-renderer.js.map

package/dist/esm/runtime/electron-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"electron-renderer.js","sourceRoot":"","sources":["../../../src/runtime/electron-renderer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAoBxD;;;;GAIG;AACH,MAAM,UAAU,6BAA6B,CAC3C,UAA0C,EAAE;IAE5C,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,IAAI,CAAC;IAEpD,OAAO;QACL,IAAI,EAAE,UAAU;QAChB,WAAW,EAAE,UAAU;QACvB,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;QACrB,GAAG,EAAE,GAAG,EAAE,CAAC,SAAS;QACpB,aAAa,EAAE,GAAG,EAAE,CAAC,KAAK;QAC1B,iBAAiB,EAAE,GAAG,EAAE;YACtB,MAAM,UAAU,GAAgB,CAAC,IAAI,gBAAgB,EAAE,CAAC,CAAC;YACzD,IAAI,aAAa,EAAE,CAAC;gBAClB,UAAU,CAAC,IAAI,CACb,IAAI,oBAAoB,CAAC;oBACvB,OAAO,EAAE,OAAO,CAAC,OAAO;oBACxB,WAAW,EAAE,OAAO,CAAC,WAAW;iBACjC,CAAC,CACH,CAAC;YACJ,CAAC;YACD,OAAO,UAAU,CAAC;QACpB,CAAC;QACD,SAAS,EAAE,kBAAkB,EAAE;KAChC,CAAC;AACJ,CAAC"}

package/dist/esm/runtime/electron.d.ts

@@ -0,0 +1,20 @@
+import type { RuntimeAdapter } from './adapter.js';
+import type { ElectronMainRuntimeOptions } from './electron-main.js';
+import type { ElectronRendererRuntimeOptions } from './electron-renderer.js';
+export { createElectronMainRuntime } from './electron-main.js';
+export type { ElectronMainRuntimeOptions } from './electron-main.js';
+export { createElectronRendererRuntime } from './electron-renderer.js';
+export type { ElectronRendererRuntimeOptions } from './electron-renderer.js';
+/**
+ * Options accepted by {@link createElectronRuntime}. This is the union of the
+ * main and renderer runtime options; only the relevant subset is used after
+ * the process type is detected.
+ */
+export type ElectronRuntimeOptions = ElectronMainRuntimeOptions & ElectronRendererRuntimeOptions;
+/**
+ * Auto-detect whether we run in the Electron main or renderer process and
+ * return the matching runtime. Prefer the explicit {@link createElectronMainRuntime}
+ * / {@link createElectronRendererRuntime} when the process type is known.
+ */
+export declare function createElectronRuntime(options?: ElectronRuntimeOptions): RuntimeAdapter;
+//# sourceMappingURL=electron.d.ts.map

package/dist/esm/runtime/electron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"electron.d.ts","sourceRoot":"","sources":["../../../src/runtime/electron.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAErE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAC;AAE7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,YAAY,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AACvE,YAAY,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAC;AAE7E;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG,0BAA0B,GAAG,8BAA8B,CAAC;AAWjG;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,GAAE,sBAA2B,GAAG,cAAc,CAI1F"}

package/dist/esm/runtime/electron.js

@@ -0,0 +1,21 @@
+import { createElectronMainRuntime } from './electron-main.js';
+import { createElectronRendererRuntime } from './electron-renderer.js';
+export { createElectronMainRuntime } from './electron-main.js';
+export { createElectronRendererRuntime } from './electron-renderer.js';
+function isMainProcess() {
+    // An Electron renderer explicitly reports `process.type === 'renderer'`.
+    // The main process may report `'browser'` *or* `undefined`, so anything
+    // that is not explicitly a renderer is treated as main.
+    return (typeof process === 'undefined' || process.type !== 'renderer');
+}
+/**
+ * Auto-detect whether we run in the Electron main or renderer process and
+ * return the matching runtime. Prefer the explicit {@link createElectronMainRuntime}
+ * / {@link createElectronRendererRuntime} when the process type is known.
+ */
+export function createElectronRuntime(options = {}) {
+    return isMainProcess()
+        ? createElectronMainRuntime(options)
+        : createElectronRendererRuntime(options);
+}
+//# sourceMappingURL=electron.js.map

package/dist/esm/runtime/electron.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"electron.js","sourceRoot":"","sources":["../../../src/runtime/electron.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAGvE,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAUvE,SAAS,aAAa;IACpB,yEAAyE;IACzE,wEAAwE;IACxE,wDAAwD;IACxD,OAAO,CACL,OAAO,OAAO,KAAK,WAAW,IAAK,OAAwC,CAAC,IAAI,KAAK,UAAU,CAChG,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,UAAkC,EAAE;IACxE,OAAO,aAAa,EAAE;QACpB,CAAC,CAAC,yBAAyB,CAAC,OAAO,CAAC;QACpC,CAAC,CAAC,6BAA6B,CAAC,OAAO,CAAC,CAAC;AAC7C,CAAC"}

package/dist/esm/runtime/index.d.ts

@@ -0,0 +1,21 @@
+import type { RuntimeAdapter } from './adapter.js';
+import type { NodeRuntimeOptions } from './node.js';
+import type { ElectronRuntimeOptions } from './electron.js';
+export type RuntimeOptions = ElectronRuntimeOptions & NodeRuntimeOptions;
+/**
+ * Auto-detect the current runtime:
+ *  - Electron main / renderer when `process.versions.electron` exists;
+ *  - Plain Node.js when a Node process is present (has filesystem + pid);
+ *  - Web (browser) otherwise.
+ *
+ * `ElectronRuntimeOptions`/`NodeRuntimeOptions` (e.g. `appName`, `fileTransportOptions`) are
+ * forwarded to the matching adapter.
+ */
+export declare function detectRuntime(options?: RuntimeOptions): RuntimeAdapter;
+export type { RuntimeAdapter, RuntimeName, ElectronProcessType, IngestFn } from './adapter.js';
+export { createWebRuntime } from './web.js';
+export { createNodeRuntime } from './node.js';
+export { createElectronRuntime, createElectronMainRuntime, createElectronRendererRuntime, } from './electron.js';
+export type { ElectronRuntimeOptions, ElectronMainRuntimeOptions, ElectronRendererRuntimeOptions, } from './electron.js';
+export { ElectronIpcTransport, registerIpcReceiver, LOGRAIL_CHANNEL, } from '../transport/electron-ipc.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAEnD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAEpD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAG5D,MAAM,MAAM,cAAc,GAAG,sBAAsB,GAAG,kBAAkB,CAAC;AAEzE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,cAAmB,GAAG,cAAc,CAa1E;AAED,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAC/F,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,6BAA6B,GAC9B,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,sBAAsB,EACtB,0BAA0B,EAC1B,8BAA8B,GAC/B,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,GAChB,MAAM,8BAA8B,CAAC"}

package/dist/esm/runtime/index.js

@@ -0,0 +1,29 @@
+import { createWebRuntime } from './web.js';
+import { createNodeRuntime } from './node.js';
+import { createElectronRuntime } from './electron.js';
+/**
+ * Auto-detect the current runtime:
+ *  - Electron main / renderer when `process.versions.electron` exists;
+ *  - Plain Node.js when a Node process is present (has filesystem + pid);
+ *  - Web (browser) otherwise.
+ *
+ * `ElectronRuntimeOptions`/`NodeRuntimeOptions` (e.g. `appName`, `fileTransportOptions`) are
+ * forwarded to the matching adapter.
+ */
+export function detectRuntime(options = {}) {
+    const versions = (typeof process !== 'undefined'
+        ? process.versions
+        : undefined) ?? {};
+    if (versions.electron) {
+        return createElectronRuntime(options);
+    }
+    if (versions.node) {
+        return createNodeRuntime(options);
+    }
+    return createWebRuntime();
+}
+export { createWebRuntime } from './web.js';
+export { createNodeRuntime } from './node.js';
+export { createElectronRuntime, createElectronMainRuntime, createElectronRendererRuntime, } from './electron.js';
+export { ElectronIpcTransport, registerIpcReceiver, LOGRAIL_CHANNEL, } from '../transport/electron-ipc.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/runtime/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAItD;;;;;;;;GAQG;AACH,MAAM,UAAU,aAAa,CAAC,UAA0B,EAAE;IACxD,MAAM,QAAQ,GACZ,CAAC,OAAO,OAAO,KAAK,WAAW;QAC7B,CAAC,CAAE,OAA0E,CAAC,QAAQ;QACtF,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;IAEvB,IAAI,QAAQ,CAAC,QAAQ,EAAE,CAAC;QACtB,OAAO,qBAAqB,CAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IACD,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;QAClB,OAAO,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,gBAAgB,EAAE,CAAC;AAC5B,CAAC;AAGD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EACL,qBAAqB,EACrB,yBAAyB,EACzB,6BAA6B,GAC9B,MAAM,eAAe,CAAC;AAMvB,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,GAChB,MAAM,8BAA8B,CAAC"}

package/dist/esm/runtime/node.d.ts

@@ -0,0 +1,27 @@
+import type { RotateTimeOptions } from '../transport/file.js';
+import type { RuntimeAdapter } from './adapter.js';
+export interface NodeRuntimeOptions {
+    /** Application name; embedded in the log file name (required). */
+    appName?: string;
+    /** Forwarded to the default `FileTransport` (mode `rotate-time`). */
+    fileTransportOptions?: Partial<Omit<RotateTimeOptions, 'mode'>>;
+    /** Disable the file transport entirely (console only). */
+    disableFile?: boolean;
+}
+/**
+ * Plain Node.js runtime (CLI / server / worker). Has both a process id and
+ * filesystem access, so by default it persists logs to a time-rotated file
+ * (in addition to the console). Pass `disableFile` to opt out, or
+ * `appName` / `fileTransportOptions` to customize. `appName` is required for
+ * the file transport; if omitted it is inferred from the launched script and
+ * throws if it cannot be determined.
+ *
+ * **Cluster support.** When running inside `node:cluster`, the runtime
+ * automatically detects whether the current process is a worker or the
+ * primary. Workers disable the file transport and send entries to the
+ * primary via `process.send()` (the `ClusterIpcTransport`). The primary
+ * receives those entries and feeds them into the logger — no manual
+ * `registerClusterReceiver` call is needed.
+ */
+export declare function createNodeRuntime(options?: NodeRuntimeOptions): RuntimeAdapter;
+//# sourceMappingURL=node.d.ts.map

package/dist/esm/runtime/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/runtime/node.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAI9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAsBnD,MAAM,WAAW,kBAAkB;IACjC,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,oBAAoB,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC,CAAC;IAChE,0DAA0D;IAC1D,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAyCD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,kBAAuB,GAAG,cAAc,CA0DlF"}

package/dist/esm/runtime/node.js

@@ -0,0 +1,123 @@
+import { ConsoleTransport } from '../transport/console.js';
+import { FileTransport } from '../transport/file.js';
+import { ClusterIpcTransport, registerClusterReceiver } from '../transport/cluster-ipc.js';
+import { WorkerIpcTransport } from '../transport/worker-ipc.js';
+import { createProcessLifecycle } from './process-lifecycle.js';
+import { tmpdir } from '../shims/index.js';
+import { basename } from '../shims/index.js';
+import { isClusterWorker } from '../shims/index.js';
+import { DEFAULT_FILE_CAPS } from './defaults.js';
+/**
+ * Detect whether the current context is a Node worker_threads worker.
+ * Uses `typeof` on `globalThis.parentPort` — safe in all environments.
+ */
+function isNodeWorkerThread() {
+    try {
+        return (typeof globalThis.parentPort?.postMessage ===
+            'function');
+    }
+    catch {
+        return false;
+    }
+}
+/** Derive an application name from the invoked script when none is given. */
+function inferAppName() {
+    try {
+        const p = process.argv[1];
+        if (p)
+            return basename(p).replace(/\.[^.]+$/, '');
+    }
+    catch {
+        /* ignore */
+    }
+    return undefined;
+}
+/**
+ * Lifecycle hooks for cluster workers. Flushes on `disconnect` (the primary
+ * closed the IPC channel) and on `beforeExit` / signals.
+ */
+function createClusterWorkerLifecycle() {
+    const lc = createProcessLifecycle();
+    return {
+        onFlushBeforeExit(cb) {
+            const detachProcess = lc.onFlushBeforeExit(cb);
+            const proc = process;
+            const onDisconnect = () => {
+                void cb();
+            };
+            proc.on?.('disconnect', onDisconnect);
+            return () => {
+                detachProcess();
+                proc.removeListener?.('disconnect', onDisconnect);
+            };
+        },
+        onUncaughtError: lc.onUncaughtError,
+    };
+}
+/**
+ * Plain Node.js runtime (CLI / server / worker). Has both a process id and
+ * filesystem access, so by default it persists logs to a time-rotated file
+ * (in addition to the console). Pass `disableFile` to opt out, or
+ * `appName` / `fileTransportOptions` to customize. `appName` is required for
+ * the file transport; if omitted it is inferred from the launched script and
+ * throws if it cannot be determined.
+ *
+ * **Cluster support.** When running inside `node:cluster`, the runtime
+ * automatically detects whether the current process is a worker or the
+ * primary. Workers disable the file transport and send entries to the
+ * primary via `process.send()` (the `ClusterIpcTransport`). The primary
+ * receives those entries and feeds them into the logger — no manual
+ * `registerClusterReceiver` call is needed.
+ */
+export function createNodeRuntime(options = {}) {
+    const pid = typeof process !== 'undefined' ? process.pid : undefined;
+    const worker = isClusterWorker();
+    // ── Cluster worker: no file, send to primary via IPC ──
+    if (worker) {
+        return {
+            name: 'node',
+            now: () => Date.now(),
+            pid: () => pid,
+            hasFileSystem: () => false,
+            defaultTransports: () => [new ConsoleTransport(), new ClusterIpcTransport()],
+            lifecycle: createClusterWorkerLifecycle(),
+        };
+    }
+    // ── Node worker_threads worker: no file, send to parent via postMessage ──
+    if (isNodeWorkerThread()) {
+        return {
+            name: 'node',
+            now: () => Date.now(),
+            pid: () => pid,
+            hasFileSystem: () => false,
+            defaultTransports: () => [new ConsoleTransport(), new WorkerIpcTransport()],
+            lifecycle: createClusterWorkerLifecycle(), // reuse: flush on disconnect/exit
+        };
+    }
+    // ── Primary or non-cluster: console + file (default) ──
+    const transports = [new ConsoleTransport()];
+    if (!options.disableFile) {
+        const appName = options.appName ?? inferAppName();
+        if (!appName) {
+            throw new Error('Node runtime requires an "appName" (or a determinable script path) for the file transport');
+        }
+        transports.push(new FileTransport({
+            mode: 'rotate-time',
+            unit: 'day',
+            appName,
+            dir: tmpdir(),
+            ...DEFAULT_FILE_CAPS,
+            ...options.fileTransportOptions,
+        }));
+    }
+    return {
+        name: 'node',
+        now: () => Date.now(),
+        pid: () => pid,
+        hasFileSystem: () => !options.disableFile,
+        defaultTransports: () => transports,
+        attachReceiver: (ingest) => registerClusterReceiver(ingest),
+        lifecycle: createProcessLifecycle(),
+    };
+}
+//# sourceMappingURL=node.js.map

package/dist/esm/runtime/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../src/runtime/node.ts"],"names":[],"mappings":"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"}

package/dist/esm/runtime/process-lifecycle.d.ts

@@ -0,0 +1,13 @@
+import type { LifecycleHooks } from './adapter.js';
+/**
+ * Lifecycle hooks backed by the Node/Electron `process` event surface. Shared
+ * by the Node runtime and both Electron process types — they all expose the
+ * same `process` events.
+ *
+ * The flush callback is supplied by the logger; this module only decides
+ * *when* to call it and owns the `process.exit()` that follows a signal or a
+ * fatal, uncaught crash. It never touches `window`, so it is safe to import in
+ * any runtime (the `process` probe just returns `undefined` where absent).
+ */
+export declare function createProcessLifecycle(): LifecycleHooks;
+//# sourceMappingURL=process-lifecycle.d.ts.map

package/dist/esm/runtime/process-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/runtime/process-lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgBnD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,IAAI,cAAc,CA2DvD"}

package/dist/esm/runtime/process-lifecycle.js

@@ -0,0 +1,77 @@
+function getProcess() {
+    if (typeof process === 'undefined' || typeof process.on !== 'function') {
+        return undefined;
+    }
+    return process;
+}
+/**
+ * Lifecycle hooks backed by the Node/Electron `process` event surface. Shared
+ * by the Node runtime and both Electron process types — they all expose the
+ * same `process` events.
+ *
+ * The flush callback is supplied by the logger; this module only decides
+ * *when* to call it and owns the `process.exit()` that follows a signal or a
+ * fatal, uncaught crash. It never touches `window`, so it is safe to import in
+ * any runtime (the `process` probe just returns `undefined` where absent).
+ */
+export function createProcessLifecycle() {
+    return {
+        onFlushBeforeExit(cb) {
+            const proc = getProcess();
+            if (!proc)
+                return () => { };
+            // Normal event-loop drain: flush pending writes; the process exits on
+            // its own once the loop empties. `beforeExit` re-fires while async writes
+            // keep it alive, so the queue keeps draining until empty.
+            const onBeforeExit = () => {
+                void cb();
+            };
+            // A signal must force an exit after flushing — but never hang shutdown on
+            // a stalled transport (the logger's flush timeout bounds it).
+            const onSignal = (code) => {
+                void Promise.resolve(cb()).finally(() => {
+                    try {
+                        proc.exit(code);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                });
+            };
+            const onSigInt = () => onSignal(130);
+            const onSigTerm = () => onSignal(143);
+            proc.on('beforeExit', onBeforeExit);
+            proc.on('SIGINT', onSigInt);
+            proc.on('SIGTERM', onSigTerm);
+            return () => {
+                proc.removeListener('beforeExit', onBeforeExit);
+                proc.removeListener('SIGINT', onSigInt);
+                proc.removeListener('SIGTERM', onSigTerm);
+            };
+        },
+        onUncaughtError(cb) {
+            const proc = getProcess();
+            if (!proc)
+                return () => { };
+            // Log the crash at fatal level, flush, then exit(1) — but never hang on a
+            // stalled transport (the logger's flush timeout bounds the flush).
+            const onErr = (err) => {
+                void Promise.resolve(cb(err)).finally(() => {
+                    try {
+                        proc.exit(1);
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                });
+            };
+            proc.on('uncaughtException', onErr);
+            proc.on('unhandledRejection', onErr);
+            return () => {
+                proc.removeListener('uncaughtException', onErr);
+                proc.removeListener('unhandledRejection', onErr);
+            };
+        },
+    };
+}
+//# sourceMappingURL=process-lifecycle.js.map

package/dist/esm/runtime/process-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-lifecycle.js","sourceRoot":"","sources":["../../../src/runtime/process-lifecycle.ts"],"names":[],"mappings":"AASA,SAAS,UAAU;IACjB,IAAI,OAAO,OAAO,KAAK,WAAW,IAAI,OAAQ,OAA4B,CAAC,EAAE,KAAK,UAAU,EAAE,CAAC;QAC7F,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,OAA0B,CAAC;AACpC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,sBAAsB;IACpC,OAAO;QACL,iBAAiB,CAAC,EAAE;YAClB,MAAM,IAAI,GAAG,UAAU,EAAE,CAAC;YAC1B,IAAI,CAAC,IAAI;gBAAE,OAAO,GAAG,EAAE,GAAE,CAAC,CAAC;YAE3B,sEAAsE;YACtE,0EAA0E;YAC1E,0DAA0D;YAC1D,MAAM,YAAY,GAAG,GAAS,EAAE;gBAC9B,KAAK,EAAE,EAAE,CAAC;YACZ,CAAC,CAAC;YACF,0EAA0E;YAC1E,8DAA8D;YAC9D,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAQ,EAAE;gBACtC,KAAK,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;oBACtC,IAAI,CAAC;wBACH,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAClB,CAAC;oBAAC,MAAM,CAAC;wBACP,YAAY;oBACd,CAAC;gBACH,CAAC,CAAC,CAAC;YACL,CAAC,CAAC;YACF,MAAM,QAAQ,GAAG,GAAS,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAC3C,MAAM,SAAS,GAAG,GAAS,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAE5C,IAAI,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;YACpC,IAAI,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;YAC5B,IAAI,CAAC,EAAE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;YAC9B,OAAO,GAAG,EAAE;gBACV,IAAI,CAAC,cAAc,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;gBAChD,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;gBACxC,IAAI,CAAC,cAAc,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;YAC5C,CAAC,CAAC;QACJ,CAAC;QAED,eAAe,CAAC,EAAE;YAChB,MAAM,IAAI,GAAG,UAAU,EAAE,CAAC;YAC1B,IAAI,CAAC,IAAI;gBAAE,OAAO,GAAG,EAAE,GAAE,CAAC,CAAC;YAE3B,0EAA0E;YAC1E,mEAAmE;YACnE,MAAM,KAAK,GAAG,CAAC,GAAY,EAAQ,EAAE;gBACnC,KAAK,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;oBACzC,IAAI,CAAC;wBACH,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oBACf,CAAC;oBAAC,MAAM,CAAC;wBACP,YAAY;oBACd,CAAC;gBACH,CAAC,CAAC,CAAC;YACL,CAAC,CAAC;YACF,IAAI,CAAC,EAAE,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAC;YACpC,IAAI,CAAC,EAAE,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;YACrC,OAAO,GAAG,EAAE;gBACV,IAAI,CAAC,cAAc,CAAC,mBAAmB,EAAE,KAAK,CAAC,CAAC;gBAChD,IAAI,CAAC,cAAc,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;YACnD,CAAC,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/esm/runtime/web-lifecycle.d.ts

@@ -0,0 +1,13 @@
+import type { LifecycleHooks } from './adapter.js';
+/**
+ * Web lifecycle: flush pending entries when the page is being unloaded. There
+ * is no `process.exit` and no `uncaughtException` concept in a browser, so this
+ * only implements the "flush before close" hook (via `pagehide` /
+ * `visibilitychange`) and intentionally omits `onUncaughtError`.
+ *
+ * The flush is best-effort: the browser terminates the page after the unload
+ * event regardless, so the logger's own flush timeout is what bounds how long
+ * we wait.
+ */
+export declare function createWebLifecycle(): LifecycleHooks;
+//# sourceMappingURL=web-lifecycle.d.ts.map

package/dist/esm/runtime/web-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/runtime/web-lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAanD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,IAAI,cAAc,CAmBnD"}

package/dist/esm/runtime/web-lifecycle.js

@@ -0,0 +1,36 @@
+function getWindow() {
+    if (typeof window === 'undefined')
+        return undefined;
+    return window;
+}
+/**
+ * Web lifecycle: flush pending entries when the page is being unloaded. There
+ * is no `process.exit` and no `uncaughtException` concept in a browser, so this
+ * only implements the "flush before close" hook (via `pagehide` /
+ * `visibilitychange`) and intentionally omits `onUncaughtError`.
+ *
+ * The flush is best-effort: the browser terminates the page after the unload
+ * event regardless, so the logger's own flush timeout is what bounds how long
+ * we wait.
+ */
+export function createWebLifecycle() {
+    return {
+        onFlushBeforeExit(cb) {
+            const win = getWindow();
+            if (!win)
+                return () => { };
+            const onHide = () => {
+                void cb();
+            };
+            // `pagehide` fires on tab close / navigation. `visibilitychange` covers
+            // the backgrounded / mobile case where the page may be discarded.
+            win.addEventListener('pagehide', onHide);
+            win.addEventListener('visibilitychange', onHide);
+            return () => {
+                win.removeEventListener('pagehide', onHide);
+                win.removeEventListener('visibilitychange', onHide);
+            };
+        },
+    };
+}
+//# sourceMappingURL=web-lifecycle.js.map

package/dist/esm/runtime/web-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-lifecycle.js","sourceRoot":"","sources":["../../../src/runtime/web-lifecycle.ts"],"names":[],"mappings":"AAQA,SAAS,SAAS;IAChB,IAAI,OAAO,MAAM,KAAK,WAAW;QAAE,OAAO,SAAS,CAAC;IACpD,OAAO,MAAwB,CAAC;AAClC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,kBAAkB;IAChC,OAAO;QACL,iBAAiB,CAAC,EAAE;YAClB,MAAM,GAAG,GAAG,SAAS,EAAE,CAAC;YACxB,IAAI,CAAC,GAAG;gBAAE,OAAO,GAAG,EAAE,GAAE,CAAC,CAAC;YAE1B,MAAM,MAAM,GAAG,GAAS,EAAE;gBACxB,KAAK,EAAE,EAAE,CAAC;YACZ,CAAC,CAAC;YACF,wEAAwE;YACxE,kEAAkE;YAClE,GAAG,CAAC,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;YACzC,GAAG,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;YACjD,OAAO,GAAG,EAAE;gBACV,GAAG,CAAC,mBAAmB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;gBAC5C,GAAG,CAAC,mBAAmB,CAAC,kBAAkB,EAAE,MAAM,CAAC,CAAC;YACtD,CAAC,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/esm/runtime/web.d.ts

@@ -0,0 +1,14 @@
+import type { RuntimeAdapter } from './adapter.js';
+/**
+ * Web runtime (browsers + Node worker_threads). No process id, no filesystem,
+ * console only by default. Remote HTTP transports can be added by the
+ * application.
+ *
+ * **Worker support.** When running inside a Web Worker or Node worker_threads
+ * worker, the runtime automatically detects the Worker context and sends
+ * entries to the main/parent thread via `postMessage()`. The parent thread
+ * receives them via `registerWorkerReceiver()` (attached automatically by
+ * `createWebRuntime()`).
+ */
+export declare function createWebRuntime(): RuntimeAdapter;
+//# sourceMappingURL=web.d.ts.map

package/dist/esm/runtime/web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../../src/runtime/web.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA8BnD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,IAAI,cAAc,CAuBjD"}