@push.rocks/smartrust 2.1.0 → 2.3.0

package/dist_ts/classes.stdiotransport.d.ts

@@ -6,7 +6,12 @@ export interface IStdioTransportOptions {
     cliArgs: string[];
     env?: Record<string, string>;
     inheritedFileDescriptors?: readonly number[];
+    sensitiveByteChannel?: {
+        maxPayloadSize: number;
+    };
     maxPayloadSize: number;
+    /** Default for every cleanup path, including automatic stdin failure. */
+    terminationGracePeriodMs?: number;
     logger: IRustBridgeLogger;
 }
 /**
@@ -21,12 +26,19 @@ export declare class StdioTransport extends plugins.events.EventEmitter implemen
     private _connected;
     constructor(options: IStdioTransportOptions);
     get connected(): boolean;
+    get sensitiveFileDescriptor(): number | null;
     /**
      * Spawn the child process. Resolves when the process is running (not necessarily ready).
      */
     connect(): Promise<void>;
     /** Write data to stdin and resolve after the stream callback confirms it. */
     write(data: string): Promise<void>;
+    /**
+     * Write the single sensitive frame owned by this child generation. The frame
+     * header and request id are non-secret; `data` is written without converting
+     * it to a string or copying its backing ArrayBuffer.
+     */
+    writeSensitiveFrame(requestId: string, data: Uint8Array<ArrayBuffer>): Promise<void>;
     /**
      * Kill the child process without waiting for confirmation.
      */
@@ -41,6 +53,8 @@ export declare class StdioTransport extends plugins.events.EventEmitter implemen
     private sendSignal;
     private hasExited;
     private destroyOwnedStdioEndpoint;
+    private writeSensitiveChunk;
+    private destroySensitiveEndpoint;
     private toError;
     private getErrorMessage;
 }

package/dist_ts/classes.stdiotransport.js

@@ -2,6 +2,8 @@ import * as plugins from './plugins.js';
 import { LineScanner } from './classes.linescanner.js';
 const DEFAULT_DISCONNECT_GRACE_PERIOD_MS = 5000;
 const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const SENSITIVE_FRAME_HEADER_SIZE = 16;
+const SENSITIVE_FRAME_MAGIC = 'SMRS';
 /**
  * Transport that spawns a child process and communicates via stdin/stdout.
  * Extracted from the original RustBridge process management logic.
@@ -14,12 +16,31 @@ export class StdioTransport extends plugins.events.EventEmitter {
     _connected = false;
     constructor(options) {
         super();
-        this.options = options;
+        if (options.terminationGracePeriodMs !== undefined
+            && (!Number.isSafeInteger(options.terminationGracePeriodMs) || options.terminationGracePeriodMs < 0)) {
+            throw new RangeError('StdioTransport terminationGracePeriodMs must be a non-negative safe integer');
+        }
+        if (options.sensitiveByteChannel
+            && (!Number.isSafeInteger(options.sensitiveByteChannel.maxPayloadSize)
+                || options.sensitiveByteChannel.maxPayloadSize <= 0)) {
+            throw new RangeError('StdioTransport sensitiveByteChannel maxPayloadSize must be a positive safe integer');
+        }
+        this.options = {
+            ...options,
+            sensitiveByteChannel: options.sensitiveByteChannel
+                ? { ...options.sensitiveByteChannel }
+                : undefined,
+        };
         this.lineScanner = new LineScanner(options.maxPayloadSize, options.logger);
     }
     get connected() {
         return this._connected;
     }
+    get sensitiveFileDescriptor() {
+        return this.options.sensitiveByteChannel
+            ? 3 + (this.options.inheritedFileDescriptors?.length ?? 0)
+            : null;
+    }
     /**
      * Spawn the child process. Resolves when the process is running (not necessarily ready).
      */
