@push.rocks/smartmta 6.5.2 → 8.0.0

package/dist_ts/mail/delivery/classes.delivery.queue.js

@@ -1,9 +1,29 @@
-import * as plugins from '../../plugins.js';
 import { EventEmitter } from 'node:events';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { deserialize, serialize } from 'node:v8';
 import { logger } from '../../logger.js';
 import {} from './interfaces.js';
+import { normalizeSmtpTranscript, SMTP_TRANSCRIPT_MAX_ENTRIES, SMTP_TRANSCRIPT_MAX_ENTRY_CODE_POINTS, SMTP_TRANSCRIPT_MAX_UTF8_BYTES, } from '../../security/classes.rustsecuritybridge.js';
+import { Email } from '../core/classes.email.js';
+import { emitSafely } from './functions.safe-observers.js';
+import { getErrorMessage } from '../../functions.errors.js';
+/**
+ * Queue statistics interface
+ */
+function normalizeStoragePrefix(prefixArg = '/email/queue/') {
+    if (!prefixArg.startsWith('/') ||
+        !prefixArg.endsWith('/') ||
+        prefixArg.includes('\\') ||
+        prefixArg.includes('\0')) {
+        throw new Error('Queue storagePrefix must be an absolute managed-storage prefix');
+    }
+    const segments = prefixArg.slice(1, -1).split('/');
+    if (segments.some((segment) => !segment || segment === '.' || segment === '..')) {
+        throw new Error('Queue storagePrefix contains an invalid path segment');
+    }
+    return prefixArg;
+}
+const managedQueueOwners = new WeakMap();
 /**
  * A unified queue for all email modes
  */
