@push.rocks/smartmta 9.4.0 → 9.5.0

package/ts/mail/delivery/classes.delivery.queue.ts

@@ -1,7 +1,10 @@
 import { EventEmitter } from 'node:events';
 import { createHash } from 'node:crypto';
 import { deserialize, serialize } from 'node:v8';
-import type { IBlobStorageManager } from '../interfaces.storage.js';
+import {
+  SMARTMTA_STORAGE_LIST_PAGE_MAX_LIMIT,
+  type IBlobStorageManager,
+} from '../interfaces.storage.js';
 import { logger } from '../../logger.js';
 import { type EmailProcessingMode } from './interfaces.js';
 import type { ISmtpTransactionAttempt } from './interfaces.js';
@@ -15,6 +18,22 @@ import type { IEmailRoute } from '../routing/interfaces.js';
 import { Email, type IEmailOptions } from '../core/classes.email.js';
 import { emitSafely } from './functions.safe-observers.js';
 import { getErrorMessage } from '../../functions.errors.js';
+import { SmtpDeliveryError } from '../../security/classes.rustsecuritybridge.js';
+import {
+  assertCanonicalRawRfc822Message,
+  cloneRawSmtpEnvelope,
+  createRawQueueFingerprint,
+  normalizeRawSmtpEnvelope,
+  type IRawSmtpEnvelope,
+} from './functions.raw-email.js';
+import {
+  kQueueCloseAdmission,
+  kQueueCreateItemSnapshot,
+  kQueueEnqueueRaw,
+  kQueueReserveRawAccess,
+  kQueueSetReadyItemsHandler,
+  kQueueWithRawMessage,
+} from './symbols.delivery.queue.js';
 
 /**
  * Queue item status
@@ -64,6 +83,14 @@ export interface IQueueItem {
   idempotencyFingerprint?: string;
   processingMode: EmailProcessingMode;
   processingResult: Email;
+  /** Present only for durable exact-byte outbound queue items. */
+  messageFormat?: 'raw-rfc822';
+  /** SHA-256 of the immutable unsigned RFC822 bytes. */
+  rawMessageSha256?: string;
+  /** Exact immutable unsigned RFC822 byte length. */
+  rawMessageLength?: number;
+  /** Canonical SMTP envelope, independent from message headers. */
+  smtpEnvelope?: IRawSmtpEnvelope;
   /** Materialized attachment count for queue/detail consumers. */
   attachmentCount?: number;
   route?: IEmailRoute;
@@ -123,7 +150,21 @@ interface IStoredQueueItemV2 extends Omit<IStoredQueueItemV1, 'schemaVersion'> {
   bounceOperations: IStoredBounceOperation[];
 }
 
-type IStoredQueueItem = IStoredQueueItemV1 | IStoredQueueItemV2;
+interface IStoredQueueItemV3 extends Omit<IStoredQueueItemV2, 'schemaVersion'> {
+  schemaVersion: 3;
+  messageFormat: 'raw-rfc822';
+  rawMessageSha256: string;
+  rawMessageLength: number;
+  smtpEnvelope: IRawSmtpEnvelope;
+  rawMessage: Buffer;
+}
+
+type IStoredQueueItem = IStoredQueueItemV1 | IStoredQueueItemV2 | IStoredQueueItemV3;
+
+interface IDeserializedQueueItem {
+  item: IQueueItem;
+  rawMessage?: Buffer;
+}
 
 type TQueueLifecycleState = 'new' | 'initialized' | 'shutting-down' | 'closed';
 