@@ -37,6 +58,7 @@ export class StdioTransport extends plugins.events.EventEmitter {
                 'pipe',
                 'pipe',
                 ...(this.options.inheritedFileDescriptors ?? []),
+                ...(this.options.sensitiveByteChannel ? ['pipe'] : []),
             ];
             childProcess = plugins.childProcess.spawn(this.options.binaryPath, this.options.cliArgs, { stdio, env });
         }
@@ -47,6 +69,12 @@ export class StdioTransport extends plugins.events.EventEmitter {
         const closePromise = new Promise((resolve) => {
             resolveClose = resolve;
         });
+        const sensitiveEndpoint = this.options.sensitiveByteChannel
+            ? childProcess.stdio[this.sensitiveFileDescriptor]
+            : null;
+        const sensitiveWriter = sensitiveEndpoint instanceof plugins.stream.Writable
+            ? sensitiveEndpoint
+            : null;
         const generation = {
             childProcess,
             stderrRemainder: '',
@@ -61,6 +89,9 @@ export class StdioTransport extends plugins.events.EventEmitter {
             sigtermAttempted: false,
             sigkillAttempted: false,
             sigtermError: null,
+            sensitiveWriter,
+            sensitiveUsed: false,
+            sensitiveError: null,
         };
         this.generation = generation;
         this.childProcess = childProcess;
@@ -94,6 +125,28 @@ export class StdioTransport extends plugins.events.EventEmitter {
                 }
             });
         });
+        generation.sensitiveWriter?.on('error', (error) => {
+            if (generation.sensitiveError)
+                return;
+            generation.sensitiveError = error;
+            if (this.generation !== generation || generation.closed)
+                return;
+            this._connected = false;
+            queueMicrotask(() => {
+                if (this.generation !== generation || generation.closed)
+                    return;
+                void this.disconnectAndWait().catch((disconnectError) => {
+                    this.options.logger.log('error', 'Failed to clean up child after sensitive pipe error: '
+                        + this.getErrorMessage(disconnectError));
+                });
+                if (this.listenerCount('error') > 0)
+                    this.emit('error', error);
+                else if (generation.disconnectPromise)
+                    this.options.logger.log('error', 'Sensitive pipe error during disconnect: ' + error.message);
+                else
+                    this.emit('error', error);
+            });
+        });
         // Handle stderr with cross-chunk buffering.
         childProcess.stderr?.on('data', (data) => {
             if (this.generation !== generation || generation.closed) {
@@ -136,6 +189,7 @@ export class StdioTransport extends plugins.events.EventEmitter {
                 this.destroyOwnedStdioEndpoint(generation, 'stdin');
                 this.destroyOwnedStdioEndpoint(generation, 'stdout');
                 this.destroyOwnedStdioEndpoint(generation, 'stderr');
+                this.destroySensitiveEndpoint(generation);
             });
         });
         // ChildProcess 'close' is the termination confirmation: the process has exited
@@ -209,6 +263,47 @@ export class StdioTransport extends plugins.events.EventEmitter {
             });
         });
     }
