@push.rocks/smartrust 2.5.0 → 2.5.1

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartrust',
-    version: '2.5.0',
+    version: '2.5.1',
     description: 'A type-safe bridge between JavaScript engines and Rust binaries.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx1QkFBdUI7SUFDN0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLGtFQUFrRTtDQUNoRixDQUFBIn0=

package/dist_ts/classes.linescanner.d.ts

@@ -3,9 +3,16 @@ import type { IRustBridgeLogger } from './interfaces/index.js';
  * Buffer-based newline scanner for streaming binary data.
  * Accumulates chunks and emits complete lines via callback.
  * Used by both StdioTransport and SocketTransport.
+ *
+ * Each byte is scanned once and copied at most once into its line, so a line that arrives in many
+ * chunks costs time linear in its length.
  */
 export declare class LineScanner {
-    private buffer;
+    /** Chunks of the line being received; none of them contains a newline. */
+    private pending;
+    private pendingLength;
+    /** Bytes after a line whose callback threw; they may contain newlines and are scanned first. */
+    private unscanned;
     private maxPayloadSize;
     private logger;
     constructor(maxPayloadSize: number, logger: IRustBridgeLogger);
@@ -15,4 +22,9 @@ export declare class LineScanner {
     push(chunk: Buffer, onLine: (line: string) => void): void;
     /** Reset the internal buffer. */
     clear(): void;
+    /** Joins the pending chunks with the line's last piece; null when the line is too large. */
+    private takeLine;
+    private appendPartial;
+    /** A subarray retains its entire backing allocation; copy a small piece of a large one. */
+    private static compact;
 }

package/dist_ts/classes.linescanner.js

@@ -2,9 +2,16 @@
  * Buffer-based newline scanner for streaming binary data.
  * Accumulates chunks and emits complete lines via callback.
  * Used by both StdioTransport and SocketTransport.
+ *
+ * Each byte is scanned once and copied at most once into its line, so a line that arrives in many
+ * chunks costs time linear in its length.
  */
 export class LineScanner {
-    buffer = Buffer.alloc(0);
+    /** Chunks of the line being received; none of them contains a newline. */
+    pending = [];
+    pendingLength = 0;
+    /** Bytes after a line whose callback threw; they may contain newlines and are scanned first. */
+    unscanned = Buffer.alloc(0);
     maxPayloadSize;
     logger;
     constructor(maxPayloadSize, logger) {
@@ -15,14 +22,15 @@ export class LineScanner {
      * Feed a chunk of data. Calls onLine for each complete newline-terminated line found.
      */
     push(chunk, onLine) {
-        this.buffer = Buffer.concat([this.buffer, chunk]);
+        const input = this.unscanned.length > 0 ? Buffer.concat([this.unscanned, chunk]) : chunk;
+        this.unscanned = Buffer.alloc(0);
+        let start = 0;
         try {
             let newlineIndex;
-            while ((newlineIndex = this.buffer.indexOf(0x0A)) !== -1) {
-                const lineBuffer = this.buffer.subarray(0, newlineIndex);
-                this.buffer = this.buffer.subarray(newlineIndex + 1);
-                if (lineBuffer.length > this.maxPayloadSize) {
-                    this.logger.log('error', `Inbound message exceeds maxPayloadSize (${lineBuffer.length} bytes), dropping`);
+            while ((newlineIndex = input.indexOf(0x0A, start)) !== -1) {
+                const lineBuffer = this.takeLine(input.subarray(start, newlineIndex));
+                start = newlineIndex + 1;
+                if (!lineBuffer) {
                     continue;
                 }
                 const line = lineBuffer.toString('utf8').trim();
@@ -30,27 +38,52 @@ export class LineScanner {
                     onLine(line);
                 }
             }
-            // Prevent OOM if sender never sends newline
-            if (this.buffer.length > this.maxPayloadSize) {
-                this.logger.log('error', `Buffer exceeded maxPayloadSize (${this.buffer.length} bytes) without newline, clearing`);
-                this.buffer = Buffer.alloc(0);
-            }
+            this.appendPartial(input.subarray(start));
         }
-        finally {
-            // A subarray retains its entire backing allocation, even when empty.
-            // Compact once per chunk, including when a callback throws, without
-            // repeatedly copying the unread suffix for each parsed line.
-            if (this.buffer.length === 0) {
-                this.buffer = Buffer.alloc(0);
-            }
-            else if (this.buffer.buffer.byteLength > Math.max(Buffer.poolSize, this.buffer.length * 2)) {
-                this.buffer = Buffer.from(this.buffer);
-            }
+        catch (error) {
+            // Keep what follows the failed line for the next push, without retaining what was consumed.
+            this.unscanned = LineScanner.compact(input.subarray(start));
+            throw error;
         }
     }
     /** Reset the internal buffer. */
     clear() {
-        this.buffer = Buffer.alloc(0);
+        this.pending = [];
+        this.pendingLength = 0;
+        this.unscanned = Buffer.alloc(0);
+    }
+    /** Joins the pending chunks with the line's last piece; null when the line is too large. */
+    takeLine(tail) {
+        const length = this.pendingLength + tail.length;
+        const pending = this.pending;
+        this.pending = [];
+        this.pendingLength = 0;
+        if (length > this.maxPayloadSize) {
+            this.logger.log('error', `Inbound message exceeds maxPayloadSize (${length} bytes), dropping`);
+            return null;
+        }
+        return pending.length === 0 ? tail : Buffer.concat([...pending, tail], length);
+    }
+    appendPartial(partial) {
+        if (partial.length === 0) {
+            return;
+        }
+        // Prevent OOM if sender never sends newline
+        if (this.pendingLength + partial.length > this.maxPayloadSize) {
+            this.logger.log('error', `Buffer exceeded maxPayloadSize (${this.pendingLength + partial.length} bytes) without newline, clearing`);
+            this.pending = [];
+            this.pendingLength = 0;
+            return;
+        }
+        this.pending.push(LineScanner.compact(partial));
+        this.pendingLength += partial.length;
+    }
+    /** A subarray retains its entire backing allocation; copy a small piece of a large one. */
+    static compact(piece) {
+        if (piece.length === 0) {
+            return Buffer.alloc(0);
+        }
+        return piece.buffer.byteLength > Math.max(Buffer.poolSize, piece.length * 2) ? Buffer.from(piece) : piece;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartrust",
-  "version": "2.5.0",
+  "version": "2.5.1",
   "private": false,
   "description": "A type-safe bridge between JavaScript engines and Rust binaries.",
   "main": "dist_ts/index.js",
@@ -9,10 +9,10 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "devDependencies": {
-    "@git.zone/tsbuild": "^5.0.0",
-    "@git.zone/tsrun": "^3.0.0",
-    "@git.zone/tstest": "^6.2.0",
-    "@types/node": "^26.6.1"
+    "@git.zone/tsbuild": "^5.1.2",
+    "@git.zone/tsrun": "^3.0.2",
+    "@git.zone/tstest": "^7.1.0",
+    "@types/node": "^26.6.3"
   },
   "dependencies": {
     "@push.rocks/smartpath": "^6.0.0"

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartrust',
-  version: '2.5.0',
+  version: '2.5.1',
   description: 'A type-safe bridge between JavaScript engines and Rust binaries.'
 }

package/ts/classes.linescanner.ts

@@ -4,9 +4,16 @@ import type { IRustBridgeLogger } from './interfaces/index.js';
  * Buffer-based newline scanner for streaming binary data.
  * Accumulates chunks and emits complete lines via callback.
  * Used by both StdioTransport and SocketTransport.
+ *
+ * Each byte is scanned once and copied at most once into its line, so a line that arrives in many
+ * chunks costs time linear in its length.
  */
 export class LineScanner {
-  private buffer: Buffer = Buffer.alloc(0);
+  /** Chunks of the line being received; none of them contains a newline. */
+  private pending: Buffer[] = [];
+  private pendingLength = 0;
+  /** Bytes after a line whose callback threw; they may contain newlines and are scanned first. */
+  private unscanned: Buffer = Buffer.alloc(0);
   private maxPayloadSize: number;
   private logger: IRustBridgeLogger;
 
@@ -19,44 +26,74 @@ export class LineScanner {
    * Feed a chunk of data. Calls onLine for each complete newline-terminated line found.
    */
   public push(chunk: Buffer, onLine: (line: string) => void): void {
-    this.buffer = Buffer.concat([this.buffer, chunk]);
+    const input = this.unscanned.length > 0 ? Buffer.concat([this.unscanned, chunk]) : chunk;
+    this.unscanned = Buffer.alloc(0);
+    let start = 0;
 
     try {
       let newlineIndex: number;
-      while ((newlineIndex = this.buffer.indexOf(0x0A)) !== -1) {
-        const lineBuffer = this.buffer.subarray(0, newlineIndex);
-        this.buffer = this.buffer.subarray(newlineIndex + 1);
-
-        if (lineBuffer.length > this.maxPayloadSize) {
-          this.logger.log('error', `Inbound message exceeds maxPayloadSize (${lineBuffer.length} bytes), dropping`);
+      while ((newlineIndex = input.indexOf(0x0A, start)) !== -1) {
+        const lineBuffer = this.takeLine(input.subarray(start, newlineIndex));
+        start = newlineIndex + 1;
+        if (!lineBuffer) {
           continue;
         }
-
         const line = lineBuffer.toString('utf8').trim();
         if (line) {
           onLine(line);
         }
       }
-
-      // Prevent OOM if sender never sends newline
-      if (this.buffer.length > this.maxPayloadSize) {
-        this.logger.log('error', `Buffer exceeded maxPayloadSize (${this.buffer.length} bytes) without newline, clearing`);
-        this.buffer = Buffer.alloc(0);
-      }
-    } finally {
-      // A subarray retains its entire backing allocation, even when empty.
-      // Compact once per chunk, including when a callback throws, without
-      // repeatedly copying the unread suffix for each parsed line.
-      if (this.buffer.length === 0) {
-        this.buffer = Buffer.alloc(0);
-      } else if (this.buffer.buffer.byteLength > Math.max(Buffer.poolSize, this.buffer.length * 2)) {
-        this.buffer = Buffer.from(this.buffer);
-      }
+      this.appendPartial(input.subarray(start));
+    } catch (error) {
+      // Keep what follows the failed line for the next push, without retaining what was consumed.
+      this.unscanned = LineScanner.compact(input.subarray(start));
+      throw error;
     }
   }
 
   /** Reset the internal buffer. */
   public clear(): void {
-    this.buffer = Buffer.alloc(0);
+    this.pending = [];
+    this.pendingLength = 0;
+    this.unscanned = Buffer.alloc(0);
+  }
+
+  /** Joins the pending chunks with the line's last piece; null when the line is too large. */
+  private takeLine(tail: Buffer): Buffer | null {
+    const length = this.pendingLength + tail.length;
+    const pending = this.pending;
+    this.pending = [];
+    this.pendingLength = 0;
+    if (length > this.maxPayloadSize) {
+      this.logger.log('error', `Inbound message exceeds maxPayloadSize (${length} bytes), dropping`);
+      return null;
+    }
+    return pending.length === 0 ? tail : Buffer.concat([...pending, tail], length);
+  }
+
+  private appendPartial(partial: Buffer): void {
+    if (partial.length === 0) {
+      return;
+    }
+    // Prevent OOM if sender never sends newline
+    if (this.pendingLength + partial.length > this.maxPayloadSize) {
+      this.logger.log(
+        'error',
+        `Buffer exceeded maxPayloadSize (${this.pendingLength + partial.length} bytes) without newline, clearing`,
+      );
+      this.pending = [];
+      this.pendingLength = 0;
+      return;
+    }
+    this.pending.push(LineScanner.compact(partial));
+    this.pendingLength += partial.length;
+  }
+
+  /** A subarray retains its entire backing allocation; copy a small piece of a large one. */
+  private static compact(piece: Buffer): Buffer {
+    if (piece.length === 0) {
+      return Buffer.alloc(0);
+    }
+    return piece.buffer.byteLength > Math.max(Buffer.poolSize, piece.length * 2) ? Buffer.from(piece) : piece;
   }
 }