@push.rocks/smartrust 1.7.0 → 1.8.0

package/ts/classes.rustbridge.ts

@@ -32,6 +32,12 @@ interface IPendingRequest {
   abortSignal?: AbortSignal;
   abortHandler?: () => void;
   streaming?: StreamingResponse<any, any>;
+  admissionReservation?: IRequestAdmissionReservation;
+}
+
+interface IRequestAdmissionReservation {
+  method: string;
+  released: boolean;
 }
 
 type TPendingRequestSettlement =
@@ -57,6 +63,7 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
   private logger: IRustBridgeLogger;
   private transport: TConfirmableRustTransport | null = null;
   private pendingRequests = new Map<string, IPendingRequest>();
+  private pendingRequestReservationsByMethod = new Map<string, number>();
   private requestCounter = 0;
   private isRunning = false;
   private binaryPath: string | null = null;
@@ -67,6 +74,15 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
 
   constructor(options: IRustBridgeOptions) {
     super();
+    if (options.maxPendingRequestsByMethod) {
+      for (const [method, limit] of Object.entries(options.maxPendingRequestsByMethod)) {
+        if (!method || !Number.isSafeInteger(limit) || limit <= 0) {
+          throw new RangeError(
+            'RustBridge maxPendingRequestsByMethod values must be positive safe integers',
+          );
+        }
+      }
+    }
     this.logger = options.logger || defaultLogger;
     this.options = {
       cliArgs: ['--management'],
@@ -75,6 +91,9 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
       readyEventName: 'ready',
       maxPayloadSize: 50 * 1024 * 1024,
       ...options,
+      maxPendingRequestsByMethod: options.maxPendingRequestsByMethod
+        ? { ...options.maxPendingRequestsByMethod }
+        : undefined,
     };
     this.locator = new RustBinaryLocator(options, this.logger);
   }
@@ -396,95 +415,137 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
       );
     }
 
