@push.rocks/smartrust 2.4.0 → 2.5.1

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartrust',
-    version: '2.4.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/dist_ts/classes.rustbridge.d.ts

@@ -1,6 +1,6 @@
 import * as plugins from './plugins.js';
 import { StreamingResponse } from './classes.streamingresponse.js';
-import type { IRustBridgeOptions, IRustBridgeRequestOptions, IRustBridgeTerminateOptions, ISocketConnectOptions, TCommandMap, TStreamingCommandKeys, TExtractChunk } from './interfaces/index.js';
+import type { IRustBridgeOptions, IRustBridgeRequestOptions, IRustBridgeStreamingRequestOptions, IRustBridgeTerminateOptions, ISocketConnectOptions, TCommandMap, TStreamingCommandKeys, TExtractChunk } from './interfaces/index.js';
 /**
  * Generic bridge between TypeScript and a Rust binary.
  * Communicates via JSON-over-stdin/stdout IPC protocol (stdio mode)
@@ -25,6 +25,9 @@ export declare class RustBridge<TCommands extends TCommandMap = TCommandMap> ext
     private sensitiveRequestId;
     private sensitiveUsedGeneration;
     private regularRequestPreparations;
+    /** Whether the current transport generation's ready event advertised `cancel`. */
+    private remoteCancelSupported;
+    private remoteCancellations;
     constructor(options: IRustBridgeOptions);
     /**
      * Spawn the Rust binary and wait for it to signal readiness.
@@ -65,7 +68,7 @@ export declare class RustBridge<TCommands extends TCommandMap = TCommandMap> ext
      * Returns a StreamingResponse that yields chunks via `for await...of`
      * and exposes `.result` for the final response.
      */
-    sendCommandStreaming<K extends string & TStreamingCommandKeys<TCommands>>(method: K, params: TCommands[K]['params']): StreamingResponse<TExtractChunk<TCommands[K]>, TCommands[K]['result']>;
+    sendCommandStreaming<K extends string & TStreamingCommandKeys<TCommands>>(method: K, params: TCommands[K]['params'], options?: IRustBridgeStreamingRequestOptions): StreamingResponse<TExtractChunk<TCommands[K]>, TCommands[K]['result']>;
     /**
      * Terminate the active transport and wait for confirmed closure.
      * For stdio this confirms child exit after SIGTERM/SIGKILL escalation.
@@ -83,6 +86,21 @@ export declare class RustBridge<TCommands extends TCommandMap = TCommandMap> ext
     private isStartingGeneration;
     private isCurrentTransport;
     private handleLine;
+    /** Start or restart the inactivity deadline of one streaming request. */
+    private armStreamingTimeout;
+    /**
+     * Reject a pending request on timeout or abort. When the request was
+     * already written to a transport that accepts cancel frames, send one and
+     * attach the remote settlement to the rejection.
+     */
+    private abandonPendingRequest;
+    /** Write one cancel frame and track the original id until Rust answers it. */
+    private sendRemoteCancel;
+    private settleRemoteCancellation;
+    /** Settle every tracked cancellation as disconnected after transport closure. */
+    private settleAllRemoteCancellations;
+    /** Read the `cancel` opt-in from a ready event's `capabilities`. */
+    private readCancelCapability;
     private acceptSensitiveResponse;
     private markSensitiveWriteComplete;
     private settleManagementResponse;