@@ -15,16 +35,24 @@ export class UnifiedDeliveryQueue extends EventEmitter {
     stats;
     processing = false;
     totalProcessed = 0;
+    ownsManagedPrefix = false;
+    lifecycleState = 'new';
     /**
      * Create a new unified delivery queue
      * @param options Queue options
      */
     constructor(options) {
         super();
-        // Set default options
+        if (options.storageMode === 'managed' && !options.storageManager) {
+            throw new Error('Managed queue storage requires an IBlobStorageManager');
+        }
+        if (options.storageMode === 'memory' && options.storageManager) {
+            throw new Error('Memory-only queue storage cannot receive an IBlobStorageManager');
+        }
         this.options = {
-            storageType: options.storageType || 'memory',
-            persistentPath: options.persistentPath || path.join(process.cwd(), 'email-queue'),
+            storageMode: options.storageMode,
+            storageManager: options.storageManager,
+            storagePrefix: normalizeStoragePrefix(options.storagePrefix),
             checkInterval: options.checkInterval || 30000, // 30 seconds
             maxQueueSize: options.maxQueueSize || 10000,
             maxPerDestination: options.maxPerDestination || 100,
@@ -52,27 +80,90 @@ export class UnifiedDeliveryQueue extends EventEmitter {
             processingActive: false
         };
     }
+    assertMutable() {
+        if (this.lifecycleState === 'shutting-down' || this.lifecycleState === 'closed') {
+            throw new Error(`Delivery queue is ${this.lifecycleState}; mutations are no longer allowed`);
+        }
+    }
+    createInitialRecipientStates(email) {
+        const byRecipient = new Map();
+        const now = new Date();
+        for (const recipient of email.getAllRecipients()) {
+            const normalizedRecipient = recipient.trim().toLowerCase();
+            if (!normalizedRecipient || byRecipient.has(normalizedRecipient))
+                continue;
+            byRecipient.set(normalizedRecipient, {
+                recipient,
+                normalizedRecipient,
+                state: 'unresolved',
+                updatedAt: now,
+            });
+        }
+        return [...byRecipient.values()];
+    }
+    createBounceOperationId(itemId, normalizedRecipient) {
+        return createHash('sha256')
+            .update(itemId)
+            .update('\0')
+            .update(normalizedRecipient)
+            .update('\0smtpFailure')
+            .digest('hex');
+    }
     /**
      * Initialize the queue
      */
-    async initialize() {
+    claimManagedPrefix() {
+        const storageManager = this.options.storageManager;
+        if (!storageManager || this.ownsManagedPrefix)
+            return;
+        let owners = managedQueueOwners.get(storageManager);
+        if (!owners) {
+            owners = new Map();
+            managedQueueOwners.set(storageManager, owners);
+        }
+        const existingOwner = owners.get(this.options.storagePrefix);
+        if (existingOwner && existingOwner !== this) {
+            throw new Error(`Managed queue prefix ${this.options.storagePrefix} already has an active delivery owner`);
+        }
+        owners.set(this.options.storagePrefix, this);
+        this.ownsManagedPrefix = true;
+    }
+    releaseManagedPrefix() {
+        const storageManager = this.options.storageManager;
+        if (!storageManager || !this.ownsManagedPrefix)
+            return;
+        const owners = managedQueueOwners.get(storageManager);
+        if (owners?.get(this.options.storagePrefix) === this) {
+            owners.delete(this.options.storagePrefix);
+            if (owners.size === 0)
+                managedQueueOwners.delete(storageManager);
+        }
+        this.ownsManagedPrefix = false;
+    }
+    async initialize(optionsArg = {}) {
         logger.log('info', 'Initializing UnifiedDeliveryQueue');
+        if (this.lifecycleState !== 'new') {
+            throw new Error(`Delivery queue cannot initialize from ${this.lifecycleState} state`);
+        }
+        this.claimManagedPrefix();
         try {
-            // Create persistent storage directory if using disk storage
-            if (this.options.storageType === 'disk') {
-                if (!fs.existsSync(this.options.persistentPath)) {
-                    fs.mkdirSync(this.options.persistentPath, { recursive: true });
-                }
-                // Load existing items from disk
-                await this.loadFromDisk();
+            if (this.options.storageManager) {
+                await this.loadFromStorage();
+            }
+            this.lifecycleState = 'initialized';
+            // Embedders may hydrate durable state before delivery dependencies are ready.
+            if (optionsArg.startProcessing !== false) {
+                this.startProcessing();
             }
-            // Start the queue processing timer
-            this.startProcessing();
             // Emit initialized event
-            this.emit('initialized');
+            await emitSafely(this, 'initialized');
             logger.log('info', 'UnifiedDeliveryQueue initialized successfully');
         }
         catch (error) {
+            this.queue.clear();
+            this.updateStats();
+            this.lifecycleState = 'new';
+            this.releaseManagedPrefix();
             logger.log('error', `Failed to initialize queue: ${error.message}`);
             throw error;
         }
@@ -96,7 +187,7 @@ export class UnifiedDeliveryQueue extends EventEmitter {
         }, 30 * 60 * 1000);
         this.processing = true;
         this.stats.processingActive = true;
-        this.emit('processingStarted');
+        void emitSafely(this, 'processingStarted');
         logger.log('info', 'Queue processing started');
     }
     /**
@@ -113,7 +204,7 @@ export class UnifiedDeliveryQueue extends EventEmitter {
         }
         this.processing = false;
         this.stats.processingActive = false;
-        this.emit('processingStopped');
+        void emitSafely(this, 'processingStopped');
         logger.log('info', 'Queue processing stopped');
     }
     /**
@@ -135,14 +226,14 @@ export class UnifiedDeliveryQueue extends EventEmitter {
             // Sort by oldest first
             readyItems.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
             // Emit event for ready items
-            this.emit('itemsReady', readyItems);
+            await emitSafely(this, 'itemsReady', readyItems);
             logger.log('info', `Found ${readyItems.length} items ready for processing`);
             // Update statistics
             this.updateStats();
         }
         catch (error) {
-            logger.log('error', `Error processing queue: ${error.message}`);
-            this.emit('error', error);
+            logger.log('error', `Error processing queue: ${getErrorMessage(error)}`);
+            await emitSafely(this, 'error', error);
         }
     }
     /**
@@ -152,6 +243,10 @@ export class UnifiedDeliveryQueue extends EventEmitter {
      * @param route Email route
      */
     async enqueue(processingResult, mode, route) {
+        this.assertMutable();
+        if (!(processingResult instanceof Email)) {
+            throw new Error('Queue processingResult must be an Email instance');
+        }
         // Check if queue is full
         if (this.queue.size >= this.options.maxQueueSize) {
             throw new Error('Queue is full');
@@ -168,18 +263,20 @@ export class UnifiedDeliveryQueue extends EventEmitter {
             attempts: 0,
             nextAttempt: new Date(),
             createdAt: new Date(),
-            updatedAt: new Date()
+            updatedAt: new Date(),
+            deliveredRecipients: [],
+            terminalRecipients: [],
+            recipientStates: this.createInitialRecipientStates(processingResult),
+            bounceOperations: [],
+            smtpTransactions: [],
         };
-        // Add to queue
+        // Commit durable state before exposing the item in memory or emitting acceptance.
+        await this.persistItem(item);
         this.queue.set(id, item);
-        // Persist to disk if using disk storage
-        if (this.options.storageType === 'disk') {
-            await this.persistItem(item);
-        }
         // Update statistics
         this.updateStats();
         // Emit event
-        this.emit('itemEnqueued', item);
+        await emitSafely(this, 'itemEnqueued', item);
         logger.log('info', `Item enqueued with ID ${id}, mode: ${mode}`);
         return id;
     }
@@ -191,29 +288,41 @@ export class UnifiedDeliveryQueue extends EventEmitter {
         return this.queue.get(id);
     }
     listItems() {
-        return Array.from(this.queue.values()).map((item) => ({ ...item }));
+        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 })),
+            })),
+        }));
     }
     /**
      * Mark an item as being processed
      * @param id Item ID
      */
     async markProcessing(id) {
+        this.assertMutable();
         const item = this.queue.get(id);
-        if (!item) {
+        if (!item
+            || !(item.status === 'pending'
+                || (item.status === 'deferred' && item.nextAttempt <= new Date()))) {
             return false;
         }
-        // Update status
-        item.status = 'processing';
-        item.attempts++;
-        item.updatedAt = new Date();
-        // Persist changes if using disk storage
-        if (this.options.storageType === 'disk') {
-            await this.persistItem(item);
-        }
+        await this.applyPersistedMutation(item, (updatedItem) => {
+            updatedItem.status = 'processing';
+            updatedItem.attempts++;
+            updatedItem.updatedAt = new Date();
+        });
         // Update statistics
         this.updateStats();
         // Emit event
-        this.emit('itemProcessing', item);
+        await emitSafely(this, 'itemProcessing', item);
         logger.log('info', `Item ${id} marked as processing, attempt ${item.attempts}`);
         return true;
     }
@@ -222,23 +331,21 @@ export class UnifiedDeliveryQueue extends EventEmitter {
      * @param id Item ID
      */
     async markDelivered(id) {
+        this.assertMutable();
         const item = this.queue.get(id);
-        if (!item) {
+        if (!item || item.status === 'delivered' || item.status === 'failed') {
             return false;
         }
-        // Update status
-        item.status = 'delivered';
-        item.updatedAt = new Date();
-        item.deliveredAt = new Date();
-        // Persist changes if using disk storage
-        if (this.options.storageType === 'disk') {
-            await this.persistItem(item);
-        }
+        await this.applyPersistedMutation(item, (updatedItem) => {
+            updatedItem.status = 'delivered';
+            updatedItem.updatedAt = new Date();
+            updatedItem.deliveredAt = new Date();
+        });
         // Update statistics
         this.totalProcessed++;
         this.updateStats();
         // Emit event
-        this.emit('itemDelivered', item);
+        await emitSafely(this, 'itemDelivered', item);
         logger.log('info', `Item ${id} marked as delivered after ${item.attempts} attempts`);
         return true;
     }
@@ -247,45 +354,227 @@ export class UnifiedDeliveryQueue extends EventEmitter {
      * @param id Item ID
      * @param error Error message
      */
-    async markFailed(id, error) {
+    async markFailed(id, error, optionsArg = {}) {
+        return (await this.markFailedWithTransition(id, error, optionsArg)).updated;
+    }
+    /** Rich internal disposition used by the delivery system without breaking markFailed(). */
+    async markFailedWithTransition(id, error, optionsArg = {}) {
+        this.assertMutable();
         const item = this.queue.get(id);
         if (!item) {
-            return false;
+            return { updated: false, terminal: false };
+        }
+        if (item.status === 'delivered' || item.status === 'failed') {
+            return {
+                updated: false,
+                status: item.status === 'failed' ? 'failed' : undefined,
+                terminal: true,
+            };
         }
         // Determine if we should retry
-        if (item.attempts < this.options.maxRetries) {
+        const retryable = optionsArg.retryable !== false;
+        if (retryable && item.attempts < this.options.maxRetries) {
             // Calculate next retry time with exponential backoff
             const delay = Math.min(this.options.baseRetryDelay * Math.pow(2, item.attempts - 1), this.options.maxRetryDelay);
-            // Update status
-            item.status = 'deferred';
-            item.lastError = error;
-            item.nextAttempt = new Date(Date.now() + delay);
-            item.updatedAt = new Date();
-            // Persist changes if using disk storage
-            if (this.options.storageType === 'disk') {
-                await this.persistItem(item);
-            }
+            await this.applyPersistedMutation(item, (updatedItem) => {
+                updatedItem.status = 'deferred';
+                updatedItem.lastError = error;
+                updatedItem.nextAttempt = new Date(Date.now() + delay);
+                updatedItem.updatedAt = new Date();
+            });
             // Emit event
-            this.emit('itemDeferred', item);
+            await emitSafely(this, '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
-            item.status = 'failed';
-            item.lastError = error;
-            item.updatedAt = new Date();
-            // Persist changes if using disk storage
-            if (this.options.storageType === 'disk') {
-                await this.persistItem(item);
-            }
+            await this.applyPersistedMutation(item, (updatedItem) => {
+                updatedItem.status = 'failed';
+                updatedItem.lastError = error;
+                updatedItem.updatedAt = new Date();
+            });
             // Update statistics
             this.totalProcessed++;
             // Emit event
-            this.emit('itemFailed', item);
+            await emitSafely(this, 'itemFailed', item);
             logger.log('warn', `Item ${id} permanently failed after ${item.attempts} attempts, error: ${error}`);
         }
-        // Update statistics
         this.updateStats();
+        return {
+            updated: true,
+            status: 'failed',
+            terminal: true,
+            terminalReason: retryable ? 'retry_exhausted' : 'permanent',
+        };
+    }
+    /** Persist a completed SMTP attempt before any queue status event is emitted. */
+    async appendSmtpTransaction(id, transaction) {
+        this.assertMutable();
+        const item = this.queue.get(id);
+        if (!item)
+            return false;
+        const normalizedTransaction = {
+            ...transaction,
+            queueItemId: id,
+            recipients: [...transaction.recipients],
+            recipientResults: transaction.recipientResults?.map((result) => ({ ...result })),
+            transcript: normalizeSmtpTranscript(transaction.transcript),
+        };
+        await this.applyPersistedMutation(item, (updatedItem) => {
+            updatedItem.smtpTransactions = [
+                ...(updatedItem.smtpTransactions || []),
+                normalizedTransaction,
+            ].slice(-20);
+            updatedItem.updatedAt = new Date();
+        });
+        await emitSafely(this, 'smtpTransaction', item, normalizedTransaction);
+        return true;
+    }
+    /** Record recipients accepted after the SMTP final-response 250 checkpoint. */
+    async markRecipientsDelivered(id, recipients) {
+        this.assertMutable();
+        const item = this.queue.get(id);
+        if (!item)
+            return false;
+        const normalizedRecipients = new Set(recipients.map((recipient) => recipient.trim().toLowerCase()).filter(Boolean));
+        if (normalizedRecipients.size === 0)
+            return false;
+        await this.applyPersistedMutation(item, (updatedItem) => {
+            const states = updatedItem.recipientStates || this.createInitialRecipientStates(updatedItem.processingResult);
+            const delivered = new Set(updatedItem.deliveredRecipients || []);
+            const now = new Date();
+            for (const state of states) {
+                if (normalizedRecipients.has(state.normalizedRecipient)
+                    && state.state === 'unresolved') {
+                    state.state = 'delivered';
+                    state.updatedAt = now;
+                    delete state.smtpCode;
+                    delete state.smtpResponse;
+                    delivered.add(state.normalizedRecipient);
+                }
+            }
+            updatedItem.recipientStates = states;
+            updatedItem.deliveredRecipients = [...delivered];
+            updatedItem.updatedAt = now;
+        });
+        return true;
+    }
+    /**
+     * Atomically checkpoint permanent recipient failures together with their
+     * durable bounce work. This is the sole 5xx recipient transition.
+     */
+    async markRecipientsTerminal(id, failures) {
+        this.assertMutable();
+        const item = this.queue.get(id);
+        if (!item || failures.length === 0)
+            return [];
+        const normalizedFailures = failures.map((failure) => (typeof failure === 'string'
+            ? {
+                recipient: failure,
+                smtpCode: 550,
+                smtpResponse: 'SMTP recipient permanently rejected',
+            }
+            : failure));
+        const newlyTerminal = [];
+        await this.applyPersistedMutation(item, (updatedItem) => {
+            const states = updatedItem.recipientStates || this.createInitialRecipientStates(updatedItem.processingResult);
+            const terminal = new Set(updatedItem.terminalRecipients || []);
+            const operations = updatedItem.bounceOperations || [];
+            const operationIds = new Set(operations.map((operation) => operation.operationId));
+            const now = new Date();
+            for (const failure of normalizedFailures) {
+                const normalizedRecipient = failure.recipient.trim().toLowerCase();
+                const state = states.find((candidate) => candidate.normalizedRecipient === normalizedRecipient);
+                if (!state || state.state !== 'unresolved')
+                    continue;
+                state.state = 'permanentFailure';
+                state.smtpCode = failure.smtpCode;
+                state.smtpResponse = failure.smtpResponse;
+                state.updatedAt = now;
+                terminal.add(normalizedRecipient);
+                newlyTerminal.push(state.recipient);
+                const operationId = this.createBounceOperationId(updatedItem.id, normalizedRecipient);
+                if (!operationIds.has(operationId)) {
+                    operations.push({
+                        operationId,
+                        kind: 'smtpFailure',
+                        recipient: state.recipient,
+                        normalizedRecipient,
+                        smtpCode: failure.smtpCode,
+                        smtpResponse: failure.smtpResponse,
+                        state: 'pending',
+                        attempts: 0,
+                        nextAttempt: now,
+                    });
+                    operationIds.add(operationId);
+                }
+            }
+            updatedItem.recipientStates = states;
+            updatedItem.terminalRecipients = [...terminal];
+            updatedItem.bounceOperations = operations;
+            updatedItem.updatedAt = now;
+        });
+        return newlyTerminal;
+    }
+    getRecipientDisposition(id) {
+        const item = this.queue.get(id);
+        if (!item)
+            return { unresolved: [], delivered: [], permanentFailures: [] };
+        const states = item.recipientStates || this.createInitialRecipientStates(item.processingResult);
+        return {
+            unresolved: states.filter((state) => state.state === 'unresolved').map((state) => state.recipient),
+            delivered: states.filter((state) => state.state === 'delivered').map((state) => state.recipient),
+            permanentFailures: states
+                .filter((state) => state.state === 'permanentFailure')
+                .map((state) => state.recipient),
+        };
+    }
+    /** Includes terminal queue items because bounce work outlives delivery status. */
+    listPendingBounceOperations(now = new Date()) {
+        const result = [];
+        for (const item of this.queue.values()) {
+            for (const operation of item.bounceOperations || []) {
+                if (operation.state === 'pending' && operation.nextAttempt <= now) {
+                    result.push({ itemId: item.id, operation: { ...operation } });
+                }
+            }
+        }
+        return result;
+    }
+    async markBounceOperationCompleted(itemId, operationId) {
+        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) => {
+            const updatedOperation = updatedItem.bounceOperations?.find((candidate) => candidate.operationId === operationId);
+            if (!updatedOperation)
+                return;
+            updatedOperation.state = 'completed';
+            updatedOperation.completedAt = new Date();
+            delete updatedOperation.lastError;
+            updatedItem.updatedAt = new Date();
+        });
+        return true;
+    }
+    async markBounceOperationFailed(itemId, operationId, error) {
+        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) => {
+            const updatedOperation = updatedItem.bounceOperations?.find((candidate) => candidate.operationId === operationId);
+            if (!updatedOperation)
+                return;
+            updatedOperation.attempts++;
+            updatedOperation.lastError = error;
+            updatedOperation.nextAttempt = new Date(Date.now() + Math.min(60_000 * (2 ** Math.max(0, updatedOperation.attempts - 1)), 3_600_000));
+            updatedItem.updatedAt = new Date();
+        });
         return true;
     }
     /**
@@ -293,92 +582,375 @@ export class UnifiedDeliveryQueue extends EventEmitter {
      * @param id Item ID
      */
     async removeItem(id) {
+        this.assertMutable();
         const item = this.queue.get(id);
         if (!item) {
             return false;
         }
-        // Remove from queue
+        // Delete durable state before making the removal visible in memory.
+        await this.removeItemFromStorage(id);
         this.queue.delete(id);
-        // Remove from disk if using disk storage
-        if (this.options.storageType === 'disk') {
-            await this.removeItemFromDisk(id);
-        }
         // Update statistics
         this.updateStats();
         // Emit event
-        this.emit('itemRemoved', item);
+        await emitSafely(this, 'itemRemoved', item);
         logger.log('info', `Item ${id} removed from queue`);
         return true;
     }
-    /**
-     * Persist an item to disk
-     * @param item Item to persist
-     */
+    storageKey(id) {
+        return `${this.options.storagePrefix}${id}.json`;
+    }
     async persistItem(item) {
+        if (!this.options.storageManager)
+            return;
+        await this.options.storageManager.set(this.storageKey(item.id), serialize(this.serializeItem(item)));
+    }
+    serializeItem(item) {
+        return {
+            schemaVersion: 2,
+            id: item.id,
+            processingMode: item.processingMode,
+            processingResult: {
+                options: item.processingResult.toEmailOptions(),
+                messageId: item.processingResult.getMessageId(),
+                envelopeFrom: item.processingResult.getEnvelopeFrom(),
+            },
+            ...(item.route ? { route: item.route } : {}),
+            status: item.status,
+            attempts: item.attempts,
+            nextAttempt: item.nextAttempt.getTime(),
+            ...(item.lastError !== undefined ? { lastError: item.lastError } : {}),
+            createdAt: item.createdAt.getTime(),
+            updatedAt: item.updatedAt.getTime(),
+            ...(item.deliveredAt ? { deliveredAt: item.deliveredAt.getTime() } : {}),
+            deliveredRecipients: item.deliveredRecipients || [],
+            terminalRecipients: item.terminalRecipients || [],
+            recipientStates: (item.recipientStates || this.createInitialRecipientStates(item.processingResult)).map((state) => ({
+                ...state,
+                updatedAt: state.updatedAt.getTime(),
+            })),
+            bounceOperations: (item.bounceOperations || []).map((operation) => {
+                const { nextAttempt, completedAt, ...storedOperation } = operation;
+                return {
+                    ...storedOperation,
+                    nextAttempt: nextAttempt.getTime(),
+                    ...(completedAt ? { completedAt: completedAt.getTime() } : {}),
+                };
+            }),
+            smtpTransactions: (item.smtpTransactions || []).slice(-20).map((transaction) => ({
+                ...transaction,
+                queueItemId: item.id,
+                recipients: [...transaction.recipients],
+                recipientResults: transaction.recipientResults?.map((result) => ({ ...result })),
+                transcript: normalizeSmtpTranscript(transaction.transcript),
+            })),
+        };
+    }
+    async applyPersistedMutation(item, mutation) {
+        this.assertMutable();
+        const updatedItem = {
+            ...item,
+            deliveredRecipients: [...(item.deliveredRecipients || [])],
+            terminalRecipients: [...(item.terminalRecipients || [])],
+            recipientStates: (item.recipientStates || []).map((state) => ({ ...state })),
+            bounceOperations: (item.bounceOperations || []).map((operation) => ({ ...operation })),
+            smtpTransactions: [...(item.smtpTransactions || [])],
+        };
+        mutation(updatedItem);
+        await this.persistItem(updatedItem);
+        Object.assign(item, updatedItem);
+    }
+    async removeItemFromStorage(id) {
+        await this.options.storageManager?.delete(this.storageKey(id));
+    }
+    deserializeItem(key, data) {
+        let parsed;
         try {
-            const filePath = path.join(this.options.persistentPath, `${item.id}.json`);
-            await fs.promises.writeFile(filePath, JSON.stringify(item, null, 2), 'utf8');
+            parsed = deserialize(data);
         }
         catch (error) {
-            logger.log('error', `Failed to persist item ${item.id}: ${error.message}`);
-            this.emit('error', error);
+            throw new Error(`Invalid managed queue item at ${key}: ${getErrorMessage(error)}`);
         }
-    }
-    /**
-     * Remove an item from disk
-     * @param id Item ID
-     */
-    async removeItemFromDisk(id) {
-        try {
-            const filePath = path.join(this.options.persistentPath, `${id}.json`);
-            if (fs.existsSync(filePath)) {
-                await fs.promises.unlink(filePath);
+        if (!parsed || typeof parsed !== 'object' || typeof parsed.id !== 'string' || !parsed.id) {
+            throw new Error(`Invalid managed queue item at ${key}: missing id`);
+        }
+        if (parsed.schemaVersion !== 1 && parsed.schemaVersion !== 2) {
+            throw new Error(`Invalid managed queue item at ${key}: unsupported schema version`);
+        }
+        if (this.storageKey(parsed.id) !== key) {
+            throw new Error(`Invalid managed queue item at ${key}: id does not match object key`);
+        }
+        if (!['pending', 'processing', 'delivered', 'failed', 'deferred'].includes(parsed.status)) {
+            throw new Error(`Invalid managed queue item at ${key}: unsupported status`);
+        }
+        if (!['forward', 'mta', 'process'].includes(parsed.processingMode)) {
+            throw new Error(`Invalid managed queue item at ${key}: unsupported processing mode`);
+        }
+        if (!Number.isInteger(parsed.attempts) || parsed.attempts < 0) {
+            throw new Error(`Invalid managed queue item at ${key}: invalid attempt count`);
+        }
+        if (parsed.deliveredRecipients !== undefined
+            && (!Array.isArray(parsed.deliveredRecipients)
+                || parsed.deliveredRecipients.some((value) => typeof value !== 'string'))) {
+            throw new Error(`Invalid managed queue item at ${key}: invalid delivered recipients`);
+        }
+        if (parsed.terminalRecipients !== undefined
+            && (!Array.isArray(parsed.terminalRecipients)
+                || parsed.terminalRecipients.some((value) => typeof value !== 'string'))) {
+            throw new Error(`Invalid managed queue item at ${key}: invalid terminal recipients`);
+        }
+        if (parsed.schemaVersion === 2) {
+            if (!Array.isArray(parsed.recipientStates)
+                || parsed.recipientStates.some((value) => {
+                    if (!value || typeof value !== 'object')
+                        return true;
+                    const state = value;
+                    return !(typeof state.recipient === 'string'
+                        && typeof state.normalizedRecipient === 'string'
+                        && state.normalizedRecipient === state.recipient.trim().toLowerCase()
+                        && ['unresolved', 'delivered', 'permanentFailure'].includes(state.state)
+                        && Number.isFinite(state.updatedAt)
+                        && (state.smtpCode === undefined || Number.isInteger(state.smtpCode))
+                        && (state.smtpResponse === undefined || typeof state.smtpResponse === 'string'));
+                })) {
+                throw new Error(`Invalid managed queue item at ${key}: invalid recipient states`);
+            }
+            if (!Array.isArray(parsed.bounceOperations)
+                || parsed.bounceOperations.some((value) => {
+                    if (!value || typeof value !== 'object')
+                        return true;
+                    const operation = value;
+                    return !(typeof operation.operationId === 'string'
+                        && operation.operationId.length > 0
+                        && operation.kind === 'smtpFailure'
+                        && typeof operation.recipient === 'string'
+                        && typeof operation.normalizedRecipient === 'string'
+                        && operation.normalizedRecipient === operation.recipient.trim().toLowerCase()
+                        && Number.isInteger(operation.smtpCode)
+                        && operation.smtpCode >= 500
+                        && typeof operation.smtpResponse === 'string'
+                        && ['pending', 'completed'].includes(operation.state)
+                        && Number.isInteger(operation.attempts)
+                        && operation.attempts >= 0
+                        && Number.isFinite(operation.nextAttempt)
+                        && (operation.lastError === undefined || typeof operation.lastError === 'string')
+                        && (operation.completedAt === undefined || Number.isFinite(operation.completedAt)));
+                })) {
+                throw new Error(`Invalid managed queue item at ${key}: invalid bounce operations`);
             }
         }
-        catch (error) {
-            logger.log('error', `Failed to remove item ${id} from disk: ${error.message}`);
-            this.emit('error', error);
+        const deliveryPhases = new Set([
+            'connect',
+            'greeting',
+            'ehlo',
+            'starttls',
+            'tls_handshake',
+            'post_tls_ehlo',
+            'auth',
+            'mail_from',
+            'rcpt_to',
+            'data_command',
+            'message_body',
+            'final_response',
+            'rset',
+            'quit',
+            'unknown',
+        ]);
+        const isValidTimestamp = (value) => (typeof value === 'string' && Number.isFinite(Date.parse(value)));
+        const isValidTranscriptEntry = (value) => {
+            if (!value || typeof value !== 'object')
+                return false;
+            const entry = value;
+            return (typeof entry.timestampMs === 'number'
+                && Number.isFinite(entry.timestampMs)
+                && deliveryPhases.has(entry.phase)
+                && ['client', 'server', 'system'].includes(entry.direction)
+                && typeof entry.text === 'string'
+                && [...entry.text].length <= SMTP_TRANSCRIPT_MAX_ENTRY_CODE_POINTS
+                && (entry.responseCode === undefined
+                    || (Number.isInteger(entry.responseCode) && entry.responseCode >= 100)));
+        };
+        const isValidTransaction = (value) => {
+            if (!value || typeof value !== 'object')
+                return false;
+            const transaction = value;
+            return (typeof transaction.id === 'string'
+                && transaction.id.length > 0
+                && transaction.queueItemId === parsed.id
+                && Number.isInteger(transaction.queueAttempt)
+                && transaction.queueAttempt >= 0
+                && typeof transaction.targetHost === 'string'
+                && transaction.targetHost.length > 0
+                && Number.isInteger(transaction.targetPort)
+                && transaction.targetPort >= 1
+                && transaction.targetPort <= 65_535
+                && (transaction.recipientDomain === undefined
+                    || typeof transaction.recipientDomain === 'string')
+                && Array.isArray(transaction.recipients)
+                && transaction.recipients.every((recipient) => typeof recipient === 'string')
+                && isValidTimestamp(transaction.startedAt)
+                && isValidTimestamp(transaction.completedAt)
+                && typeof transaction.durationMs === 'number'
+                && Number.isFinite(transaction.durationMs)
+                && transaction.durationMs >= 0
+                && ['succeeded', 'failed'].includes(transaction.outcome)
+                && typeof transaction.retryable === 'boolean'
+                && (transaction.errorType === undefined || typeof transaction.errorType === 'string')
+                && (transaction.smtpCode === undefined || Number.isInteger(transaction.smtpCode))
+                && (transaction.recipientResults === undefined
+                    || (Array.isArray(transaction.recipientResults)
+                        && transaction.recipientResults.every((value) => {
+                            if (!value || typeof value !== 'object')
+                                return false;
+                            const result = value;
+                            return (typeof result.recipient === 'string'
+                                && typeof result.accepted === 'boolean'
+                                && Number.isInteger(result.responseCode));
+                        })))
+                && (transaction.failurePhase === undefined || deliveryPhases.has(transaction.failurePhase))
+                && (transaction.error === undefined || typeof transaction.error === 'string')
+                && Array.isArray(transaction.transcript)
+                && transaction.transcript.length <= SMTP_TRANSCRIPT_MAX_ENTRIES
+                && transaction.transcript.every(isValidTranscriptEntry)
+                && transaction.transcript.reduce((sum, entry) => sum + Buffer.byteLength(entry.text, 'utf8'), 0) <= SMTP_TRANSCRIPT_MAX_UTF8_BYTES);
+        };
+        if (parsed.smtpTransactions !== undefined
+            && (!Array.isArray(parsed.smtpTransactions)
+                || parsed.smtpTransactions.length > 20
+                || parsed.smtpTransactions.some((value) => !isValidTransaction(value)))) {
+            throw new Error(`Invalid managed queue item at ${key}: invalid SMTP transactions`);
         }
-    }
-    /**
-     * Load queue items from disk
-     */
-    async loadFromDisk() {
-        try {
-            // Check if directory exists
-            if (!fs.existsSync(this.options.persistentPath)) {
-                return;
+        const parseDate = (value, field) => {
+            if (!Number.isFinite(value) || value < 0) {
+                throw new Error(`Invalid managed queue item at ${key}: invalid ${field}`);
             }
-            // Get all JSON files
-            const files = fs.readdirSync(this.options.persistentPath).filter(file => file.endsWith('.json'));
-            // Load each file
-            for (const file of files) {
-                try {
-                    const filePath = path.join(this.options.persistentPath, file);
-                    const data = await fs.promises.readFile(filePath, 'utf8');
-                    const item = JSON.parse(data);
-                    // Convert date strings to Date objects
-                    item.createdAt = new Date(item.createdAt);
-                    item.updatedAt = new Date(item.updatedAt);
-                    item.nextAttempt = new Date(item.nextAttempt);
-                    if (item.deliveredAt) {
-                        item.deliveredAt = new Date(item.deliveredAt);
-                    }
-                    // Add to queue
-                    this.queue.set(item.id, item);
-                }
-                catch (error) {
-                    logger.log('error', `Failed to load item from ${file}: ${error.message}`);
+            return new Date(value);
+        };
+        if (!parsed.processingResult ||
+            typeof parsed.processingResult !== 'object' ||
+            !parsed.processingResult.options ||
+            typeof parsed.processingResult.options !== 'object' ||
+            typeof parsed.processingResult.messageId !== 'string' ||
+            !parsed.processingResult.messageId ||
+            typeof parsed.processingResult.envelopeFrom !== 'string') {
+            throw new Error(`Invalid managed queue item at ${key}: invalid email payload`);
+        }
+        const storedOptions = parsed.processingResult.options;
+        if (storedOptions.attachments !== undefined) {
+            if (!Array.isArray(storedOptions.attachments)) {
+                throw new Error(`Invalid managed queue item at ${key}: invalid attachments`);
+            }
+            for (const attachment of storedOptions.attachments) {
+                if (!attachment || typeof attachment !== 'object' || !Buffer.isBuffer(attachment.content)) {
+                    throw new Error(`Invalid managed queue item at ${key}: invalid attachment content`);
                 }
             }
-            // Update statistics
-            this.updateStats();
-            logger.log('info', `Loaded ${this.queue.size} items from disk`);
+        }
+        let processingResult;
+        try {
+            processingResult = new Email(storedOptions)
+                .setMessageId(parsed.processingResult.messageId)
+                .setEnvelopeFrom(parsed.processingResult.envelopeFrom);
         }
         catch (error) {
-            logger.log('error', `Failed to load items from disk: ${error.message}`);
-            throw error;
+            throw new Error(`Invalid managed queue item at ${key}: ${getErrorMessage(error)}`);
         }
+        let recipientStates;
+        let bounceOperations;
+        if (parsed.schemaVersion === 2) {
+            recipientStates = parsed.recipientStates.map((state) => ({
+                ...state,
+                updatedAt: parseDate(state.updatedAt, 'recipient state updatedAt'),
+            }));
+            bounceOperations = parsed.bounceOperations.map((operation) => ({
+                ...operation,
+                nextAttempt: parseDate(operation.nextAttempt, 'bounce operation nextAttempt'),
+                ...(operation.completedAt !== undefined
+                    ? { completedAt: parseDate(operation.completedAt, 'bounce operation completedAt') }
+                    : {}),
+            }));
+        }
+        else {
+            // V1 hydration deliberately starts with an empty outbox. Bounce work is
+            // never synthesized retroactively without a durable recipient transition.
+            recipientStates = this.createInitialRecipientStates(processingResult);
+            const delivered = new Set((parsed.deliveredRecipients || []).map((recipient) => recipient.toLowerCase()));
+            const terminal = new Set((parsed.terminalRecipients || []).map((recipient) => recipient.toLowerCase()));
+            for (const state of recipientStates) {
+                if (delivered.has(state.normalizedRecipient))
+                    state.state = 'delivered';
+                else if (terminal.has(state.normalizedRecipient))
+                    state.state = 'permanentFailure';
+            }
+            bounceOperations = [];
+        }
+        return {
+            id: parsed.id,
+            processingMode: parsed.processingMode,
+            processingResult,
+            ...(parsed.route ? { route: parsed.route } : {}),
+            status: parsed.status,
+            attempts: parsed.attempts,
+            ...(typeof parsed.lastError === 'string' ? { lastError: parsed.lastError } : {}),
+            createdAt: parseDate(parsed.createdAt, 'createdAt'),
+            updatedAt: parseDate(parsed.updatedAt, 'updatedAt'),
+            nextAttempt: parseDate(parsed.nextAttempt, 'nextAttempt'),
+            ...(parsed.deliveredAt
+                ? { deliveredAt: parseDate(parsed.deliveredAt, 'deliveredAt') }
+                : {}),
+            deliveredRecipients: Array.isArray(parsed.deliveredRecipients)
+                ? [...parsed.deliveredRecipients]
+                : [],
+            terminalRecipients: Array.isArray(parsed.terminalRecipients)
+                ? [...parsed.terminalRecipients]
+                : [],
+            recipientStates,
+            bounceOperations,
+            smtpTransactions: Array.isArray(parsed.smtpTransactions)
+                ? parsed.smtpTransactions.slice(-20).map((transaction) => ({
+                    ...transaction,
+                    recipients: [...transaction.recipients],
+                    recipientResults: transaction.recipientResults?.map((result) => ({ ...result })),
+                    transcript: normalizeSmtpTranscript(transaction.transcript),
+                }))
+                : [],
+        };
+    }
+    async loadFromStorage() {
+        const storageManager = this.options.storageManager;
+        if (!storageManager)
+            return;
+        const keys = (await storageManager.list(this.options.storagePrefix)).sort();
+        const recoveredItems = [];
+        for (const key of keys) {
+            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;
+            const data = await storageManager.get(key);
+            if (!data) {
+                throw new Error(`Managed queue item disappeared while loading: ${key}`);
+            }
+            const item = this.deserializeItem(key, data);
+            if (this.queue.has(item.id)) {
+                throw new Error(`Duplicate managed queue item id: ${item.id}`);
+            }
+            if (this.queue.size >= this.options.maxQueueSize) {
+                throw new Error(`Managed queue contains more than ${this.options.maxQueueSize} items`);
+            }
+            if (item.status === 'processing') {
+                item.status = 'deferred';
+                item.nextAttempt = new Date();
+                item.updatedAt = new Date();
+                item.lastError = 'Recovered after process restart during delivery';
+                recoveredItems.push(item);
+            }
+            this.queue.set(item.id, item);
+        }
+        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)`);
     }
     /**
      * Update queue statistics
@@ -428,7 +1000,7 @@ export class UnifiedDeliveryQueue extends EventEmitter {
         // Set processing active
         this.stats.processingActive = this.processing;
         // Emit statistics event
-        this.emit('statsUpdated', this.stats);
+        void emitSafely(this, 'statsUpdated', this.stats);
     }
     /**
      * Get queue statistics
@@ -440,6 +1012,7 @@ export class UnifiedDeliveryQueue extends EventEmitter {
      * Pause queue processing
      */
     pause() {
+        this.assertMutable();
         if (this.processing) {
             this.stopProcessing();
             logger.log('info', 'Queue processing paused');
@@ -449,6 +1022,7 @@ export class UnifiedDeliveryQueue extends EventEmitter {
      * Resume queue processing
      */
     resume() {
+        this.assertMutable();
         if (!this.processing) {
             this.startProcessing();
             logger.log('info', 'Queue processing resumed');
@@ -459,11 +1033,15 @@ export class UnifiedDeliveryQueue extends EventEmitter {
      * @param maxAge Maximum age in milliseconds (default: 7 days)
      */
     async cleanupOldItems(maxAge = 7 * 24 * 60 * 60 * 1000) {
+        this.assertMutable();
         const cutoff = new Date(Date.now() - maxAge);
         // Collect IDs first to avoid modifying the Map during iteration
         const idsToRemove = [];
         for (const item of this.queue.values()) {
-            if (['delivered', 'failed'].includes(item.status) && item.updatedAt < cutoff) {
+            const hasPendingBounceWork = (item.bounceOperations || []).some((operation) => operation.state !== 'completed');
+            if (['delivered', 'failed'].includes(item.status)
+                && item.updatedAt < cutoff
+                && !hasPendingBounceWork) {
                 idsToRemove.push(item.id);
             }
         }
@@ -480,25 +1058,34 @@ export class UnifiedDeliveryQueue extends EventEmitter {
      * Shutdown the queue
      */
     async shutdown() {
+        if (this.lifecycleState === 'closed')
+            return;
         logger.log('info', 'Shutting down UnifiedDeliveryQueue');
-        // Stop processing (clears both check and cleanup timers)
-        this.stopProcessing();
-        // If using disk storage, make sure all items are persisted
-        if (this.options.storageType === 'disk') {
-            const pendingWrites = [];
-            for (const item of this.queue.values()) {
-                pendingWrites.push(this.persistItem(item));
+        this.lifecycleState = 'shutting-down';
+        let persistenceError;
+        try {
+            // Stop processing (clears both check and cleanup timers).
+            this.stopProcessing();
+            if (this.options.storageManager) {
+                await Promise.all([...this.queue.values()].map((item) => this.persistItem(item)));
             }
-            // Wait for all writes to complete
-            await Promise.all(pendingWrites);
         }
-        // Clear the queue (memory only)
-        this.queue.clear();
-        // Update statistics
-        this.updateStats();
-        // Emit shutdown event
-        this.emit('shutdown');
+        catch (error) {
+            // Preserve the original persistence failure; observer diagnostics are
+            // isolated and can never replace it.
+            persistenceError = error;
+            logger.log('error', `Failed to persist delivery queue during shutdown: ${error.message}`);
+        }
+        finally {
+            this.queue.clear();
+            this.updateStats();
+            await emitSafely(this, 'shutdown');
+            this.lifecycleState = 'closed';
+            this.releaseManagedPrefix();
+        }
+        if (persistenceError)
+            throw persistenceError;
         logger.log('info', 'UnifiedDeliveryQueue shut down successfully');
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.delivery.queue.js","sourceRoot":"","sources":["../../../ts/mail/delivery/classes.delivery.queue.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.delivery.queue.js","sourceRoot":"","sources":["../../../ts/mail/delivery/classes.delivery.queue.ts"],"names":[],"mappings":"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"}