-    if (!this.transport?.connected || !this.isRunning) {
+    const transport = this.transport;
+    if (!transport?.connected || !this.isRunning) {
       throw new Error(`${this.options.binaryName} bridge is not running`);
     }
 
-    const transport = this.transport;
-    const id = `req_${++this.requestCounter}`;
-    const request: IManagementRequest = { id, method, params };
-    const json = JSON.stringify(request);
-
-    // Check outbound payload size
-    const byteLength = Buffer.byteLength(json, 'utf8');
-    if (byteLength > this.options.maxPayloadSize) {
-      throw new Error(
-        `Outbound message exceeds maxPayloadSize (${byteLength} > ${this.options.maxPayloadSize})`
-      );
-    }
+    const lifecycleGeneration = this.lifecycleGeneration;
+    const admissionReservation = this.reservePendingRequest(method);
+    let reservationTransferred = false;
 
-    return new Promise<TCommands[K]['result']>((resolve, reject) => {
-      const pending: IPendingRequest = {
-        resolve,
-        reject,
-        timer: null,
+    try {
+      const id = `req_${++this.requestCounter}`;
+      const request: IManagementRequest = { id, method, params };
+      const json = JSON.stringify(request);
+
+      const byteLength = Buffer.byteLength(json, 'utf8');
+      if (byteLength > this.options.maxPayloadSize) {
+        throw new Error(
+          `Outbound message exceeds maxPayloadSize (${byteLength} > ${this.options.maxPayloadSize})`
+        );
+      }
+
+      const availabilityError = this.getRequestAvailabilityError(
         method,
-        abortSignal: options?.signal,
-      };
-      this.pendingRequests.set(id, pending);
+        options?.signal,
+        transport,
+        lifecycleGeneration,
+      );
+      if (availabilityError) {
+        throw availabilityError;
+      }
 
-      if (options?.signal) {
-        pending.abortHandler = () => {
-          this.settlePendingRequest(id, {
-            outcome: 'reject',
-            error: new RustBridgeRequestError(
-              `Command '${method}' was aborted`,
-              {
-                code: 'ERR_RUST_BRIDGE_REQUEST_ABORTED',
-                requestId: id,
-                method,
-                cause: options.signal?.reason,
-              },
-            ),
-          });
+      return new Promise<TCommands[K]['result']>((resolve, reject) => {
+        const pending: IPendingRequest = {
+          resolve,
+          reject,
+          timer: null,
+          method,
+          abortSignal: options?.signal,
+          admissionReservation,
         };
-        options.signal.addEventListener('abort', pending.abortHandler, { once: true });
-      }
+        this.pendingRequests.set(id, pending);
+        reservationTransferred = true;
 
-      pending.timer = setTimeout(() => {
-        this.settlePendingRequest(id, {
-          outcome: 'reject',
-          error: new RustBridgeRequestError(
-            `Command '${method}' timed out after ${timeoutMs}ms`,
-            {
-              code: 'ERR_RUST_BRIDGE_REQUEST_TIMEOUT',
-              requestId: id,
-              method,
-            },
-          ),
-        });
-      }, timeoutMs);
+        try {
+          if (options?.signal) {
+            pending.abortHandler = () => {
+              this.settlePendingRequest(id, {
+                outcome: 'reject',
+                error: new RustBridgeRequestError(
+                  `Command '${method}' was aborted`,
+                  {
+                    code: 'ERR_RUST_BRIDGE_REQUEST_ABORTED',
+                    requestId: id,
+                    method,
+                    cause: options.signal?.reason,
+                  },
+                ),
+              });
+            };
+            options.signal.addEventListener('abort', pending.abortHandler, { once: true });
+            if (options.signal.aborted) {
+              pending.abortHandler();
+              return;
+            }
+          }
 
-      try {
-        void transport.write(json + '\n').catch((err: unknown) => {
+          pending.timer = setTimeout(() => {
+            this.settlePendingRequest(id, {
+              outcome: 'reject',
+              error: new RustBridgeRequestError(
+                `Command '${method}' timed out after ${timeoutMs}ms`,
+                {
+                  code: 'ERR_RUST_BRIDGE_REQUEST_TIMEOUT',
+                  requestId: id,
+                  method,
+                },
+              ),
+            });
+          }, timeoutMs);
+
+          const currentAvailabilityError = this.getRequestAvailabilityError(
+            method,
+            options?.signal,
+            transport,
+            lifecycleGeneration,
+            id,
+          );
+          if (currentAvailabilityError) {
+            this.settlePendingRequest(id, {
+              outcome: 'reject',
+              error: currentAvailabilityError,
+            });
+            return;
+          }
+
+          void transport.write(json + '\n').catch((err: unknown) => {
+            this.settlePendingRequest(id, {
+              outcome: 'reject',
+              error: new RustBridgeRequestError(
+                `Failed to write to transport: ${this.getErrorMessage(err)}`,
+                {
+                  code: 'ERR_RUST_BRIDGE_REQUEST_WRITE',
+                  requestId: id,
+                  method,
+                  cause: err,
+                },
+              ),
+            });
+          });
+        } catch (err: unknown) {
           this.settlePendingRequest(id, {
             outcome: 'reject',
-            error: new RustBridgeRequestError(
-              `Failed to write to transport: ${this.getErrorMessage(err)}`,
-              {
-                code: 'ERR_RUST_BRIDGE_REQUEST_WRITE',
-                requestId: id,
-                method,
-                cause: err,
-              },
-            ),
+            error: err instanceof RustBridgeRequestError
+              ? err
+              : new RustBridgeRequestError(
+                `Failed to write to transport: ${this.getErrorMessage(err)}`,
+                {
+                  code: 'ERR_RUST_BRIDGE_REQUEST_WRITE',
+                  requestId: id,
+                  method,
+                  cause: err,
+                },
+              ),
           });
-        });
-      } catch (err: unknown) {
-        this.settlePendingRequest(id, {
-          outcome: 'reject',
-          error: new RustBridgeRequestError(
-            `Failed to write to transport: ${this.getErrorMessage(err)}`,
-            {
-              code: 'ERR_RUST_BRIDGE_REQUEST_WRITE',
-              requestId: id,
-              method,
-              cause: err,
-            },
-          ),
-        });
+        }
+      });
+    } finally {
+      if (!reservationTransferred) {
+        this.releasePendingRequestReservation(admissionReservation);
       }
-    });
+    }
   }
 
   /**
@@ -498,51 +559,120 @@ 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.transport?.connected || !this.isRunning) {
+    const transport = this.transport;
+    if (!transport?.connected || !this.isRunning) {
       streaming.fail(new Error(`${this.options.binaryName} bridge is not running`));
       return streaming;
     }
 
-    const id = `req_${++this.requestCounter}`;
-    const request: IManagementRequest = { id, method, params };
-    const json = JSON.stringify(request);
+    const lifecycleGeneration = this.lifecycleGeneration;
+    let admissionReservation: IRequestAdmissionReservation | undefined;
+    let reservationTransferred = false;
+    let requestId: string | undefined;
+
+    try {
+      admissionReservation = this.reservePendingRequest(method);
+      const id = `req_${++this.requestCounter}`;
+      requestId = id;
+      const request: IManagementRequest = { id, method, params };
+      const json = JSON.stringify(request);
+
+      const byteLength = Buffer.byteLength(json, 'utf8');
+      if (byteLength > this.options.maxPayloadSize) {
+        throw new Error(
+          `Outbound message exceeds maxPayloadSize (${byteLength} > ${this.options.maxPayloadSize})`,
+        );
+      }
 
-    const byteLength = Buffer.byteLength(json, 'utf8');
-    if (byteLength > this.options.maxPayloadSize) {
-      streaming.fail(
-        new Error(`Outbound message exceeds maxPayloadSize (${byteLength} > ${this.options.maxPayloadSize})`)
+      const availabilityError = this.getRequestAvailabilityError(
+        method,
+        undefined,
+        transport,
+        lifecycleGeneration,
       );
-      return streaming;
-    }
+      if (availabilityError) {
+        throw availabilityError;
+      }
 
-    const timeoutMs = this.options.streamTimeoutMs ?? this.options.requestTimeoutMs;
-    const timer = setTimeout(() => {
-      this.settlePendingRequest(id, {
-        outcome: 'reject',
-        error: new Error(`Streaming command '${method}' timed out after ${timeoutMs}ms`),
+      this.pendingRequests.set(id, {
+        resolve: (result: any) => streaming.finish(result),
+        reject: (error: Error) => streaming.fail(error),
+        timer: null,
+        method,
+        streaming,
+        admissionReservation,
       });
-    }, timeoutMs);
-
-    this.pendingRequests.set(id, {
-      resolve: (result: any) => streaming.finish(result),
-      reject: (error: Error) => streaming.fail(error),
-      timer,
-      method,
-      streaming,
-    });
+      reservationTransferred = true;
 
-    try {
-      void this.transport!.write(json + '\n').catch((err: unknown) => {
+      try {
+        const timeoutMs = this.options.streamTimeoutMs ?? this.options.requestTimeoutMs;
+        const pending = this.pendingRequests.get(id)!;
+        pending.timer = setTimeout(() => {
+          this.settlePendingRequest(id, {
+            outcome: 'reject',
+            error: new Error(`Streaming command '${method}' timed out after ${timeoutMs}ms`),
+          });
+        }, timeoutMs);
+
+        const currentAvailabilityError = this.getRequestAvailabilityError(
+          method,
+          undefined,
+          transport,
+          lifecycleGeneration,
+          id,
+        );
+        if (currentAvailabilityError) {
+          this.settlePendingRequest(id, {
+            outcome: 'reject',
+            error: currentAvailabilityError,
+          });
+          return streaming;
+        }
+
+        void transport.write(json + '\n').catch((err: unknown) => {
+          this.settlePendingRequest(id, {
+            outcome: 'reject',
+            error: new RustBridgeRequestError(
+              `Failed to write to transport: ${this.getErrorMessage(err)}`,
+              {
+                code: 'ERR_RUST_BRIDGE_REQUEST_WRITE',
+                requestId: id,
+                method,
+                cause: err,
+              },
+            ),
+          });
+        });
+      } catch (err: unknown) {
         this.settlePendingRequest(id, {
           outcome: 'reject',
-          error: new Error(`Failed to write to transport: ${this.getErrorMessage(err)}`),
+          error: err instanceof RustBridgeRequestError
+            ? err
+            : new RustBridgeRequestError(
+              `Failed to write to transport: ${this.getErrorMessage(err)}`,
+              {
+                code: 'ERR_RUST_BRIDGE_REQUEST_WRITE',
+                requestId: id,
+                method,
+                cause: err,
+              },
+            ),
         });
-      });
+      }
     } catch (err: unknown) {
-      this.settlePendingRequest(id, {
-        outcome: 'reject',
-        error: new Error(`Failed to write to transport: ${this.getErrorMessage(err)}`),
-      });
+      const error = err instanceof Error ? err : new Error(this.getErrorMessage(err));
+      if (reservationTransferred && requestId) {
+        this.settlePendingRequest(requestId, {
+          outcome: 'reject',
+          error,
+        });
+      } else {
+        streaming.fail(error);
+      }
+    } finally {
+      if (!reservationTransferred) {
+        this.releasePendingRequestReservation(admissionReservation);
+      }
     }
 
     return streaming;
@@ -746,6 +876,7 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
     }
 
     this.pendingRequests.delete(id);
+    this.releasePendingRequestReservation(pending.admissionReservation);
     if (pending.timer) {
       clearTimeout(pending.timer);
       pending.timer = null;
@@ -782,6 +913,86 @@ export class RustBridge<TCommands extends TCommandMap = TCommandMap> extends plu
     }
   }
 
+  private reservePendingRequest(method: string): IRequestAdmissionReservation | undefined {
+    const configuredLimits = this.options.maxPendingRequestsByMethod;
+    const limit = configuredLimits
+      && Object.prototype.hasOwnProperty.call(configuredLimits, method)
+      ? configuredLimits[method]
+      : undefined;
+    if (limit === undefined) {
+      return undefined;
+    }
+
+    const currentCount = this.pendingRequestReservationsByMethod.get(method) || 0;
+    if (currentCount >= limit) {
+      throw new RustBridgeRequestError(
+        `Command '${method}' reached its pending request limit of ${limit}`,
+        {
+          code: 'ERR_RUST_BRIDGE_REQUEST_LIMIT',
+          method,
+        },
+      );
+    }
+
+    this.pendingRequestReservationsByMethod.set(method, currentCount + 1);
+    return { method, released: false };
+  }
+
+  private releasePendingRequestReservation(
+    reservation: IRequestAdmissionReservation | undefined,
+  ): void {
+    if (!reservation || reservation.released) {
+      return;
+    }
+    reservation.released = true;
+
+    const currentCount = this.pendingRequestReservationsByMethod.get(reservation.method) || 0;
+    if (currentCount <= 1) {
+      this.pendingRequestReservationsByMethod.delete(reservation.method);
+    } else {
+      this.pendingRequestReservationsByMethod.set(reservation.method, currentCount - 1);
+    }
+  }
+
+  private getRequestAvailabilityError(
+    method: string,
+    signal: AbortSignal | undefined,
+    transport: TConfirmableRustTransport,
+    lifecycleGeneration: number,
+    requestId?: string,
+  ): RustBridgeRequestError | null {
+    if (signal?.aborted) {
+      return new RustBridgeRequestError(
+        `Command '${method}' was aborted before it was sent`,
+        {
+          code: 'ERR_RUST_BRIDGE_REQUEST_ABORTED',
+          requestId,
+          method,
+          cause: signal.reason,
+        },
+      );
+    }
+
+    if (
+      this.lifecycleState !== 'ready'
+      || !this.isRunning
+      || this.lifecycleGeneration !== lifecycleGeneration
+      || this.transport !== transport
+      || !transport.connected
+    ) {
+      return new RustBridgeRequestError(
+        `Command '${method}' could not be sent because the bridge lifecycle changed`,
+        {
+          code: 'ERR_RUST_BRIDGE_REQUEST_TRANSPORT',
+          requestId,
+          method,
+        },
+      );
+    }
+
+    return null;
+  }
+
   private getErrorMessage(error: unknown): string {
     return error instanceof Error ? error.message : String(error);
   }

package/ts/classes.rustbridgerequesterror.ts

@@ -4,6 +4,7 @@
 export type TRustBridgeRequestErrorCode =
   | 'ERR_RUST_BRIDGE_REQUEST_TIMEOUT'
   | 'ERR_RUST_BRIDGE_REQUEST_ABORTED'
+  | 'ERR_RUST_BRIDGE_REQUEST_LIMIT'
   | 'ERR_RUST_BRIDGE_REQUEST_WRITE'
   | 'ERR_RUST_BRIDGE_REQUEST_TRANSPORT'
   | 'ERR_RUST_BRIDGE_REQUEST_RUST_RESPONSE';
@@ -20,8 +21,8 @@ export interface IRustBridgeRequestErrorOptions {
  * Error raised while preparing or waiting for a Rust bridge request.
  *
  * Existing error messages are preserved while `code` provides a stable way to
- * distinguish timeout, cancellation, transport, write, and Rust response
- * failures.
+ * distinguish admission, timeout, cancellation, transport, write, and Rust
+ * response failures.
  */
 export class RustBridgeRequestError extends Error {
   public readonly code: TRustBridgeRequestErrorCode;

package/ts/classes.sockettransport.ts

@@ -320,9 +320,7 @@ export class SocketTransport extends plugins.events.EventEmitter implements IRus
     }, delay);
   }
 
