@push.rocks/smartrust 1.2.1 → 1.3.1

package/ts/classes.rustbridge.ts

@@ -1,15 +1,19 @@
 import * as plugins from './plugins.js';
 import { RustBinaryLocator } from './classes.rustbinarylocator.js';
 import { StreamingResponse } from './classes.streamingresponse.js';
+import { StdioTransport } from './classes.stdiotransport.js';
+import { SocketTransport } from './classes.sockettransport.js';
 import type {
   IRustBridgeOptions,
   IRustBridgeLogger,
+  ISocketConnectOptions,
   TCommandMap,
   IManagementRequest,
   IManagementResponse,
   IManagementEvent,
   TStreamingCommandKeys,
   TExtractChunk,
+  IRustTransport,
 } from './interfaces/index.js';
 
 const defaultLogger: IRustBridgeLogger = {
@@ -18,7 +22,8 @@ const defaultLogger: IRustBridgeLogger = {
 
 /**
  * Generic bridge between TypeScript and a Rust binary.
- * Communicates via JSON-over-stdin/stdout IPC protocol.
+ * Communicates via JSON-over-stdin/stdout IPC protocol (stdio mode)
+ * or JSON-over-Unix-socket/named-pipe (socket mode).
  *
  * @typeParam TCommands - Map of command names to their param/result types
  */
@@ -26,9 +31,7 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
   private locator: RustBinaryLocator;
   private options: Required<Pick<IRustBridgeOptions, 'cliArgs' | 'requestTimeoutMs' | 'readyTimeoutMs' | 'readyEventName' | 'maxPayloadSize'>> & IRustBridgeOptions;
   private logger: IRustBridgeLogger;
-  private childProcess: plugins.childProcess.ChildProcess | null = null;
-  private stdoutBuffer: Buffer = Buffer.alloc(0);
-  private stderrRemainder: string = '';
+  private transport: IRustTransport | null = null;
   private pendingRequests = new Map<string, {
     resolve: (value: any) => void;
     reject: (error: Error) => void;
@@ -63,71 +66,93 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
       return false;
     }
 
+    const transport = new StdioTransport({
+      binaryPath: this.binaryPath,
+      cliArgs: this.options.cliArgs,
+      env: this.options.env,
+      maxPayloadSize: this.options.maxPayloadSize,
+      logger: this.logger,
+    });
+
+    return this.connectWithTransport(transport);
+  }
+
+  /**
+   * Connect to an already-running Rust daemon via Unix socket or named pipe.
+   * Returns true if the connection was established and the daemon signaled readiness.
+   *
+   * @param socketPath - Path to Unix socket or Windows named pipe
+   * @param socketOptions - Optional socket connection options (reconnect, etc.)
+   */
+  public async connect(socketPath: string, socketOptions?: ISocketConnectOptions): Promise<boolean> {
+    const transport = new SocketTransport({
+      socketPath,
+      maxPayloadSize: this.options.maxPayloadSize,
+      logger: this.logger,
+      autoReconnect: socketOptions?.autoReconnect,
+      reconnectBaseDelayMs: socketOptions?.reconnectBaseDelayMs,
+      reconnectMaxDelayMs: socketOptions?.reconnectMaxDelayMs,
+      maxReconnectAttempts: socketOptions?.maxReconnectAttempts,
+    });
+
+    return this.connectWithTransport(transport);
+  }
+
+  /**
+   * Internal: wire up any transport and wait for the ready handshake.
+   */
+  private connectWithTransport(transport: IRustTransport): Promise<boolean> {
     return new Promise<boolean>((resolve) => {
       try {
-        const env = this.options.env
-          ? { ...process.env, ...this.options.env }
-          : { ...process.env };
+        this.transport = transport;
 
-        this.childProcess = plugins.childProcess.spawn(this.binaryPath!, this.options.cliArgs, {
-          stdio: ['pipe', 'pipe', 'pipe'],
-          env,
-        });
-
-        // Handle stderr with cross-chunk buffering
-        this.childProcess.stderr?.on('data', (data: Buffer) => {
-          this.stderrRemainder += data.toString();
-          const lines = this.stderrRemainder.split('\n');
-          // Keep the last element (incomplete line) as remainder
-          this.stderrRemainder = lines.pop()!;
-          for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed) {
-              this.logger.log('debug', `[${this.options.binaryName}] ${trimmed}`);
-              this.emit('stderr', trimmed);
-            }
-          }
-        });
+        // Wire transport events
+        transport.on('line', (line: string) => this.handleLine(line));
 
-        // Handle stdout via Buffer-based newline scanner
-        this.childProcess.stdout!.on('data', (chunk: Buffer) => {
-          this.handleStdoutChunk(chunk);
+        transport.on('stderr', (line: string) => {
+          this.logger.log('debug', `[${this.options.binaryName}] ${line}`);
+          this.emit('stderr', line);
         });
 
-        // Handle process exit
-        this.childProcess.on('exit', (code, signal) => {
-          this.logger.log('info', `Process exited (code=${code}, signal=${signal})`);
-          // Flush any remaining stderr
-          if (this.stderrRemainder.trim()) {
-            this.logger.log('debug', `[${this.options.binaryName}] ${this.stderrRemainder.trim()}`);
-            this.emit('stderr', this.stderrRemainder.trim());
-          }
+        transport.on('close', (...args: any[]) => {
+          this.logger.log('info', `Transport closed`);
           this.cleanup();
-          this.emit('exit', code, signal);
+          this.emit('exit', ...args);
         });
 
-        this.childProcess.on('error', (err) => {
-          this.logger.log('error', `Process error: ${err.message}`);
+        transport.on('error', (err: Error) => {
+          this.logger.log('error', `Transport error: ${err.message}`);
           this.cleanup();
           resolve(false);
         });
 
-        // Wait for the ready event
-        const readyTimeout = setTimeout(() => {
-          this.logger.log('error', `Process did not send ready event within ${this.options.readyTimeoutMs}ms`);
-          this.kill();
+        transport.on('reconnected', () => {
+          this.logger.log('info', 'Transport reconnected, waiting for ready event');
+          this.emit('reconnected');
+        });
+
+        // Connect the transport
+        transport.connect().then(() => {
+          // Wait for the ready event from the protocol layer
+          const readyTimeout = setTimeout(() => {
+            this.logger.log('error', `Process did not send ready event within ${this.options.readyTimeoutMs}ms`);
+            this.kill();
+            resolve(false);
+          }, this.options.readyTimeoutMs);
+
+          this.once(`management:${this.options.readyEventName}`, () => {
+            clearTimeout(readyTimeout);
+            this.isRunning = true;
+            this.logger.log('info', `Bridge connected to ${this.options.binaryName}`);
+            this.emit('ready');
+            resolve(true);
+          });
+        }).catch((err: Error) => {
+          this.logger.log('error', `Transport connect failed: ${err.message}`);
           resolve(false);
-        }, this.options.readyTimeoutMs);
-
-        this.once(`management:${this.options.readyEventName}`, () => {
-          clearTimeout(readyTimeout);
-          this.isRunning = true;
-          this.logger.log('info', `Bridge connected to ${this.options.binaryName}`);
-          this.emit('ready');
-          resolve(true);
         });
       } catch (err: any) {
-        this.logger.log('error', `Failed to spawn: ${err.message}`);
+        this.logger.log('error', `Failed to connect: ${err.message}`);
         resolve(false);
       }
     });
@@ -140,7 +165,7 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
     method: K,
     params: TCommands[K]['params'],
   ): Promise<TCommands[K]['result']> {
-    if (!this.childProcess || !this.isRunning) {
+    if (!this.transport?.connected || !this.isRunning) {
       throw new Error(`${this.options.binaryName} bridge is not running`);
     }
 
@@ -164,10 +189,10 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
 
       this.pendingRequests.set(id, { resolve, reject, timer });
 
-      this.writeToStdin(json + '\n').catch((err) => {
+      this.transport!.write(json + '\n').catch((err) => {
         clearTimeout(timer);
         this.pendingRequests.delete(id);
-        reject(new Error(`Failed to write to stdin: ${err.message}`));
+        reject(new Error(`Failed to write to transport: ${err.message}`));
       });
     });
   }
@@ -183,7 +208,7 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
   ): StreamingResponse<TExtractChunk<TCommands[K]>, TCommands[K]['result']> {
     const streaming = new StreamingResponse<TExtractChunk<TCommands[K]>, TCommands[K]['result']>();
 
-    if (!this.childProcess || !this.isRunning) {
+    if (!this.transport?.connected || !this.isRunning) {
       streaming.fail(new Error(`${this.options.binaryName} bridge is not running`));
       return streaming;
     }
@@ -213,28 +238,26 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
       streaming,
     });
 
-    this.writeToStdin(json + '\n').catch((err) => {
+    this.transport!.write(json + '\n').catch((err) => {
       clearTimeout(timer);
       this.pendingRequests.delete(id);
-      streaming.fail(new Error(`Failed to write to stdin: ${err.message}`));
+      streaming.fail(new Error(`Failed to write to transport: ${err.message}`));
     });
 
     return streaming;
   }
 
   /**
-   * Kill the Rust process and clean up all resources.
+   * Kill the connection and clean up all resources.
+   * For stdio: kills the child process (SIGTERM, then SIGKILL).
+   * For socket: closes the socket connection (does NOT kill the daemon).
    */
   public kill(): void {
-    if (this.childProcess) {
-      const proc = this.childProcess;
-      this.childProcess = null;
+    if (this.transport) {
+      const transport = this.transport;
+      this.transport = null;
       this.isRunning = false;
 
-      // Clear buffers
-      this.stdoutBuffer = Buffer.alloc(0);
-      this.stderrRemainder = '';
-
       // Reject pending requests
       for (const [, pending] of this.pendingRequests) {
         clearTimeout(pending.timer);
@@ -242,27 +265,8 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
       }
       this.pendingRequests.clear();
 
-      // 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();
+      transport.removeAllListeners();
+      transport.disconnect();
     }
   }
 
@@ -273,62 +277,6 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
     return this.isRunning;
   }
 
-  /**
-   * Buffer-based newline scanner for stdout chunks.
-   * Replaces readline to handle large payloads without buffering entire lines in a separate abstraction.
-   */
-  private handleStdoutChunk(chunk: Buffer): void {
-    this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, chunk]);
-
-    let newlineIndex: number;
-    while ((newlineIndex = this.stdoutBuffer.indexOf(0x0A)) !== -1) {
-      const lineBuffer = this.stdoutBuffer.subarray(0, newlineIndex);
-      this.stdoutBuffer = this.stdoutBuffer.subarray(newlineIndex + 1);
-
-      if (lineBuffer.length > this.options.maxPayloadSize) {
-        this.logger.log('error', `Inbound message exceeds maxPayloadSize (${lineBuffer.length} bytes), dropping`);
-        continue;
-      }
-
-      const line = lineBuffer.toString('utf8').trim();
-      this.handleLine(line);
-    }
-
-    // If accumulated buffer exceeds maxPayloadSize (sender never sends newline), clear to prevent OOM
-    if (this.stdoutBuffer.length > this.options.maxPayloadSize) {
-      this.logger.log('error', `Stdout buffer exceeded maxPayloadSize (${this.stdoutBuffer.length} bytes) without newline, clearing`);
-      this.stdoutBuffer = Buffer.alloc(0);
-    }
-  }
-
-  /**
-   * Write data to stdin with backpressure support.
-   * Waits for drain if the internal buffer is full.
-   */
-  private writeToStdin(data: string): Promise<void> {
-    return new Promise<void>((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 {
-        // Wait for drain before resolving
-        this.childProcess.stdin.once('drain', () => {
-          resolve();
-        });
-      }
-    });
-  }
-
   private handleLine(line: string): void {
     if (!line) return;
 
@@ -381,9 +329,7 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
 
   private cleanup(): void {
     this.isRunning = false;
-    this.childProcess = null;
-    this.stdoutBuffer = Buffer.alloc(0);
-    this.stderrRemainder = '';
+    this.transport = null;
 
     // Reject all pending requests
     for (const [, pending] of this.pendingRequests) {

package/ts/classes.sockettransport.ts

@@ -0,0 +1,187 @@
+import * as plugins from './plugins.js';
+import { LineScanner } from './classes.linescanner.js';
+import type { IRustBridgeLogger } from './interfaces/index.js';
+import type { IRustTransport } from './interfaces/transport.js';
+
+export interface ISocketTransportOptions {
+  /** Path to Unix socket (Linux/macOS) or named pipe path (Windows) */
+  socketPath: string;
+  /** Maximum inbound message size in bytes */
+  maxPayloadSize: number;
+  /** Logger instance */
+  logger: IRustBridgeLogger;
+  /** 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;
+}
+
+interface IResolvedSocketTransportOptions {
+  socketPath: string;
+  maxPayloadSize: number;
+  logger: IRustBridgeLogger;
+  autoReconnect: boolean;
+  reconnectBaseDelayMs: number;
+  reconnectMaxDelayMs: number;
+  maxReconnectAttempts: number;
+}
+
+/**
+ * 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 implements IRustTransport {
+  private options: IResolvedSocketTransportOptions;
+  private socket: plugins.net.Socket | null = null;
+  private lineScanner: LineScanner;
+  private _connected: boolean = false;
+  private intentionalDisconnect: boolean = false;
+  private reconnectAttempts: number = 0;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(options: ISocketTransportOptions) {
+    super();
+    this.options = {
+      autoReconnect: false,
+      reconnectBaseDelayMs: 100,
+      reconnectMaxDelayMs: 30000,
+      maxReconnectAttempts: 10,
+      ...options,
+    };
+    this.lineScanner = new LineScanner(options.maxPayloadSize, options.logger);
+  }
+
+  public get connected(): boolean {
+    return this._connected;
+  }
+
+  /**
+   * Connect to the socket. Resolves when the TCP/Unix connection is established.
+   */
+  public async connect(): Promise<void> {
+    this.intentionalDisconnect = false;
+    this.reconnectAttempts = 0;
+    return this.doConnect();
+  }
+
+  private doConnect(): Promise<void> {
+    return new Promise<void>((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: Buffer) => {
+        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: Error) => {
+        this._connected = false;
+        if (!settled) {
+          settled = true;
+          reject(err);
+        } else if (!this.intentionalDisconnect) {
+          this.emit('error', err);
+        }
+      });
+    });
+  }
+
+  private attemptReconnect(): void {
+    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.
+   */
+  public async write(data: string): Promise<void> {
+    return new Promise<void>((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.
+   */
+  public disconnect(): void {
+    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();
+    }
+  }
+}

package/ts/classes.stdiotransport.ts

@@ -0,0 +1,149 @@
+import * as plugins from './plugins.js';
+import { LineScanner } from './classes.linescanner.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 class StdioTransport extends plugins.events.EventEmitter implements IRustTransport {
+  private options: IStdioTransportOptions;
+  private childProcess: plugins.childProcess.ChildProcess | null = null;
+  private lineScanner: LineScanner;
+  private stderrRemainder: string = '';
+  private _connected: boolean = false;
+
+  constructor(options: IStdioTransportOptions) {
+    super();
+    this.options = options;
+    this.lineScanner = new LineScanner(options.maxPayloadSize, options.logger);
+  }
+
+  public get connected(): boolean {
+    return this._connected;
+  }
+
+  /**
+   * Spawn the child process. Resolves when the process is running (not necessarily ready).
+   */
+  public async connect(): Promise<void> {
+    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: Buffer) => {
+      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: Buffer) => {
+      this.lineScanner.push(chunk, (line) => {
+        this.emit('line', line);
+      });
+    });
+
+    // Handle process exit
+    this.childProcess.on('exit', (code: number | null, signal: string | null) => {
+      // 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: Error) => {
+      this._connected = false;
+      this.emit('error', err);
+    });
+
+    this._connected = true;
+  }
+
+  /**
+   * Write data to stdin with backpressure support.
+   */
+  public async write(data: string): Promise<void> {
+    return new Promise<void>((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.
+   */
+  public disconnect(): void {
+    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();
+  }
+}

package/ts/index.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';