@push.rocks/smartrust 1.5.0 → 1.6.1

package/dist_ts/classes.stdiotransport.js

@@ -1,5 +1,7 @@
 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;
 /**
  * Transport that spawns a child process and communicates via stdin/stdout.
  * Extracted from the original RustBridge process management logic.
@@ -7,8 +9,8 @@ import { LineScanner } from './classes.linescanner.js';
 export class StdioTransport extends plugins.events.EventEmitter {
     options;
     childProcess = null;
+    generation = null;
     lineScanner;
-    stderrRemainder = '';
     _connected = false;
     constructor(options) {
         super();
@@ -21,16 +23,48 @@ export class StdioTransport extends plugins.events.EventEmitter {
     /**
      * Spawn the child process. Resolves when the process is running (not necessarily ready).
      */
-    async connect() {
+    connect() {
+        if (this.generation && !this.generation.closed) {
+            return Promise.reject(new Error('Stdio transport cannot connect until the previous child has closed'));
+        }
         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();
+        let childProcess;
+        try {
+            childProcess = plugins.childProcess.spawn(this.options.binaryPath, this.options.cliArgs, { stdio: ['pipe', 'pipe', 'pipe'], env });
+        }
+        catch (error) {
+            return Promise.reject(this.toError(error, 'Failed to spawn child process'));
+        }
+        let resolveClose;
+        const closePromise = new Promise((resolve) => {
+            resolveClose = resolve;
+        });
+        const generation = {
+            childProcess,
+            stderrRemainder: '',
+            exited: false,
+            closed: false,
+            closePromise,
+            resolveClose,
+            disconnectPromise: null,
+            rejectDisconnect: null,
+            forceKillTimer: null,
+            sigtermAttempted: false,
+            sigkillAttempted: false,
+            sigtermError: null,
+        };
+        this.generation = generation;
+        this.childProcess = childProcess;
+        // Handle stderr with cross-chunk buffering.
+        childProcess.stderr?.on('data', (data) => {
+            if (this.generation !== generation || generation.closed) {
+                return;
+            }
+            generation.stderrRemainder += data.toString();
+            const lines = generation.stderrRemainder.split('\n');
+            generation.stderrRemainder = lines.pop();
             for (const line of lines) {
                 const trimmed = line.trim();
                 if (trimmed) {
@@ -38,99 +72,274 @@ export class StdioTransport extends plugins.events.EventEmitter {
                 }
             }
         });
-        // Handle stdout via LineScanner
-        this.childProcess.stdout.on('data', (chunk) => {
+        // Handle stdout via LineScanner.
+        childProcess.stdout.on('data', (chunk) => {
+            if (this.generation !== generation || generation.closed) {
+                return;
+            }
             this.lineScanner.push(chunk, (line) => {
-                this.emit('line', line);
+                if (this.generation === generation && !generation.closed) {
+                    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());
+        childProcess.on('exit', () => {
+            generation.exited = true;
+            if (this.generation === generation) {
+                this._connected = false;
+            }
+            // A descendant may inherit the child's stdio descriptors and otherwise
+            // keep ChildProcess 'close' from ever firing after the owned child exits.
+            // Allow already-queued data events through this poll turn, then close our
+            // endpoints so confirmation cannot retain that pipe graph indefinitely.
+            setImmediate(() => {
+                if (generation.closed) {
+                    return;
+                }
+                this.destroyOwnedStdioEndpoint(generation, 'stdin');
+                this.destroyOwnedStdioEndpoint(generation, 'stdout');
+                this.destroyOwnedStdioEndpoint(generation, 'stderr');
+            });
+        });
+        // ChildProcess 'close' is the termination confirmation: the process has exited
+        // and its stdio streams have closed.
+        childProcess.on('close', (code, signal) => {
+            if (generation.closed) {
+                return;
+            }
+            // Flush stderr while this generation is still considered active so a
+            // synchronous listener cannot start a replacement child mid-cleanup.
+            if (this.generation === generation
+                && generation.stderrRemainder.trim()) {
+                this.emit('stderr', generation.stderrRemainder.trim());
+            }
+            generation.stderrRemainder = '';
+            generation.exited = true;
+            generation.closed = true;
+            if (generation.forceKillTimer) {
+                clearTimeout(generation.forceKillTimer);
+                generation.forceKillTimer = null;
+            }
+            generation.resolveClose();
+            if (this.generation !== generation) {
+                return;
             }
             this._connected = false;
+            this.childProcess = null;
             this.lineScanner.clear();
-            this.stderrRemainder = '';
             this.emit('close', code, signal);
         });
-        this.childProcess.on('error', (err) => {
+        childProcess.on('error', (error) => {
+            if (this.generation !== generation || generation.closed) {
+                return;
+            }
             this._connected = false;
-            this.emit('error', err);
+            if (generation.sigkillAttempted && generation.rejectDisconnect) {
+                generation.rejectDisconnect(this.toError(error, 'Unable to confirm child termination after SIGKILL'));
+            }
+            if (this.listenerCount('error') > 0) {
+                this.emit('error', error);
+            }
+            else if (generation.disconnectPromise) {
+                this.options.logger.log('error', 'Stdio transport error during disconnect: ' + error.message);
+            }
+            else {
+                this.emit('error', error);
+            }
         });
         this._connected = true;
+        return Promise.resolve();
     }
     /**
      * Write data to stdin with backpressure support.
      */
-    async write(data) {
+    write(data) {
         return new Promise((resolve, reject) => {
-            if (!this.childProcess?.stdin) {
+            const generation = this.generation;
+            if (!generation
+                || generation.closed
+                || generation.childProcess !== this.childProcess
+                || !this._connected
+                || !generation.childProcess.stdin) {
                 reject(new Error('stdin not available'));
                 return;
             }
-            const canContinue = this.childProcess.stdin.write(data, 'utf8', (err) => {
-                if (err) {
-                    reject(err);
+            const canContinue = generation.childProcess.stdin.write(data, 'utf8', (error) => {
+                if (error) {
+                    reject(error);
                 }
             });
             if (canContinue) {
                 resolve();
             }
             else {
-                this.childProcess.stdin.once('drain', () => {
+                generation.childProcess.stdin.once('drain', () => {
                     resolve();
                 });
             }
         });
     }
     /**
-     * Kill the child process. Sends SIGTERM, then SIGKILL after 5s.
+     * Kill the child process without waiting for confirmation.
      */
     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');
+            void this.disconnectAndWait().catch((error) => {
+                this.options.logger.log('error', 'Failed to disconnect stdio transport: ' + this.getErrorMessage(error));
+            });
         }
-        catch { /* already dead */ }
-        // Destroy stdio pipes
-        try {
-            proc.stdin?.destroy();
+        catch (error) {
+            this.options.logger.log('error', 'Failed to disconnect stdio transport: ' + this.getErrorMessage(error));
+        }
+    }
+    /**
+     * Send SIGTERM, escalate to SIGKILL after the grace period, and wait for
+     * ChildProcess 'close' to confirm termination.
+     */
+    disconnectAndWait(options = {}) {
+        const gracePeriodMs = options.gracePeriodMs ?? DEFAULT_DISCONNECT_GRACE_PERIOD_MS;
+        if (!Number.isSafeInteger(gracePeriodMs) || gracePeriodMs < 0) {
+            throw new RangeError('StdioTransport gracePeriodMs must be a non-negative safe integer');
+        }
+        const generation = this.generation;
+        if (!generation) {
+            return Promise.resolve();
         }
-        catch { /* ignore */ }
+        if (generation.disconnectPromise) {
+            return generation.disconnectPromise;
+        }
+        if (generation.closed) {
+            generation.disconnectPromise = generation.closePromise;
+            return generation.disconnectPromise;
+        }
+        let rejectDisconnect;
+        const disconnectPromise = new Promise((resolve, reject) => {
+            rejectDisconnect = reject;
+            void generation.closePromise.then(resolve);
+        });
+        generation.disconnectPromise = disconnectPromise;
+        generation.rejectDisconnect = rejectDisconnect;
+        this._connected = false;
+        void disconnectPromise.then(() => {
+            if (generation.disconnectPromise === disconnectPromise) {
+                generation.rejectDisconnect = null;
+            }
+        }, () => {
+            if (generation.disconnectPromise !== disconnectPromise) {
+                return;
+            }
+            if (generation.forceKillTimer) {
+                clearTimeout(generation.forceKillTimer);
+                generation.forceKillTimer = null;
+            }
+            generation.disconnectPromise = null;
+            generation.rejectDisconnect = null;
+            generation.sigtermAttempted = false;
+            generation.sigkillAttempted = false;
+            generation.sigtermError = null;
+        });
+        if (this.hasExited(generation)) {
+            this.destroyOwnedStdioEndpoint(generation, 'stdin');
+            this.destroyOwnedStdioEndpoint(generation, 'stdout');
+            this.destroyOwnedStdioEndpoint(generation, 'stderr');
+            return disconnectPromise;
+        }
+        generation.sigtermAttempted = true;
+        generation.sigtermError = this.sendSignal(generation, 'SIGTERM');
+        if (generation.closed || this.hasExited(generation)) {
+            return disconnectPromise;
+        }
+        if (gracePeriodMs === 0) {
+            this.forceKill(generation);
+        }
+        else {
+            this.scheduleForceKill(generation, gracePeriodMs);
+        }
+        return disconnectPromise;
+    }
+    scheduleForceKill(generation, remainingMs) {
+        if (generation.closed || this.hasExited(generation)) {
+            return;
+        }
+        const delayMs = Math.min(remainingMs, MAX_TIMER_DELAY_MS);
+        const scheduledAt = Date.now();
         try {
-            proc.stdout?.destroy();
+            generation.forceKillTimer = setTimeout(() => {
+                generation.forceKillTimer = null;
+                if (generation.closed || this.hasExited(generation)) {
+                    return;
+                }
+                const elapsedMs = Math.max(1, Date.now() - scheduledAt);
+                const nextRemainingMs = remainingMs - elapsedMs;
+                if (nextRemainingMs > 0) {
+                    this.scheduleForceKill(generation, nextRemainingMs);
+                }
+                else {
+                    this.forceKill(generation);
+                }
+            }, delayMs);
+        }
+        catch (error) {
+            generation.rejectDisconnect?.(this.toError(error, 'Unable to schedule SIGKILL escalation'));
+        }
+    }
+    forceKill(generation) {
+        if (generation.closed
+            || generation.sigkillAttempted
+            || this.hasExited(generation)) {
+            return;
         }
-        catch { /* ignore */ }
+        generation.sigkillAttempted = true;
+        const sigkillError = this.sendSignal(generation, 'SIGKILL');
+        if (sigkillError && !generation.closed && !this.hasExited(generation)) {
+            const sigtermDetail = generation.sigtermError
+                ? ' SIGTERM also failed: ' + generation.sigtermError.message + '.'
+                : '';
+            generation.rejectDisconnect?.(new Error(sigkillError.message + '.' + sigtermDetail));
+        }
+    }
+    sendSignal(generation, signal) {
         try {
-            proc.stderr?.destroy();
+            const delivered = generation.childProcess.kill(signal);
+            if (delivered || generation.closed || this.hasExited(generation)) {
+                return null;
+            }
+            return new Error('Failed to send ' + signal + ' to child process');
+        }
+        catch (error) {
+            if (generation.closed || this.hasExited(generation)) {
+                return null;
+            }
+            return this.toError(error, 'Failed to send ' + signal + ' to child process');
+        }
+    }
+    hasExited(generation) {
+        return (generation.exited
+            || generation.childProcess.exitCode !== null
+            || generation.childProcess.signalCode !== null);
+    }
+    destroyOwnedStdioEndpoint(generation, endpointName) {
+        const endpoint = generation.childProcess[endpointName];
+        if (!endpoint || endpoint.destroyed) {
+            return;
         }
-        catch { /* ignore */ }
-        // Unref so Node doesn't wait
         try {
-            proc.unref();
+            endpoint.destroy();
         }
-        catch { /* ignore */ }
-        // Force kill after 5 seconds
-        setTimeout(() => {
-            try {
-                proc.kill('SIGKILL');
+        catch (error) {
+            const endpointError = this.toError(error, 'Failed to close inherited child ' + endpointName);
+            generation.rejectDisconnect?.(endpointError);
+            this.options.logger.log('error', endpointError.message);
+            if (this.listenerCount('error') > 0) {
+                this.emit('error', endpointError);
             }
-            catch { /* already dead */ }
-        }, 5000).unref();
+        }
+    }
+    toError(error, prefix) {
+        return new Error(prefix + ': ' + this.getErrorMessage(error));
+    }
+    getErrorMessage(error) {
+        return error instanceof Error ? error.message : String(error);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zdGRpb3RyYW5zcG9ydC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2NsYXNzZXMuc3RkaW90cmFuc3BvcnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFDeEMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBWXZEOzs7R0FHRztBQUNILE1BQU0sT0FBTyxjQUFlLFNBQVEsT0FBTyxDQUFDLE1BQU0sQ0FBQyxZQUFZO0lBQ3JELE9BQU8sQ0FBeUI7SUFDaEMsWUFBWSxHQUE2QyxJQUFJLENBQUM7SUFDOUQsV0FBVyxDQUFjO0lBQ3pCLGVBQWUsR0FBVyxFQUFFLENBQUM7SUFDN0IsVUFBVSxHQUFZLEtBQUssQ0FBQztJQUVwQyxZQUFZLE9BQStCO1FBQ3pDLEtBQUssRUFBRSxDQUFDO1FBQ1IsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLFdBQVcsQ0FBQyxPQUFPLENBQUMsY0FBYyxFQUFFLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUM3RSxDQUFDO0lBRUQsSUFBVyxTQUFTO1FBQ2xCLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQztJQUN6QixDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsT0FBTztRQUNsQixNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUc7WUFDMUIsQ0FBQyxDQUFDLEVBQUUsR0FBRyxPQUFPLENBQUMsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUU7WUFDekMsQ0FBQyxDQUFDLEVBQUUsR0FBRyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUM7UUFFdkIsSUFBSSxDQUFDLFlBQVksR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FDNUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxVQUFVLEVBQ3ZCLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUNwQixFQUFFLEtBQUssRUFBRSxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQ3pDLENBQUM7UUFFRiwyQ0FBMkM7UUFDM0MsSUFBSSxDQUFDLFlBQVksQ0FBQyxNQUFNLEVBQUUsRUFBRSxDQUFDLE1BQU0sRUFBRSxDQUFDLElBQVksRUFBRSxFQUFFO1lBQ3BELElBQUksQ0FBQyxlQUFlLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ3hDLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQy9DLElBQUksQ0FBQyxlQUFlLEdBQUcsS0FBSyxDQUFDLEdBQUcsRUFBRyxDQUFDO1lBQ3BDLEtBQUssTUFBTSxJQUFJLElBQUksS0FBSyxFQUFFLENBQUM7Z0JBQ3pCLE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztnQkFDNUIsSUFBSSxPQUFPLEVBQUUsQ0FBQztvQkFDWixJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxPQUFPLENBQUMsQ0FBQztnQkFDL0IsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDLENBQUMsQ0FBQztRQUVILGdDQUFnQztRQUNoQyxJQUFJLENBQUMsWUFBWSxDQUFDLE1BQU8sQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsS0FBYSxFQUFFLEVBQUU7WUFDckQsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUMsSUFBSSxFQUFFLEVBQUU7Z0JBQ3BDLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO1lBQzFCLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQyxDQUFDLENBQUM7UUFFSCxzQkFBc0I7UUFDdEIsSUFBSSxDQUFDLFlBQVksQ0FBQyxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsSUFBbUIsRUFBRSxNQUFxQixFQUFFLEVBQUU7WUFDMUUseUJBQXlCO1lBQ3pCLElBQUksSUFBSSxDQUFDLGVBQWUsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDO2dCQUNoQyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUMsZUFBZSxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7WUFDbkQsQ0FBQztZQUNELElBQUksQ0FBQyxVQUFVLEdBQUcsS0FBSyxDQUFDO1lBQ3hCLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDekIsSUFBSSxDQUFDLGVBQWUsR0FBRyxFQUFFLENBQUM7WUFDMUIsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQ25DLENBQUMsQ0FBQyxDQUFDO1FBRUgsSUFBSSxDQUFDLFlBQVksQ0FBQyxFQUFFLENBQUMsT0FBTyxFQUFFLENBQUMsR0FBVSxFQUFFLEVBQUU7WUFDM0MsSUFBSSxDQUFDLFVBQVUsR0FBRyxLQUFLLENBQUM7WUFDeEIsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsR0FBRyxDQUFDLENBQUM7UUFDMUIsQ0FBQyxDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQztJQUN6QixDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLLENBQUMsS0FBSyxDQUFDLElBQVk7UUFDN0IsT0FBTyxJQUFJLE9BQU8sQ0FBTyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtZQUMzQyxJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRSxLQUFLLEVBQUUsQ0FBQztnQkFDOUIsTUFBTSxDQUFDLElBQUksS0FBSyxDQUFDLHFCQUFxQixDQUFDLENBQUMsQ0FBQztnQkFDekMsT0FBTztZQUNULENBQUM7WUFFRCxNQUFNLFdBQVcsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRSxDQUFDLEdBQUcsRUFBRSxFQUFFO2dCQUN0RSxJQUFJLEdBQUcsRUFBRSxDQUFDO29CQUNSLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztnQkFDZCxDQUFDO1lBQ0gsQ0FBQyxDQUFDLENBQUM7WUFFSCxJQUFJLFdBQVcsRUFBRSxDQUFDO2dCQUNoQixPQUFPLEVBQUUsQ0FBQztZQUNaLENBQUM7aUJBQU0sQ0FBQztnQkFDTixJQUFJLENBQUMsWUFBWSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLEdBQUcsRUFBRTtvQkFDekMsT0FBTyxFQUFFLENBQUM7Z0JBQ1osQ0FBQyxDQUFDLENBQUM7WUFDTCxDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxVQUFVO1FBQ2YsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZO1lBQUUsT0FBTztRQUUvQixNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDO1FBQy9CLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDO1FBQ3pCLElBQUksQ0FBQyxVQUFVLEdBQUcsS0FBSyxDQUFDO1FBQ3hCLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDekIsSUFBSSxDQUFDLGVBQWUsR0FBRyxFQUFFLENBQUM7UUFFMUIsdUJBQXVCO1FBQ3ZCLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1FBQzFCLElBQUksQ0FBQyxNQUFNLEVBQUUsa0JBQWtCLEVBQUUsQ0FBQztRQUNsQyxJQUFJLENBQUMsTUFBTSxFQUFFLGtCQUFrQixFQUFFLENBQUM7UUFDbEMsSUFBSSxDQUFDLEtBQUssRUFBRSxrQkFBa0IsRUFBRSxDQUFDO1FBRWpDLG1CQUFtQjtRQUNuQixJQUFJLENBQUM7WUFBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQUMsQ0FBQztRQUFDLE1BQU0sQ0FBQyxDQUFDLGtCQUFrQixDQUFDLENBQUM7UUFFMUQsc0JBQXNCO1FBQ3RCLElBQUksQ0FBQztZQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsT0FBTyxFQUFFLENBQUM7UUFBQyxDQUFDO1FBQUMsTUFBTSxDQUFDLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDckQsSUFBSSxDQUFDO1lBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxPQUFPLEVBQUUsQ0FBQztRQUFDLENBQUM7UUFBQyxNQUFNLENBQUMsQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUN0RCxJQUFJLENBQUM7WUFBQyxJQUFJLENBQUMsTUFBTSxFQUFFLE9BQU8sRUFBRSxDQUFDO1FBQUMsQ0FBQztRQUFDLE1BQU0sQ0FBQyxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBRXRELDZCQUE2QjtRQUM3QixJQUFJLENBQUM7WUFBQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7UUFBQyxDQUFDO1FBQUMsTUFBTSxDQUFDLENBQUMsWUFBWSxDQUFDLENBQUM7UUFFNUMsNkJBQTZCO1FBQzdCLFVBQVUsQ0FBQyxHQUFHLEVBQUU7WUFDZCxJQUFJLENBQUM7Z0JBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztZQUFDLENBQUM7WUFBQyxNQUFNLENBQUMsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO1FBQzVELENBQUMsRUFBRSxJQUFJLENBQUMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUNuQixDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stdiotransport.js","sourceRoot":"","sources":["../ts/classes.stdiotransport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAOvD,MAAM,kCAAkC,GAAG,IAAI,CAAC;AAChD,MAAM,kBAAkB,GAAG,aAAa,CAAC;AAyBzC;;;GAGG;AACH,MAAM,OAAO,cAAe,SAAQ,OAAO,CAAC,MAAM,CAAC,YAAY;IACrD,OAAO,CAAyB;IAChC,YAAY,GAA6C,IAAI,CAAC;IAC9D,UAAU,GAAqC,IAAI,CAAC;IACpD,WAAW,CAAc;IACzB,UAAU,GAAY,KAAK,CAAC;IAEpC,YAAY,OAA+B;QACzC,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,WAAW,GAAG,IAAI,WAAW,CAAC,OAAO,CAAC,cAAc,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7E,CAAC;IAED,IAAW,SAAS;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,IAAI,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;YAC/C,OAAO,OAAO,CAAC,MAAM,CACnB,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAChF,CAAC;QACJ,CAAC;QAED,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG;YAC1B,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE;YACzC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;QAEvB,IAAI,YAA+C,CAAC;QACpD,IAAI,CAAC;YACH,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CACvC,IAAI,CAAC,OAAO,CAAC,UAAU,EACvB,IAAI,CAAC,OAAO,CAAC,OAAO,EACpB,EAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,CACzC,CAAC;QACJ,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,OAAO,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,+BAA+B,CAAC,CAAC,CAAC;QAC9E,CAAC;QAED,IAAI,YAAyB,CAAC;QAC9B,MAAM,YAAY,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YACjD,YAAY,GAAG,OAAO,CAAC;QACzB,CAAC,CAAC,CAAC;QACH,MAAM,UAAU,GAA8B;YAC5C,YAAY;YACZ,eAAe,EAAE,EAAE;YACnB,MAAM,EAAE,KAAK;YACb,MAAM,EAAE,KAAK;YACb,YAAY;YACZ,YAAY;YACZ,iBAAiB,EAAE,IAAI;YACvB,gBAAgB,EAAE,IAAI;YACtB,cAAc,EAAE,IAAI;YACpB,gBAAgB,EAAE,KAAK;YACvB,gBAAgB,EAAE,KAAK;YACvB,YAAY,EAAE,IAAI;SACnB,CAAC;QAEF,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QAEjC,4CAA4C;QAC5C,YAAY,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,IAAY,EAAE,EAAE;YAC/C,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;gBACxD,OAAO;YACT,CAAC;YAED,UAAU,CAAC,eAAe,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC9C,MAAM,KAAK,GAAG,UAAU,CAAC,eAAe,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACrD,UAAU,CAAC,eAAe,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;YAC1C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBACzB,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;gBAC5B,IAAI,OAAO,EAAE,CAAC;oBACZ,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;gBAC/B,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,iCAAiC;QACjC,YAAY,CAAC,MAAO,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAa,EAAE,EAAE;YAChD,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;gBACxD,OAAO;YACT,CAAC;YAED,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,EAAE;gBACpC,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;oBACzD,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;gBAC1B,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;YAC3B,UAAU,CAAC,MAAM,GAAG,IAAI,CAAC;YACzB,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;gBACnC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;YAC1B,CAAC;YAED,uEAAuE;YACvE,0EAA0E;YAC1E,0EAA0E;YAC1E,wEAAwE;YACxE,YAAY,CAAC,GAAG,EAAE;gBAChB,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;oBACtB,OAAO;gBACT,CAAC;gBACD,IAAI,CAAC,yBAAyB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBACpD,IAAI,CAAC,yBAAyB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;gBACrD,IAAI,CAAC,yBAAyB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;YACvD,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,+EAA+E;QAC/E,qCAAqC;QACrC,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,IAAmB,EAAE,MAA6B,EAAE,EAAE;YAC9E,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;gBACtB,OAAO;YACT,CAAC;YAED,qEAAqE;YACrE,qEAAqE;YACrE,IACE,IAAI,CAAC,UAAU,KAAK,UAAU;mBAC3B,UAAU,CAAC,eAAe,CAAC,IAAI,EAAE,EACpC,CAAC;gBACD,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC;YACzD,CAAC;YACD,UAAU,CAAC,eAAe,GAAG,EAAE,CAAC;YAChC,UAAU,CAAC,MAAM,GAAG,IAAI,CAAC;YACzB,UAAU,CAAC,MAAM,GAAG,IAAI,CAAC;YACzB,IAAI,UAAU,CAAC,cAAc,EAAE,CAAC;gBAC9B,YAAY,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;gBACxC,UAAU,CAAC,cAAc,GAAG,IAAI,CAAC;YACnC,CAAC;YACD,UAAU,CAAC,YAAY,EAAE,CAAC;YAE1B,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;gBACnC,OAAO;YACT,CAAC;YAED,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;YACxB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QAEH,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAY,EAAE,EAAE;YACxC,IAAI,IAAI,CAAC,UAAU,KAAK,UAAU,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;gBACxD,OAAO;YACT,CAAC;YAED,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;YACxB,IAAI,UAAU,CAAC,gBAAgB,IAAI,UAAU,CAAC,gBAAgB,EAAE,CAAC;gBAC/D,UAAU,CAAC,gBAAgB,CACzB,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,mDAAmD,CAAC,CACzE,CAAC;YACJ,CAAC;YAED,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;gBACpC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;YAC5B,CAAC;iBAAM,IAAI,UAAU,CAAC,iBAAiB,EAAE,CAAC;gBACxC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,2CAA2C,GAAG,KAAK,CAAC,OAAO,CAAC,CAAC;YAChG,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;YAC5B,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,IAAY;QACvB,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3C,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;YACnC,IACE,CAAC,UAAU;mBACR,UAAU,CAAC,MAAM;mBACjB,UAAU,CAAC,YAAY,KAAK,IAAI,CAAC,YAAY;mBAC7C,CAAC,IAAI,CAAC,UAAU;mBAChB,CAAC,UAAU,CAAC,YAAY,CAAC,KAAK,EACjC,CAAC;gBACD,MAAM,CAAC,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC,CAAC;gBACzC,OAAO;YACT,CAAC;YAED,MAAM,WAAW,GAAG,UAAU,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE;gBAC9E,IAAI,KAAK,EAAE,CAAC;oBACV,MAAM,CAAC,KAAK,CAAC,CAAC;gBAChB,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,IAAI,WAAW,EAAE,CAAC;gBAChB,OAAO,EAAE,CAAC;YACZ,CAAC;iBAAM,CAAC;gBACN,UAAU,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE;oBAC/C,OAAO,EAAE,CAAC;gBACZ,CAAC,CAAC,CAAC;YACL,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,UAAU;QACf,IAAI,CAAC;YACH,KAAK,IAAI,CAAC,iBAAiB,EAAE,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;gBACrD,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CACrB,OAAO,EACP,wCAAwC,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CACvE,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CACrB,OAAO,EACP,wCAAwC,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CACvE,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,iBAAiB,CACtB,UAA2C,EAAE;QAE7C,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,IAAI,kCAAkC,CAAC;QAClF,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,aAAa,CAAC,IAAI,aAAa,GAAG,CAAC,EAAE,CAAC;YAC9D,MAAM,IAAI,UAAU,CAClB,kEAAkE,CACnE,CAAC;QACJ,CAAC;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;QAC3B,CAAC;QACD,IAAI,UAAU,CAAC,iBAAiB,EAAE,CAAC;YACjC,OAAO,UAAU,CAAC,iBAAiB,CAAC;QACtC,CAAC;QACD,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;YACtB,UAAU,CAAC,iBAAiB,GAAG,UAAU,CAAC,YAAY,CAAC;YACvD,OAAO,UAAU,CAAC,iBAAiB,CAAC;QACtC,CAAC;QAED,IAAI,gBAAyC,CAAC;QAC9C,MAAM,iBAAiB,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC9D,gBAAgB,GAAG,MAAM,CAAC;YAC1B,KAAK,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;QACH,UAAU,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;QACjD,UAAU,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;QAC/C,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,KAAK,iBAAiB,CAAC,IAAI,CACzB,GAAG,EAAE;YACH,IAAI,UAAU,CAAC,iBAAiB,KAAK,iBAAiB,EAAE,CAAC;gBACvD,UAAU,CAAC,gBAAgB,GAAG,IAAI,CAAC;YACrC,CAAC;QACH,CAAC,EACD,GAAG,EAAE;YACH,IAAI,UAAU,CAAC,iBAAiB,KAAK,iBAAiB,EAAE,CAAC;gBACvD,OAAO;YACT,CAAC;YACD,IAAI,UAAU,CAAC,cAAc,EAAE,CAAC;gBAC9B,YAAY,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;gBACxC,UAAU,CAAC,cAAc,GAAG,IAAI,CAAC;YACnC,CAAC;YACD,UAAU,CAAC,iBAAiB,GAAG,IAAI,CAAC;YACpC,UAAU,CAAC,gBAAgB,GAAG,IAAI,CAAC;YACnC,UAAU,CAAC,gBAAgB,GAAG,KAAK,CAAC;YACpC,UAAU,CAAC,gBAAgB,GAAG,KAAK,CAAC;YACpC,UAAU,CAAC,YAAY,GAAG,IAAI,CAAC;QACjC,CAAC,CACF,CAAC;QAEF,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;YAC/B,IAAI,CAAC,yBAAyB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;YACpD,IAAI,CAAC,yBAAyB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;YACrD,IAAI,CAAC,yBAAyB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;YACrD,OAAO,iBAAiB,CAAC;QAC3B,CAAC;QAED,UAAU,CAAC,gBAAgB,GAAG,IAAI,CAAC;QACnC,UAAU,CAAC,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAEjE,IAAI,UAAU,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;YACpD,OAAO,iBAAiB,CAAC;QAC3B,CAAC;QAED,IAAI,aAAa,KAAK,CAAC,EAAE,CAAC;YACxB,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;QAC7B,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;QACpD,CAAC;QAED,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAEO,iBAAiB,CACvB,UAAqC,EACrC,WAAmB;QAEnB,IAAI,UAAU,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;YACpD,OAAO;QACT,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,kBAAkB,CAAC,CAAC;QAC1D,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC/B,IAAI,CAAC;YACH,UAAU,CAAC,cAAc,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC1C,UAAU,CAAC,cAAc,GAAG,IAAI,CAAC;gBACjC,IAAI,UAAU,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;oBACpD,OAAO;gBACT,CAAC;gBAED,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,WAAW,CAAC,CAAC;gBACxD,MAAM,eAAe,GAAG,WAAW,GAAG,SAAS,CAAC;gBAChD,IAAI,eAAe,GAAG,CAAC,EAAE,CAAC;oBACxB,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;gBACtD,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;gBAC7B,CAAC;YACH,CAAC,EAAE,OAAO,CAAC,CAAC;QACd,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,UAAU,CAAC,gBAAgB,EAAE,CAC3B,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,uCAAuC,CAAC,CAC7D,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,SAAS,CAAC,UAAqC;QACrD,IACE,UAAU,CAAC,MAAM;eACd,UAAU,CAAC,gBAAgB;eAC3B,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAC7B,CAAC;YACD,OAAO;QACT,CAAC;QAED,UAAU,CAAC,gBAAgB,GAAG,IAAI,CAAC;QACnC,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAC5D,IAAI,YAAY,IAAI,CAAC,UAAU,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;YACtE,MAAM,aAAa,GAAG,UAAU,CAAC,YAAY;gBAC3C,CAAC,CAAC,wBAAwB,GAAG,UAAU,CAAC,YAAY,CAAC,OAAO,GAAG,GAAG;gBAClE,CAAC,CAAC,EAAE,CAAC;YACP,UAAU,CAAC,gBAAgB,EAAE,CAC3B,IAAI,KAAK,CAAC,YAAY,CAAC,OAAO,GAAG,GAAG,GAAG,aAAa,CAAC,CACtD,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,UAAU,CAChB,UAAqC,EACrC,MAAsB;QAEtB,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,UAAU,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACvD,IAAI,SAAS,IAAI,UAAU,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;gBACjE,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,IAAI,KAAK,CAAC,iBAAiB,GAAG,MAAM,GAAG,mBAAmB,CAAC,CAAC;QACrE,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,IAAI,UAAU,CAAC,MAAM,IAAI,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;gBACpD,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,GAAG,mBAAmB,CAAC,CAAC;QAC/E,CAAC;IACH,CAAC;IAEO,SAAS,CAAC,UAAqC;QACrD,OAAO,CACL,UAAU,CAAC,MAAM;eACd,UAAU,CAAC,YAAY,CAAC,QAAQ,KAAK,IAAI;eACzC,UAAU,CAAC,YAAY,CAAC,UAAU,KAAK,IAAI,CAC/C,CAAC;IACJ,CAAC;IAEO,yBAAyB,CAC/B,UAAqC,EACrC,YAA2C;QAE3C,MAAM,QAAQ,GAAG,UAAU,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;QACvD,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,SAAS,EAAE,CAAC;YACpC,OAAO;QACT,CAAC;QAED,IAAI,CAAC;YACH,QAAQ,CAAC,OAAO,EAAE,CAAC;QACrB,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAChC,KAAK,EACL,kCAAkC,GAAG,YAAY,CAClD,CAAC;YACF,UAAU,CAAC,gBAAgB,EAAE,CAAC,aAAa,CAAC,CAAC;YAC7C,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;YACxD,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;gBACpC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;IACH,CAAC;IAEO,OAAO,CAAC,KAAc,EAAE,MAAc;QAC5C,OAAO,IAAI,KAAK,CAAC,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC;IAChE,CAAC;IAEO,eAAe,CAAC,KAAc;QACpC,OAAO,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAChE,CAAC;CACF"}

package/dist_ts/interfaces/config.d.ts

@@ -13,6 +13,14 @@ export interface IRustBridgeRequestOptions {
     /** Override the bridge request timeout for this call, in milliseconds. */
     timeoutMs?: number;
 }
+/** Options for confirmed bridge termination. */
+export interface IRustBridgeTerminateOptions {
+    /**
+     * Time to allow an owned stdio child to exit after SIGTERM before SIGKILL.
+     * Zero requests immediate SIGKILL. Defaults to 5000 milliseconds.
+     */
+    gracePeriodMs?: number;
+}
 /**
  * Options for locating a Rust binary.
  */

package/dist_ts/interfaces/transport.d.ts

@@ -1,4 +1,9 @@
 import type * as plugins from '../plugins.js';
+/** Options for confirmed transport disconnection. */
+export interface IRustTransportDisconnectOptions {
+    /** Grace period before escalating process termination, in milliseconds. */
+    gracePeriodMs?: number;
+}
 /**
  * Abstract transport for communicating with a Rust process.
  * Both stdio and socket transports implement this interface.
@@ -17,6 +22,10 @@ export interface IRustTransport extends plugins.events.EventEmitter {
     write(data: string): 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. */
+    disconnectAndWait?(options?: IRustTransportDisconnectOptions): Promise<void>;
     /** Whether the transport is currently connected and writable. */
     readonly connected: boolean;
+    /** Whether the transport is preserving its lifecycle for an automatic reconnect. */
+    readonly reconnecting?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartrust",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "private": false,
   "description": "A type-safe bridge between JavaScript engines and Rust binaries.",
   "main": "dist_ts/index.js",

package/readme.md

@@ -99,8 +99,8 @@ bridge.on('management:configChanged', (data) => {
   console.log('Config was changed:', data);
 });
 
-// Clean shutdown (SIGTERM → SIGKILL after 5s)
-bridge.kill();
+// Confirmed shutdown (SIGTERM → SIGKILL after 5s)
+await bridge.terminate();
 ```
 
 ### Per-Command Deadlines and Cancellation
@@ -154,6 +154,30 @@ programmatic handling:
 | `ERR_RUST_BRIDGE_REQUEST_TRANSPORT` | The transport exited, disconnected, or was killed |
 | `ERR_RUST_BRIDGE_REQUEST_RUST_RESPONSE` | Rust returned `success: false` |
 
+### Confirmed Termination
+
+Use `await bridge.terminate()` when later work must not overlap the current
+worker. In stdio mode it sends SIGTERM, escalates to SIGKILL after five seconds,
+and resolves only after the child process and its stdio handles have closed.
+The grace period can be changed per termination; zero requests immediate
+SIGKILL:
+
+```typescript
+await bridge.terminate({ gracePeriodMs: 250 });
+```
+
+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
+daemon is never signaled. `kill()` remains available for compatibility as a
+fire-and-forget wrapper, but callers that require confirmed ownership release
+must await `terminate()`.
+
+If termination rejects, the bridge retains the transport and remains in its
+stopping state because closure was not confirmed. A later `terminate()` call
+starts a fresh cleanup attempt; activation remains unavailable until one of
+those attempts confirms closure.
+
 ### Socket Mode — Connect to a Running Daemon 🔗
 
 When the Rust binary runs as a system service (e.g., via `systemd`, `launchd`, or a Windows Service), use `connect()` to talk to it over a Unix socket or named pipe:
@@ -174,8 +198,8 @@ if (!ok) {
 const { pid } = await bridge.sendCommand('start', { port: 8080, host: '0.0.0.0' });
 const metrics = await bridge.sendCommand('getMetrics', {});
 
-// kill() closes the socket — it does NOT kill the daemon
-bridge.kill();
+// terminate() confirms local socket closure — it does NOT kill the daemon
+await bridge.terminate();
 ```
 
 #### Auto-Reconnect
@@ -539,7 +563,8 @@ fn main() {
 | `connect(socketPath, options?)` | `Promise<boolean>` | **Socket mode**: Connect to a running daemon; returns `false` on failure |
 | `sendCommand(method, params, options?)` | `Promise<TCommands[K]['result']>` | Send a typed command with an optional per-call timeout or abort signal |
 | `sendCommandStreaming(method, params)` | `StreamingResponse<TChunk, TResult>` | Send a streaming command; returns immediately |
-| `kill()` | `void` | Stdio: SIGTERM the process, SIGKILL after 5s. Socket: close the connection (daemon stays alive) |
+| `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()` |
 | `running` | `boolean` | Whether the bridge is currently connected and ready |
 
 ### `StreamingResponse<TChunk, TResult>`
@@ -565,6 +590,7 @@ fn main() {
 | `connect()` | `Promise<void>` | Spawn the child process |
 | `write(data)` | `Promise<void>` | Write to stdin with backpressure handling |
 | `disconnect()` | `void` | Kill the process (SIGTERM → SIGKILL after 5s) |
+| `disconnectAndWait(options?)` | `Promise<void>` | Confirm child close after SIGTERM/SIGKILL escalation |
 | `connected` | `boolean` | Whether the process is running |
 
 ### `SocketTransport`
@@ -575,7 +601,9 @@ fn main() {
 | `connect()` | `Promise<void>` | Connect to the Unix socket / named pipe |
 | `write(data)` | `Promise<void>` | Write to socket with backpressure handling |
 | `disconnect()` | `void` | Close the socket (does not kill the daemon) |
+| `disconnectAndWait()` | `Promise<void>` | Confirm local socket closure without signaling the daemon |
 | `connected` | `boolean` | Whether the socket is connected |
+| `reconnecting` | `boolean` | Whether an automatic reconnect timer or attempt owns the socket lifecycle |
 
 ### `LineScanner`
 
@@ -591,6 +619,8 @@ fn main() {
 |---|---|
 | `IRustBridgeOptions` | Full configuration for `RustBridge` |
 | `IRustBridgeRequestOptions` | Per-command options: `{ signal?, timeoutMs? }` |
+| `IRustBridgeTerminateOptions` | Confirmed termination options: `{ gracePeriodMs? }` |
+| `IRustTransportDisconnectOptions` | Optional confirmed-disconnect grace period for owned process transports |
 | `IBinaryLocatorOptions` | Configuration for `RustBinaryLocator` |
 | `ISocketConnectOptions` | Socket connection options (reconnect settings) |
 | `IRustBridgeLogger` | Logger interface: `{ log(level, message, data?) }` |

package/ts/00_commitinfo_data.ts

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