-  /**
-   * Write data to the socket with backpressure support.
-   */
+  /** Write data to the socket and resolve after the stream callback confirms it. */
   public write(data: string): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       const generation = this.generation;
@@ -336,19 +334,13 @@ export class SocketTransport extends plugins.events.EventEmitter implements IRus
         return;
       }
 
-      const canContinue = generation.socket.write(data, 'utf8', (error) => {
+      generation.socket.write(data, 'utf8', (error) => {
         if (error) {
           reject(error);
+        } else {
+          resolve();
         }
       });
-
-      if (canContinue) {
-        resolve();
-      } else {
-        generation.socket.once('drain', () => {
-          resolve();
-        });
-      }
     });
   }
 

package/ts/classes.stdiotransport.ts

@@ -20,6 +20,7 @@ export interface IStdioTransportOptions {
 interface IStdioTransportGeneration {
   childProcess: plugins.childProcess.ChildProcess;
   stderrRemainder: string;
+  stdinError: Error | null;
   exited: boolean;
   closed: boolean;
   closePromise: Promise<void>;
@@ -85,6 +86,7 @@ export class StdioTransport extends plugins.events.EventEmitter implements IRust
     const generation: IStdioTransportGeneration = {
       childProcess,
       stderrRemainder: '',
+      stdinError: null,
       exited: false,
       closed: false,
       closePromise,
@@ -100,6 +102,42 @@ export class StdioTransport extends plugins.events.EventEmitter implements IRust
     this.generation = generation;
     this.childProcess = childProcess;
 
+    childProcess.stdin?.on('error', (error: Error) => {
+      if (generation.stdinError) {
+        return;
+      }
+      generation.stdinError = error;
+      if (this.generation !== generation || generation.closed) {
+        return;
+      }
+
+      this._connected = false;
+      // Let the write callback settle its request before the bridge rejects all
+      // other pending work through the transport-wide error path.
+      queueMicrotask(() => {
+        if (this.generation !== generation || generation.closed) {
+          return;
+        }
+        void this.disconnectAndWait().catch((disconnectError: unknown) => {
+          this.options.logger.log(
+            'error',
+            'Failed to clean up child after stdin error: '
+              + this.getErrorMessage(disconnectError),
+          );
+        });
+        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);
+        }
+      });
+    });
+
     // Handle stderr with cross-chunk buffering.
     childProcess.stderr?.on('data', (data: Buffer) => {
       if (this.generation !== generation || generation.closed) {
@@ -209,9 +247,7 @@ export class StdioTransport extends plugins.events.EventEmitter implements IRust
     return Promise.resolve();
   }
 
-  /**
-   * Write data to stdin with backpressure support.
-   */
+  /** Write data to stdin and resolve after the stream callback confirms it. */
   public write(data: string): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       const generation = this.generation;
@@ -226,19 +262,13 @@ export class StdioTransport extends plugins.events.EventEmitter implements IRust
         return;
       }
 
-      const canContinue = generation.childProcess.stdin.write(data, 'utf8', (error) => {
+      generation.childProcess.stdin.write(data, 'utf8', (error) => {
         if (error) {
           reject(error);
+        } else {
+          resolve();
         }
       });
-
-      if (canContinue) {
-        resolve();
-      } else {
-        generation.childProcess.stdin.once('drain', () => {
-          resolve();
-        });
-      }
     });
   }
 

package/ts/interfaces/config.ts

@@ -63,6 +63,12 @@ export interface IRustBridgeOptions extends IBinaryLocatorOptions {
   /** Inactivity timeout for streaming commands in ms (default: same as requestTimeoutMs).
    *  Resets on each chunk received. */
   streamTimeoutMs?: number;
+  /**
+   * Optional per-method limits for locally pending requests. A saturated
+   * method fails before serialization or transport writes, while other
+   * methods remain available for control and callback traffic.
+   */
+  maxPendingRequestsByMethod?: Record<string, number>;
 }
 
 /**