+    /**
+     * Write the single sensitive frame owned by this child generation. The frame
+     * header and request id are non-secret; `data` is written without converting
+     * it to a string or copying its backing ArrayBuffer.
+     */
+    async writeSensitiveFrame(requestId, data) {
+        if (!(data instanceof Uint8Array) || !(data.buffer instanceof ArrayBuffer)) {
+            throw new TypeError('sensitive bytes must use an ArrayBuffer-backed Uint8Array');
+        }
+        const generation = this.generation;
+        if (!generation || generation.closed || generation.childProcess !== this.childProcess
+            || !this._connected || !generation.sensitiveWriter || generation.sensitiveWriter.destroyed) {
+            throw new Error('sensitive byte pipe not available');
+        }
+        if (generation.sensitiveUsed)
+            throw new Error('sensitive byte pipe was already used');
+        generation.sensitiveUsed = true;
+        const maxPayloadSize = this.options.sensitiveByteChannel?.maxPayloadSize;
+        if (maxPayloadSize === undefined || data.byteLength > maxPayloadSize) {
+            throw new Error('sensitive byte payload exceeds its configured limit');
+        }
+        if (!/^[A-Za-z0-9_-]{1,128}$/.test(requestId))
+            throw new Error('invalid sensitive request id');
+        const requestIdBytes = Buffer.from(requestId, 'ascii');
+        const header = Buffer.alloc(SENSITIVE_FRAME_HEADER_SIZE + requestIdBytes.byteLength);
+        header.write(SENSITIVE_FRAME_MAGIC, 0, 4, 'ascii');
+        header.writeUInt8(1, 4);
+        header.writeUInt8(0, 5);
+        header.writeUInt16BE(requestIdBytes.byteLength, 6);
+        header.writeBigUInt64BE(BigInt(data.byteLength), 8);
+        requestIdBytes.copy(header, SENSITIVE_FRAME_HEADER_SIZE);
+        const payload = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+        try {
+            await this.writeSensitiveChunk(generation, header, false);
+            await this.writeSensitiveChunk(generation, payload, true);
+        }
+        catch (error) {
+            this.destroySensitiveEndpoint(generation);
+            throw error;
+        }
+    }
     /**
      * Kill the child process without waiting for confirmation.
      */
