lograil 0.1.0

package/dist/cjs/runtime/electron-lifecycle.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createElectronLifecycle = createElectronLifecycle;
+const electron_binding_js_1 = require("./electron-binding.js");
+const process_lifecycle_js_1 = require("./process-lifecycle.js");
+/**
+ * Electron **main process** lifecycle hooks.
+ *
+ * GUI-driven termination goes through the Electron `app` event surface
+ * (`before-quit` / `will-quit`) rather than Node's `process` events, which do
+ * not fire on a normal window close. We flush pending entries on those events,
+ * mirroring the existing Node `beforeExit` semantics (fire-and-forget, bounded
+ * by the logger's flush timeout). When `app` is unavailable (e.g. a plain Node
+ * host, or a test runtime), we fall back to the process-based hooks so the
+ * behaviour degrades gracefully.
+ *
+ * Uncaught-error handling stays on `process` (`uncaughtException` /
+ * `unhandledRejection`) — those are still the right surface inside Electron.
+ */
+function createElectronLifecycle() {
+    const app = (0, electron_binding_js_1.getElectronApp)();
+    const nodeFallback = () => (0, process_lifecycle_js_1.createProcessLifecycle)();
+    return {
+        onFlushBeforeExit(cb) {
+            if (!app)
+                return nodeFallback().onFlushBeforeExit(cb);
+            // `before-quit` fires first and covers the normal close path; `will-quit`
+            // covers the final teardown so a slow first flush still drains.
+            const onBeforeQuit = () => {
+                void cb();
+            };
+            const onWillQuit = () => {
+                void cb();
+            };
+            app.on('before-quit', onBeforeQuit);
+            app.on('will-quit', onWillQuit);
+            return () => {
+                app.removeListener('before-quit', onBeforeQuit);
+                app.removeListener('will-quit', onWillQuit);
+            };
+        },
+        onUncaughtError(cb) {
+            return nodeFallback().onUncaughtError?.(cb) ?? (() => { });
+        },
+    };
+}
+//# sourceMappingURL=electron-lifecycle.js.map

package/dist/cjs/runtime/electron-lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"electron-lifecycle.js","sourceRoot":"","sources":["../../../src/runtime/electron-lifecycle.ts"],"names":[],"mappings":";;AAkBA,0DA4BC;AA7CD,+DAAuD;AACvD,iEAAgE;AAEhE;;;;;;;;;;;;;GAaG;AACH,SAAgB,uBAAuB;IACrC,MAAM,GAAG,GAAG,IAAA,oCAAc,GAAE,CAAC;IAC7B,MAAM,YAAY,GAAG,GAAmB,EAAE,CAAC,IAAA,6CAAsB,GAAE,CAAC;IAEpE,OAAO;QACL,iBAAiB,CAAC,EAAE;YAClB,IAAI,CAAC,GAAG;gBAAE,OAAO,YAAY,EAAE,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;YAEtD,0EAA0E;YAC1E,gEAAgE;YAChE,MAAM,YAAY,GAAG,GAAS,EAAE;gBAC9B,KAAK,EAAE,EAAE,CAAC;YACZ,CAAC,CAAC;YACF,MAAM,UAAU,GAAG,GAAS,EAAE;gBAC5B,KAAK,EAAE,EAAE,CAAC;YACZ,CAAC,CAAC;YACF,GAAG,CAAC,EAAE,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;YACpC,GAAG,CAAC,EAAE,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;YAChC,OAAO,GAAG,EAAE;gBACV,GAAG,CAAC,cAAc,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;gBAChD,GAAG,CAAC,cAAc,CAAC,WAAW,EAAE,UAAU,CAAC,CAAC;YAC9C,CAAC,CAAC;QACJ,CAAC;QAED,eAAe,CAAC,EAAE;YAChB,OAAO,YAAY,EAAE,CAAC,eAAe,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAC5D,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/cjs/runtime/electron-main.d.ts

