@push.rocks/smartrust 1.2.1 → 1.3.0

package/dist_ts/classes.sockettransport.js

@@ -0,0 +1,138 @@
+import * as plugins from './plugins.js';
+import { LineScanner } from './classes.linescanner.js';
+/**
+ * Transport that connects to an already-running process via Unix socket or Windows named pipe.
+ * The JSON-over-newline protocol is identical to stdio; only the transport changes.
+ */
+export class SocketTransport extends plugins.events.EventEmitter {
+    options;
+    socket = null;
+    lineScanner;
+    _connected = false;
+    intentionalDisconnect = false;
+    reconnectAttempts = 0;
+    reconnectTimer = null;
+    constructor(options) {
+        super();
+        this.options = {
+            autoReconnect: false,
+            reconnectBaseDelayMs: 100,
+            reconnectMaxDelayMs: 30000,
+            maxReconnectAttempts: 10,
+            ...options,
+        };
+        this.lineScanner = new LineScanner(options.maxPayloadSize, options.logger);
+    }
+    get connected() {
+        return this._connected;
+    }
+    /**
+     * Connect to the socket. Resolves when the TCP/Unix connection is established.
+     */
+    async connect() {
+        this.intentionalDisconnect = false;
+        this.reconnectAttempts = 0;
+        return this.doConnect();
+    }
+    doConnect() {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            this.socket = plugins.net.connect({ path: this.options.socketPath });
+            this.socket.on('connect', () => {
+                if (!settled) {
+                    settled = true;
+                    this._connected = true;
+                    this.reconnectAttempts = 0;
+                    resolve();
+                }
+            });
+            this.socket.on('data', (chunk) => {
+                this.lineScanner.push(chunk, (line) => {
+                    this.emit('line', line);
+                });
+            });
+            this.socket.on('close', () => {
+                const wasConnected = this._connected;
+                this._connected = false;
+                this.lineScanner.clear();
+                if (!this.intentionalDisconnect && wasConnected && this.options.autoReconnect) {
+                    this.attemptReconnect();
+                }
+                this.emit('close');
+            });
+            this.socket.on('error', (err) => {
+                this._connected = false;
+                if (!settled) {
+                    settled = true;
+                    reject(err);
+                }
+                else if (!this.intentionalDisconnect) {
+                    this.emit('error', err);
+                }
+            });
+        });
+    }
+    attemptReconnect() {
+        if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+            this.options.logger.log('error', `Max reconnect attempts (${this.options.maxReconnectAttempts}) reached`);
+            this.emit('reconnect_failed');
+            return;
+        }
+        const delay = Math.min(this.options.reconnectBaseDelayMs * Math.pow(2, this.reconnectAttempts), this.options.reconnectMaxDelayMs);
+        this.reconnectAttempts++;
+        this.options.logger.log('info', `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.options.maxReconnectAttempts})`);
+        this.reconnectTimer = setTimeout(async () => {
+            this.reconnectTimer = null;
+            try {
+                await this.doConnect();
+                this.emit('reconnected');
+            }
+            catch {
+                // doConnect rejected — the 'close' handler on the new socket will trigger another attempt
+            }
+        }, delay);
+    }
+    /**
+     * Write data to the socket with backpressure support.
+     */
+    async write(data) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this._connected) {
+                reject(new Error('Socket not connected'));
+                return;
+            }
+            const canContinue = this.socket.write(data, 'utf8', (err) => {
+                if (err) {
+                    reject(err);
+                }
+            });
+            if (canContinue) {
+                resolve();
+            }
+            else {
+                this.socket.once('drain', () => {
+                    resolve();
+                });
+            }
+        });
+    }
+    /**
+     * Close the socket connection. Does NOT kill the remote daemon.
+     */
+    disconnect() {
+        this.intentionalDisconnect = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.socket) {
+            const sock = this.socket;
+            this.socket = null;
+            this._connected = false;
+            this.lineScanner.clear();
+            sock.removeAllListeners();
+            sock.destroy();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.stdiotransport.d.ts

@@ -0,0 +1,35 @@
+import * as plugins from './plugins.js';
+import type { IRustBridgeLogger } from './interfaces/index.js';
+import type { IRustTransport } from './interfaces/transport.js';
+export interface IStdioTransportOptions {
+    binaryPath: string;
+    cliArgs: string[];
+    env?: Record<string, string>;
+    maxPayloadSize: number;
+    logger: IRustBridgeLogger;
+}
+/**
+ * Transport that spawns a child process and communicates via stdin/stdout.
+ * Extracted from the original RustBridge process management logic.
+ */
+export declare class StdioTransport extends plugins.events.EventEmitter implements IRustTransport {
+    private options;
+    private childProcess;
+    private lineScanner;
+    private stderrRemainder;
+    private _connected;
+    constructor(options: IStdioTransportOptions);
+    get connected(): boolean;
+    /**
+     * Spawn the child process. Resolves when the process is running (not necessarily ready).
+     */
+    connect(): Promise<void>;
+    /**
+     * Write data to stdin with backpressure support.
+     */
+    write(data: string): Promise<void>;
+    /**
+     * Kill the child process. Sends SIGTERM, then SIGKILL after 5s.
+     */
+    disconnect(): void;
+}

package/dist_ts/classes.stdiotransport.js

@@ -0,0 +1,136 @@
+import * as plugins from './plugins.js';
+import { LineScanner } from './classes.linescanner.js';
+/**
+ * Transport that spawns a child process and communicates via stdin/stdout.
+ * Extracted from the original RustBridge process management logic.
+ */
+export class StdioTransport extends plugins.events.EventEmitter {
+    options;
+    childProcess = null;
+    lineScanner;
+    stderrRemainder = '';
+    _connected = false;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.lineScanner = new LineScanner(options.maxPayloadSize, options.logger);
+    }
+    get connected() {
+        return this._connected;
+    }
+    /**
+     * Spawn the child process. Resolves when the process is running (not necessarily ready).
+     */
+    async connect() {
+        const env = this.options.env
+            ? { ...process.env, ...this.options.env }
+            : { ...process.env };
+        this.childProcess = plugins.childProcess.spawn(this.options.binaryPath, this.options.cliArgs, { stdio: ['pipe', 'pipe', 'pipe'], env });
+        // Handle stderr with cross-chunk buffering
+        this.childProcess.stderr?.on('data', (data) => {
+            this.stderrRemainder += data.toString();
+            const lines = this.stderrRemainder.split('\n');
+            this.stderrRemainder = lines.pop();
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    this.emit('stderr', trimmed);
+                }
+            }
+        });
+        // Handle stdout via LineScanner
+        this.childProcess.stdout.on('data', (chunk) => {
+            this.lineScanner.push(chunk, (line) => {
+                this.emit('line', line);
+            });
+        });
+        // Handle process exit
+        this.childProcess.on('exit', (code, signal) => {
+            // Flush remaining stderr
+            if (this.stderrRemainder.trim()) {
+                this.emit('stderr', this.stderrRemainder.trim());
+            }
+            this._connected = false;
+            this.lineScanner.clear();
+            this.stderrRemainder = '';
+            this.emit('close', code, signal);
+        });
+        this.childProcess.on('error', (err) => {
+            this._connected = false;
+            this.emit('error', err);
+        });
+        this._connected = true;
+    }
+    /**
+     * Write data to stdin with backpressure support.
+     */
+    async write(data) {
+        return new Promise((resolve, reject) => {
+            if (!this.childProcess?.stdin) {
+                reject(new Error('stdin not available'));
+                return;
+            }
+            const canContinue = this.childProcess.stdin.write(data, 'utf8', (err) => {
+                if (err) {
+                    reject(err);
+                }
+            });
+            if (canContinue) {
+                resolve();
+            }
+            else {
+                this.childProcess.stdin.once('drain', () => {
+                    resolve();
+                });
+            }
+        });
+    }
+    /**
+     * Kill the child process. Sends SIGTERM, then SIGKILL after 5s.
+     */
+    disconnect() {
+        if (!this.childProcess)
+            return;
+        const proc = this.childProcess;
+        this.childProcess = null;
+        this._connected = false;
+        this.lineScanner.clear();
+        this.stderrRemainder = '';
+        // Remove all listeners
+        proc.removeAllListeners();
+        proc.stdout?.removeAllListeners();
+        proc.stderr?.removeAllListeners();
+        proc.stdin?.removeAllListeners();
+        // Kill the process
+        try {
+            proc.kill('SIGTERM');
+        }
+        catch { /* already dead */ }
+        // Destroy stdio pipes
+        try {
+            proc.stdin?.destroy();
+        }
+        catch { /* ignore */ }
+        try {
+            proc.stdout?.destroy();
+        }
+        catch { /* ignore */ }
+        try {
+            proc.stderr?.destroy();
+        }
+        catch { /* ignore */ }
+        // Unref so Node doesn't wait
+        try {
+            proc.unref();
+        }
+        catch { /* ignore */ }
+        // Force kill after 5 seconds
+        setTimeout(() => {
+            try {
+                proc.kill('SIGKILL');
+            }
+            catch { /* already dead */ }
+        }, 5000).unref();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -1,4 +1,7 @@
 export { RustBridge } from './classes.rustbridge.js';
 export { RustBinaryLocator } from './classes.rustbinarylocator.js';
 export { StreamingResponse } from './classes.streamingresponse.js';
+export { StdioTransport } from './classes.stdiotransport.js';
+export { SocketTransport } from './classes.sockettransport.js';
+export { LineScanner } from './classes.linescanner.js';
 export * from './interfaces/index.js';

package/dist_ts/index.js

@@ -1,5 +1,8 @@
 export { RustBridge } from './classes.rustbridge.js';
 export { RustBinaryLocator } from './classes.rustbinarylocator.js';
 export { StreamingResponse } from './classes.streamingresponse.js';
+export { StdioTransport } from './classes.stdiotransport.js';
+export { SocketTransport } from './classes.sockettransport.js';
+export { LineScanner } from './classes.linescanner.js';
 export * from './interfaces/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDckQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDbkUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDbkUsY0FBYyx1QkFBdUIsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFDckQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDbkUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDbkUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQzdELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUMvRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDdkQsY0FBYyx1QkFBdUIsQ0FBQyJ9

package/dist_ts/interfaces/config.d.ts

@@ -43,3 +43,16 @@ export interface IRustBridgeOptions extends IBinaryLocatorOptions {
      *  Resets on each chunk received. */
     streamTimeoutMs?: number;
 }
+/**
+ * Options for connecting to an already-running daemon via Unix socket or named pipe.
+ */
+export interface ISocketConnectOptions {
+    /** Enable auto-reconnect on unexpected disconnect (default: false) */
+    autoReconnect?: boolean;
+    /** Initial delay between reconnect attempts in ms (default: 100) */
+    reconnectBaseDelayMs?: number;
+    /** Maximum delay between reconnect attempts in ms (default: 30000) */
+    reconnectMaxDelayMs?: number;
+    /** Maximum number of reconnect attempts before giving up (default: 10) */
+    maxReconnectAttempts?: number;
+}

package/dist_ts/interfaces/index.d.ts

@@ -1,2 +1,3 @@
 export * from './ipc.js';
 export * from './config.js';
+export * from './transport.js';

package/dist_ts/interfaces/index.js

@@ -1,3 +1,4 @@
 export * from './ipc.js';
 export * from './config.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDIn0=
+export * from './transport.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9pbnRlcmZhY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZ0JBQWdCLENBQUMifQ==

package/dist_ts/interfaces/transport.d.ts

@@ -0,0 +1,22 @@
+import type * as plugins from '../plugins.js';
+/**
+ * Abstract transport for communicating with a Rust process.
+ * Both stdio and socket transports implement this interface.
+ *
+ * Events emitted:
+ * - 'line' (line: string) — a complete newline-terminated JSON line received
+ * - 'error' (err: Error) — transport-level error
+ * - 'close' (...args: any[]) — transport has closed/disconnected
+ * - 'stderr' (line: string) — stderr output (stdio transport only)
+ * - 'reconnected' () — transport reconnected after unexpected disconnect (socket only)
+ */
+export interface IRustTransport extends plugins.events.EventEmitter {
+    /** Connect the transport (spawn process or connect to socket). Resolves when I/O channel is open. */
+    connect(): Promise<void>;
+    /** Write a string to the transport. Handles backpressure. */
+    write(data: string): Promise<void>;
+    /** Disconnect the transport. For stdio: kills the process. For socket: closes the connection. */
+    disconnect(): void;
+    /** Whether the transport is currently connected and writable. */
+    readonly connected: boolean;
+}

package/dist_ts/interfaces/transport.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNwb3J0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvaW50ZXJmYWNlcy90cmFuc3BvcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist_ts/plugins.d.ts

@@ -3,6 +3,7 @@ import * as fs from 'fs';
 import * as childProcess from 'child_process';
 import * as events from 'events';
 import * as url from 'url';
-export { path, fs, childProcess, events, url };
+import * as net from 'net';
+export { path, fs, childProcess, events, url, net };
 import * as smartpath from '@push.rocks/smartpath';
 export { smartpath };

package/dist_ts/plugins.js

@@ -4,8 +4,9 @@ import * as fs from 'fs';
 import * as childProcess from 'child_process';
 import * as events from 'events';
 import * as url from 'url';
-export { path, fs, childProcess, events, url };
+import * as net from 'net';
+export { path, fs, childProcess, events, url, net };
 // @push.rocks scope
 import * as smartpath from '@push.rocks/smartpath';
 export { smartpath };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZUFBZTtBQUNmLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxZQUFZLE1BQU0sZUFBZSxDQUFDO0FBQzlDLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBRTNCLE9BQU8sRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLENBQUM7QUFFL0Msb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUFFLFNBQVMsRUFBRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZUFBZTtBQUNmLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxZQUFZLE1BQU0sZUFBZSxDQUFDO0FBQzlDLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBRTNCLE9BQU8sRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxDQUFDO0FBRXBELG9CQUFvQjtBQUNwQixPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBRW5ELE9BQU8sRUFBRSxTQUFTLEVBQUUsQ0FBQyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartrust",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "private": false,
   "description": "a bridge between JS engines and rust",
   "main": "dist_ts/index.js",

package/test/helpers/mock-socket-server.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+/**
+ * Mock "Rust daemon" for testing the SocketTransport and RustBridge socket mode.
+ * Creates a Unix socket server, accepts connections, and speaks the same
+ * JSON-over-newline IPC protocol as mock-rust-binary.mjs.
+ *
+ * Usage: node mock-socket-server.mjs <socket-path>
+ * Signals readiness by writing a JSON line to stdout: {"socketPath":"...","ready":true}
+ */
+
+import * as net from 'net';
+import * as fs from 'fs';
+
+const socketPath = process.argv[2];
+if (!socketPath) {
+  process.stderr.write('Usage: mock-socket-server.mjs <socket-path>\n');
+  process.exit(1);
+}
+
+// Remove stale socket file
+try { fs.unlinkSync(socketPath); } catch { /* ignore */ }
+
+/**
+ * Backpressure-aware write to a socket.
+ */
+function writeResponse(conn, data) {
+  const json = JSON.stringify(data) + '\n';
+  if (!conn.write(json)) {
+    conn.once('drain', () => {});
+  }
+}
+
+function handleLine(line, conn) {
+  let request;
+  try {
+    request = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  const { id, method, params } = request;
+
+  if (method === 'echo') {
+    writeResponse(conn, { id, success: true, result: params });
+  } else if (method === 'largeEcho') {
+    writeResponse(conn, { id, success: true, result: params });
+  } else if (method === 'error') {
+    writeResponse(conn, { id, success: false, error: 'Test error message' });
+  } else if (method === 'emitEvent') {
+    writeResponse(conn, { event: params.eventName, data: params.eventData });
+    writeResponse(conn, { id, success: true, result: null });
+  } else if (method === 'slow') {
+    setTimeout(() => {
+      writeResponse(conn, { id, success: true, result: { delayed: true } });
+    }, 100);
+  } else if (method === 'streamEcho') {
+    const count = params.count || 0;
+    let sent = 0;
+    const interval = setInterval(() => {
+      if (sent < count) {
+        writeResponse(conn, { id, stream: true, data: { index: sent, value: `chunk_${sent}` } });
+        sent++;
+      } else {
+        clearInterval(interval);
+        writeResponse(conn, { id, success: true, result: { totalChunks: count } });
+      }
+    }, 10);
+  } else if (method === 'streamError') {
+    writeResponse(conn, { id, stream: true, data: { index: 0, value: 'before_error' } });
+    setTimeout(() => {
+      writeResponse(conn, { id, success: false, error: 'Stream error after chunk' });
+    }, 20);
+  } else if (method === 'streamEmpty') {
+    writeResponse(conn, { id, success: true, result: { totalChunks: 0 } });
+  } else if (method === 'exit') {
+    writeResponse(conn, { id, success: true, result: null });
+    // In socket mode, 'exit' just closes this connection, not the server
+    setTimeout(() => conn.end(), 50);
+  } else {
+    writeResponse(conn, { id, success: false, error: `Unknown method: ${method}` });
+  }
+}
+
+const server = net.createServer((conn) => {
+  // Send ready event on each new connection
+  writeResponse(conn, { event: 'ready', data: { version: '1.0.0' } });
+
+  // Buffer-based newline scanner for incoming data
+  let buffer = Buffer.alloc(0);
+  conn.on('data', (chunk) => {
+    buffer = Buffer.concat([buffer, chunk]);
+    let idx;
+    while ((idx = buffer.indexOf(0x0A)) !== -1) {
+      const lineBuffer = buffer.subarray(0, idx);
+      buffer = buffer.subarray(idx + 1);
+      const line = lineBuffer.toString('utf8').trim();
+      if (line) {
+        handleLine(line, conn);
+      }
+    }
+  });
+
+  conn.on('error', () => { /* ignore client errors */ });
+});
+
+server.listen(socketPath, () => {
+  // Signal to parent that the server is ready
+  process.stdout.write(JSON.stringify({ socketPath, ready: true }) + '\n');
+});
+
+// Handle SIGTERM gracefully
+process.on('SIGTERM', () => {
+  server.close();
+  try { fs.unlinkSync(socketPath); } catch { /* ignore */ }
+  process.exit(0);
+});
+
+// Handle SIGINT
+process.on('SIGINT', () => {
+  server.close();
+  try { fs.unlinkSync(socketPath); } catch { /* ignore */ }
+  process.exit(0);
+});

package/test/test.linescanner.node.ts

@@ -0,0 +1,89 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import { LineScanner } from '../ts/classes.linescanner.js';
+
+const noopLogger = { log() {} };
+
+tap.test('should parse a single complete line', async () => {
+  const scanner = new LineScanner(1024 * 1024, noopLogger);
+  const lines: string[] = [];
+  scanner.push(Buffer.from('{"hello":"world"}\n'), (line) => lines.push(line));
+  expect(lines.length).toEqual(1);
+  expect(lines[0]).toEqual('{"hello":"world"}');
+});
+
+tap.test('should parse multiple lines in one chunk', async () => {
+  const scanner = new LineScanner(1024 * 1024, noopLogger);
+  const lines: string[] = [];
+  scanner.push(Buffer.from('{"a":1}\n{"b":2}\n{"c":3}\n'), (line) => lines.push(line));
+  expect(lines.length).toEqual(3);
+  expect(lines[0]).toEqual('{"a":1}');
+  expect(lines[1]).toEqual('{"b":2}');
+  expect(lines[2]).toEqual('{"c":3}');
+});
+
+tap.test('should handle a line split across chunks', async () => {
+  const scanner = new LineScanner(1024 * 1024, noopLogger);
+  const lines: string[] = [];
+  scanner.push(Buffer.from('{"hel'), (line) => lines.push(line));
+  expect(lines.length).toEqual(0);
+  scanner.push(Buffer.from('lo":"world"}\n'), (line) => lines.push(line));
+  expect(lines.length).toEqual(1);
+  expect(lines[0]).toEqual('{"hello":"world"}');
+});
+
+tap.test('should drop oversized lines', async () => {
+  const scanner = new LineScanner(100, noopLogger);
+  const lines: string[] = [];
+  // Line is 200 chars + newline, exceeds maxPayloadSize of 100
+  const oversized = 'x'.repeat(200) + '\n';
+  scanner.push(Buffer.from(oversized), (line) => lines.push(line));
+  expect(lines.length).toEqual(0);
+});
+
+tap.test('should clear buffer on OOM (no newline, exceeds max)', async () => {
+  const scanner = new LineScanner(100, noopLogger);
+  const lines: string[] = [];
+  // Push 200 bytes without any newline — exceeds maxPayloadSize
+  scanner.push(Buffer.from('x'.repeat(200)), (line) => lines.push(line));
+  expect(lines.length).toEqual(0);
+  // After clearing, should work normally again
+  scanner.push(Buffer.from('{"ok":true}\n'), (line) => lines.push(line));
+  expect(lines.length).toEqual(1);
+  expect(lines[0]).toEqual('{"ok":true}');
+});
+
+tap.test('should skip empty lines', async () => {
+  const scanner = new LineScanner(1024 * 1024, noopLogger);
+  const lines: string[] = [];
+  scanner.push(Buffer.from('\n\n{"a":1}\n\n'), (line) => lines.push(line));
+  expect(lines.length).toEqual(1);
+  expect(lines[0]).toEqual('{"a":1}');
+});
+
+tap.test('should handle mixed complete and partial lines', async () => {
+  const scanner = new LineScanner(1024 * 1024, noopLogger);
+  const lines: string[] = [];
+  // First chunk: one complete line + start of second line
+  scanner.push(Buffer.from('{"first":1}\n{"sec'), (line) => lines.push(line));
+  expect(lines.length).toEqual(1);
+  // Second chunk: end of second line + complete third line
+  scanner.push(Buffer.from('ond":2}\n{"third":3}\n'), (line) => lines.push(line));
+  expect(lines.length).toEqual(3);
+  expect(lines[1]).toEqual('{"second":2}');
+  expect(lines[2]).toEqual('{"third":3}');
+});
+
+tap.test('clear should reset the buffer', async () => {
+  const scanner = new LineScanner(1024 * 1024, noopLogger);
+  const lines: string[] = [];
+  // Push partial data
+  scanner.push(Buffer.from('{"partial":'), (line) => lines.push(line));
+  // Clear
+  scanner.clear();
+  // Now push a complete new line — old partial should not affect it
+  scanner.push(Buffer.from('{"fresh":true}\n'), (line) => lines.push(line));
+  expect(lines.length).toEqual(1);
+  expect(lines[0]).toEqual('{"fresh":true}');
+});
+
+export default tap.start();