@push.rocks/smartmta 13.0.1 → 14.0.0

package/ts/security/classes.rustsecuritybridge.ts

@@ -546,6 +546,66 @@ interface IEmailData {
   base64: string;
 }
 
+/** A mailbox of the parsed-message bridge JSON. */
+export interface IBridgeMailAddress {
+  email: string;
+  name?: string;
+}
+
+/** The header fields of an inline nested message (never produced with smartmta's setting). */
+export interface IBridgeMessageHeader {
+  from: IBridgeMailAddress[];
+  to: IBridgeMailAddress[];
+  cc: IBridgeMailAddress[];
+  bcc: IBridgeMailAddress[];
+  subject?: string;
+  date?: string;
+}
+
+/** One body group: the text and HTML sections of one multipart/alternative or one body part. */
+export interface IBridgeMailBodyGroup {
+  text?: string;
+  html?: string;
+  messageHeader?: IBridgeMessageHeader;
+}
+
+export interface IBridgeParsedAttachment {
+  filename?: string;
+  contentType: string;
+  disposition?: 'attachment' | 'inline';
+  contentId?: string;
+  /** Standard base64 of the transfer-decoded bytes. */
+  content: string;
+  size: number;
+}
+
+/**
+ * A message as the Rust mailer-mime crate parsed it (docs/cleanroom/mailer-mime.md section 2.3).
+ * Each body travels once, in `bodyGroups`; the flattened From list is the concatenation of
+ * `fromFields`.
+ */
+export interface IBridgeParsedMessage {
+  headers: Array<{ key: string; name: string; value: string }>;
+  headerLines: Array<{ key: string; line: string }>;
+  messageId?: string;
+  inReplyTo?: string;
+  references: string[];
+  /** ISO 8601 UTC with milliseconds. */
+  date?: string;
+  subject?: string;
+  sender?: IBridgeMailAddress;
+  replyTo: IBridgeMailAddress[];
+  to: IBridgeMailAddress[];
+  cc: IBridgeMailAddress[];
+  bcc: IBridgeMailAddress[];
+  bodyGroups: IBridgeMailBodyGroup[];
+  attachments: IBridgeParsedAttachment[];
+  /** One flattened mailbox list per From field, in field order. */
+  fromFields: IBridgeMailAddress[][];
+  partFilenames: string[];
+  abruptHeaderEnd: boolean;
+}
+
 interface IEmailReceivedEvent {
   correlationId: string;
   sessionId: string;
@@ -557,6 +617,8 @@ interface IEmailReceivedEvent {
   secure: boolean;
   authenticatedUser: string | null;
   securityResults: IInboundEmailSecurityResult | null;
+  /** The one parse Rust made at DATA. */
+  parsed: IBridgeParsedMessage;
 }
 
 interface IRcptToRequestEvent {
@@ -641,6 +703,10 @@ type TMailerCommands = {
     };
     result: IEmailSecurityResult;
   };
+  parseMessage: {
+    params: { data: string };
+    result: { parsed: IBridgeParsedMessage };
+  };
   startSmtpServer: {
     params: ISmtpServerConfig;
     result: { started: boolean };
@@ -726,6 +792,8 @@ type TMailerCommands = {
   };
 };
 
+type TMailerBridge = InstanceType<typeof plugins.smartrust.RustBridge<TMailerCommands>>;
+
 // ---------------------------------------------------------------------------
 // Bridge state machine
 // ---------------------------------------------------------------------------
@@ -773,7 +841,18 @@ export class RustSecurityBridge extends EventEmitter {
   private static instance: RustSecurityBridge | null = null;
   private static _resilienceConfig: IBridgeResilienceConfig = { ...DEFAULT_RESILIENCE_CONFIG };
 
-  private bridge: InstanceType<typeof plugins.smartrust.RustBridge<TMailerCommands>>;
+  /** The server default maximum message size, used until `setMaxMessageSize` is called. */
+  private static readonly defaultMaxMessageSize = 10 * 1024 * 1024;
+
+  /** The smartrust bridge of the running process; a new one is created at every spawn. */
+  private bridge: TMailerBridge | null = null;
+  private readonly localPaths: string[];
+  /** The IPC line cap the next spawn uses: 4 × the maximum message size. */
+  private _lineCap = 4 * RustSecurityBridge.defaultMaxMessageSize;
+  /** The line cap of the running process, which both transport ends were created with. */
+  private _runningLineCap: number | null = null;
+  /** Management event handlers, attached to every bridge this singleton creates. */
+  private readonly managementHandlers = new Map<string, Set<(data: any) => void>>();
   private _running = false;
   private _state: BridgeState = BridgeState.Idle;
   private _restartAttempts = 0;
@@ -785,7 +864,7 @@ export class RustSecurityBridge extends EventEmitter {
   private _smtpServerConfig: ISmtpServerConfig | null = null;
 
   /**
-   * Map Node.js process.platform / process.arch to the tsrust target suffix
+   * Map Node.js process.platform / process.arch to the rsrepo target suffix
    * of the shipped binaries. Linux binaries are static musl builds, e.g.
    * mailer-bin_linux_amd64_musl.
    */
@@ -804,7 +883,7 @@ export class RustSecurityBridge extends EventEmitter {
     const suffix = RustSecurityBridge.getPlatformSuffix();
     const localPaths: string[] = [];
 
-    // dist_rust/ candidates (tsrust cross-compiled output)
+    // dist_rust/ candidates (rsrepo cross-compiled output)
     if (suffix) {
       localPaths.push(plugins.path.join(paths.packageDir, 'dist_rust', `mailer-bin_${suffix}`));
     }
@@ -813,24 +892,37 @@ export class RustSecurityBridge extends EventEmitter {
     localPaths.push(plugins.path.join(paths.packageDir, 'rust', 'target', 'release', 'mailer-bin'));
     localPaths.push(plugins.path.join(paths.packageDir, 'rust', 'target', 'debug', 'mailer-bin'));
 
-    this.bridge = new plugins.smartrust.RustBridge<TMailerCommands>({
+    this.localPaths = localPaths;
+  }
+
+  /**
+   * Creates the smartrust bridge for one spawn. The line cap is fixed per process at both ends
+   * of the transport: smartrust's `maxPayloadSize` and `mailer-bin --max-line-bytes` get the
+   * one computed value. Lifecycle listeners and every registered management handler are
+   * attached, so a handler registered before a spawn or restart keeps receiving events.
+   */
+  private createBridge(): TMailerBridge {
+    const cap = this._lineCap;
+    const bridge: TMailerBridge = new plugins.smartrust.RustBridge<TMailerCommands>({
       binaryName: 'mailer-bin',
-      cliArgs: ['--management'],
+      cliArgs: ['--management', '--max-line-bytes', String(cap)],
       // A full SMTP transaction can legitimately span several socket waits.
       // Health checks retain their own short timeout and run concurrently.
       requestTimeoutMs: 300_000,
       readyTimeoutMs: 10_000,
-      localPaths,
+      maxPayloadSize: cap,
+      localPaths: this.localPaths,
       searchSystemPath: false,
     });
 
-    // Forward lifecycle events
-    this.bridge.on('ready', () => {
+    bridge.on('ready', () => {
+      if (bridge !== this.bridge) return;
       this._running = true;
       logger.log('info', 'Rust security bridge is ready');
     });
 
-    this.bridge.on('exit', (code: number | null, signal: string | null) => {
+    bridge.on('exit', (code: number | null, signal: string | null) => {
+      if (bridge !== this.bridge) return;
       this._running = false;
       logger.log('error', `Rust security bridge exited (code=${code}, signal=${signal})`);
 
@@ -845,9 +937,41 @@ export class RustSecurityBridge extends EventEmitter {
       }
     });
 
-    this.bridge.on('stderr', (line: string) => {
+    bridge.on('stderr', (line: string) => {
       logger.log('debug', `[rust-bridge] ${line}`);
     });
+
+    for (const [eventName, handlers] of this.managementHandlers) {
+      for (const handler of handlers) {
+        bridge.on(eventName, handler);
+      }
+    }
+    return bridge;
+  }
+
+  /** Replaces the bridge with a new one for the current cap and spawns it. */
+  private async spawnBridge(): Promise<boolean> {
+    const previous = this.bridge;
+    if (previous) {
+      previous.removeAllListeners();
+      previous.kill();
+    }
+    const bridge = this.createBridge();
+    this.bridge = bridge;
+    this._runningLineCap = null;
+    const ok = await bridge.spawn();
+    if (ok && bridge === this.bridge) {
+      this._runningLineCap = this._lineCap;
+    }
+    return ok;
+  }
+
+  /** The bridge of the running process; commands are guarded by ensureRunning() first. */
+  private get activeBridge(): TMailerBridge {
+    if (!this.bridge) {
+      throw new Error('Rust bridge has not been started yet. Call start() first.');
+    }
+    return this.bridge;
   }
 
   // -----------------------------------------------------------------------
@@ -952,7 +1076,7 @@ export class RustSecurityBridge extends EventEmitter {
     this.setState(BridgeState.Starting);
 
     try {
-      const ok = await this.bridge.spawn();
+      const ok = await this.spawnBridge();
       this._running = ok;
       if (ok) {
         this.setState(BridgeState.Running);
@@ -988,7 +1112,7 @@ export class RustSecurityBridge extends EventEmitter {
       return;
     }
     try {
-      this.bridge.kill();
+      this.bridge?.kill();
       this._running = false;
       this.setState(BridgeState.Stopped);
       logger.log('info', 'Rust security bridge stopped');
@@ -997,6 +1121,71 @@ export class RustSecurityBridge extends EventEmitter {
     }
   }
 
+  // -----------------------------------------------------------------------
+  // IPC line cap
+  // -----------------------------------------------------------------------
+
+  /** The IPC line cap the next spawn uses (4 × the maximum message size). */
+  public get lineCap(): number {
+    return this._lineCap;
+  }
+
+  /**
+   * Sets the SMTP maximum message size the IPC line cap derives from: `cap = 4 × n`, the one
+   * value used as smartrust's `maxPayloadSize` and as `mailer-bin --max-line-bytes`. Outbound
+   * requests (`sendEmail`, `sendRawEmail`, `signDkim`, `verifyDkim`) are limited by the same
+   * cap. When the process runs with a different cap it is restarted deliberately (no crash
+   * count, no backoff) and a stored listener configuration is restored; otherwise the value is
+   * recorded for the next spawn. Throws, changing nothing, for an `n` that is not a positive
+   * safe integer or whose cap is not a safe integer.
+   */
+  public async setMaxMessageSize(maxMessageSize: number): Promise<void> {
+    const cap = 4 * maxMessageSize;
+    if (!Number.isSafeInteger(maxMessageSize) || maxMessageSize <= 0 || !Number.isSafeInteger(cap)) {
+      throw new Error(
+        `maxMessageSize must be a positive safe integer whose 4x line cap is a safe integer, got ${maxMessageSize}`,
+      );
+    }
+    this._lineCap = cap;
+    if (this._running && this._state === BridgeState.Running && this._runningLineCap !== cap) {
+      await this.restartForLineCap();
+    }
+  }
+
+  /** A deliberate restart for a changed line cap; it is not a crash. */
+  private async restartForLineCap(): Promise<void> {
+    logger.log('info', `Restarting Rust bridge for IPC line cap ${this._lineCap}`);
+    this.stopHealthCheck();
+    this.setState(BridgeState.Restarting);
+    this._spawnInFlight = true;
+    try {
+      const previous = this.bridge;
+      if (previous) {
+        previous.removeAllListeners();
+        await previous.terminate();
+      }
+      this._running = false;
+      const ok = await this.spawnBridge();
+      this._running = ok;
+      if (!ok) {
+        throw new Error('spawn returned false');
+      }
+      if (!(await this.restoreAfterRestart())) {
+        throw new Error('SMTP server restore failed');
+      }
+      this.setState(BridgeState.Running);
+      this.startHealthCheck();
+      logger.log('info', `Rust bridge running with IPC line cap ${this._lineCap}`);
+    } catch (error) {
+      logger.log('error', `Rust bridge restart for a new line cap failed: ${(error as Error).message}`);
+      // The process did not come back: from here on it is a failure, recovered like a crash.
+      this.attemptRestart();
+      throw error;
+    } finally {
+      this._spawnInFlight = false;
+    }
+  }
+
   // -----------------------------------------------------------------------
   // Auto-restart with exponential backoff
   // -----------------------------------------------------------------------
@@ -1042,7 +1231,7 @@ export class RustSecurityBridge extends EventEmitter {
 
     this._spawnInFlight = true;
     try {
-      const ok = await this.bridge.spawn();
+      const ok = await this.spawnBridge();
       this._running = ok;
       if (!ok) {
         throw new Error('spawn returned false');
@@ -1054,7 +1243,7 @@ export class RustSecurityBridge extends EventEmitter {
         // and go through another restart cycle instead of sitting half-alive.
         logger.log('error', 'Rust bridge restarted but the SMTP server could not be restored — killing process to retry');
         try {
-          this.bridge.kill();
+          this.bridge?.kill();
         } catch {
           // Already dead
         }
@@ -1086,7 +1275,7 @@ export class RustSecurityBridge extends EventEmitter {
     }
     try {
       logger.log('info', 'Restoring SMTP server after bridge restart');
-      const result = await this.bridge.sendCommand('startSmtpServer', this._smtpServerConfig);
+      const result = await this.activeBridge.sendCommand('startSmtpServer', this._smtpServerConfig);
       if (result?.started) {
         logger.log('info', 'SMTP server restored after bridge restart');
         return true;
@@ -1114,7 +1303,7 @@ export class RustSecurityBridge extends EventEmitter {
       }
 
       try {
-        const pongPromise = this.bridge.sendCommand('ping', {} as any);
+        const pongPromise = this.activeBridge.sendCommand('ping', {} as any);
         const timeoutPromise = new Promise<never>((_, reject) =>
           setTimeout(() => reject(new Error('Health check timeout')), config.healthCheckTimeoutMs),
         );
@@ -1134,7 +1323,7 @@ export class RustSecurityBridge extends EventEmitter {
         logger.log('error', `Rust bridge health check failed twice in a row: ${(err as Error).message}. Killing process to trigger restart.`);
         this._healthCheckStrikes = 0;
         try {
-          this.bridge.kill();
+          this.bridge?.kill();
         } catch {
           // Already dead
         }
@@ -1157,20 +1346,20 @@ export class RustSecurityBridge extends EventEmitter {
   /** Ping the Rust process. */
   public async ping(): Promise<boolean> {
     this.ensureRunning();
-    const res = await this.bridge.sendCommand('ping', {} as any);
+    const res = await this.activeBridge.sendCommand('ping', {} as any);
     return res?.pong === true;
   }
 
   /** Get version information for all Rust crates. */
   public async getVersion(): Promise<IVersionInfo> {
     this.ensureRunning();
-    return this.bridge.sendCommand('version', {} as any);
+    return this.activeBridge.sendCommand('version', {} as any);
   }
 
   /** Validate an email address. */
   public async validateEmail(email: string): Promise<IValidationResult> {
     this.ensureRunning();
-    return this.bridge.sendCommand('validateEmail', { email });
+    return this.activeBridge.sendCommand('validateEmail', { email });
   }
 
   /** Detect bounce type from SMTP response / diagnostic code. */
@@ -1180,7 +1369,7 @@ export class RustSecurityBridge extends EventEmitter {
     statusCode?: string;
   }): Promise<IBounceDetection> {
     this.ensureRunning();
-    return this.bridge.sendCommand('detectBounce', opts);
+    return this.activeBridge.sendCommand('detectBounce', opts);
   }
 
   /** Scan email content for threats (phishing, spam, malware, etc.). */
@@ -1191,19 +1380,19 @@ export class RustSecurityBridge extends EventEmitter {
     attachmentNames?: string[];
   }): Promise<IContentScanResult> {
     this.ensureRunning();
-    return this.bridge.sendCommand('scanContent', opts);
+    return this.activeBridge.sendCommand('scanContent', opts);
   }
 
   /** Check IP reputation via DNSBL. */
   public async checkIpReputation(ip: string): Promise<IReputationResult> {
     this.ensureRunning();
-    return this.bridge.sendCommand('checkIpReputation', { ip });
+    return this.activeBridge.sendCommand('checkIpReputation', { ip });
   }
 
   /** Verify DKIM signatures on a raw email message. */
   public async verifyDkim(rawMessage: string): Promise<IDkimVerificationResult[]> {
     this.ensureRunning();
-    return this.bridge.sendCommand('verifyDkim', { rawMessage });
+    return this.activeBridge.sendCommand('verifyDkim', { rawMessage });
   }
 
   /** Sign an email with DKIM (RSA or Ed25519). */
@@ -1215,7 +1404,7 @@ export class RustSecurityBridge extends EventEmitter {
     keyType?: string;
   }): Promise<{ header: string; signedMessage: string }> {
     this.ensureRunning();
-    return this.bridge.sendCommand('signDkim', opts);
+    return this.activeBridge.sendCommand('signDkim', opts);
   }
 
   /** Check SPF for a sender. */
@@ -1226,7 +1415,7 @@ export class RustSecurityBridge extends EventEmitter {
     mailFrom: string;
   }): Promise<ISpfResult> {
     this.ensureRunning();
-    return this.bridge.sendCommand('checkSpf', opts);
+    return this.activeBridge.sendCommand('checkSpf', opts);
   }
 
   /**
@@ -1243,7 +1432,18 @@ export class RustSecurityBridge extends EventEmitter {
     mailFrom: string;
   }): Promise<IEmailSecurityResult> {
     this.ensureRunning();
-    return this.bridge.sendCommand('verifyEmail', opts);
+    return this.activeBridge.sendCommand('verifyEmail', opts);
+  }
+
+  /**
+   * Parses stored message bytes with the parser and setting of the DATA path (`parseMessage`,
+   * ruling Q1), so a replay builds the same Email the live path built. Rejects with the
+   * parser's error text when a parser limit is exceeded or the answer would exceed the line cap.
+   */
+  public async parseMessage(rawMessage: Buffer): Promise<IBridgeParsedMessage> {
+    this.ensureRunning();
+    const result = await this.activeBridge.sendCommand('parseMessage', { data: rawMessage.toString('base64') });
+    return result.parsed;
   }
 
   // -----------------------------------------------------------------------
@@ -1254,7 +1454,7 @@ export class RustSecurityBridge extends EventEmitter {
   public async sendOutboundEmail(opts: ISmtpSendOptions): Promise<ISmtpSendResult> {
     this.ensureRunning();
     try {
-      const result = await this.bridge.sendCommand('sendEmail', opts);
+      const result = await this.activeBridge.sendCommand('sendEmail', opts);
       return {
         ...result,
         transactionLog: normalizeSmtpTranscript(result.transactionLog),
@@ -1271,7 +1471,7 @@ export class RustSecurityBridge extends EventEmitter {
   public async sendRawEmail(opts: TSmtpSendRawOptions): Promise<ISmtpSendResult> {
     this.ensureRunning();
     try {
-      const result = await this.bridge.sendCommand('sendRawEmail', opts);
+      const result = await this.activeBridge.sendCommand('sendRawEmail', opts);
 
       return {
         ...result,
@@ -1290,30 +1490,30 @@ export class RustSecurityBridge extends EventEmitter {
     mailFrom: string;
   }): Promise<IVerifyCapturedOutboundEmailResult> {
     this.ensureRunning();
-    return this.bridge.sendCommand('verifyCapturedOutboundEmail', opts);
+    return this.activeBridge.sendCommand('verifyCapturedOutboundEmail', opts);
   }
 
   public async discardCapturedOutboundEmail(captureId: string): Promise<void> {
     this.ensureRunning();
-    await this.bridge.sendCommand('discardCapturedOutboundEmail', { captureId });
+    await this.activeBridge.sendCommand('discardCapturedOutboundEmail', { captureId });
   }
 
   /** Verify connectivity to an SMTP server. */
   public async verifySmtpConnection(opts: ISmtpVerifyOptions): Promise<ISmtpVerifyResult> {
     this.ensureRunning();
-    return this.bridge.sendCommand('verifySmtpConnection', opts);
+    return this.activeBridge.sendCommand('verifySmtpConnection', opts);
   }
 
   /** Close a specific connection pool (or all pools if no key is given). */
   public async closeSmtpPool(poolKey?: string): Promise<void> {
     this.ensureRunning();
-    await this.bridge.sendCommand('closeSmtpPool', poolKey ? { poolKey } : ({} as any));
+    await this.activeBridge.sendCommand('closeSmtpPool', poolKey ? { poolKey } : ({} as any));
   }
 
   /** Get status of all SMTP client connection pools. */
   public async getSmtpPoolStatus(): Promise<ISmtpPoolStatus> {
     this.ensureRunning();
-    return this.bridge.sendCommand('getSmtpPoolStatus', {} as any);
+    return this.activeBridge.sendCommand('getSmtpPoolStatus', {} as any);
   }
 
   // -----------------------------------------------------------------------
@@ -1328,7 +1528,7 @@ export class RustSecurityBridge extends EventEmitter {
   public async startSmtpServer(config: ISmtpServerConfig): Promise<boolean> {
     this.ensureRunning();
     this._smtpServerConfig = config;
-    const result = await this.bridge.sendCommand('startSmtpServer', config);
+    const result = await this.activeBridge.sendCommand('startSmtpServer', config);
     return result?.started === true;
   }
 
@@ -1336,7 +1536,7 @@ export class RustSecurityBridge extends EventEmitter {
   public async stopSmtpServer(): Promise<void> {
     this.ensureRunning();
     this._smtpServerConfig = null;
-    await this.bridge.sendCommand('stopSmtpServer', {} as any);
+    await this.activeBridge.sendCommand('stopSmtpServer', {} as any);
   }
 
   /**
@@ -1351,7 +1551,7 @@ export class RustSecurityBridge extends EventEmitter {
     smtpMessage?: string;
   }): Promise<void> {
     this.ensureRunning();
-    await this.bridge.sendCommand('emailProcessingResult', opts);
+    await this.activeBridge.sendCommand('emailProcessingResult', opts);
   }
 
   /**
@@ -1364,7 +1564,7 @@ export class RustSecurityBridge extends EventEmitter {
     smtpMessage?: string;
   }): Promise<void> {
     this.ensureRunning();
-    await this.bridge.sendCommand('rcptToResult', opts);
+    await this.activeBridge.sendCommand('rcptToResult', opts);
   }
 
   /**
@@ -1376,7 +1576,7 @@ export class RustSecurityBridge extends EventEmitter {
     message?: string;
   }): Promise<void> {
     this.ensureRunning();
-    await this.bridge.sendCommand('authResult', opts);
+    await this.activeBridge.sendCommand('authResult', opts);
   }
 
   /**
@@ -1392,32 +1592,47 @@ export class RustSecurityBridge extends EventEmitter {
     serverKey?: string;
   }): Promise<void> {
     this.ensureRunning();
-    await this.bridge.sendCommand('scramCredentialResult', opts);
+    await this.activeBridge.sendCommand('scramCredentialResult', opts);
   }
 
   /** Update rate limit configuration at runtime. */
   public async configureRateLimits(config: IRateLimitConfig): Promise<void> {
     this.ensureRunning();
-    await this.bridge.sendCommand('configureRateLimits', config);
+    await this.activeBridge.sendCommand('configureRateLimits', config);
   }
 
   // -----------------------------------------------------------------------
   // Event registration — delegates to the underlying bridge EventEmitter
   // -----------------------------------------------------------------------
 
+  private addManagementHandler(eventName: string, handler: (data: any) => void): void {
+    let handlers = this.managementHandlers.get(eventName);
+    if (!handlers) {
+      handlers = new Set();
+      this.managementHandlers.set(eventName, handlers);
+    }
+    handlers.add(handler);
+    this.bridge?.on(eventName, handler);
+  }
+
+  private removeManagementHandler(eventName: string, handler: (data: any) => void): void {
+    this.managementHandlers.get(eventName)?.delete(handler);
+    this.bridge?.off(eventName, handler);
+  }
+
   /**
    * Register a handler for emailReceived events from the Rust SMTP server.
    * These events fire when a complete email has been received and needs processing.
    */
   public onEmailReceived(handler: (data: IEmailReceivedEvent) => void): void {
-    this.bridge.on('management:emailReceived', handler);
+    this.addManagementHandler('management:emailReceived', handler);
   }
 
   /**
    * Register a handler for RCPT TO policy requests from the Rust SMTP server.
    */
   public onRcptToRequest(handler: (data: IRcptToRequestEvent) => void): void {
-    this.bridge.on('management:rcptToRequest', handler);
+    this.addManagementHandler('management:rcptToRequest', handler);
   }
 
   /**
@@ -1425,7 +1640,7 @@ export class RustSecurityBridge extends EventEmitter {
    * The handler must call sendAuthResult() with the correlationId.
    */
   public onAuthRequest(handler: (data: IAuthRequestEvent) => void): void {
-    this.bridge.on('management:authRequest', handler);
+    this.addManagementHandler('management:authRequest', handler);
   }
 
   /**
@@ -1433,27 +1648,27 @@ export class RustSecurityBridge extends EventEmitter {
    * The handler must call sendScramCredentialResult() with the correlationId.
    */
   public onScramCredentialRequest(handler: (data: IScramCredentialRequestEvent) => void): void {
-    this.bridge.on('management:scramCredentialRequest', handler);
+    this.addManagementHandler('management:scramCredentialRequest', handler);
   }
 
   /** Remove an emailReceived event handler. */
   public offEmailReceived(handler: (data: IEmailReceivedEvent) => void): void {
-    this.bridge.off('management:emailReceived', handler);
+    this.removeManagementHandler('management:emailReceived', handler);
   }
 
   /** Remove an RCPT TO policy request handler. */
   public offRcptToRequest(handler: (data: IRcptToRequestEvent) => void): void {
-    this.bridge.off('management:rcptToRequest', handler);
+    this.removeManagementHandler('management:rcptToRequest', handler);
   }
 
   /** Remove an authRequest event handler. */
   public offAuthRequest(handler: (data: IAuthRequestEvent) => void): void {
-    this.bridge.off('management:authRequest', handler);
+    this.removeManagementHandler('management:authRequest', handler);
   }
 
   /** Remove a scramCredentialRequest event handler. */
   public offScramCredentialRequest(handler: (data: IScramCredentialRequestEvent) => void): void {
-    this.bridge.off('management:scramCredentialRequest', handler);
+    this.removeManagementHandler('management:scramCredentialRequest', handler);
   }
 }
 

package/native-notices/crates/charset-0.1.5/copyright

@@ -1,12 +0,0 @@
-charset is copyright 2013-2016 Mozilla Foundation.
-
-Licensed under the Apache License, Version 2.0
-<LICENSE-APACHE or
-https://www.apache.org/licenses/LICENSE-2.0> or the MIT
-license <LICENSE-MIT or https://opensource.org/licenses/MIT>,
-at your option. All files in the project carrying such
-notice may not be copied, modified, or distributed except
-according to those terms.
-
-Test code within encoding_rs is dedicated to the Public Domain when so
-designated (see the individual files for PD/CC0-dedicated sections).