@@ -227,7 +322,7 @@ export class StdioTransport extends plugins.events.EventEmitter {
      * ChildProcess 'close' to confirm termination.
      */
     disconnectAndWait(options = {}) {
-        const gracePeriodMs = options.gracePeriodMs ?? DEFAULT_DISCONNECT_GRACE_PERIOD_MS;
+        const gracePeriodMs = options.gracePeriodMs ?? this.options.terminationGracePeriodMs ?? DEFAULT_DISCONNECT_GRACE_PERIOD_MS;
         if (!Number.isSafeInteger(gracePeriodMs) || gracePeriodMs < 0) {
             throw new RangeError('StdioTransport gracePeriodMs must be a non-negative safe integer');
         }
@@ -250,6 +345,7 @@ export class StdioTransport extends plugins.events.EventEmitter {
         generation.disconnectPromise = disconnectPromise;
         generation.rejectDisconnect = rejectDisconnect;
         this._connected = false;
+        this.destroySensitiveEndpoint(generation);
         void disconnectPromise.then(() => {
             if (generation.disconnectPromise === disconnectPromise) {
                 generation.rejectDisconnect = null;
@@ -272,6 +368,7 @@ export class StdioTransport extends plugins.events.EventEmitter {
             this.destroyOwnedStdioEndpoint(generation, 'stdin');
             this.destroyOwnedStdioEndpoint(generation, 'stdout');
             this.destroyOwnedStdioEndpoint(generation, 'stderr');
+            this.destroySensitiveEndpoint(generation);
             return disconnectPromise;
         }
         generation.sigtermAttempted = true;
@@ -365,6 +462,58 @@ export class StdioTransport extends plugins.events.EventEmitter {
             }
         }
     }
+    writeSensitiveChunk(generation, data, end) {
+        return new Promise((resolve, reject) => {
+            const writer = generation.sensitiveWriter;
+            if (!writer || writer.destroyed || generation.closed || this.generation !== generation) {
+                reject(new Error('sensitive byte pipe not available'));
+                return;
+            }
+            let settled = false;
+            const cleanup = () => {
+                writer.off('error', onError);
+                writer.off('close', onClose);
+            };
+            const settle = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            const onError = (error) => settle(error);
+            const onClose = () => settle(new Error('sensitive byte pipe closed before write completion'));
+            writer.once('error', onError);
+            writer.once('close', onClose);
+            try {
+                if (end)
+                    writer.end(data, () => settle());
+                else
+                    writer.write(data, error => settle(error));
+            }
+            catch (error) {
+                settle(this.toError(error, 'Failed to write sensitive byte pipe'));
+            }
+        });
+    }
+    destroySensitiveEndpoint(generation) {
+        const endpoint = generation.sensitiveWriter;
+        if (!endpoint || endpoint.destroyed)
+            return;
+        try {
+            endpoint.destroy();
+        }
+        catch (error) {
+            const endpointError = this.toError(error, 'Failed to close sensitive byte pipe');
+            generation.rejectDisconnect?.(endpointError);
+            this.options.logger.log('error', endpointError.message);
+            if (this.listenerCount('error') > 0)
+                this.emit('error', endpointError);
+        }
+    }
     toError(error, prefix) {
         return new Error(prefix + ': ' + this.getErrorMessage(error));
     }
@@ -372,4 +521,4 @@ export class StdioTransport extends plugins.events.EventEmitter {
         return error instanceof Error ? error.message : String(error);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stdiotransport.js","sourceRoot":"","sources":["../ts/classes.stdiotransport.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stdiotransport.js","sourceRoot":"","sources":["../ts/classes.stdiotransport.ts"],"names":[],"mappings":"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"}

package/dist_ts/interfaces/config.d.ts

@@ -17,7 +17,8 @@ export interface IRustBridgeRequestOptions {
 export interface IRustBridgeTerminateOptions {
     /**
      * Time to allow an owned stdio child to exit after SIGTERM before SIGKILL.
-     * Zero requests immediate SIGKILL. Defaults to 5000 milliseconds.
+     * Zero requests immediate SIGKILL. Defaults to the bridge's
+     * terminationGracePeriodMs, or 5000 milliseconds when not configured.
      */
     gracePeriodMs?: number;
 }
@@ -56,10 +57,27 @@ export interface IRustBridgeOptions extends IBinaryLocatorOptions {
      * closes the caller's source descriptors.
      */
     inheritedFileDescriptors?: readonly number[];
+    /**
+     * Opt in to one owned, one-shot binary pipe for a sensitive request in each
+     * spawned stdio generation. The pipe is appended after caller-owned inherited
+     * descriptors, so their child descriptor numbers remain unchanged.
+     */
+    sensitiveByteChannel?: {
+        /** Maximum raw sensitive payload size accepted by the bridge. */
+        maxPayloadSize: number;
+    };
     /** Timeout for individual requests in ms (default: 30000) */
     requestTimeoutMs?: number;
     /** Timeout for the ready event during spawn in ms (default: 10000) */
     readyTimeoutMs?: number;
+    /**
+     * Default stdio SIGTERM-to-SIGKILL grace period in milliseconds, including
+     * automatic startup and stdin-failure cleanup (default: 5000).
+     * Must be a non-negative safe integer. Explicit terminate() options override
+     * it only before cleanup starts; concurrent cleanup keeps its first choice.
+     * Socket termination never signals the remote daemon.
+     */
+    terminationGracePeriodMs?: number;
     /** Additional environment variables for the child process */
     env?: Record<string, string>;
     /** Name of the ready event emitted by the Rust binary (default: 'ready') */

package/dist_ts/interfaces/ipc.d.ts

@@ -5,6 +5,18 @@ export interface IManagementRequest {
     id: string;
     method: string;
     params: Record<string, any>;
+    /** Value-free metadata for an associated one-shot binary frame. */
+    sensitive?: IManagementSensitivePayload;
+}
+export interface IManagementSensitivePayload {
+    protocol: 'smartrust-sensitive-v1';
+    fileDescriptor: number;
+    byteLength: number;
+}
+export interface IManagementSensitiveAck {
+    protocol: 'smartrust-sensitive-v1';
+    consumed: true;
+    byteLength: number;
 }
 /**
  * Management response received from the Rust binary via stdout.
@@ -15,6 +27,8 @@ export interface IManagementResponse {
     result?: any;
     error?: string;
     errorCode?: string;
+    /** Required after the receiver consumed the exact associated binary frame. */
+    sensitiveAck?: IManagementSensitiveAck;
 }
 /**
  * Management event received from the Rust binary (unsolicited, no id field).

package/dist_ts/interfaces/transport.d.ts

@@ -30,6 +30,10 @@ export interface IRustTransport extends plugins.events.EventEmitter {
     connect(): Promise<void>;
     /** Write a string to the transport. Handles backpressure. */
     write(data: string): Promise<void>;
+    /** Child descriptor for the optional one-shot sensitive byte pipe. */
+    readonly sensitiveFileDescriptor?: number | null;
+    /** Write and close one correlated binary frame. Available only in stdio mode. */
+    writeSensitiveFrame?(requestId: string, data: Uint8Array<ArrayBuffer>): Promise<void>;
     /** Disconnect the transport. For stdio: kills the process. For socket: closes the connection. */
     disconnect(): void;
     /** Disconnect and resolve only after the local transport has confirmed closure. */

package/dist_ts/plugins.d.ts

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

package/dist_ts/plugins.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartrust",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "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": "^4.4.3",
+    "@git.zone/tsbuild": "^4.5.0",
     "@git.zone/tsrun": "^2.0.6",
-    "@git.zone/tstest": "^6.0.0",
-    "@types/node": "^26.5.0"
+    "@git.zone/tstest": "^6.1.1",
+    "@types/node": "^26.5.1"
   },
   "dependencies": {
     "@push.rocks/smartpath": "^6.0.0"

package/readme.md

@@ -134,6 +134,65 @@ non-empty descriptor list rejects because a socket daemon is not a child of the
 bridge and cannot inherit them. Node.js does not support passing socket
 descriptors this way on Windows.
 
+### One-shot sensitive byte requests
+
+Stdio mode can append one Smartrust-owned pipe after all caller-owned inherited
+descriptors. It carries one raw byte payload without putting those bytes in the
+JSON request, a string, an environment variable, or a backing file:
+
+```typescript
+const bridge = new RustBridge<TMyCommands>({
+  binaryName: 'my-rust-server',
+  sensitiveByteChannel: { maxPayloadSize: 2 * 1024 * 1024 },
+});
+
+await bridge.spawn();
+const bytes = new Uint8Array([1, 2, 3]);
+const result = await bridge.sendCommandWithSensitiveBytes('start', { port: 8080 }, bytes);
+// Smartrust has cleared the exact `bytes` view before the promise settles.
+```
+
+Only one sensitive request may use a spawned generation. It runs exclusively
+with respect to other commands, but ordinary JSON commands can continue after
+its successful acknowledgement. A new `spawn()` creates a new pipe. Socket
+mode rejects `sensitiveByteChannel` because the daemon is not a child process.
+
+The JSON request adds only this value-free metadata:
+
+```json
+{"sensitive":{"protocol":"smartrust-sensitive-v1","fileDescriptor":3,"byteLength":3}}
+```
+
+The child descriptor is `3 + inheritedFileDescriptors.length`, so existing
+inherited descriptor numbers never move. The binary frame is:
+
+| Offset | Size | Value |
+|---:|---:|---|
+| 0 | 4 | ASCII `SMRS` |
+| 4 | 1 | version `1` |
+| 5 | 1 | flags `0` |
+| 6 | 2 | big-endian request-id byte length |
+| 8 | 8 | big-endian payload byte length |
+| 16 | variable | ASCII request id, then raw payload bytes |
+
+The receiver must consume and validate the complete frame before sending its
+normal JSON response. That response must include an exact value-free ACK:
+
+```json
+{"sensitiveAck":{"protocol":"smartrust-sensitive-v1","consumed":true,"byteLength":3}}
+```
+
+Smartrust settles only after both the local pipe write callback and the matching
+ACK, regardless of their event order. Abort, timeout, partial pipe failure,
+malformed ACK, or a receiver error terminates the child and rejects every pending
+request, so buffered bytes cannot become a later request.
+
+Calling the method transfers exclusive use of the supplied mutable
+`Uint8Array<ArrayBuffer>` view until settlement. Smartrust clears that exact
+view after the write callback or failure. It cannot promise erasure of aliases,
+JavaScript engine or Node.js internal copies, kernel pipe buffers, or memory the
+receiver owns; each receiver must bound and clear its own buffers.
+
 ### Per-Command Deadlines and Cancellation
 
 Non-streaming commands accept an optional `IRustBridgeRequestOptions` argument:
@@ -227,6 +286,24 @@ SIGKILL:
 await bridge.terminate({ gracePeriodMs: 250 });
 ```
 
+For workers that need longer cleanup, set `terminationGracePeriodMs` when
+constructing the bridge. This default also applies when startup fails or stdin
+breaks and cleanup begins automatically. Calling `terminate()` afterwards
+cannot replace a grace period already selected by automatic cleanup.
+
+```typescript
+const bridge = new RustBridge({
+  binaryName: 'worker',
+  terminationGracePeriodMs: 60_000,
+});
+await bridge.spawn();
+await bridge.terminate(); // allows up to 60 seconds before SIGKILL
+```
+
+`terminationGracePeriodMs` accepts non-negative safe integers and defaults to
+5000. `StdioTransport` accepts the same constructor option. Confirmed process
+closure alone does not prove that an application's external cleanup succeeded.
+
 Concurrent calls share one termination operation, and calls after confirmed
 closure are no-ops. The first concurrent caller's grace period applies. In
 socket mode, termination confirms only the local socket closure; the remote
@@ -439,6 +516,7 @@ const bridge = new RustBridge<TMyCommands>({
   // --- Bridge Options ---
   cliArgs: ['--management'],                  // optional: args passed to binary (default: ['--management'])
   inheritedFileDescriptors: [sourceFd],       // optional: caller-owned source fds mapped to child fd 3+
+  sensitiveByteChannel: { maxPayloadSize: 2 * 1024 * 1024 }, // optional: one owned raw-byte pipe per spawn
   requestTimeoutMs: 30000,                    // optional: default request timeout (default: 30000)
   streamTimeoutMs: 30000,                     // optional: streaming inactivity timeout (default: requestTimeoutMs)
   readyTimeoutMs: 10000,                      // optional: ready event timeout (default: 10000)
@@ -654,8 +732,9 @@ fn main() {
 |---|---|---|
 | `constructor` | `new RustBridge<T>(options: IRustBridgeOptions)` | Create a new bridge instance |
 | `spawn()` | `Promise<boolean>` | **Stdio mode**: Spawn and wait for ready; rejects invalid explicit selection, returns `false` for ordinary discovery/startup failure |
-| `connect(socketPath, options?)` | `Promise<boolean>` | **Socket mode**: Connect to a running daemon; returns `false` on connection/readiness failure and rejects when a non-empty `inheritedFileDescriptors` list is configured |
+| `connect(socketPath, options?)` | `Promise<boolean>` | **Socket mode**: Connect to a running daemon; returns `false` on connection/readiness failure and rejects stdio-only descriptor/byte-channel options |
 | `sendCommand(method, params, options?)` | `Promise<TCommands[K]['result']>` | Send a typed command with an optional per-call timeout or abort signal |
+| `sendCommandWithSensitiveBytes(method, params, bytes, options?)` | `Promise<TCommands[K]['result']>` | Send one exclusive JSON command with its raw bytes on the generation-owned one-shot pipe |
 | `sendCommandStreaming(method, params)` | `StreamingResponse<TChunk, TResult>` | Send a streaming command; returns immediately |
 | `terminate(options?)` | `Promise<void>` | Confirm stdio child exit or local socket closure; `gracePeriodMs` controls SIGKILL escalation |
 | `kill()` | `void` | Fire-and-forget compatibility wrapper around `terminate()` |

package/ts/00_commitinfo_data.ts

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