@@ -0,0 +1,24 @@
+import type { RuntimeAdapter } from './adapter.js';
+import type { RotateTimeOptions } from '../transport/file.js';
+export interface ElectronMainRuntimeOptions {
+    /** Forwarded to the main/renderer `FileTransport` (mode `rotate-time`). */
+    fileTransportOptions?: Partial<Omit<RotateTimeOptions, 'mode'>>;
+    /** Disable the file transport entirely (console only). */
+    disableFile?: boolean;
+    /**
+     * Listen for renderer entries over IPC and write them to the dedicated
+     * `renderer.{date}.log` file (default `true`). Main-process entries
+     * go to `main.{date}.log`. By default both land under the app's `logs`
+     * directory (`app.getPath('logs')`); pass `fileTransportOptions: { dir }`
+     * to place them elsewhere.
+     */
+    receiveFromRenderer?: boolean;
+}
+/**
+ * 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 declare function createElectronMainRuntime(options?: ElectronMainRuntimeOptions): RuntimeAdapter;
+//# sourceMappingURL=electron-main.d.ts.map

package/dist/cjs/runtime/electron-main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"electron-main.d.ts","sourceRoot":"","sources":["../../../src/runtime/electron-main.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAGnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAS9D,MAAM,WAAW,0BAA0B;IACzC,2EAA2E;IAC3E,oBAAoB,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC,CAAC;IAChE,0DAA0D;IAC1D,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAyBD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,0BAA+B,GACvC,cAAc,CAkEhB"}

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createElectronMainRuntime = createElectronMainRuntime;
+const console_js_1 = require("../transport/console.js");
+const file_js_1 = require("../transport/file.js");
+const electron_ipc_js_1 = require("../transport/electron-ipc.js");
+const electron_binding_js_1 = require("./electron-binding.js");
+const electron_lifecycle_js_1 = require("./electron-lifecycle.js");
+const index_js_1 = require("../shims/index.js");
+const index_js_2 = require("../shims/index.js");
+const defaults_js_1 = require("./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 = (0, electron_binding_js_1.getElectronApp)();
+    if (app?.getPath) {
+        try {
+            return app.getPath('logs');
+        }
+        catch {
+            /* app not ready yet — try the next fallback */
+        }
+        try {
+            return (0, index_js_2.join)(app.getPath('appData'), 'Logs');
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return (0, index_js_1.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.
+ */
+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 console_js_1.ConsoleTransport()];
+            if (!options.disableFile) {
+                const dir = defaultElectronLogDir();
+                transports.push(new file_js_1.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.
+                    ...defaults_js_1.DEFAULT_FILE_CAPS,
+                    // Main-process entries only: renderer entries are routed to the
+                    // dedicated renderer log file below.
+                    filter: (entry) => entry.metadata?.[electron_ipc_js_1.RENDERER_PROCESS_MARKER] !== 'renderer',
+                    ...options.fileTransportOptions,
+                }));
+                if (receiveFromRenderer) {
+                    transports.push(new file_js_1.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.
+                        ...defaults_js_1.DEFAULT_FILE_CAPS,
+                        // Renderer entries only.
+                        filter: (entry) => entry.metadata?.[electron_ipc_js_1.RENDERER_PROCESS_MARKER] === 'renderer',
+                        ...options.fileTransportOptions,
+                    }));
+                }
+            }
+            return transports;
+        },
+        lifecycle: (0, electron_lifecycle_js_1.createElectronLifecycle)(),
+    };
+    if (receiveFromRenderer) {
+        runtime.attachReceiver = (ingest) => {
+            try {
+                return (0, electron_ipc_js_1.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/cjs/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/cjs/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/cjs/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/cjs/runtime/electron-renderer.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createElectronRendererRuntime = createElectronRendererRuntime;
+const console_js_1 = require("../transport/console.js");
+const electron_ipc_js_1 = require("../transport/electron-ipc.js");
+const web_lifecycle_js_1 = require("./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.
+ */
+function createElectronRendererRuntime(options = {}) {
+    const forwardToMain = options.forwardToMain ?? true;
+    return {
+        name: 'electron',
+        processType: 'renderer',
+        now: () => Date.now(),
+        pid: () => undefined,
+        hasFileSystem: () => false,
+        defaultTransports: () => {
+            const transports = [new console_js_1.ConsoleTransport()];
+            if (forwardToMain) {
+                transports.push(new electron_ipc_js_1.ElectronIpcTransport({
+                    channel: options.channel,
+                    ipcRenderer: options.ipcRenderer,
+                }));
+            }
+            return transports;
+        },
+        lifecycle: (0, web_lifecycle_js_1.createWebLifecycle)(),
+    };
+}
+//# sourceMappingURL=electron-renderer.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"electron-renderer.js","sourceRoot":"","sources":["../../../src/runtime/electron-renderer.ts"],"names":[],"mappings":";;AA8BA,sEAyBC;AApDD,wDAA2D;AAC3D,kEAAoE;AACpE,yDAAwD;AAoBxD;;;;GAIG;AACH,SAAgB,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,6BAAgB,EAAE,CAAC,CAAC;YACzD,IAAI,aAAa,EAAE,CAAC;gBAClB,UAAU,CAAC,IAAI,CACb,IAAI,sCAAoB,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,IAAA,qCAAkB,GAAE;KAChC,CAAC;AACJ,CAAC"}

package/dist/cjs/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/cjs/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/cjs/runtime/electron.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createElectronRendererRuntime = exports.createElectronMainRuntime = void 0;
+exports.createElectronRuntime = createElectronRuntime;
+const electron_main_js_1 = require("./electron-main.js");
+const electron_renderer_js_1 = require("./electron-renderer.js");
+var electron_main_js_2 = require("./electron-main.js");
+Object.defineProperty(exports, "createElectronMainRuntime", { enumerable: true, get: function () { return electron_main_js_2.createElectronMainRuntime; } });
+var electron_renderer_js_2 = require("./electron-renderer.js");
+Object.defineProperty(exports, "createElectronRendererRuntime", { enumerable: true, get: function () { return electron_renderer_js_2.createElectronRendererRuntime; } });
+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.
+ */
+function createElectronRuntime(options = {}) {
+    return isMainProcess()
+        ? (0, electron_main_js_1.createElectronMainRuntime)(options)
+        : (0, electron_renderer_js_1.createElectronRendererRuntime)(options);
+}
+//# sourceMappingURL=electron.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"electron.js","sourceRoot":"","sources":["../../../src/runtime/electron.ts"],"names":[],"mappings":";;;AAgCA,sDAIC;AAnCD,yDAA+D;AAE/D,iEAAuE;AAGvE,uDAA+D;AAAtD,6HAAA,yBAAyB,OAAA;AAElC,+DAAuE;AAA9D,qIAAA,6BAA6B,OAAA;AAUtC,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,SAAgB,qBAAqB,CAAC,UAAkC,EAAE;IACxE,OAAO,aAAa,EAAE;QACpB,CAAC,CAAC,IAAA,4CAAyB,EAAC,OAAO,CAAC;QACpC,CAAC,CAAC,IAAA,oDAA6B,EAAC,OAAO,CAAC,CAAC;AAC7C,CAAC"}

package/dist/cjs/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/cjs/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/cjs/runtime/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGRAIL_CHANNEL = exports.registerIpcReceiver = exports.ElectronIpcTransport = exports.createElectronRendererRuntime = exports.createElectronMainRuntime = exports.createElectronRuntime = exports.createNodeRuntime = exports.createWebRuntime = void 0;
+exports.detectRuntime = detectRuntime;
+const web_js_1 = require("./web.js");
+const node_js_1 = require("./node.js");
+const electron_js_1 = require("./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.
+ */
+function detectRuntime(options = {}) {
+    const versions = (typeof process !== 'undefined'
+        ? process.versions
+        : undefined) ?? {};
+    if (versions.electron) {
+        return (0, electron_js_1.createElectronRuntime)(options);
+    }
+    if (versions.node) {
+        return (0, node_js_1.createNodeRuntime)(options);
+    }
+    return (0, web_js_1.createWebRuntime)();
+}
+var web_js_2 = require("./web.js");
+Object.defineProperty(exports, "createWebRuntime", { enumerable: true, get: function () { return web_js_2.createWebRuntime; } });
+var node_js_2 = require("./node.js");
+Object.defineProperty(exports, "createNodeRuntime", { enumerable: true, get: function () { return node_js_2.createNodeRuntime; } });
+var electron_js_2 = require("./electron.js");
+Object.defineProperty(exports, "createElectronRuntime", { enumerable: true, get: function () { return electron_js_2.createElectronRuntime; } });
+Object.defineProperty(exports, "createElectronMainRuntime", { enumerable: true, get: function () { return electron_js_2.createElectronMainRuntime; } });
+Object.defineProperty(exports, "createElectronRendererRuntime", { enumerable: true, get: function () { return electron_js_2.createElectronRendererRuntime; } });
+var electron_ipc_js_1 = require("../transport/electron-ipc.js");
+Object.defineProperty(exports, "ElectronIpcTransport", { enumerable: true, get: function () { return electron_ipc_js_1.ElectronIpcTransport; } });
+Object.defineProperty(exports, "registerIpcReceiver", { enumerable: true, get: function () { return electron_ipc_js_1.registerIpcReceiver; } });
+Object.defineProperty(exports, "LOGRAIL_CHANNEL", { enumerable: true, get: function () { return electron_ipc_js_1.LOGRAIL_CHANNEL; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/index.ts"],"names":[],"mappings":";;;AAkBA,sCAaC;AA9BD,qCAA4C;AAE5C,uCAA8C;AAE9C,+CAAsD;AAItD;;;;;;;;GAQG;AACH,SAAgB,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,IAAA,mCAAqB,EAAC,OAAO,CAAC,CAAC;IACxC,CAAC;IACD,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC;QAClB,OAAO,IAAA,2BAAiB,EAAC,OAAO,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,IAAA,yBAAgB,GAAE,CAAC;AAC5B,CAAC;AAGD,mCAA4C;AAAnC,0GAAA,gBAAgB,OAAA;AACzB,qCAA8C;AAArC,4GAAA,iBAAiB,OAAA;AAC1B,6CAIuB;AAHrB,oHAAA,qBAAqB,OAAA;AACrB,wHAAA,yBAAyB,OAAA;AACzB,4HAAA,6BAA6B,OAAA;AAO/B,gEAIsC;AAHpC,uHAAA,oBAAoB,OAAA;AACpB,sHAAA,mBAAmB,OAAA;AACnB,kHAAA,eAAe,OAAA"}

package/dist/cjs/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/cjs/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/cjs/runtime/node.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeRuntime = createNodeRuntime;
+const console_js_1 = require("../transport/console.js");
+const file_js_1 = require("../transport/file.js");
+const cluster_ipc_js_1 = require("../transport/cluster-ipc.js");
+const worker_ipc_js_1 = require("../transport/worker-ipc.js");
+const process_lifecycle_js_1 = require("./process-lifecycle.js");
+const index_js_1 = require("../shims/index.js");
+const index_js_2 = require("../shims/index.js");
+const index_js_3 = require("../shims/index.js");
+const defaults_js_1 = require("./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 (0, index_js_2.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 = (0, process_lifecycle_js_1.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.
+ */
+function createNodeRuntime(options = {}) {
+    const pid = typeof process !== 'undefined' ? process.pid : undefined;
+    const worker = (0, index_js_3.isClusterWorker)();
+    // ── Cluster worker: no file, send to primary via IPC ──
+    if (worker) {
+        return {
+            name: 'node',
+            now: () => Date.now(),
+            pid: () => pid,
+            hasFileSystem: () => false,
+            defaultTransports: () => [new console_js_1.ConsoleTransport(), new cluster_ipc_js_1.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 console_js_1.ConsoleTransport(), new worker_ipc_js_1.WorkerIpcTransport()],
+            lifecycle: createClusterWorkerLifecycle(), // reuse: flush on disconnect/exit
+        };
+    }
+    // ── Primary or non-cluster: console + file (default) ──
+    const transports = [new console_js_1.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 file_js_1.FileTransport({
+            mode: 'rotate-time',
+            unit: 'day',
+            appName,
+            dir: (0, index_js_1.tmpdir)(),
+            ...defaults_js_1.DEFAULT_FILE_CAPS,
+            ...options.fileTransportOptions,
+        }));
+    }
+    return {
+        name: 'node',
+        now: () => Date.now(),
+        pid: () => pid,
+        hasFileSystem: () => !options.disableFile,
+        defaultTransports: () => transports,
+        attachReceiver: (ingest) => (0, cluster_ipc_js_1.registerClusterReceiver)(ingest),
+        lifecycle: (0, process_lifecycle_js_1.createProcessLifecycle)(),
+    };
+}
+//# sourceMappingURL=node.js.map

package/dist/cjs/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/cjs/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/cjs/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"}