@push.rocks/smartmta 8.0.1 → 8.1.1

package/ts/mail/delivery/classes.delivery.system.ts

@@ -10,6 +10,7 @@ import {
   UnifiedDeliveryQueue,
   type IQueueItem,
   type IRecipientPermanentFailure,
+  type IBounceOperation,
 } from './classes.delivery.queue.js';
 import { Email } from '../core/classes.email.js';
 import type { UnifiedEmailServer } from '../routing/classes.unified.email.server.js';
@@ -41,6 +42,17 @@ export interface IDeliveryHandler {
   deliver(item: IQueueItem): Promise<any>;
 }
 
+export interface IDeliveryFailureNotice {
+  itemId: string;
+  operation: Readonly<IBounceOperation>;
+  sender: string;
+  headers: Readonly<Record<string, string>>;
+}
+
+export interface IDeliveryFailureHandler {
+  processDeliveryFailure(notice: IDeliveryFailureNotice): Promise<void>;
+}
+
 /**
  * Delivery options
  */
@@ -71,7 +83,9 @@ export interface IMultiModeDeliveryOptions {
   bounceHandler?: {
     processSmtpFailure: (recipient: string, smtpResponse: string, options: any) => Promise<any>;
   };
-  
+  /** Durable, idempotent terminal-delivery notice consumer. */
+  deliveryFailureHandler?: IDeliveryFailureHandler;
+
   // Event hooks
   onDeliveryStart?: (item: IQueueItem) => Promise<void>;
   onDeliverySuccess?: (item: IQueueItem, result: any) => Promise<void>;
@@ -112,9 +126,10 @@ export interface IDeliveryStats {
  */
 type TResolvedMultiModeDeliveryOptions = Omit<
   Required<IMultiModeDeliveryOptions>,
-  'bounceHandler'
+  'bounceHandler' | 'deliveryFailureHandler'
 > & {
   bounceHandler?: NonNullable<IMultiModeDeliveryOptions['bounceHandler']>;
+  deliveryFailureHandler: IDeliveryFailureHandler;
 };
 
 export class MultiModeDeliverySystem extends EventEmitter {
@@ -165,6 +180,12 @@ export class MultiModeDeliverySystem extends EventEmitter {
       perPatternRateLimit: options.perPatternRateLimit || {},
       processBounces: options.processBounces !== false, // Default to true
       bounceHandler: options.bounceHandler,
+      deliveryFailureHandler: options.deliveryFailureHandler || {
+        processDeliveryFailure: async (notice) => {
+          logger.log('warn', `Terminal delivery failure persisted for ${notice.operation.recipient}`);
+          await emitSafely(this, 'deliveryFailureNotice', notice);
+        },
+      },
       onDeliveryStart: options.onDeliveryStart || (async () => {}),
       onDeliverySuccess: options.onDeliverySuccess || (async () => {}),
       onDeliveryFailed: options.onDeliveryFailed || (async () => {})
@@ -313,34 +334,68 @@ export class MultiModeDeliverySystem extends EventEmitter {
   }
 
   /**
-   * Drain durable bounce work with one in-process flight. Custom handlers
+   * Drain durable failure work with one in-process flight. Custom handlers
    * receive operationId and must use it for their own idempotency.
    */
   public async drainBounceOutbox(): Promise<void> {
     if (this.bounceDrainPromise) return this.bounceDrainPromise;
     const drain = (async () => {
-      if (!this.options.processBounces || !this.options.bounceHandler) return;
-      for (const { itemId, operation } of this.queue.listPendingBounceOperations()) {
+      if (this.options.processBounces && this.options.bounceHandler) {
+        for (const { itemId, operation } of this.queue.listPendingBounceOperations()) {
+          const item = this.queue.getItem(itemId);
+          if (!item) continue;
+          const email = item.processingResult as Email;
+          try {
+            await this.options.bounceHandler.processSmtpFailure(
+              operation.recipient,
+              operation.smtpResponse,
+              {
+                operationId: operation.operationId,
+                sender: email.from,
+                originalEmailId: item.id,
+                headers: email.headers,
+                statusCode: String(operation.smtpCode),
+              },
+            );
+            await this.queue.markBounceOperationCompleted(itemId, operation.operationId);
+          } catch (error) {
+            logger.log(
+              'error',
+              `Bounce operation ${operation.operationId} failed: ${(error as Error).message}`,
+            );
+            try {
+              await this.queue.markBounceOperationFailed(
+                itemId,
+                operation.operationId,
+                (error as Error).message,
+              );
+            } catch (checkpointError) {
+              logger.log(
+                'error',
+                `Could not checkpoint failed bounce operation ${operation.operationId}: ${(checkpointError as Error).message}`,
+              );
+            }
+          }
+        }
+      }
+
+      for (const { itemId, operation } of this.queue.listPendingDeliveryFailureOperations()) {
         const item = this.queue.getItem(itemId);
         if (!item) continue;
         const email = item.processingResult as Email;
+        const notice: IDeliveryFailureNotice = {
+          itemId,
+          operation,
+          sender: email.from,
+          headers: { ...email.headers },
+        };
         try {
-          await this.options.bounceHandler.processSmtpFailure(
-            operation.recipient,
-            operation.smtpResponse,
-            {
-              operationId: operation.operationId,
-              sender: email.from,
-              originalEmailId: item.id,
-              headers: email.headers,
-              statusCode: String(operation.smtpCode),
-            },
-          );
+          await this.options.deliveryFailureHandler.processDeliveryFailure(notice);
           await this.queue.markBounceOperationCompleted(itemId, operation.operationId);
         } catch (error) {
           logger.log(
             'error',
-            `Bounce operation ${operation.operationId} failed: ${(error as Error).message}`,
+            `Delivery-failure operation ${operation.operationId} failed: ${(error as Error).message}`,
           );
           try {
             await this.queue.markBounceOperationFailed(
@@ -351,7 +406,7 @@ export class MultiModeDeliverySystem extends EventEmitter {
           } catch (checkpointError) {
             logger.log(
               'error',
-              `Could not checkpoint failed bounce operation ${operation.operationId}: ${(checkpointError as Error).message}`,
+              `Could not checkpoint failed delivery-failure operation ${operation.operationId}: ${(checkpointError as Error).message}`,
             );
           }
         }
@@ -619,6 +674,12 @@ export class MultiModeDeliverySystem extends EventEmitter {
 
       const transition = await this.queue.markFailedWithTransition(item.id, deliveryError.message, {
         retryable: deliveryError.retryable,
+        terminalFailure: {
+          failureClass: deliveryError.errorType.startsWith('self_mx_')
+            ? 'localTopology'
+            : 'transport',
+          ...(deliveryError.smtpCode !== undefined ? { smtpCode: deliveryError.smtpCode } : {}),
+        },
       });
       if (this.running) void this.drainBounceOutbox();
       if (!transition.updated) return;
@@ -832,6 +893,9 @@ export class MultiModeDeliverySystem extends EventEmitter {
       && typeof failure.smtpCode === 'number'
       && failure.smtpCode >= 500
     ));
+    const allLocalTopologyFailures = normalized.every((failure) => (
+      failure.errorType.startsWith('self_mx_')
+    ));
     const selected = normalized.find((failure) => failure.retryable)
       || normalized[normalized.length - 1];
     const smtpCode = allPermanentRecipientRejections
@@ -839,7 +903,11 @@ export class MultiModeDeliverySystem extends EventEmitter {
       : selected.smtpCode;
     return new SmtpDeliveryError({
       message: normalized.map((failure) => failure.message).join('; '),
-      errorType: allPermanentRecipientRejections ? 'protocol' : 'smtp_aggregate',
+      errorType: allPermanentRecipientRejections
+        ? 'protocol'
+        : allLocalTopologyFailures
+          ? selected.errorType
+          : 'smtp_aggregate',
       retryable,
       ...(smtpCode !== undefined ? { smtpCode } : {}),
       phase: allPermanentRecipientRejections ? 'rcpt_to' : selected.phase,
@@ -903,37 +971,65 @@ export class MultiModeDeliverySystem extends EventEmitter {
 
     for (const [domain, recipients] of domainGroups) {
       const allMxHosts = await this.resolveMxForDomain(domain);
+      let recipientsForMx = [...recipients];
+      const domainFailures: SmtpDeliveryError[] = [];
+      const acceptedForDomain: string[] = [];
+      const mxHosts: typeof allMxHosts = [];
+
+      // RFC 5321 §5.3.6: skip local MX identities but continue to non-local
+      // backup MX hosts. Proxy connection targets are intentionally absent
+      // from this identity check.
+      for (const mx of allMxHosts) {
+        const identity = await this.emailServer.resolveSelfMxIdentity(mx.exchange);
+        if (!identity.isSelf && !identity.indeterminate) {
+          mxHosts.push(mx);
+          continue;
+        }
 
-      // RFC 5321 §5.3.6: never relay to an MX that is this server itself —
-      // that is a mail loop (observed live: a managed domain whose MX record
-      // points at our own mail hostname re-enters the inbound pipeline).
-      const mxHosts = allMxHosts.filter(mx => !this.emailServer!.isSelfHostname(mx.exchange));
-      if (mxHosts.length === 0) {
-        const selfMx = allMxHosts.map(mx => mx.exchange).join(', ');
+        const startedAt = new Date();
+        const retryable = identity.source !== 'explicit';
+        const errorType = identity.indeterminate
+          ? 'self_mx_dns_indeterminate'
+          : identity.source === 'explicit'
+            ? 'self_mx_config'
+            : 'self_mx_loop';
+        const reason = identity.indeterminate
+          ? 'could not be safely classified against current DNS and listener topology'
+          : identity.source === 'explicit'
+            ? 'exactly matches a configured listener identity'
+            : 'resolves to the current listener topology';
+        const evidence = identity.evidence.length > 0
+          ? ` (${identity.evidence.join('; ')})`
+          : '';
         const loopError = new SmtpDeliveryError({
-          message: `MX for ${domain} (${selfMx || 'none'}) points back at this server — refusing self-delivery to avoid a mail loop`,
-          errorType: 'config',
-          retryable: false,
+          message: identity.indeterminate
+            ? `MX ${mx.exchange} for ${domain} ${reason}${evidence}`
+            : `MX ${mx.exchange} for ${domain} points back at this server because it ${reason}${evidence}`,
+          errorType,
+          retryable,
           phase: 'connect',
-          transactionLog: [],
+          transactionLog: [{
+            timestampMs: Date.now(),
+            phase: 'connect',
+            direction: 'system',
+            text: `Skipped ${mx.exchange}: ${reason}`,
+          }],
           recipients,
           recipientDomain: domain,
         });
-        unresolvedFailures.push(loopError);
-        unresolvedRecipients.push(...recipients);
-        results.push({
-          domain,
-          success: false,
-          error: loopError.message,
+        await this.persistSmtpAttempt({
+          item,
+          targetHost: mx.exchange,
+          targetPort: 25,
+          recipientDomain: domain,
+          recipients,
+          startedAt,
+          error: loopError,
         });
-        logger.log('error', `MTA: refusing self-delivery for ${domain} — MX (${selfMx}) is this server's own hostname (mail loop)`);
-        continue;
+        domainFailures.push(loopError);
+        logger.log(retryable ? 'warn' : 'error', `MTA: skipped MX ${mx.exchange} for ${domain}: ${loopError.message}`);
       }
 
-      let recipientsForMx = [...recipients];
-      const domainFailures: SmtpDeliveryError[] = [];
-      const acceptedForDomain: string[] = [];
-
       for (const mx of mxHosts) {
         if (recipientsForMx.length === 0) break;
         const startedAt = new Date();

package/ts/mail/interfaces.storage.ts

@@ -9,6 +9,23 @@ export interface IStorageManager {
   get(key: string): Promise<string | null>;
   set(key: string, value: string): Promise<void>;
   list(prefix: string): Promise<string[]>;
+  /**
+   * Return at most `limit` keys from one backend-bounded page.
+   *
+   * Continuation tokens are opaque, scoped to the supplied prefix, and must
+   * only be passed back to the same storage implementation. A returned token
+   * must advance a non-overlapping traversal, remain valid after any keys in
+   * its page are deleted, and eventually exhaust an otherwise stable prefix.
+   * Offset-based tokens do not satisfy this deletion-stability requirement.
+   *
+   * This optional method preserves compatibility for existing callers;
+   * features which need bounded cleanup must require it explicitly and must
+   * never fall back to list().
+   */
+  listPage?(
+    prefix: string,
+    options: IStorageListPageOptions,
+  ): Promise<IStorageListPageResult>;
   delete(key: string): Promise<void>;
 }
 
@@ -17,18 +34,131 @@ export interface IBlobStorageManager {
   get(key: string): Promise<Buffer | null>;
   set(key: string, value: Buffer): Promise<void>;
   list(prefix: string): Promise<string[]>;
+  /** Backend-bounded counterpart to list(); see IStorageManager.listPage. */
+  listPage?(
+    prefix: string,
+    options: IStorageListPageOptions,
+  ): Promise<IStorageListPageResult>;
   delete(key: string): Promise<void>;
 }
 
+export interface IStorageListPageOptions {
+  /** Positive maximum number of keys the backend may return. */
+  readonly limit: number;
+  /** Opaque token returned by the immediately preceding page. */
+  readonly continuationToken?: string;
+}
+
+export interface IStorageListPageResult {
+  /** Unique keys under the requested prefix; length must not exceed limit. */
+  readonly keys: string[];
+  /** Omitted when the prefix has been exhausted. */
+  readonly continuationToken?: string;
+}
+
+/** Hard upper bound for one SmartMTA storage listing page. */
+export const SMARTMTA_STORAGE_LIST_PAGE_MAX_LIMIT = 1_000;
+
+function assertValidListPageOptions(options: IStorageListPageOptions): void {
+  if (
+    !Number.isInteger(options.limit)
+    || options.limit < 1
+    || options.limit > SMARTMTA_STORAGE_LIST_PAGE_MAX_LIMIT
+  ) {
+    throw new Error(
+      `Storage list page limit must be an integer from 1 to ${SMARTMTA_STORAGE_LIST_PAGE_MAX_LIMIT}`,
+    );
+  }
+  if (
+    options.continuationToken !== undefined
+    && (
+      typeof options.continuationToken !== 'string'
+      || options.continuationToken.length === 0
+    )
+  ) {
+    throw new Error('Storage list page continuation token must be a non-empty string');
+  }
+}
+
+function lowerBound(sortedKeys: readonly string[], target: string): number {
+  let low = 0;
+  let high = sortedKeys.length;
+  while (low < high) {
+    const middle = low + Math.floor((high - low) / 2);
+    if (sortedKeys[middle] < target) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+}
+
+function upperBound(sortedKeys: readonly string[], target: string): number {
+  let low = 0;
+  let high = sortedKeys.length;
+  while (low < high) {
+    const middle = low + Math.floor((high - low) / 2);
+    if (sortedKeys[middle] <= target) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+}
+
+function insertSortedKey(sortedKeys: string[], key: string): void {
+  sortedKeys.splice(lowerBound(sortedKeys, key), 0, key);
+}
+
+function removeSortedKey(sortedKeys: string[], key: string): void {
+  const index = lowerBound(sortedKeys, key);
+  if (sortedKeys[index] === key) sortedKeys.splice(index, 1);
+}
+
+function listSortedPrefixPage(
+  sortedKeys: readonly string[],
+  prefix: string,
+  options: IStorageListPageOptions,
+): IStorageListPageResult {
+  assertValidListPageOptions(options);
+  if (
+    options.continuationToken !== undefined
+    && !options.continuationToken.startsWith(prefix)
+  ) {
+    throw new Error('Storage list page continuation token does not belong to the prefix');
+  }
+  let index = options.continuationToken === undefined
+    ? lowerBound(sortedKeys, prefix)
+    : Math.max(
+        lowerBound(sortedKeys, prefix),
+        upperBound(sortedKeys, options.continuationToken),
+      );
+  const keys: string[] = [];
+  while (index < sortedKeys.length && keys.length < options.limit) {
+    const key = sortedKeys[index];
+    if (!key.startsWith(prefix)) break;
+    keys.push(key);
+    index++;
+  }
+  const hasMore = (
+    index < sortedKeys.length
+    && sortedKeys[index].startsWith(prefix)
+  );
+  return {
+    keys,
+    ...(hasMore && keys.length > 0
+      ? { continuationToken: keys[keys.length - 1] }
+      : {}),
+  };
+}
+
 /** In-memory small-state store for tests and explicitly non-durable runtimes. */
 export class MemoryStorageManager implements IStorageManager {
   private readonly entries = new Map<string, string>();
+  private readonly sortedKeys: string[] = [];
 
   public async get(key: string): Promise<string | null> {
     return this.entries.get(key) ?? null;
   }
 
   public async set(key: string, value: string): Promise<void> {
+    if (!this.entries.has(key)) insertSortedKey(this.sortedKeys, key);
     this.entries.set(key, value);
   }
 
@@ -36,14 +166,22 @@ export class MemoryStorageManager implements IStorageManager {
     return [...this.entries.keys()].filter((key) => key.startsWith(prefix)).sort();
   }
 
+  public async listPage(
+    prefix: string,
+    options: IStorageListPageOptions,
+  ): Promise<IStorageListPageResult> {
+    return listSortedPrefixPage(this.sortedKeys, prefix, options);
+  }
+
   public async delete(key: string): Promise<void> {
-    this.entries.delete(key);
+    if (this.entries.delete(key)) removeSortedKey(this.sortedKeys, key);
   }
 }
 
 /** In-memory blob store for tests and explicitly non-durable runtimes. */
 export class MemoryBlobStorageManager implements IBlobStorageManager {
   private readonly entries = new Map<string, Buffer>();
+  private readonly sortedKeys: string[] = [];
 
   public async get(key: string): Promise<Buffer | null> {
     const value = this.entries.get(key);
@@ -51,6 +189,7 @@ export class MemoryBlobStorageManager implements IBlobStorageManager {
   }
 
   public async set(key: string, value: Buffer): Promise<void> {
+    if (!this.entries.has(key)) insertSortedKey(this.sortedKeys, key);
     this.entries.set(key, Buffer.from(value));
   }
 
@@ -58,8 +197,15 @@ export class MemoryBlobStorageManager implements IBlobStorageManager {
     return [...this.entries.keys()].filter((key) => key.startsWith(prefix)).sort();
   }
 
+  public async listPage(
+    prefix: string,
+    options: IStorageListPageOptions,
+  ): Promise<IStorageListPageResult> {
+    return listSortedPrefixPage(this.sortedKeys, prefix, options);
+  }
+
   public async delete(key: string): Promise<void> {
-    this.entries.delete(key);
+    if (this.entries.delete(key)) removeSortedKey(this.sortedKeys, key);
   }
 }
 

package/ts/mail/routing/classes.domain.registry.ts

@@ -1,5 +1,6 @@
 import type { IEmailDomainConfig } from './interfaces.js';
 import { logger } from '../../logger.js';
+import { assertValidInboundPolicy } from './functions.routing.validation.js';
 
 /**
  * Registry for email domain configurations
@@ -30,6 +31,9 @@ export class DomainRegistry {
     
     // Process and store domain configurations
     for (const config of domainConfigs) {
+      if (config.inboundPolicy) {
+        assertValidInboundPolicy(config.inboundPolicy, config.domain);
+      }
       const processedConfig = this.applyDefaults(config);
       this.domains.set(config.domain.toLowerCase(), processedConfig);
       logger.log('info', `Registered domain: ${config.domain} with DNS mode: ${processedConfig.dnsMode}`);

package/ts/mail/routing/classes.email.action.executor.ts

@@ -30,6 +30,22 @@ export interface IActionExecutorDeps {
   deliveryQueue: UnifiedDeliveryQueue;
 }
 
+export interface IActionExecutionOptions {
+  /**
+   * Queue the action with a deterministic durable id instead of performing
+   * direct delivery. Used when replaying an already-accepted envelope.
+   */
+  durableQueue?: {
+    idempotencyKey: string;
+    fingerprint: string;
+  };
+}
+
+export interface IActionExecutionResult {
+  outcome: 'completed' | 'queued';
+  queueId?: string;
+}
+
 /**
  * Executes email routing actions (forward, process, deliver, reject)
  */
@@ -61,26 +77,45 @@ export class EmailActionExecutor {
     }
   }
 
-  async executeAction(action: IEmailAction, email: Email, context: IEmailContext): Promise<void> {
+  async executeAction(
+    action: IEmailAction,
+    email: Email,
+    context: IEmailContext,
+  ): Promise<void> {
+    await this.executeActionWithResult(action, email, context);
+  }
+
+  async executeActionWithResult(
+    action: IEmailAction,
+    email: Email,
+    context: IEmailContext,
+    options: IActionExecutionOptions = {},
+  ): Promise<IActionExecutionResult> {
     switch (action.type) {
       case 'forward':
-        await this.handleForwardAction(action, email, context);
-        break;
+        return this.handleForwardAction(action, email, context, options);
       case 'process':
-        await this.handleProcessAction(action, email, context);
-        break;
+        return this.handleProcessAction(action, email, context, options);
       case 'deliver':
-        await this.handleDeliverAction(action, email, context);
-        break;
+        return this.handleDeliverAction(action, email, context, options);
+      case 'store':
+        throw new Error(
+          'Store actions require raw SMTP context and an awaited hooks.onAcceptEnvelope handler',
+        );
       case 'reject':
         await this.handleRejectAction(action, email, context);
-        break;
+        throw new Error('Reject action unexpectedly returned');
       default:
         throw new Error(`Unknown action type: ${(action as any).type}`);
     }
   }
 
-  private async handleForwardAction(action: IEmailAction, email: Email, context: IEmailContext): Promise<void> {
+  private async handleForwardAction(
+    action: IEmailAction,
+    email: Email,
+    context: IEmailContext,
+    options: IActionExecutionOptions,
+  ): Promise<IActionExecutionResult> {
     if (!action.forward) {
       throw new Error('Forward action requires forward configuration');
     }
@@ -101,6 +136,20 @@ export class EmailActionExecutor {
     email.headers['X-Forwarded-To'] = email.to.join(', ');
     email.headers['X-Forwarded-Date'] = new Date().toISOString();
 
+    if (options.durableQueue) {
+      const queueId = await this.deps.deliveryQueue.enqueue(
+        email,
+        'forward',
+        context.session.matchedRoute!,
+        {
+          idempotencyKey: options.durableQueue.idempotencyKey,
+          idempotencyFingerprint: options.durableQueue.fingerprint,
+          requireDurable: true,
+        },
+      );
+      return { outcome: 'queued', queueId };
+    }
+
     try {
       // Send email via Rust SMTP client
       const result = await this.deps.sendOutboundEmail(host, port, email, {
@@ -124,6 +173,7 @@ export class EmailActionExecutor {
         },
         success: true
       }));
+      return { outcome: 'completed' };
     } catch (error) {
       const errorMessage = getErrorMessage(error);
       logger.log('error', `Failed to forward email: ${errorMessage}`);
@@ -168,7 +218,12 @@ export class EmailActionExecutor {
     }
   }
 
-  private async handleProcessAction(action: IEmailAction, email: Email, context: IEmailContext): Promise<void> {
+  private async handleProcessAction(
+    action: IEmailAction,
+    email: Email,
+    context: IEmailContext,
+    options: IActionExecutionOptions,
+  ): Promise<IActionExecutionResult> {
     logger.log('info', `Processing email with action options`);
 
     // Apply scanning if requested
@@ -178,18 +233,47 @@ export class EmailActionExecutor {
 
     // Queue for delivery
     const queue = action.process?.queue || 'normal';
-    await this.deps.deliveryQueue.enqueue(email, 'process', context.session.matchedRoute!);
+    const queueId = await this.deps.deliveryQueue.enqueue(
+      email,
+      'process',
+      context.session.matchedRoute!,
+      options.durableQueue
+        ? {
+            idempotencyKey: options.durableQueue.idempotencyKey,
+            idempotencyFingerprint: options.durableQueue.fingerprint,
+            requireDurable: true,
+          }
+        : {},
+    );
 
     logger.log('info', `Email queued for delivery in ${queue} queue`);
+    return { outcome: 'queued', queueId };
   }
 
-  private async handleDeliverAction(_action: IEmailAction, email: Email, context: IEmailContext): Promise<void> {
+  private async handleDeliverAction(
+    _action: IEmailAction,
+    email: Email,
+    context: IEmailContext,
+    options: IActionExecutionOptions,
+  ): Promise<IActionExecutionResult> {
     logger.log('info', `Delivering email locally`);
 
     // Queue for local delivery
-    await this.deps.deliveryQueue.enqueue(email, 'mta', context.session.matchedRoute!);
+    const queueId = await this.deps.deliveryQueue.enqueue(
+      email,
+      'mta',
+      context.session.matchedRoute!,
+      options.durableQueue
+        ? {
+            idempotencyKey: options.durableQueue.idempotencyKey,
+            idempotencyFingerprint: options.durableQueue.fingerprint,
+            requireDurable: true,
+          }
+        : {},
+    );
 
     logger.log('info', 'Email queued for local delivery');
+    return { outcome: 'queued', queueId };
   }
 
   private async handleRejectAction(action: IEmailAction, _email: Email, context: IEmailContext): Promise<void> {