@@ -137,6 +178,20 @@ interface IStoredQueueIdempotencyTombstone {
 
 export const ACCEPTED_ENVELOPE_IDEMPOTENCY_RETENTION_MS = 31 * 24 * 60 * 60 * 1000;
 const QUEUE_IDEMPOTENCY_TOMBSTONE_CLEANUP_LIMIT = 256;
+export const DEFAULT_MAX_RAW_MESSAGE_BYTES = 32 * 1024 * 1024;
+const RAW_ENQUEUE_RESERVATION_MULTIPLIER = 3;
+const RAW_ACCESS_RESERVATION_MULTIPLIER = 6;
+const RAW_BYTE_WAITER_LIMIT = 1_024;
+const RAW_RESERVATION_LIMIT = 1_024;
+export const DEFAULT_RAW_IN_FLIGHT_BYTE_BUDGET = 192 * 1024 * 1024;
+
+const weightedRawBytes = (bytesArg: number, multiplierArg: number): number => {
+  const weightedBytes = bytesArg * multiplierArg;
+  if (!Number.isSafeInteger(weightedBytes) || weightedBytes < 1) {
+    throw new Error('Raw payload memory reservation exceeds the safe integer range');
+  }
+  return weightedBytes;
+};
 
 export interface IQueueFailureOptions {
   /** Unknown failures default to retryable so temporary internal faults do not lose mail. */
@@ -169,6 +224,10 @@ export interface IQueueOptions {
   checkInterval?: number;
   maxQueueSize?: number;
   maxPerDestination?: number;
+  /** Maximum exact RFC822 bytes accepted by enqueueRawEmail. Defaults to 32 MiB. */
+  maxRawMessageBytes?: number;
+  /** Conservative memory budget for active raw operations. Defaults to 192 MiB. */
+  rawInFlightByteBudget?: number;
   
   // Delivery attempts
   maxRetries?: number;
@@ -185,6 +244,12 @@ export interface IQueueEnqueueOptions {
   requireDurable?: boolean;
 }
 
+interface IRawQueueEnqueueOptions {
+  rawMessage: Buffer;
+  envelope: IRawSmtpEnvelope;
+  idempotencyKey: string;
+}
+
 /**
  * Queue statistics interface
  */
@@ -242,12 +307,17 @@ export class UnifiedDeliveryQueue extends EventEmitter {
     maxRetries: number;
     baseRetryDelay: number;
     maxRetryDelay: number;
+    maxRawMessageBytes: number;
+    rawInFlightByteBudget: number;
   };
   private queue: Map<string, IQueueItem> = new Map();
   private checkTimer?: NodeJS.Timeout;
   private cleanupTimer?: NodeJS.Timeout;
+  private cleanupFlight?: Promise<void>;
   private stats: IQueueStats;
   private processing: boolean = false;
+  private processingScanPromise?: Promise<void>;
+  private processingRescanRequested = false;
   private totalProcessed: number = 0;
   private ownsManagedPrefix = false;
   private lifecycleState: TQueueLifecycleState = 'new';
@@ -256,6 +326,22 @@ export class UnifiedDeliveryQueue extends EventEmitter {
     promise: Promise<string>;
   }>();
   private idempotencyTombstoneCleanupCursor?: string;
+  private readonly itemMutationFlights = new Map<string, Promise<void>>();
+  private rawBytesInFlight = 0;
+  private rawByteWaiters: Array<{
+    bytes: number;
+    resolve: () => void;
+    reject: (error: Error) => void;
+  }> = [];
+  private rawReservationCount = 0;
+  private rawReservationDrainWaiters: Array<() => void> = [];
+  private readyItemsHandler?: (itemIds: string[]) => Promise<void>;
+  private acceptingNewItems = true;
+  private acceptingMutations = true;
+  private acceptingRawReservations = true;
+  private readonly enqueueFlights = new Set<Promise<string>>();
+  private pendingNewItemCount = 0;
+  private shutdownFlight?: Promise<void>;
   
   /**
    * Create a new unified delivery queue
@@ -270,6 +356,24 @@ export class UnifiedDeliveryQueue extends EventEmitter {
     if (options.storageMode === 'memory' && options.storageManager) {
       throw new Error('Memory-only queue storage cannot receive an IBlobStorageManager');
     }
+    const maxRawMessageBytes = options.maxRawMessageBytes ?? DEFAULT_MAX_RAW_MESSAGE_BYTES;
+    const minimumRawInFlightByteBudget = weightedRawBytes(
+      maxRawMessageBytes,
+      RAW_ACCESS_RESERVATION_MULTIPLIER,
+    );
+    const rawInFlightByteBudget = options.rawInFlightByteBudget
+      ?? Math.max(DEFAULT_RAW_IN_FLIGHT_BYTE_BUDGET, minimumRawInFlightByteBudget);
+    if (!Number.isSafeInteger(maxRawMessageBytes) || maxRawMessageBytes < 1) {
+      throw new Error('Queue maxRawMessageBytes must be a positive safe integer');
+    }
+    if (
+      !Number.isSafeInteger(rawInFlightByteBudget)
+      || rawInFlightByteBudget < minimumRawInFlightByteBudget
+    ) {
+      throw new Error(
+        `Queue rawInFlightByteBudget must be a safe integer at least ${minimumRawInFlightByteBudget}`,
+      );
+    }
 
     this.options = {
       storageMode: options.storageMode,
@@ -280,7 +384,9 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       maxPerDestination: options.maxPerDestination || 100,
       maxRetries: options.maxRetries || 5,
       baseRetryDelay: options.baseRetryDelay || 60000, // 1 minute
-      maxRetryDelay: options.maxRetryDelay || 3600000 // 1 hour
+      maxRetryDelay: options.maxRetryDelay || 3600000, // 1 hour
+      maxRawMessageBytes,
+      rawInFlightByteBudget,
     };
     
     // Initialize statistics
@@ -305,11 +411,32 @@ export class UnifiedDeliveryQueue extends EventEmitter {
   }
 
   private assertMutable(): void {
-    if (this.lifecycleState === 'shutting-down' || this.lifecycleState === 'closed') {
+    if (
+      !this.acceptingMutations
+      || this.lifecycleState === 'shutting-down'
+      || this.lifecycleState === 'closed'
+    ) {
       throw new Error(`Delivery queue is ${this.lifecycleState}; mutations are no longer allowed`);
     }
   }
 
+  private assertAcceptingNewItems(): void {
+    if (!this.acceptingNewItems) {
+      throw new Error('Delivery queue is not accepting new items');
+    }
+  }
+
+  private trackEnqueueFlight(operationArg: () => Promise<string>): Promise<string> {
+    let flight: Promise<string>;
+    flight = Promise.resolve()
+      .then(operationArg)
+      .finally(() => {
+        this.enqueueFlights.delete(flight);
+      });
+    this.enqueueFlights.add(flight);
+    return flight;
+  }
+
   /** Whether queue entries are committed through caller-managed blob storage. */
   public hasManagedStorage(): boolean {
     return !!this.options.storageManager;
@@ -320,6 +447,93 @@ export class UnifiedDeliveryQueue extends EventEmitter {
     return typeof this.options.storageManager?.listPage === 'function';
   }
 
+  public [kQueueCloseAdmission](): void {
+    this.acceptingNewItems = false;
+  }
+
+  public [kQueueSetReadyItemsHandler](handlerArg?: (itemIds: string[]) => Promise<void>): void {
+    this.readyItemsHandler = handlerArg;
+  }
+
+  private cloneEmail(emailArg: Email): Email {
+    const options = deserialize(serialize(emailArg.toEmailOptions())) as IEmailOptions;
+    return new Email(options)
+      .setMessageId(emailArg.getMessageId())
+      .setEnvelopeFrom(emailArg.getEnvelopeFrom());
+  }
+
+  public [kQueueCreateItemSnapshot](itemArg: IQueueItem): IQueueItem {
+    return {
+      ...itemArg,
+      processingResult: this.cloneEmail(itemArg.processingResult),
+      ...(itemArg.smtpEnvelope
+        ? { smtpEnvelope: cloneRawSmtpEnvelope(itemArg.smtpEnvelope) }
+        : {}),
+      ...(itemArg.route
+        ? { route: deserialize(serialize(itemArg.route)) as IEmailRoute }
+        : {}),
+      nextAttempt: new Date(itemArg.nextAttempt),
+      createdAt: new Date(itemArg.createdAt),
+      updatedAt: new Date(itemArg.updatedAt),
+      ...(itemArg.deliveredAt ? { deliveredAt: new Date(itemArg.deliveredAt) } : {}),
+      deliveredRecipients: [...(itemArg.deliveredRecipients || [])],
+      terminalRecipients: [...(itemArg.terminalRecipients || [])],
+      recipientStates: (itemArg.recipientStates || []).map((state) => ({
+        ...state,
+        updatedAt: new Date(state.updatedAt),
+      })),
+      bounceOperations: (itemArg.bounceOperations || []).map((operation) => ({
+        ...operation,
+        nextAttempt: new Date(operation.nextAttempt),
+        ...(operation.completedAt ? { completedAt: new Date(operation.completedAt) } : {}),
+      })),
+      smtpTransactions: (itemArg.smtpTransactions || []).map((transaction) => ({
+        ...transaction,
+        recipients: [...transaction.recipients],
+        recipientResults: transaction.recipientResults?.map((result) => ({ ...result })),
+        outboundAuthentication: transaction.outboundAuthentication
+          ? deserialize(serialize(transaction.outboundAuthentication))
+          : undefined,
+        transcript: transaction.transcript.map((entry) => ({
+          ...entry,
+          ...(entry.transferStats ? { transferStats: { ...entry.transferStats } } : {}),
+        })),
+      })),
+    };
+  }
+
+  private async emitItemEventSafely(
+    eventNameArg: string,
+    itemArg: IQueueItem,
+    ...additionalArgsArg: unknown[]
+  ): Promise<void> {
+    for (const rawListener of this.rawListeners(eventNameArg)) {
+      try {
+        await Reflect.apply(rawListener, this, [
+          this[kQueueCreateItemSnapshot](itemArg),
+          ...deserialize(serialize(additionalArgsArg)),
+        ]);
+      } catch (error) {
+        logger.log(
+          'error',
+          `Observer for ${eventNameArg} failed: ${getErrorMessage(error)}`,
+        );
+      }
+    }
+  }
+
+  private async emitReadyItemsSafely(itemsArg: IQueueItem[]): Promise<void> {
+    for (const rawListener of this.rawListeners('itemsReady')) {
+      try {
+        await Reflect.apply(rawListener, this, [
+          itemsArg.map((item) => this[kQueueCreateItemSnapshot](item)),
+        ]);
+      } catch (error) {
+        logger.log('error', `Observer for itemsReady failed: ${getErrorMessage(error)}`);
+      }
+    }
+  }
+
   private idempotentQueueId(idempotencyKey: string): string {
     return `idempotent-${createHash('sha256')
       .update('smartmta-queue-v1\0')
@@ -548,22 +762,37 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       clearInterval(this.checkTimer);
     }
 
-    this.checkTimer = setInterval(() => this.processQueue(), this.options.checkInterval);
+    this.checkTimer = setInterval(() => this.wake(), this.options.checkInterval);
 
     // Start periodic cleanup of delivered/failed items (every 30 minutes)
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
     }
     this.cleanupTimer = setInterval(() => {
-      this.cleanupOldItems(24 * 60 * 60 * 1000).catch((err) => {
-        logger.log('error', `Auto-cleanup failed: ${err.message}`);
-      });
+      this.runPeriodicCleanup();
     }, 30 * 60 * 1000);
 
     this.processing = true;
     this.stats.processingActive = true;
     void emitSafely(this, 'processingStarted');
     logger.log('info', 'Queue processing started');
+    this.wake();
+  }
+
+  private runPeriodicCleanup(): void {
+    if (this.cleanupFlight) return;
+    let cleanupFlight: Promise<void>;
+    cleanupFlight = this.cleanupOldItems(24 * 60 * 60 * 1000)
+      .then(() => undefined)
+      .catch((error) => {
+        logger.log('error', `Auto-cleanup failed: ${getErrorMessage(error)}`);
+      })
+      .finally(() => {
+        if (this.cleanupFlight === cleanupFlight) {
+          this.cleanupFlight = undefined;
+        }
+      });
+    this.cleanupFlight = cleanupFlight;
   }
   
   /**
@@ -580,6 +809,7 @@ export class UnifiedDeliveryQueue extends EventEmitter {
     }
 
     this.processing = false;
+    this.processingRescanRequested = false;
     this.stats.processingActive = false;
     void emitSafely(this, 'processingStopped');
     logger.log('info', 'Queue processing stopped');
@@ -591,7 +821,7 @@ export class UnifiedDeliveryQueue extends EventEmitter {
   private async processQueue(): Promise<void> {
     try {
       const now = new Date();
-      let readyItems: IQueueItem[] = [];
+      const readyItems: IQueueItem[] = [];
       
       // Find items ready for processing
       for (const item of this.queue.values()) {
@@ -606,9 +836,16 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       
       // Sort by oldest first
       readyItems.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+
+      if (!this.processing) {
+        return;
+      }
       
-      // Emit event for ready items
-      await emitSafely(this, 'itemsReady', readyItems);
+      const readyItemIds = readyItems.map((item) => item.id);
+      await this.readyItemsHandler?.([...readyItemIds]);
+      if (this.listenerCount('itemsReady') > 0) {
+        await this.emitReadyItemsSafely(readyItems);
+      }
       logger.log('info', `Found ${readyItems.length} items ready for processing`);
       
       // Update statistics
@@ -618,6 +855,36 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       await emitSafely(this, 'error', error);
     }
   }
+
+  /**
+   * Wake the normal eligibility scan without bypassing pause or retry timing.
+   * The interval remains the recovery path for retries and any missed wakeup.
+   */
+  public wake(): void {
+    if (!this.processing) return;
+    this.processingRescanRequested = true;
+    if (this.processingScanPromise) return;
+
+    // Defer observer-capable work until after the active-scan guard is stored.
+    // Otherwise a synchronous itemsReady observer can re-enter wake() here.
+    const scanPromise = Promise.resolve().then(() => this.runProcessingScans());
+    this.processingScanPromise = scanPromise;
+    void scanPromise.finally(() => {
+      if (this.processingScanPromise === scanPromise) {
+        this.processingScanPromise = undefined;
+      }
+      if (this.processing && this.processingRescanRequested) {
+        this.wake();
+      }
+    });
+  }
+
+  private async runProcessingScans(): Promise<void> {
+    while (this.processing && this.processingRescanRequested) {
+      this.processingRescanRequested = false;
+      await this.processQueue();
+    }
+  }
   
   /**
    * Add an item to the queue
@@ -625,13 +892,28 @@ export class UnifiedDeliveryQueue extends EventEmitter {
    * @param mode Processing mode
    * @param route Email route
    */
-  public async enqueue(
+  public enqueue(
     processingResult: Email,
     mode: EmailProcessingMode,
     route?: IEmailRoute,
     enqueueOptions: IQueueEnqueueOptions = {},
   ): Promise<string> {
     this.assertMutable();
+    this.assertAcceptingNewItems();
+    return this.trackEnqueueFlight(() => this.enqueueAccepted(
+      processingResult,
+      mode,
+      route,
+      enqueueOptions,
+    ));
+  }
+
+  private async enqueueAccepted(
+    processingResult: Email,
+    mode: EmailProcessingMode,
+    route: IEmailRoute | undefined,
+    enqueueOptions: IQueueEnqueueOptions,
+  ): Promise<string> {
     if (!(processingResult instanceof Email)) {
       throw new Error('Queue processingResult must be an Email instance');
     }
@@ -646,68 +928,170 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       throw new Error('Queue idempotencyKey and idempotencyFingerprint must be provided together');
     }
     if (enqueueOptions.idempotencyKey !== undefined) {
-      if (this.options.storageManager && !this.options.storageManager.listPage) {
-        throw new Error(
-          'Managed idempotent enqueue requires paginated managed queue storage',
-        );
+      return this.enqueueIdempotent(
+        enqueueOptions.idempotencyKey,
+        enqueueOptions.idempotencyFingerprint!,
+        (idempotency) => this.enqueueNew(processingResult, mode, route, idempotency),
+      );
+    }
+
+    return this.enqueueNew(processingResult, mode, route);
+  }
+
+  public [kQueueEnqueueRaw](optionsArg: IRawQueueEnqueueOptions): Promise<string> {
+    this.assertMutable();
+    this.assertAcceptingNewItems();
+    if (!this.hasManagedStorage()) {
+      throw new Error('Raw outbound queue requires managed queue storage');
+    }
+    if (!this.hasPaginatedManagedStorage()) {
+      throw new Error('Raw outbound queue requires paginated managed queue storage');
+    }
+    if (!optionsArg.idempotencyKey || optionsArg.idempotencyKey.length > 512) {
+      throw new Error('Queue idempotencyKey must contain 1 to 512 characters');
+    }
+    try {
+      assertCanonicalRawRfc822Message(optionsArg.rawMessage);
+    } catch (error) {
+      if (!Buffer.isBuffer(optionsArg.rawMessage)) {
+        throw new Error('Raw outbound queue message must be a Buffer');
       }
-      if (!enqueueOptions.idempotencyKey || enqueueOptions.idempotencyKey.length > 512) {
-        throw new Error('Queue idempotencyKey must contain 1 to 512 characters');
+      throw error;
+    }
+    if (optionsArg.rawMessage.length > this.options.maxRawMessageBytes) {
+      throw new Error(
+        `Raw outbound queue message exceeds ${this.options.maxRawMessageBytes} bytes`,
+      );
+    }
+    const releaseRawReservation = this.reserveRawBytesImmediately(
+      weightedRawBytes(optionsArg.rawMessage.length, RAW_ENQUEUE_RESERVATION_MULTIPLIER),
+    );
+    let rawMessage: Buffer;
+    let smtpEnvelope: IRawSmtpEnvelope;
+    let rawMessageSha256: string;
+    let fingerprint: string;
+    let processingResult: Email;
+    try {
+      rawMessage = Buffer.from(optionsArg.rawMessage);
+      assertCanonicalRawRfc822Message(rawMessage);
+      smtpEnvelope = normalizeRawSmtpEnvelope(optionsArg.envelope);
+      rawMessageSha256 = createHash('sha256').update(rawMessage).digest('hex');
+      fingerprint = createRawQueueFingerprint(rawMessage, smtpEnvelope);
+      processingResult = new Email({
+        from: smtpEnvelope.from,
+        to: smtpEnvelope.to,
+        subject: '',
+        text: '',
+      }).setEnvelopeFrom(smtpEnvelope.from);
+    } catch (error) {
+      releaseRawReservation();
+      throw error;
+    }
+
+    return this.trackEnqueueFlight(async () => {
+      try {
+        return await this.enqueueRawAccepted({
+          rawMessage,
+          smtpEnvelope,
+          idempotencyKey: optionsArg.idempotencyKey,
+          rawMessageSha256,
+          fingerprint,
+          processingResult,
+        });
+      } finally {
+        releaseRawReservation();
       }
-      if (!/^[a-f0-9]{64}$/.test(enqueueOptions.idempotencyFingerprint!)) {
-        throw new Error('Queue idempotencyFingerprint must be a lowercase SHA-256 digest');
+    });
+  }
+
+  private async enqueueRawAccepted(optionsArg: {
+    rawMessage: Buffer;
+    smtpEnvelope: IRawSmtpEnvelope;
+    idempotencyKey: string;
+    rawMessageSha256: string;
+    fingerprint: string;
+    processingResult: Email;
+  }): Promise<string> {
+    return this.enqueueIdempotent(
+      optionsArg.idempotencyKey,
+      optionsArg.fingerprint,
+      (idempotency) => this.enqueueNew(
+        optionsArg.processingResult,
+        'mta',
+        undefined,
+        idempotency,
+        {
+          rawMessage: optionsArg.rawMessage,
+          rawMessageSha256: optionsArg.rawMessageSha256,
+          smtpEnvelope: optionsArg.smtpEnvelope,
+        },
+      ),
+    );
+  }
+
+  private async enqueueIdempotent(
+    idempotencyKeyArg: string,
+    fingerprintArg: string,
+    createArg: (idempotency: {
+      id: string;
+      idempotencyKey: string;
+      idempotencyFingerprint: string;
+    }) => Promise<string>,
+  ): Promise<string> {
+    if (this.options.storageManager && !this.options.storageManager.listPage) {
+      throw new Error('Managed idempotent enqueue requires paginated managed queue storage');
+    }
+    if (!idempotencyKeyArg || idempotencyKeyArg.length > 512) {
+      throw new Error('Queue idempotencyKey must contain 1 to 512 characters');
+    }
+    if (!/^[a-f0-9]{64}$/.test(fingerprintArg)) {
+      throw new Error('Queue idempotencyFingerprint must be a lowercase SHA-256 digest');
+    }
+
+    const id = this.idempotentQueueId(idempotencyKeyArg);
+    const existing = this.queue.get(id);
+    if (existing) {
+      if (
+        existing.idempotencyKey !== idempotencyKeyArg
+        || existing.idempotencyFingerprint !== fingerprintArg
+      ) {
+        throw new Error(`Queue idempotency key collision for ${id}`);
       }
+      return id;
+    }
 
-      const id = this.idempotentQueueId(enqueueOptions.idempotencyKey);
-      const existing = this.queue.get(id);
-      if (existing) {
+    const activeFlight = this.idempotentEnqueueFlights.get(id);
+    if (activeFlight) {
+      if (activeFlight.fingerprint !== fingerprintArg) {
+        throw new Error(`Queue idempotency key collision for ${id}`);
+      }
+      return activeFlight.promise;
+    }
+    const flight = (async () => {
+      const tombstone = await this.readIdempotencyTombstone(id);
+      if (tombstone) {
         if (
-          existing.idempotencyKey !== enqueueOptions.idempotencyKey
-          || existing.idempotencyFingerprint !== enqueueOptions.idempotencyFingerprint
+          tombstone.idempotencyKey !== idempotencyKeyArg
+          || tombstone.idempotencyFingerprint !== fingerprintArg
         ) {
           throw new Error(`Queue idempotency key collision for ${id}`);
         }
         return id;
       }
-
-      const activeFlight = this.idempotentEnqueueFlights.get(id);
-      if (activeFlight) {
-        if (activeFlight.fingerprint !== enqueueOptions.idempotencyFingerprint) {
-          throw new Error(`Queue idempotency key collision for ${id}`);
-        }
-        return activeFlight.promise;
-      }
-      const flight = (async () => {
-        const tombstone = await this.readIdempotencyTombstone(id);
-        if (tombstone) {
-          if (
-            tombstone.idempotencyKey !== enqueueOptions.idempotencyKey
-            || tombstone.idempotencyFingerprint !== enqueueOptions.idempotencyFingerprint
-          ) {
-            throw new Error(`Queue idempotency key collision for ${id}`);
-          }
-          return id;
-        }
-        return this.enqueueNew(processingResult, mode, route, {
-          id,
-          idempotencyKey: enqueueOptions.idempotencyKey!,
-          idempotencyFingerprint: enqueueOptions.idempotencyFingerprint!,
-        });
-      })();
-      this.idempotentEnqueueFlights.set(id, {
-        fingerprint: enqueueOptions.idempotencyFingerprint!,
-        promise: flight,
+      return createArg({
+        id,
+        idempotencyKey: idempotencyKeyArg,
+        idempotencyFingerprint: fingerprintArg,
       });
-      try {
-        return await flight;
-      } finally {
-        if (this.idempotentEnqueueFlights.get(id)?.promise === flight) {
-          this.idempotentEnqueueFlights.delete(id);
-        }
+    })();
+    this.idempotentEnqueueFlights.set(id, { fingerprint: fingerprintArg, promise: flight });
+    try {
+      return await flight;
+    } finally {
+      if (this.idempotentEnqueueFlights.get(id)?.promise === flight) {
+        this.idempotentEnqueueFlights.delete(id);
       }
     }
-
-    return this.enqueueNew(processingResult, mode, route);
   }
 
   private async enqueueNew(
@@ -719,56 +1103,66 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       idempotencyKey: string;
       idempotencyFingerprint: string;
     },
+    raw?: {
+      rawMessage: Buffer;
+      rawMessageSha256: string;
+      smtpEnvelope: IRawSmtpEnvelope;
+    },
   ): Promise<string> {
-    // Check if queue is full
-    if (this.queue.size >= this.options.maxQueueSize) {
+    if (this.queue.size + this.pendingNewItemCount >= this.options.maxQueueSize) {
       throw new Error('Queue is full');
     }
-    
-    // Generate a unique ID
-    const id = idempotency?.id
-      || `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
-    
-    // Create queue item
-    const item: IQueueItem = {
-      id,
-      ...(idempotency ? {
-        idempotencyKey: idempotency.idempotencyKey,
-        idempotencyFingerprint: idempotency.idempotencyFingerprint,
-      } : {}),
-      processingMode: mode,
-      processingResult,
-      attachmentCount: processingResult.attachments.length,
-      route,
-      status: 'pending',
-      attempts: 0,
-      nextAttempt: new Date(),
-      createdAt: new Date(),
-      updatedAt: new Date(),
-      deliveredRecipients: [],
-      terminalRecipients: [],
-      recipientStates: this.createInitialRecipientStates(processingResult),
-      bounceOperations: [],
-      smtpTransactions: [],
-    };
-    
-    // Commit durable state before exposing the item in memory or emitting acceptance.
-    await this.persistItem(item);
-    if (idempotency) {
-      await this.persistIdempotencyTombstone(
+    this.pendingNewItemCount++;
+    let slotPending = true;
+    let id: string;
+    let item: IQueueItem;
+    try {
+      id = idempotency?.id
+        || `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+      item = {
         id,
-        idempotency.idempotencyKey,
-        idempotency.idempotencyFingerprint,
-      );
+        ...(idempotency ? {
+          idempotencyKey: idempotency.idempotencyKey,
+          idempotencyFingerprint: idempotency.idempotencyFingerprint,
+        } : {}),
+        processingMode: mode,
+        processingResult,
+        ...(raw ? {
+          messageFormat: 'raw-rfc822' as const,
+          rawMessageSha256: raw.rawMessageSha256,
+          rawMessageLength: raw.rawMessage.length,
+          smtpEnvelope: cloneRawSmtpEnvelope(raw.smtpEnvelope),
+        } : {}),
+        attachmentCount: raw ? 0 : processingResult.attachments.length,
+        route,
+        status: 'pending',
+        attempts: 0,
+        nextAttempt: new Date(),
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        deliveredRecipients: [],
+        terminalRecipients: [],
+        recipientStates: this.createInitialRecipientStates(processingResult),
+        bounceOperations: [],
+        smtpTransactions: [],
+      };
+
+      // Commit durable state before exposing the item in memory or emitting acceptance.
+      await this.persistItem(item, raw?.rawMessage);
+      this.queue.set(id, item);
+      this.pendingNewItemCount--;
+      slotPending = false;
+    } finally {
+      if (slotPending) this.pendingNewItemCount--;
     }
-    this.queue.set(id, item);
     
     // Update statistics
     this.updateStats();
     
     // Emit event
-    await emitSafely(this, 'itemEnqueued', item);
+    await this.emitItemEventSafely('itemEnqueued', item);
     logger.log('info', `Item enqueued with ID ${id}, mode: ${mode}`);
+    this.wake();
     
     return id;
   }
@@ -778,23 +1172,12 @@ export class UnifiedDeliveryQueue extends EventEmitter {
    * @param id Item ID
    */
   public getItem(id: string): IQueueItem | undefined {
-    return this.queue.get(id);
+    const item = this.queue.get(id);
+    return item ? this[kQueueCreateItemSnapshot](item) : undefined;
   }
 
   public listItems(): IQueueItem[] {
-    return Array.from(this.queue.values()).map((item) => ({
-      ...item,
-      deliveredRecipients: [...(item.deliveredRecipients || [])],
-      terminalRecipients: [...(item.terminalRecipients || [])],
-      recipientStates: (item.recipientStates || []).map((state) => ({ ...state })),
-      bounceOperations: (item.bounceOperations || []).map((operation) => ({ ...operation })),
-      smtpTransactions: (item.smtpTransactions || []).map((transaction) => ({
-        ...transaction,
-        recipients: [...transaction.recipients],
-        recipientResults: transaction.recipientResults?.map((result) => ({ ...result })),
-        transcript: transaction.transcript.map((entry) => ({ ...entry })),
-      })),
-    }));
+    return Array.from(this.queue.values()).map((item) => this[kQueueCreateItemSnapshot](item));
   }
   
   /**
@@ -804,28 +1187,25 @@ export class UnifiedDeliveryQueue extends EventEmitter {
   public async markProcessing(id: string): Promise<boolean> {
     this.assertMutable();
     const item = this.queue.get(id);
+    if (!item) return false;
     
-    if (
-      !item
-      || !(
-        item.status === 'pending'
-        || (item.status === 'deferred' && item.nextAttempt <= new Date())
-      )
-    ) {
-      return false;
-    }
-    
-    await this.applyPersistedMutation(item, (updatedItem) => {
+    const updated = await this.applyPersistedMutation(item, (updatedItem) => {
       updatedItem.status = 'processing';
       updatedItem.attempts++;
       updatedItem.updatedAt = new Date();
-    });
+    }, (currentItem) => (
+      currentItem.status === 'pending'
+      || (currentItem.status === 'deferred' && currentItem.nextAttempt <= new Date())
+    ));
+    if (!updated) {
+      return false;
+    }
     
     // Update statistics
     this.updateStats();
     
     // Emit event
-    await emitSafely(this, 'itemProcessing', item);
+    await this.emitItemEventSafely('itemProcessing', item);
     logger.log('info', `Item ${id} marked as processing, attempt ${item.attempts}`);
     
     return true;
@@ -843,18 +1223,19 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       return false;
     }
     
-    await this.applyPersistedMutation(item, (updatedItem) => {
+    const updated = await this.applyPersistedMutation(item, (updatedItem) => {
       updatedItem.status = 'delivered';
       updatedItem.updatedAt = new Date();
       updatedItem.deliveredAt = new Date();
-    });
+    }, (currentItem) => currentItem.status !== 'delivered' && currentItem.status !== 'failed');
+    if (!updated) return false;
     
     // Update statistics
     this.totalProcessed++;
     this.updateStats();
     
     // Emit event
-    await emitSafely(this, 'itemDelivered', item);
+    await this.emitItemEventSafely('itemDelivered', item);
     logger.log('info', `Item ${id} marked as delivered after ${item.attempts} attempts`);
     
     return true;
@@ -902,21 +1283,22 @@ export class UnifiedDeliveryQueue extends EventEmitter {
         this.options.maxRetryDelay
       );
       
-      await this.applyPersistedMutation(item, (updatedItem) => {
+      const updated = await this.applyPersistedMutation(item, (updatedItem) => {
         updatedItem.status = 'deferred';
         updatedItem.lastError = error;
         updatedItem.nextAttempt = new Date(Date.now() + delay);
         updatedItem.updatedAt = new Date();
-      });
+      }, (currentItem) => currentItem.status !== 'delivered' && currentItem.status !== 'failed');
+      if (!updated) return { updated: false, terminal: true };
       
       // Emit event
-      await emitSafely(this, 'itemDeferred', item);
+      await this.emitItemEventSafely('itemDeferred', item);
       logger.log('info', `Item ${id} deferred for ${delay}ms, attempt ${item.attempts}, error: ${error}`);
       this.updateStats();
       return { updated: true, status: 'deferred', terminal: false };
     } else {
       // Mark as permanently failed
-      await this.applyPersistedMutation(item, (updatedItem) => {
+      const updated = await this.applyPersistedMutation(item, (updatedItem) => {
         const now = new Date();
         updatedItem.status = 'failed';
         updatedItem.lastError = error;
@@ -966,13 +1348,14 @@ export class UnifiedDeliveryQueue extends EventEmitter {
           updatedItem.terminalRecipients = [...terminal];
           updatedItem.bounceOperations = operations;
         }
-      });
+      }, (currentItem) => currentItem.status !== 'delivered' && currentItem.status !== 'failed');
+      if (!updated) return { updated: false, terminal: true };
       
       // Update statistics
       this.totalProcessed++;
       
       // Emit event
-      await emitSafely(this, 'itemFailed', item);
+      await this.emitItemEventSafely('itemFailed', item);
       logger.log('warn', `Item ${id} permanently failed after ${item.attempts} attempts, error: ${error}`);
     }
 
@@ -1007,7 +1390,7 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       ].slice(-20);
       updatedItem.updatedAt = new Date();
     });
-    await emitSafely(this, 'smtpTransaction', item, normalizedTransaction);
+    await this.emitItemEventSafely('smtpTransaction', item, normalizedTransaction);
     return true;
   }
 
@@ -1020,8 +1403,6 @@ export class UnifiedDeliveryQueue extends EventEmitter {
     this.assertMutable();
     const item = this.queue.get(id);
     if (!item) return false;
-    const transactionIndex = (item.smtpTransactions || []).findIndex((value) => value.id === transactionId);
-    if (transactionIndex < 0) return false;
     const normalizedTransaction: ISmtpTransactionAttempt = {
       ...transaction,
       queueItemId: id,
@@ -1032,13 +1413,18 @@ export class UnifiedDeliveryQueue extends EventEmitter {
         : undefined,
       transcript: normalizeSmtpTranscript(transaction.transcript),
     };
-    await this.applyPersistedMutation(item, (updatedItem) => {
+    const updated = await this.applyPersistedMutation(item, (updatedItem) => {
       const transactions = [...(updatedItem.smtpTransactions || [])];
+      const transactionIndex = transactions.findIndex((value) => value.id === transactionId);
+      if (transactionIndex < 0) return;
       transactions[transactionIndex] = normalizedTransaction;
       updatedItem.smtpTransactions = transactions.slice(-20);
       updatedItem.updatedAt = new Date();
-    });
-    await emitSafely(this, 'smtpTransactionUpdated', item, normalizedTransaction);
+    }, (currentItem) => (
+      (currentItem.smtpTransactions || []).some((value) => value.id === transactionId)
+    ));
+    if (!updated) return false;
+    await this.emitItemEventSafely('smtpTransactionUpdated', item, normalizedTransaction);
     return true;
   }
 
@@ -1219,11 +1605,8 @@ export class UnifiedDeliveryQueue extends EventEmitter {
   ): Promise<boolean> {
     this.assertMutable();
     const item = this.queue.get(itemId);
-    const operation = item?.bounceOperations?.find(
-      (candidate) => candidate.operationId === operationId,
-    );
-    if (!item || !operation || operation.state === 'completed') return false;
-    await this.applyPersistedMutation(item, (updatedItem) => {
+    if (!item) return false;
+    const updated = await this.applyPersistedMutation(item, (updatedItem) => {
       const updatedOperation = updatedItem.bounceOperations?.find(
         (candidate) => candidate.operationId === operationId,
       );
@@ -1232,8 +1615,10 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       updatedOperation.completedAt = new Date();
       delete updatedOperation.lastError;
       updatedItem.updatedAt = new Date();
-    });
-    return true;
+    }, (currentItem) => Boolean(currentItem.bounceOperations?.some(
+      (operation) => operation.operationId === operationId && operation.state !== 'completed',
+    )));
+    return updated;
   }
 
   public async markBounceOperationFailed(
@@ -1243,11 +1628,8 @@ export class UnifiedDeliveryQueue extends EventEmitter {
   ): Promise<boolean> {
     this.assertMutable();
     const item = this.queue.get(itemId);
-    const operation = item?.bounceOperations?.find(
-      (candidate) => candidate.operationId === operationId,
-    );
-    if (!item || !operation || operation.state === 'completed') return false;
-    await this.applyPersistedMutation(item, (updatedItem) => {
+    if (!item) return false;
+    const updated = await this.applyPersistedMutation(item, (updatedItem) => {
       const updatedOperation = updatedItem.bounceOperations?.find(
         (candidate) => candidate.operationId === operationId,
       );
@@ -1258,8 +1640,10 @@ export class UnifiedDeliveryQueue extends EventEmitter {
         Date.now() + Math.min(60_000 * (2 ** Math.max(0, updatedOperation.attempts - 1)), 3_600_000),
       );
       updatedItem.updatedAt = new Date();
-    });
-    return true;
+    }, (currentItem) => Boolean(currentItem.bounceOperations?.some(
+      (operation) => operation.operationId === operationId && operation.state !== 'completed',
+    )));
+    return updated;
   }
 
   /**
@@ -1268,28 +1652,33 @@ export class UnifiedDeliveryQueue extends EventEmitter {
    */
   public async removeItem(id: string): Promise<boolean> {
     this.assertMutable();
-    const item = this.queue.get(id);
-    
-    if (!item) {
-      return false;
-    }
-    
-    if (item.idempotencyKey && item.idempotencyFingerprint) {
-      await this.persistIdempotencyTombstone(
-        item.id,
-        item.idempotencyKey,
-        item.idempotencyFingerprint,
-      );
-    }
-    // Delete durable state before making the removal visible in memory.
-    await this.removeItemFromStorage(id);
-    this.queue.delete(id);
+    let removedItem: IQueueItem | undefined;
+    const removed = await this.withItemMutex(id, async () => {
+      const item = this.queue.get(id);
+      if (!item) return false;
+      if (item.status === 'processing') {
+        throw new Error(`Cannot remove queue item ${id} while it is processing`);
+      }
+      if (item.idempotencyKey && item.idempotencyFingerprint) {
+        await this.persistIdempotencyTombstone(
+          item.id,
+          item.idempotencyKey,
+          item.idempotencyFingerprint,
+        );
+      }
+      // Delete durable state before making the removal visible in memory.
+      await this.removeItemFromStorage(id);
+      removedItem = item;
+      this.queue.delete(id);
+      return true;
+    });
+    if (!removed || !removedItem) return false;
     
     // Update statistics
     this.updateStats();
     
     // Emit event
-    await emitSafely(this, 'itemRemoved', item);
+    await this.emitItemEventSafely('itemRemoved', removedItem);
     logger.log('info', `Item ${id} removed from queue`);
     
     return true;
@@ -1299,16 +1688,34 @@ export class UnifiedDeliveryQueue extends EventEmitter {
     return `${this.options.storagePrefix}${id}.json`;
   }
 
-  private async persistItem(item: IQueueItem): Promise<void> {
+  private async persistItem(item: IQueueItem, rawMessageArg?: Buffer): Promise<void> {
     if (!this.options.storageManager) return;
+    if (item.messageFormat === 'raw-rfc822' && !rawMessageArg) {
+      throw new Error(`Raw queue item ${item.id} requires its exact payload for persistence`);
+    }
     await this.options.storageManager.set(
       this.storageKey(item.id),
-      serialize(this.serializeItem(item)),
+      serialize(this.serializeItem(item, rawMessageArg)),
     );
   }
 
-  private serializeItem(item: IQueueItem): IStoredQueueItem {
-    return {
+  private async persistCurrentItem(itemArg: IQueueItem): Promise<void> {
+    if (itemArg.messageFormat !== 'raw-rfc822') {
+      await this.persistItem(itemArg);
+      return;
+    }
+    await this.withRawByteReservation(
+      weightedRawBytes(itemArg.rawMessageLength!, RAW_ACCESS_RESERVATION_MULTIPLIER),
+      async () => {
+        const rawMessage = await this.readVerifiedRawMessage(itemArg);
+        await this.persistItem(itemArg, rawMessage);
+      },
+      true,
+    );
+  }
+
+  private serializeItem(item: IQueueItem, rawMessageArg?: Buffer): IStoredQueueItem {
+    const storedItem: IStoredQueueItemV2 = {
       schemaVersion: 2,
       id: item.id,
       ...(item.idempotencyKey !== undefined ? {
@@ -1354,31 +1761,240 @@ export class UnifiedDeliveryQueue extends EventEmitter {
         transcript: normalizeSmtpTranscript(transaction.transcript),
       })),
     };
+    if (item.messageFormat !== 'raw-rfc822') return storedItem;
+    if (!rawMessageArg) {
+      throw new Error(`Raw queue item ${item.id} cannot be persisted without its exact payload`);
+    }
+    return {
+      ...storedItem,
+      schemaVersion: 3,
+      messageFormat: 'raw-rfc822',
+      rawMessageSha256: item.rawMessageSha256!,
+      rawMessageLength: item.rawMessageLength!,
+      smtpEnvelope: cloneRawSmtpEnvelope(item.smtpEnvelope!),
+      rawMessage: rawMessageArg,
+    };
+  }
+
+  private async withItemMutex<T>(itemIdArg: string, operationArg: () => Promise<T>): Promise<T> {
+    const previous = this.itemMutationFlights.get(itemIdArg) || Promise.resolve();
+    const result = previous.catch(() => undefined).then(operationArg);
+    const settled = result.then(() => undefined, () => undefined);
+    this.itemMutationFlights.set(itemIdArg, settled);
+    try {
+      return await result;
+    } finally {
+      if (this.itemMutationFlights.get(itemIdArg) === settled) {
+        this.itemMutationFlights.delete(itemIdArg);
+      }
+    }
   }
 
   private async applyPersistedMutation(
     item: IQueueItem,
     mutation: (updatedItem: IQueueItem) => void,
-  ): Promise<void> {
+    shouldMutateArg: (currentItem: IQueueItem) => boolean = () => true,
+  ): Promise<boolean> {
     this.assertMutable();
-    const updatedItem: IQueueItem = {
-      ...item,
-      deliveredRecipients: [...(item.deliveredRecipients || [])],
-      terminalRecipients: [...(item.terminalRecipients || [])],
-      recipientStates: (item.recipientStates || []).map((state) => ({ ...state })),
-      bounceOperations: (item.bounceOperations || []).map((operation) => ({ ...operation })),
-      smtpTransactions: [...(item.smtpTransactions || [])],
+    return this.withItemMutex(item.id, async () => {
+      const currentItem = this.queue.get(item.id);
+      if (!currentItem || !shouldMutateArg(currentItem)) return false;
+      const updatedItem = this[kQueueCreateItemSnapshot](currentItem);
+      mutation(updatedItem);
+      await this.persistCurrentItem(updatedItem);
+      for (const key of Object.keys(currentItem) as Array<keyof IQueueItem>) {
+        delete currentItem[key];
+      }
+      Object.assign(currentItem, updatedItem);
+      return true;
+    });
+  }
+
+  private createRawIntegrityError(itemArg: IQueueItem, detailArg: string): SmtpDeliveryError {
+    return new SmtpDeliveryError({
+      message: `Raw queue payload integrity failure for item ${itemArg.id}: ${detailArg}`,
+      errorType: 'raw_queue_integrity',
+      retryable: false,
+      phase: 'message_body',
+      transactionLog: [],
+      recipients: itemArg.smtpEnvelope?.to || [],
+    });
+  }
+
+  private async readVerifiedRawMessage(itemArg: IQueueItem): Promise<Buffer> {
+    const storageManager = this.options.storageManager;
+    if (!storageManager) {
+      throw this.createRawIntegrityError(itemArg, 'managed storage is unavailable');
+    }
+    const data = await storageManager.get(this.storageKey(itemArg.id));
+    if (!data) {
+      throw this.createRawIntegrityError(itemArg, 'atomic queue blob is missing');
+    }
+    let stored: IDeserializedQueueItem;
+    try {
+      stored = this.deserializeItem(this.storageKey(itemArg.id), data);
+    } catch (error) {
+      throw this.createRawIntegrityError(itemArg, getErrorMessage(error));
+    }
+    if (
+      stored.item.messageFormat !== 'raw-rfc822'
+      || !stored.rawMessage
+      || stored.item.rawMessageSha256 !== itemArg.rawMessageSha256
+      || stored.item.rawMessageLength !== itemArg.rawMessageLength
+      || stored.item.idempotencyFingerprint !== itemArg.idempotencyFingerprint
+      || JSON.stringify(stored.item.smtpEnvelope) !== JSON.stringify(itemArg.smtpEnvelope)
+    ) {
+      throw this.createRawIntegrityError(itemArg, 'stored metadata does not match memory state');
+    }
+    return stored.rawMessage;
+  }
+
+  private claimRawReservation(allowDuringShutdownArg = false): () => void {
+    if (
+      this.lifecycleState === 'closed'
+      || (!allowDuringShutdownArg && !this.acceptingRawReservations)
+    ) {
+      throw new Error(`Delivery queue is ${this.lifecycleState}; raw payload access is unavailable`);
+    }
+    if (this.rawReservationCount >= RAW_RESERVATION_LIMIT) {
+      throw new Error(`Raw payload reservation limit ${RAW_RESERVATION_LIMIT} reached`);
+    }
+    this.rawReservationCount++;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.rawReservationCount--;
+      if (this.rawReservationCount === 0) {
+        for (const resolve of this.rawReservationDrainWaiters.splice(0)) resolve();
+      }
+    };
+  }
+
+  private createRawByteRelease(bytesArg: number, releaseReservationArg: () => void): () => void {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.releaseRawBytes(bytesArg);
+      releaseReservationArg();
     };
-    mutation(updatedItem);
-    await this.persistItem(updatedItem);
-    Object.assign(item, updatedItem);
+  }
+
+  private async reserveRawBytes(
+    bytesArg: number,
+    allowDuringShutdownArg = false,
+  ): Promise<() => void> {
+    if (!Number.isSafeInteger(bytesArg) || bytesArg < 1) {
+      throw new Error('Raw payload memory reservation must be a positive safe integer');
+    }
+    if (bytesArg > this.options.rawInFlightByteBudget) {
+      throw new Error(
+        `Raw payload memory reservation ${bytesArg} exceeds queue budget ${this.options.rawInFlightByteBudget}`,
+      );
+    }
+    const releaseReservation = this.claimRawReservation(allowDuringShutdownArg);
+    if (this.rawByteWaiters.length === 0 && this.rawBytesInFlight + bytesArg <= this.options.rawInFlightByteBudget) {
+      this.rawBytesInFlight += bytesArg;
+      return this.createRawByteRelease(bytesArg, releaseReservation);
+    }
+    if (this.rawByteWaiters.length >= RAW_BYTE_WAITER_LIMIT) {
+      releaseReservation();
+      throw new Error(`Raw payload memory waiter limit ${RAW_BYTE_WAITER_LIMIT} reached`);
+    }
+    return new Promise<() => void>((resolve, reject) => {
+      this.rawByteWaiters.push({
+        bytes: bytesArg,
+        resolve: () => resolve(this.createRawByteRelease(bytesArg, releaseReservation)),
+        reject: (error) => {
+          releaseReservation();
+          reject(error);
+        },
+      });
+    });
+  }
+
+  private reserveRawBytesImmediately(bytesArg: number): () => void {
+    if (!Number.isSafeInteger(bytesArg) || bytesArg < 1) {
+      throw new Error('Raw payload memory reservation must be a positive safe integer');
+    }
+    if (bytesArg > this.options.rawInFlightByteBudget) {
+      throw new Error(
+        `Raw payload memory reservation ${bytesArg} exceeds queue budget ${this.options.rawInFlightByteBudget}`,
+      );
+    }
+    const releaseReservation = this.claimRawReservation();
+    if (
+      this.rawByteWaiters.length > 0
+      || this.rawBytesInFlight + bytesArg > this.options.rawInFlightByteBudget
+    ) {
+      releaseReservation();
+      throw new Error('Raw payload memory budget is currently exhausted');
+    }
+    this.rawBytesInFlight += bytesArg;
+    return this.createRawByteRelease(bytesArg, releaseReservation);
+  }
+
+  public [kQueueReserveRawAccess](rawMessageLengthArg: number): () => void {
+    return this.reserveRawBytesImmediately(
+      weightedRawBytes(rawMessageLengthArg, RAW_ACCESS_RESERVATION_MULTIPLIER),
+    );
+  }
+
+  private releaseRawBytes(bytesArg: number): void {
+    this.rawBytesInFlight -= bytesArg;
+    while (this.rawByteWaiters.length > 0) {
+      const waiter = this.rawByteWaiters[0];
+      if (this.rawBytesInFlight + waiter.bytes > this.options.rawInFlightByteBudget) break;
+      this.rawByteWaiters.shift();
+      this.rawBytesInFlight += waiter.bytes;
+      waiter.resolve();
+    }
+  }
+
+  private async withRawByteReservation<T>(
+    bytesArg: number,
+    callbackArg: () => Promise<T>,
+    allowDuringShutdownArg = false,
+  ): Promise<T> {
+    const releaseReservation = await this.reserveRawBytes(bytesArg, allowDuringShutdownArg);
+    try {
+      return await callbackArg();
+    } finally {
+      releaseReservation();
+    }
+  }
+
+  private async waitForRawReservationsToDrain(): Promise<void> {
+    if (this.rawReservationCount === 0) return;
+    await new Promise<void>((resolve) => {
+      this.rawReservationDrainWaiters.push(resolve);
+    });
+  }
+
+  public async [kQueueWithRawMessage]<T>(
+    itemIdArg: string,
+    callbackArg: (rawMessage: Buffer) => Promise<T>,
+  ): Promise<T> {
+    const item = this.queue.get(itemIdArg);
+    if (!item || item.messageFormat !== 'raw-rfc822' || !item.rawMessageLength) {
+      throw new Error(`Queue item ${itemIdArg} is not a raw outbound item`);
+    }
+    const reservedBytes = weightedRawBytes(
+      item.rawMessageLength,
+      RAW_ACCESS_RESERVATION_MULTIPLIER,
+    );
+    return this.withRawByteReservation(reservedBytes, async () => {
+      const rawMessage = await this.readVerifiedRawMessage(item);
+      return await callbackArg(rawMessage);
+    });
   }
 
   private async removeItemFromStorage(id: string): Promise<void> {
     await this.options.storageManager?.delete(this.storageKey(id));
   }
 
-  private deserializeItem(key: string, data: Buffer): IQueueItem {
+  private deserializeItem(key: string, data: Buffer): IDeserializedQueueItem {
     let parsed: Record<string, any>;
     try {
       parsed = deserialize(data) as Record<string, any>;
@@ -1409,7 +2025,7 @@ export class UnifiedDeliveryQueue extends EventEmitter {
         throw new Error(`Invalid managed queue item at ${key}: idempotency id mismatch`);
       }
     }
-    if (parsed.schemaVersion !== 1 && parsed.schemaVersion !== 2) {
+    if (parsed.schemaVersion !== 1 && parsed.schemaVersion !== 2 && parsed.schemaVersion !== 3) {
       throw new Error(`Invalid managed queue item at ${key}: unsupported schema version`);
     }
     if (this.storageKey(parsed.id) !== key) {
@@ -1444,7 +2060,7 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       throw new Error(`Invalid managed queue item at ${key}: invalid terminal recipients`);
     }
 
-    if (parsed.schemaVersion === 2) {
+    if (parsed.schemaVersion === 2 || parsed.schemaVersion === 3) {
       if (
         !Array.isArray(parsed.recipientStates)
         || parsed.recipientStates.some((value: unknown) => {
@@ -1671,9 +2287,70 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       throw new Error(`Invalid managed queue item at ${key}: ${getErrorMessage(error)}`);
     }
 
+    let rawMessage: Buffer | undefined;
+    let smtpEnvelope: IRawSmtpEnvelope | undefined;
+    if (parsed.schemaVersion === 3) {
+      if (!this.hasPaginatedManagedStorage()) {
+        throw new Error(`Invalid managed queue item at ${key}: raw queue requires paginated storage`);
+      }
+      if (
+        parsed.messageFormat !== 'raw-rfc822'
+        || parsed.processingMode !== 'mta'
+        || parsed.route !== undefined
+        || parsed.attachmentCount !== 0
+        || typeof parsed.rawMessageSha256 !== 'string'
+        || !/^[a-f0-9]{64}$/.test(parsed.rawMessageSha256)
+        || !Number.isSafeInteger(parsed.rawMessageLength)
+        || parsed.rawMessageLength < 1
+        || parsed.rawMessageLength > this.options.maxRawMessageBytes
+        || !Buffer.isBuffer(parsed.rawMessage)
+        || parsed.rawMessage.length !== parsed.rawMessageLength
+      ) {
+        throw new Error(`Invalid managed queue item at ${key}: invalid raw payload metadata`);
+      }
+      try {
+        assertCanonicalRawRfc822Message(parsed.rawMessage);
+      } catch (error) {
+        throw new Error(`Invalid managed queue item at ${key}: ${getErrorMessage(error)}`);
+      }
+      let normalizedEnvelope: IRawSmtpEnvelope;
+      try {
+        normalizedEnvelope = normalizeRawSmtpEnvelope(parsed.smtpEnvelope);
+      } catch (error) {
+        throw new Error(`Invalid managed queue item at ${key}: ${getErrorMessage(error)}`);
+      }
+      if (JSON.stringify(normalizedEnvelope) !== JSON.stringify(parsed.smtpEnvelope)) {
+        throw new Error(`Invalid managed queue item at ${key}: SMTP envelope is not canonical`);
+      }
+      const digest = createHash('sha256').update(parsed.rawMessage).digest('hex');
+      if (digest !== parsed.rawMessageSha256) {
+        throw new Error(`Invalid managed queue item at ${key}: raw payload digest mismatch`);
+      }
+      if (
+        parsed.idempotencyFingerprint
+        !== createRawQueueFingerprint(parsed.rawMessage, normalizedEnvelope)
+      ) {
+        throw new Error(`Invalid managed queue item at ${key}: raw queue fingerprint mismatch`);
+      }
+      if (
+        storedOptions.from !== normalizedEnvelope.from
+        || JSON.stringify(Array.isArray(storedOptions.to) ? storedOptions.to : [storedOptions.to])
+          !== JSON.stringify(normalizedEnvelope.to)
+        || storedOptions.subject !== ''
+        || storedOptions.text !== ''
+        || storedOptions.html !== undefined
+        || storedOptions.attachments !== undefined
+        || storedOptions.headers !== undefined
+      ) {
+        throw new Error(`Invalid managed queue item at ${key}: raw queue Email metadata is not minimal`);
+      }
+      rawMessage = parsed.rawMessage;
+      smtpEnvelope = normalizedEnvelope;
+    }
+
     let recipientStates: IRecipientDeliveryState[];
     let bounceOperations: IBounceOperation[];
-    if (parsed.schemaVersion === 2) {
+    if (parsed.schemaVersion === 2 || parsed.schemaVersion === 3) {
       recipientStates = parsed.recipientStates.map((state: IStoredRecipientDeliveryState) => ({
         ...state,
         updatedAt: parseDate(state.updatedAt, 'recipient state updatedAt'),
@@ -1702,7 +2379,7 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       bounceOperations = [];
     }
 
-    return {
+    const item: IQueueItem = {
       id: parsed.id,
       ...(parsed.idempotencyKey !== undefined ? {
         idempotencyKey: parsed.idempotencyKey,
@@ -1710,6 +2387,12 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       } : {}),
       processingMode: parsed.processingMode,
       processingResult,
+      ...(parsed.schemaVersion === 3 ? {
+        messageFormat: 'raw-rfc822' as const,
+        rawMessageSha256: parsed.rawMessageSha256,
+        rawMessageLength: parsed.rawMessageLength,
+        smtpEnvelope: cloneRawSmtpEnvelope(smtpEnvelope!),
+      } : {}),
       attachmentCount: parsed.attachmentCount ?? processingResult.attachments.length,
       ...(parsed.route ? { route: parsed.route as IEmailRoute } : {}),
       status: parsed.status,
@@ -1738,24 +2421,27 @@ export class UnifiedDeliveryQueue extends EventEmitter {
           }))
         : [],
     } as IQueueItem;
+    return {
+      item,
+      ...(rawMessage ? { rawMessage } : {}),
+    };
   }
 
   private async loadFromStorage(): Promise<void> {
     const storageManager = this.options.storageManager;
     if (!storageManager) return;
-    const keys = (await storageManager.list(this.options.storagePrefix)).sort();
-    const recoveredItems: IQueueItem[] = [];
+    let recoveredItemCount = 0;
 
-    for (const key of keys) {
+    const loadKey = async (key: string): Promise<void> => {
       if (!key.startsWith(this.options.storagePrefix)) {
         throw new Error(`Blob storage returned a queue key outside ${this.options.storagePrefix}: ${key}`);
       }
-      if (!key.endsWith('.json')) continue;
+      if (!key.endsWith('.json')) return;
       const data = await storageManager.get(key);
       if (!data) {
         throw new Error(`Managed queue item disappeared while loading: ${key}`);
       }
-      const item = this.deserializeItem(key, data);
+      const { item, rawMessage } = this.deserializeItem(key, data);
       if (this.queue.has(item.id)) {
         throw new Error(`Duplicate managed queue item id: ${item.id}`);
       }
@@ -1767,16 +2453,53 @@ export class UnifiedDeliveryQueue extends EventEmitter {
         item.nextAttempt = new Date();
         item.updatedAt = new Date();
         item.lastError = 'Recovered after process restart during delivery';
-        recoveredItems.push(item);
+        await this.persistItem(item, rawMessage);
+        recoveredItemCount++;
       }
       this.queue.set(item.id, item);
+    };
+
+    if (storageManager.listPage) {
+      let continuationToken: string | undefined;
+      const seenTokens = new Set<string>();
+      do {
+        const page = await storageManager.listPage(this.options.storagePrefix, {
+          limit: SMARTMTA_STORAGE_LIST_PAGE_MAX_LIMIT,
+          ...(continuationToken ? { continuationToken } : {}),
+        });
+        if (
+          !page
+          || !Array.isArray(page.keys)
+          || page.keys.length > SMARTMTA_STORAGE_LIST_PAGE_MAX_LIMIT
+          || page.keys.some((key) => typeof key !== 'string')
+          || new Set(page.keys).size !== page.keys.length
+        ) {
+          throw new Error('Invalid paginated managed queue listing');
+        }
+        for (const key of [...page.keys].sort()) await loadKey(key);
+        if (page.continuationToken !== undefined) {
+          if (
+            typeof page.continuationToken !== 'string'
+            || !page.continuationToken
+            || page.keys.length === 0
+            || seenTokens.has(page.continuationToken)
+          ) {
+            throw new Error('Invalid paginated managed queue continuation token');
+          }
+          seenTokens.add(page.continuationToken);
+        }
+        continuationToken = page.continuationToken;
+      } while (continuationToken);
+    } else {
+      for (const key of (await storageManager.list(this.options.storagePrefix)).sort()) {
+        await loadKey(key);
+      }
     }
 
-    await Promise.all(recoveredItems.map((item) => this.persistItem(item)));
     this.updateStats();
     logger.log(
       'info',
-      `Loaded ${this.queue.size} items from managed blob storage; recovered ${recoveredItems.length} interrupted item(s)`,
+      `Loaded ${this.queue.size} items from managed blob storage; recovered ${recoveredItemCount} interrupted item(s)`,
     );
   }
 
@@ -1838,14 +2561,20 @@ export class UnifiedDeliveryQueue extends EventEmitter {
     this.stats.processingActive = this.processing;
     
     // Emit statistics event
-    void emitSafely(this, 'statsUpdated', this.stats);
+    void emitSafely(this, 'statsUpdated', this.getStats());
   }
   
   /**
    * Get queue statistics
    */
   public getStats(): IQueueStats {
-    return { ...this.stats };
+    return {
+      ...this.stats,
+      status: { ...this.stats.status },
+      modes: { ...this.stats.modes },
+      ...(this.stats.oldestItem ? { oldestItem: new Date(this.stats.oldestItem) } : {}),
+      ...(this.stats.newestItem ? { newestItem: new Date(this.stats.newestItem) } : {}),
+    };
   }
   
   /**
@@ -1867,6 +2596,8 @@ export class UnifiedDeliveryQueue extends EventEmitter {
     if (!this.processing) {
       this.startProcessing();
       logger.log('info', 'Queue processing resumed');
+    } else {
+      this.wake();
     }
   }
   
@@ -1908,20 +2639,47 @@ export class UnifiedDeliveryQueue extends EventEmitter {
   /**
    * Shutdown the queue
    */
-  public async shutdown(): Promise<void> {
-    if (this.lifecycleState === 'closed') return;
+  public shutdown(): Promise<void> {
+    if (this.shutdownFlight) return this.shutdownFlight;
+    if (this.lifecycleState === 'closed') return Promise.resolve();
+    this.acceptingNewItems = false;
+    this.acceptingMutations = false;
+    this.acceptingRawReservations = false;
+    this.shutdownFlight = this.shutdownOnce();
+    return this.shutdownFlight;
+  }
+
+  private async shutdownOnce(): Promise<void> {
     logger.log('info', 'Shutting down UnifiedDeliveryQueue');
-    this.lifecycleState = 'shutting-down';
     let persistenceError: unknown;
 
     try {
       // Stop processing (clears both check and cleanup timers).
       this.stopProcessing();
+      const activeScan = this.processingScanPromise;
+      if (activeScan) {
+        await activeScan;
+      }
+      await this.cleanupFlight;
+      while (this.enqueueFlights.size > 0) {
+        await Promise.allSettled([...this.enqueueFlights]);
+      }
+      while (this.itemMutationFlights.size > 0) {
+        await Promise.allSettled([...this.itemMutationFlights.values()]);
+      }
+      await this.waitForRawReservationsToDrain();
+      this.lifecycleState = 'shutting-down';
 
       if (this.options.storageManager) {
-        await Promise.all(
-          [...this.queue.values()].map((item) => this.persistItem(item)),
-        );
+        for (const itemId of [...this.queue.keys()]) {
+          await this.withItemMutex(itemId, async () => {
+            const currentItem = this.queue.get(itemId);
+            // Raw records are immutable single blobs and every transition is
+            // already persisted. Avoid rereading large payloads during shutdown.
+            if (!currentItem || currentItem.messageFormat === 'raw-rfc822') return;
+            await this.persistItem(currentItem);
+          });
+        }
       }
     } catch (error) {
       // Preserve the original persistence failure; observer diagnostics are
@@ -1933,7 +2691,9 @@ export class UnifiedDeliveryQueue extends EventEmitter {
       this.updateStats();
       await emitSafely(this, 'shutdown');
       this.lifecycleState = 'closed';
+      this.readyItemsHandler = undefined;
       this.releaseManagedPrefix();
+      this.removeAllListeners();
     }
 
     if (persistenceError) throw persistenceError;