@push.rocks/smartmta 8.0.1 → 8.1.1

package/ts/mail/routing/classes.unified.email.server.ts

@@ -10,16 +10,34 @@ import {
 import { DKIMCreator } from '../security/classes.dkimcreator.js';
 import type { IStorageManager } from '../interfaces.storage.js';
 import { RustSecurityBridge } from '../../security/classes.rustsecuritybridge.js';
-import type { IEmailReceivedEvent, IRcptToRequestEvent, IAuthRequestEvent, IScramCredentialRequestEvent } from '../../security/classes.rustsecuritybridge.js';
+import type {
+  IAuthRequestEvent,
+  IEmailReceivedEvent,
+  IEmailSecurityResult,
+  IInboundEmailSecurityResult,
+  IRcptToRequestEvent,
+  IScramCredentialRequestEvent,
+} from '../../security/classes.rustsecuritybridge.js';
 import { EmailRouter } from './classes.email.router.js';
-import type { IEmailRoute, IEmailContext, IEmailDomainConfig } from './interfaces.js';
+import type {
+  IEmailRoute,
+  IEmailAction,
+  IEmailContext,
+  IEmailDomainConfig,
+} from './interfaces.js';
 import { Email } from '../core/classes.email.js';
 import { DomainRegistry } from './classes.domain.registry.js';
 import { DnsManager } from './classes.dns.manager.js';
 import { BounceManager, BounceType, BounceCategory } from '../core/classes.bouncemanager.js';
 import type { ISmtpSendResult, IOutboundEmail } from '../../security/classes.rustsecuritybridge.js';
 import { MultiModeDeliverySystem, type IDeliveryStats, type IMultiModeDeliveryOptions } from '../delivery/classes.delivery.system.js';
-import { UnifiedDeliveryQueue, type IQueueItem, type IQueueOptions, type IQueueStats } from '../delivery/classes.delivery.queue.js';
+import {
+  ACCEPTED_ENVELOPE_IDEMPOTENCY_RETENTION_MS,
+  UnifiedDeliveryQueue,
+  type IQueueItem,
+  type IQueueOptions,
+  type IQueueStats,
+} from '../delivery/classes.delivery.queue.js';
 import { UnifiedRateLimiter, type IHierarchicalRateLimits } from '../delivery/classes.unified.rate.limiter.js';
 import { SmtpState } from '../delivery/interfaces.js';
 import type { EmailProcessingMode, ISmtpSession as IBaseSmtpSession } from '../delivery/interfaces.js';
@@ -35,6 +53,41 @@ interface DcRouter {
   options?: any;
 }
 
+export type TRecipientRouteSource = 'explicit-route' | 'domain-policy' | 'no-route';
+export type TRecipientRejectionReason =
+  | 'explicit-route'
+  | 'domain-policy'
+  | 'no-route'
+  | 'domain-not-hosted'
+  | 'relay-denied'
+  | 'recipient-hook'
+  | 'policy-error';
+
+export interface IResolvedRecipientRoute {
+  recipient: string;
+  localDomain: string | null;
+  route: IEmailRoute | null;
+  source: TRecipientRouteSource;
+}
+
+export interface IRecipientRejectedEvent {
+  timestamp: string;
+  sender: string;
+  recipient: string;
+  localDomain: string | null;
+  remoteAddress: string;
+  smtpCode: number;
+  smtpMessage: string;
+  routeName: string | null;
+  reason: TRecipientRejectionReason;
+}
+
+interface IRecipientPolicyResolution extends IResolvedRecipientRoute {
+  decision: ISmtpDecision;
+  rejectionReason?: TRecipientRejectionReason;
+  policyRouteName?: string;
+}
+
 /**
  * Extended SMTP session interface with route information
  */
@@ -43,6 +96,10 @@ export interface IExtendedSmtpSession extends ISmtpSession {
    * Matched route for this session
    */
   matchedRoute?: IEmailRoute;
+  /** Per-envelope-recipient routes resolved before DATA acceptance. */
+  resolvedRecipientRoutes?: IResolvedRecipientRoute[];
+  /** Results computed by the Rust inbound pipeline before the message event is emitted. */
+  securityResults?: IInboundEmailSecurityResult | null;
 }
 
 export interface ISmtpDecision {
@@ -68,9 +125,102 @@ export interface IMessageAcceptanceContext {
   email: Email;
   rawMessage: Buffer;
   session: IExtendedSmtpSession;
+  matchedRoute?: IEmailRoute;
+  /** Full-envelope route resolution. */
+  resolvedRecipientRoutes: IResolvedRecipientRoute[];
+  abortSignal?: AbortSignal;
+}
+
+/**
+ * Terminal durable acceptance context for an envelope containing at least one `store` route.
+ * The consumer owns persistence and all recipient fan-out before this hook resolves.
+ */
+export interface IAcceptEnvelopeContext {
+  email: Email;
+  /** Exact bytes received during SMTP DATA, before parsing or transformation. */
+  rawMessage: Buffer;
+  session: IExtendedSmtpSession;
+  envelope: {
+    mailFrom: string;
+    rcptTo: string[];
+  };
+  /** Complete resolved plan for every SMTP envelope recipient. */
+  resolvedRecipientRoutes: IResolvedRecipientRoute[];
   abortSignal?: AbortSignal;
+  /** Immutable attachment count derived from the parsed message. */
+  readonly attachmentCount: number;
+  /** Rust-computed inbound verdicts, available before durable acceptance. */
+  securityResults: IInboundEmailSecurityResult | null;
+}
+
+/**
+ * JSON-safe, immutable snapshot of one accepted envelope recipient's exact
+ * routing decision. The snapshot is safe to persist and replay without
+ * consulting the live route table.
+ */
+export interface IAcceptedEnvelopeRecipientPlan {
+  readonly recipient: string;
+  readonly localDomain: string | null;
+  readonly routeName: string;
+  readonly source: TRecipientRouteSource;
+  readonly action: IEmailAction;
+  readonly idempotencyKey: string;
 }
 
+/** Serializable SMTP metadata needed to recreate an isolated action session. */
+export interface IAcceptedEnvelopeDispatchMetadata {
+  readonly mailFrom: string;
+  readonly session?: {
+    readonly id?: string;
+    readonly remoteAddress?: string;
+    readonly clientHostname?: string;
+    readonly secure?: boolean;
+    readonly authenticated?: boolean;
+    readonly authenticatedUser?: string | null;
+    readonly user?: Readonly<{
+      username: string;
+      [key: string]: unknown;
+    }>;
+  };
+}
+
+export type TAcceptedEnvelopeRecipientDispatchStatus =
+  | 'stored'
+  | 'queued'
+  | 'rejected'
+  | 'failed';
+
+export interface IAcceptedEnvelopeRecipientDispatchResult {
+  recipient: string;
+  localDomain: string | null;
+  routeName: string;
+  source: TRecipientRouteSource;
+  actionType: IEmailAction['type'];
+  idempotencyKey: string;
+  status: TAcceptedEnvelopeRecipientDispatchStatus;
+  replayed: boolean;
+  queueId?: string;
+  smtpCode?: number;
+  message?: string;
+}
+
+export interface IAcceptedEnvelopeDispatchResult {
+  complete: boolean;
+  results: IAcceptedEnvelopeRecipientDispatchResult[];
+}
+
+interface IStoredAcceptedEnvelopeDispatchResult {
+  schemaVersion: 1;
+  fingerprint: string;
+  expiresAt: number;
+  result: Omit<IAcceptedEnvelopeRecipientDispatchResult, 'replayed'>;
+}
+
+const ACCEPTED_ENVELOPE_DISPATCH_STORAGE_PREFIX =
+  '/email/accepted-envelope-dispatch/v1/';
+const ACCEPTED_ENVELOPE_DISPATCH_CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
+const ACCEPTED_ENVELOPE_DISPATCH_CLEANUP_LIMIT = 256;
+
 export interface IMessageAcceptanceDecision extends ISmtpDecision {
   /** Continue SmartMTA's built-in route processing after the consumer accepted responsibility. */
   continueProcessing?: boolean;
@@ -95,6 +245,18 @@ export interface IOutboundConnectionProxy {
   close?: () => Promise<void> | void;
 }
 
+export interface IOutboundTopologyIdentity {
+  hostnames?: string[];
+  ipAddresses?: string[];
+}
+
+export interface ISelfMxIdentityMatch {
+  isSelf: boolean;
+  source: 'explicit' | 'dns-derived' | 'dynamic' | null;
+  indeterminate: boolean;
+  evidence: string[];
+}
+
 /**
  * Options for the unified email server
  */
@@ -159,10 +321,14 @@ export interface IUnifiedEmailServerOptions {
   };
 
   hooks?: {
-    /** Async recipient policy hook, called before each RCPT TO is accepted. */
+    /** Async recipient policy hook that may further restrict an accepted built-in decision. */
     onRcptTo?: (context: IRcptToPolicyContext) => Promise<ISmtpDecision>;
-    /** Async message acceptance hook, called after DATA before the final SMTP response. */
+    /** Async message acceptance hook for envelopes with no resolved `store` action. */
     onMessageData?: (context: IMessageAcceptanceContext) => Promise<IMessageAcceptanceDecision>;
+    /** Required terminal durable owner for any envelope containing a resolved `store` action. */
+    onAcceptEnvelope?: (context: IAcceptEnvelopeContext) => Promise<void>;
+    /** Observer-safe callback for SMTP recipient rejections. */
+    onRecipientRejected?: (event: IRecipientRejectedEvent) => Promise<void> | void;
   };
 
   // Global defaults for all domains
@@ -181,6 +347,10 @@ export interface IUnifiedEmailServerOptions {
     socketTimeout?: number;
     retryAttempts?: number;
     defaultFrom?: string;
+    /** Static public listener identities that must never be selected as outbound MX targets. */
+    selfListenerIdentities?: IOutboundTopologyIdentity;
+    /** Current proven mail-edge identities. Connection proxy targets are deliberately not identities. */
+    topologyIdentityProvider?: () => Promise<IOutboundTopologyIdentity | null | undefined>;
     connectionProxyProvider?: (context: IOutboundConnectionProxyContext) => Promise<IOutboundConnectionProxy | null | undefined>;
   };
 
@@ -268,6 +438,9 @@ export class UnifiedEmailServer extends EventEmitter {
   private bridgeEmailReceivedHandler?: (data: IEmailReceivedEvent) => void;
   private bridgeAuthRequestHandler?: (data: IAuthRequestEvent) => void;
   private bridgeScramCredentialRequestHandler?: (data: IScramCredentialRequestEvent) => void;
+  private acceptedEnvelopeDispatchCleanupTimer?: ReturnType<typeof setInterval>;
+  private acceptedEnvelopeDispatchCleanupPromise?: Promise<void>;
+  private acceptedEnvelopeDispatchCleanupCursor?: string;
 
   constructor(dcRouter: DcRouter, options: IUnifiedEmailServerOptions) {
     super();
@@ -390,6 +563,18 @@ export class UnifiedEmailServer extends EventEmitter {
     // We'll create the SMTP servers during the start() method
   }
 
+  public onRecipientRejected(
+    listener: (event: IRecipientRejectedEvent) => Promise<void> | void,
+  ): this {
+    return super.on('recipientRejected', listener);
+  }
+
+  public offRecipientRejected(
+    listener: (event: IRecipientRejectedEvent) => Promise<void> | void,
+  ): this {
+    return super.off('recipientRejected', listener);
+  }
+
   private getAdvertisedHostname(): string {
     return this.options.hostname;
   }
@@ -398,6 +583,120 @@ export class UnifiedEmailServer extends EventEmitter {
     return this.options.outbound?.hostname || this.options.hostname;
   }
 
+  private normalizeTopologyIdentity(valueArg: string): string {
+    const value = valueArg.trim().replace(/^\[|\]$/g, '').replace(/\.$/, '');
+    if (!value) return '';
+    if (plugins.net.isIP(value)) {
+      if (plugins.net.isIPv6(value)) {
+        try {
+          return new URL(`http://[${value}]/`).hostname.slice(1, -1).toLowerCase();
+        } catch {
+          return value.toLowerCase();
+        }
+      }
+      return value;
+    }
+    return plugins.url.domainToASCII(value).toLowerCase();
+  }
+
+  private getExplicitTopologyIdentity(): Required<IOutboundTopologyIdentity> {
+    const configured = this.options.outbound?.selfListenerIdentities;
+    return {
+      hostnames: [
+        this.options.hostname,
+        this.options.outbound?.hostname || '',
+        ...(configured?.hostnames || []),
+      ].map((value) => this.normalizeTopologyIdentity(value)).filter(Boolean),
+      ipAddresses: (configured?.ipAddresses || [])
+        .map((value) => this.normalizeTopologyIdentity(value))
+        .filter((value) => Boolean(plugins.net.isIP(value))),
+    };
+  }
+
+  private async withTopologyTimeout<T>(operation: Promise<T>): Promise<T> {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      return await Promise.race([
+        operation,
+        new Promise<T>((_resolve, reject) => {
+          timer = setTimeout(() => reject(new Error('self-MX DNS resolution timed out')), 3_000);
+        }),
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+
+  private async resolveTopologyHostname(hostnameArg: string): Promise<{
+    hostnames: Set<string>;
+    ipAddresses: Set<string>;
+    indeterminate: boolean;
+    evidence: string[];
+  }> {
+    const hostname = this.normalizeTopologyIdentity(hostnameArg);
+    const hostnames = new Set<string>();
+    const ipAddresses = new Set<string>();
+    const evidence: string[] = [];
+    if (!hostname) return { hostnames, ipAddresses, indeterminate: false, evidence };
+    if (plugins.net.isIP(hostname)) {
+      ipAddresses.add(hostname);
+      return { hostnames, ipAddresses, indeterminate: false, evidence };
+    }
+
+    const resolver = new plugins.dns.promises.Resolver();
+    const isAbsent = (errorArg: unknown): boolean => {
+      const code = (errorArg as NodeJS.ErrnoException)?.code;
+      return code === 'ENODATA' || code === 'ENOTFOUND';
+    };
+    let current = hostname;
+    let indeterminate = false;
+    for (let depth = 0; depth < 8; depth++) {
+      if (hostnames.has(current)) {
+        evidence.push(`CNAME loop at ${current}`);
+        indeterminate = true;
+        break;
+      }
+      hostnames.add(current);
+      let aliases: string[];
+      try {
+        aliases = await resolver.resolveCname(current);
+      } catch (error) {
+        if (!isAbsent(error)) {
+          evidence.push(`CNAME lookup failed for ${current}`);
+          indeterminate = true;
+        }
+        break;
+      }
+      const alias = this.normalizeTopologyIdentity(aliases[0] || '');
+      if (!alias) break;
+      evidence.push(`${current} CNAME ${alias}`);
+      current = alias;
+      if (depth === 7) {
+        evidence.push('CNAME chain exceeded 8 hops');
+        indeterminate = true;
+      }
+    }
+
+    const resolveAddresses = async (family: 4 | 6): Promise<{ addresses: string[]; indeterminate: boolean }> => {
+      try {
+        const values = family === 4 ? await resolver.resolve4(current) : await resolver.resolve6(current);
+        return { addresses: values, indeterminate: false };
+      } catch (error) {
+        return { addresses: [], indeterminate: !isAbsent(error) };
+      }
+    };
+    const [ipv4, ipv6] = await Promise.all([resolveAddresses(4), resolveAddresses(6)]);
+    for (const address of [...ipv4.addresses, ...ipv6.addresses]) {
+      const normalized = this.normalizeTopologyIdentity(address);
+      if (normalized) ipAddresses.add(normalized);
+    }
+    if (ipv4.indeterminate || ipv6.indeterminate) {
+      evidence.push(`address lookup failed for ${current}`);
+      indeterminate = true;
+    }
+    return { hostnames, ipAddresses, indeterminate, evidence };
+  }
+
   /**
    * Whether a hostname refers to this server's own SMTP identity.
    * Used by MTA delivery to refuse self-addressed relaying: a domain whose
@@ -405,13 +704,115 @@ export class UnifiedEmailServer extends EventEmitter {
    * full outbound/inbound pipeline forever.
    */
   public isSelfHostname(hostname: string): boolean {
-    const normalize = (name: string) => name.toLowerCase().replace(/\.$/, '');
-    const candidate = normalize(hostname);
+    const candidate = this.normalizeTopologyIdentity(hostname);
     if (!candidate) return false;
-    return (
-      candidate === normalize(this.options.hostname) ||
-      candidate === normalize(this.options.outbound?.hostname || '')
-    );
+    const explicit = this.getExplicitTopologyIdentity();
+    return explicit.hostnames.includes(candidate) || explicit.ipAddresses.includes(candidate);
+  }
+
+  /** Resolve a candidate MX against explicit and current proven listener topology. */
+  public async resolveSelfMxIdentity(hostnameArg: string): Promise<ISelfMxIdentityMatch> {
+    const candidate = this.normalizeTopologyIdentity(hostnameArg);
+    const evidence: string[] = [];
+    if (!candidate) {
+      return { isSelf: false, source: null, indeterminate: true, evidence: ['empty MX identity'] };
+    }
+
+    const explicit = this.getExplicitTopologyIdentity();
+    if (explicit.hostnames.includes(candidate) || explicit.ipAddresses.includes(candidate)) {
+      return { isSelf: true, source: 'explicit', indeterminate: false, evidence: [`exact identity ${candidate}`] };
+    }
+
+    let dynamic: Required<IOutboundTopologyIdentity> = { hostnames: [], ipAddresses: [] };
+    try {
+      const topologyIdentityProvider = this.options.outbound?.topologyIdentityProvider;
+      const provided = topologyIdentityProvider
+        ? await this.withTopologyTimeout(topologyIdentityProvider())
+        : undefined;
+      if (topologyIdentityProvider && provided == null) {
+        return {
+          isSelf: false,
+          source: null,
+          indeterminate: true,
+          evidence: ['dynamic topology identity provider returned no proof'],
+        };
+      }
+      dynamic = {
+        hostnames: (provided?.hostnames || [])
+          .map((value) => this.normalizeTopologyIdentity(value)).filter(Boolean),
+        ipAddresses: (provided?.ipAddresses || [])
+          .map((value) => this.normalizeTopologyIdentity(value))
+          .filter((value) => Boolean(plugins.net.isIP(value))),
+      };
+      if (
+        topologyIdentityProvider
+        && dynamic.hostnames.length === 0
+        && dynamic.ipAddresses.length === 0
+      ) {
+        return {
+          isSelf: false,
+          source: null,
+          indeterminate: true,
+          evidence: ['dynamic topology identity provider returned no valid proof'],
+        };
+      }
+    } catch {
+      return { isSelf: false, source: null, indeterminate: true, evidence: ['dynamic topology identity unavailable'] };
+    }
+    if (dynamic.hostnames.includes(candidate) || dynamic.ipAddresses.includes(candidate)) {
+      return { isSelf: true, source: 'dynamic', indeterminate: false, evidence: [`dynamic identity ${candidate}`] };
+    }
+
+    try {
+      const candidateResolution = await this.withTopologyTimeout(this.resolveTopologyHostname(candidate));
+      evidence.push(...candidateResolution.evidence);
+      const intersects = (left: Set<string>, right: Iterable<string>): string | undefined => {
+        for (const value of right) if (left.has(value)) return value;
+        return undefined;
+      };
+
+      const explicitHostname = intersects(candidateResolution.hostnames, explicit.hostnames);
+      const explicitIp = intersects(candidateResolution.ipAddresses, explicit.ipAddresses);
+      if (explicitHostname || explicitIp) {
+        evidence.push(`resolved to explicit identity ${explicitHostname || explicitIp}`);
+        return { isSelf: true, source: 'dns-derived', indeterminate: false, evidence };
+      }
+      const dynamicHostname = intersects(candidateResolution.hostnames, dynamic.hostnames);
+      const dynamicIp = intersects(candidateResolution.ipAddresses, dynamic.ipAddresses);
+      if (dynamicHostname || dynamicIp) {
+        evidence.push(`resolved to dynamic identity ${dynamicHostname || dynamicIp}`);
+        return { isSelf: true, source: 'dynamic', indeterminate: false, evidence };
+      }
+
+      const identities = [
+        ...explicit.hostnames.map((hostname) => ({ hostname, source: 'explicit' as const })),
+        ...dynamic.hostnames.map((hostname) => ({ hostname, source: 'dynamic' as const })),
+      ];
+      for (const identity of identities) {
+        const resolved = await this.withTopologyTimeout(this.resolveTopologyHostname(identity.hostname));
+        const matchedIp = intersects(candidateResolution.ipAddresses, resolved.ipAddresses);
+        if (matchedIp) {
+          evidence.push(`shares address ${matchedIp} with ${identity.hostname}`);
+          return {
+            isSelf: true,
+            source: identity.source === 'explicit' ? 'dns-derived' : 'dynamic',
+            indeterminate: false,
+            evidence,
+          };
+        }
+        if (resolved.indeterminate) {
+          evidence.push(...resolved.evidence);
+          return { isSelf: false, source: null, indeterminate: true, evidence };
+        }
+      }
+      if (candidateResolution.indeterminate) {
+        return { isSelf: false, source: null, indeterminate: true, evidence };
+      }
+      return { isSelf: false, source: null, indeterminate: false, evidence };
+    } catch (error) {
+      evidence.push((error as Error).message);
+      return { isSelf: false, source: null, indeterminate: true, evidence };
+    }
   }
 
   /**
@@ -455,6 +856,12 @@ export class UnifiedEmailServer extends EventEmitter {
       text: email.text || '',
       html: email.html || undefined,
       headers: email.headers as Record<string, string> || {},
+      attachments: email.attachments.map((attachment) => ({
+        filename: attachment.filename,
+        contentBase64: attachment.content.toString('base64'),
+        contentType: attachment.contentType,
+        ...(attachment.contentId ? { contentId: attachment.contentId } : {}),
+      })),
     };
 
     const secure = port === 465;
@@ -499,6 +906,7 @@ export class UnifiedEmailServer extends EventEmitter {
 
     try {
       await this.startDeliveryPipeline();
+      this.startAcceptedEnvelopeDispatchCleanup();
       await this.startRustBridge();
       await this.initializeDkimAndDns();
       await this.startDeliveryProcessing();
@@ -740,7 +1148,7 @@ export class UnifiedEmailServer extends EventEmitter {
       authEnabled: !!this.options.auth?.required || !!(this.options.auth?.users?.length),
       maxAuthFailures: 3,
       socketTimeoutSecs: this.options.socketTimeout ? Math.floor(this.options.socketTimeout / 1000) : 300,
-      processingTimeoutSecs: this.options.hooks?.onMessageData
+      processingTimeoutSecs: this.options.hooks?.onMessageData || this.options.hooks?.onAcceptEnvelope
         ? Math.ceil(this.getMessageAcceptanceTimeoutMs() / 1000) + 1
         : 30,
       maxConcurrentMessages: this.options.smtp?.maxConcurrentMessages ?? 4,
@@ -771,6 +1179,11 @@ export class UnifiedEmailServer extends EventEmitter {
     logger.log('info', 'Stopping UnifiedEmailServer');
 
     try {
+      if (this.acceptedEnvelopeDispatchCleanupTimer) {
+        clearInterval(this.acceptedEnvelopeDispatchCleanupTimer);
+        this.acceptedEnvelopeDispatchCleanupTimer = undefined;
+      }
+      await this.acceptedEnvelopeDispatchCleanupPromise;
       await this.stopDnsValidation();
 
       // Stop the Rust SMTP server first
@@ -803,6 +1216,9 @@ export class UnifiedEmailServer extends EventEmitter {
       this.bounceManager.stop();
       logger.log('info', 'Bounce manager stopped');
 
+      this.rateLimiter.stop();
+      logger.log('info', 'Rate limiter stopped');
+
       // Close all Rust SMTP client connection pools
       try {
         await this.rustBridge.closeSmtpPool();
@@ -835,16 +1251,47 @@ export class UnifiedEmailServer extends EventEmitter {
       authenticatedUser: data.authenticatedUser,
     };
 
-    const hookDecision = this.options.hooks?.onRcptTo
-      ? await this.runHookWithTimeout(
+    const resolution = await this.resolveRecipientPolicy(context);
+    let decision = resolution.decision;
+    if (resolution.decision.accepted && this.options.hooks?.onRcptTo) {
+      try {
+        decision = await this.runHookWithTimeout(
           this.getRecipientValidationTimeoutMs(),
           'Recipient policy timeout',
-          (abortSignal) => this.options.hooks!.onRcptTo!({ ...context, abortSignal })
-        )
-      : await this.evaluateDefaultRcptToPolicy(context);
-    const decision = this.options.hooks?.onRcptTo
-      ? await this.enforceAcceptedRcptToRelayPolicy(context, hookDecision)
-      : hookDecision;
+          (abortSignal) => this.options.hooks!.onRcptTo!({ ...context, abortSignal }),
+        );
+      } catch (error) {
+        logger.log(
+          'error',
+          `Recipient policy callback failed for ${context.rcptTo}: ${getErrorMessage(error)}`,
+        );
+        decision = {
+          accepted: false,
+          smtpCode: 451,
+          smtpMessage: 'Recipient policy error',
+        };
+        await this.notifyRecipientRejected(context, decision, resolution, 'policy-error');
+        await this.rustBridge.sendRcptToResult({
+          correlationId: data.correlationId,
+          accepted: false,
+          smtpCode: 451,
+          smtpMessage: 'Recipient policy error',
+        });
+        return;
+      }
+    }
+
+    if (!decision.accepted) {
+      const rejectedByHook = resolution.decision.accepted;
+      await this.notifyRecipientRejected(
+        context,
+        decision,
+        resolution,
+        rejectedByHook
+          ? 'recipient-hook'
+          : resolution.rejectionReason || this.getRejectionReasonForResolution(resolution),
+      );
+    }
 
     await this.rustBridge.sendRcptToResult({
       correlationId: data.correlationId,
@@ -855,65 +1302,158 @@ export class UnifiedEmailServer extends EventEmitter {
   }
 
   private async evaluateDefaultRcptToPolicy(context: IRcptToPolicyContext): Promise<ISmtpDecision> {
+    return (await this.resolveRecipientPolicy(context)).decision;
+  }
+
+  private async resolveRecipientPolicy(
+    context: IRcptToPolicyContext,
+    emailArg?: Email,
+    sessionArg?: IExtendedSmtpSession,
+  ): Promise<IRecipientPolicyResolution> {
     const currentRecipientContext = { ...context, acceptedRcptTo: [] };
-    const email = new Email({
+    const email = emailArg || new Email({
       from: context.mailFrom || '<>',
       to: [context.rcptTo],
       subject: '',
       text: '',
     });
-    const session = this.buildPolicySession(currentRecipientContext);
+    const session = sessionArg || this.buildPolicySession(currentRecipientContext);
     const route = await this.emailRouter.evaluateRoutes({ email, session });
+    const recipientDomain = this.getAddressDomain(context.rcptTo);
+    const isLocalRecipient = !!recipientDomain && this.domainRegistry.isDomainRegistered(recipientDomain);
+    const localDomain = isLocalRecipient ? recipientDomain! : null;
+
+    if (route) {
+      if (route.action.type === 'reject') {
+        return {
+          recipient: context.rcptTo,
+          localDomain,
+          route,
+          source: 'explicit-route',
+          decision: {
+            accepted: false,
+            smtpCode: route.action.reject?.code || 550,
+            smtpMessage: route.action.reject?.message || 'Recipient rejected',
+          },
+          rejectionReason: 'explicit-route',
+        };
+      }
+
+      if (!isLocalRecipient && !route.action.allowRelay) {
+        return {
+          recipient: context.rcptTo,
+          localDomain: null,
+          route,
+          source: 'explicit-route',
+          decision: { accepted: false, smtpCode: 550, smtpMessage: 'Relay not permitted' },
+          rejectionReason: 'relay-denied',
+        };
+      }
 
-    if (!route) {
-      return { accepted: false, smtpCode: 550, smtpMessage: 'No route for recipient' };
-    }
-    if (route.action.type === 'reject') {
       return {
-        accepted: false,
-        smtpCode: route.action.reject?.code || 550,
-        smtpMessage: route.action.reject?.message || 'Recipient rejected',
+        recipient: context.rcptTo,
+        localDomain,
+        route,
+        source: 'explicit-route',
+        decision: { accepted: true, smtpCode: 250, smtpMessage: 'OK' },
       };
     }
 
-    const recipientDomain = this.getAddressDomain(context.rcptTo);
-    const isLocalRecipient = !!recipientDomain && this.domainRegistry.isDomainRegistered(recipientDomain);
-    if (!isLocalRecipient && !route.action.allowRelay) {
-      return { accepted: false, smtpCode: 550, smtpMessage: 'Relay not permitted' };
+    if (!isLocalRecipient) {
+      return {
+        recipient: context.rcptTo,
+        localDomain: null,
+        route: null,
+        source: 'no-route',
+        decision: { accepted: false, smtpCode: 550, smtpMessage: 'domain not hosted here' },
+        rejectionReason: 'domain-not-hosted',
+      };
     }
 
-    return { accepted: true, smtpCode: 250, smtpMessage: 'OK' };
-  }
-
-  private async enforceAcceptedRcptToRelayPolicy(
-    context: IRcptToPolicyContext,
-    decision: ISmtpDecision
-  ): Promise<ISmtpDecision> {
-    if (!decision.accepted) {
-      return decision;
+    const inboundPolicy = this.domainRegistry.getDomainConfig(recipientDomain!)?.inboundPolicy;
+    if (!inboundPolicy) {
+      return {
+        recipient: context.rcptTo,
+        localDomain,
+        route: null,
+        source: 'no-route',
+        decision: {
+          accepted: false,
+          smtpCode: 550,
+          smtpMessage: `no mailbox configured for ${context.rcptTo}`,
+        },
+        rejectionReason: 'no-route',
+      };
     }
 
-    const recipientDomain = this.getAddressDomain(context.rcptTo);
-    const isLocalRecipient = !!recipientDomain && this.domainRegistry.isDomainRegistered(recipientDomain);
-    if (isLocalRecipient) {
-      return decision;
+    const policyRouteName = `__smartmta_inbound_${inboundPolicy.defaultAction}:${recipientDomain}`;
+    if (inboundPolicy.defaultAction === 'reject') {
+      return {
+        recipient: context.rcptTo,
+        localDomain,
+        route: null,
+        source: 'domain-policy',
+        decision: {
+          accepted: false,
+          smtpCode: 550,
+          smtpMessage: `no mailbox configured for ${context.rcptTo}`,
+        },
+        rejectionReason: 'domain-policy',
+        policyRouteName,
+      };
     }
 
-    const currentRecipientContext = { ...context, acceptedRcptTo: [] };
-    const email = new Email({
-      from: context.mailFrom || '<>',
-      to: [context.rcptTo],
-      subject: '',
-      text: '',
-    });
-    const session = this.buildPolicySession(currentRecipientContext);
-    const route = await this.emailRouter.evaluateRoutes({ email, session });
+    return {
+      recipient: context.rcptTo,
+      localDomain,
+      route: {
+        name: policyRouteName,
+        match: { recipients: `*@${recipientDomain}` },
+        action: {
+          type: 'store',
+          store: { retentionDays: inboundPolicy.retentionDays },
+        },
+      },
+      source: 'domain-policy',
+      decision: { accepted: true, smtpCode: 250, smtpMessage: 'OK' },
+      policyRouteName,
+    };
+  }
 
-    if (route?.action.type !== 'reject' && route?.action.allowRelay) {
-      return decision;
-    }
+  private getRejectionReasonForResolution(
+    resolution: IRecipientPolicyResolution,
+  ): TRecipientRejectionReason {
+    if (resolution.source === 'explicit-route') return 'explicit-route';
+    if (resolution.source === 'domain-policy') return 'domain-policy';
+    return resolution.localDomain ? 'no-route' : 'domain-not-hosted';
+  }
 
-    return { accepted: false, smtpCode: 550, smtpMessage: 'Relay not permitted' };
+  private async notifyRecipientRejected(
+    context: IRcptToPolicyContext,
+    decision: ISmtpDecision,
+    resolution: IRecipientPolicyResolution,
+    reason: TRecipientRejectionReason,
+  ): Promise<void> {
+    const event: IRecipientRejectedEvent = {
+      timestamp: new Date().toISOString(),
+      sender: context.mailFrom,
+      recipient: context.rcptTo,
+      localDomain: resolution.localDomain,
+      remoteAddress: context.remoteAddress,
+      smtpCode: decision.smtpCode || 550,
+      smtpMessage: decision.smtpMessage || 'Recipient rejected',
+      routeName: resolution.route?.name || resolution.policyRouteName || null,
+      reason,
+    };
+
+    if (this.options.hooks?.onRecipientRejected) {
+      await callObserverSafely(
+        'recipientRejected callback',
+        this.options.hooks.onRecipientRejected,
+        event,
+      );
+    }
+    await emitSafely(this, 'recipientRejected', event);
   }
 
   private buildPolicySession(context: IRcptToPolicyContext): IExtendedSmtpSession {
@@ -986,6 +1526,704 @@ export class UnifiedEmailServer extends EventEmitter {
     }
   }
 
+  /** Build a route-evaluation view containing only the current SMTP envelope recipient. */
+  private cloneEmailForRoutingRecipient(email: Email, recipient: string): Email {
+    return new Email({
+      from: email.from,
+      to: [recipient],
+      cc: [],
+      bcc: [],
+      subject: email.subject,
+      text: email.text,
+      html: email.html,
+      attachments: email.attachments.map((attachment) => ({
+        ...attachment,
+        content: Buffer.from(attachment.content),
+      })),
+      headers: { ...email.headers },
+      mightBeSpam: email.mightBeSpam,
+      priority: email.priority,
+      variables: structuredClone(email.variables),
+    })
+      .setMessageId(email.getMessageId())
+      .setEnvelopeFrom(email.getEnvelopeFrom());
+  }
+
+  private scopeSessionForRoutingRecipient(
+    session: IExtendedSmtpSession,
+    recipient: string,
+  ): IExtendedSmtpSession {
+    return {
+      ...session,
+      ...(session.user ? { user: structuredClone(session.user) } : {}),
+      ...(session.securityResults
+        ? { securityResults: structuredClone(session.securityResults) }
+        : {}),
+      rcptTo: [recipient],
+      envelope: {
+        mailFrom: { ...session.envelope.mailFrom },
+        rcptTo: [{ address: recipient, args: {} }],
+      },
+      matchedRoute: undefined,
+      resolvedRecipientRoutes: undefined,
+    };
+  }
+
+  private buildDataPolicyContext(
+    session: IExtendedSmtpSession,
+    recipient: string,
+  ): IRcptToPolicyContext {
+    return {
+      sessionId: session.id,
+      mailFrom: session.envelope.mailFrom.address,
+      rcptTo: recipient,
+      acceptedRcptTo: session.envelope.rcptTo
+        .map((entry) => entry.address)
+        .filter((address) => address !== recipient),
+      remoteAddress: session.remoteAddress || '',
+      clientHostname: session.clientHostname || null,
+      secure: !!session.secure,
+      authenticated: !!session.authenticated,
+      authenticatedUser: session.user?.username || null,
+    };
+  }
+
+  private async resolveDataRecipientRoutes(
+    email: Email,
+    session: IExtendedSmtpSession,
+  ): Promise<IRecipientPolicyResolution[]> {
+    const resolutions: IRecipientPolicyResolution[] = [];
+    for (const envelopeRecipient of session.envelope.rcptTo) {
+      const recipient = envelopeRecipient.address;
+      const scopedEmail = this.cloneEmailForRoutingRecipient(email, recipient);
+      const scopedSession = this.scopeSessionForRoutingRecipient(session, recipient);
+      resolutions.push(await this.resolveRecipientPolicy(
+        this.buildDataPolicyContext(session, recipient),
+        scopedEmail,
+        scopedSession,
+      ));
+    }
+
+    session.resolvedRecipientRoutes = resolutions.map((resolution) => ({
+      recipient: resolution.recipient,
+      localDomain: resolution.localDomain,
+      route: resolution.route,
+      source: resolution.source,
+    }));
+    const routeNames = new Set(
+      session.resolvedRecipientRoutes.map((resolution) => resolution.route?.name || ''),
+    );
+    if (routeNames.size === 1) {
+      session.matchedRoute = session.resolvedRecipientRoutes[0]?.route || undefined;
+    }
+    return resolutions;
+  }
+
+  private async acceptDurableEnvelope(
+    email: Email,
+    rawMessage: Buffer,
+    session: IExtendedSmtpSession,
+  ): Promise<void> {
+    const onAcceptEnvelope = this.options.hooks?.onAcceptEnvelope;
+    if (!onAcceptEnvelope) {
+      throw new Error('No durable onAcceptEnvelope hook is configured');
+    }
+
+    let hookContext: IAcceptEnvelopeContext | undefined;
+    await this.runHookWithTimeout(
+      this.getMessageAcceptanceTimeoutMs(),
+      'Envelope acceptance timeout',
+      (abortSignal) => {
+        hookContext = {
+          email,
+          rawMessage,
+          session,
+          envelope: {
+            mailFrom: session.envelope.mailFrom.address,
+            rcptTo: session.envelope.rcptTo.map((recipient) => recipient.address),
+          },
+          resolvedRecipientRoutes: session.resolvedRecipientRoutes || [],
+          attachmentCount: email.attachments.length,
+          securityResults: session.securityResults ?? null,
+          abortSignal,
+        };
+        return onAcceptEnvelope(hookContext);
+      },
+      () => {
+        if (hookContext) {
+          hookContext.rawMessage = Buffer.alloc(0);
+          (hookContext as any).email = undefined;
+          (hookContext as any).session = undefined;
+        }
+      },
+    );
+  }
+
+  private cloneJsonSafe<T>(
+    value: T,
+    path = 'value',
+    seen = new WeakSet<object>(),
+  ): T {
+    if (
+      value === null
+      || typeof value === 'string'
+      || typeof value === 'boolean'
+    ) {
+      return value;
+    }
+    if (typeof value === 'number') {
+      if (!Number.isFinite(value)) {
+        throw new Error(`${path} must contain only finite JSON numbers`);
+      }
+      return value;
+    }
+    if (Array.isArray(value)) {
+      if (Object.getPrototypeOf(value) !== Array.prototype) {
+        throw new Error(`${path} must use the standard Array prototype`);
+      }
+      if (seen.has(value)) {
+        throw new Error(`${path} must not contain circular references`);
+      }
+      seen.add(value);
+      const ownKeys = Reflect.ownKeys(value);
+      if (ownKeys.some((key) => typeof key === 'symbol')) {
+        throw new Error(`${path} must not contain symbol keys`);
+      }
+      const elementKeys = ownKeys.filter((key) => key !== 'length') as string[];
+      if (
+        elementKeys.length !== value.length
+        || elementKeys.some((key, index) => key !== String(index))
+      ) {
+        throw new Error(`${path} must be a dense JSON array without custom keys`);
+      }
+      const clone: unknown[] = [];
+      for (let index = 0; index < value.length; index++) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor?.enumerable || !('value' in descriptor)) {
+          throw new Error(`${path}[${index}] must be an enumerable data property`);
+        }
+        clone.push(this.cloneJsonSafe(
+          descriptor.value,
+          `${path}[${index}]`,
+          seen,
+        ));
+      }
+      seen.delete(value);
+      return Object.freeze(clone) as T;
+    }
+    if (typeof value === 'object') {
+      const prototype = Object.getPrototypeOf(value);
+      if (prototype !== Object.prototype && prototype !== null) {
+        throw new Error(`${path} must contain only JSON-safe plain objects`);
+      }
+      if (seen.has(value)) {
+        throw new Error(`${path} must not contain circular references`);
+      }
+      seen.add(value);
+      const ownKeys = Reflect.ownKeys(value);
+      if (ownKeys.some((key) => typeof key === 'symbol')) {
+        throw new Error(`${path} must not contain symbol keys`);
+      }
+      const clone = Object.create(null) as Record<string, unknown>;
+      for (const key of ownKeys as string[]) {
+        if (key === '__proto__') {
+          throw new Error(`${path} must not contain __proto__ keys`);
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor?.enumerable || !('value' in descriptor)) {
+          throw new Error(`${path}.${key} must be an enumerable data property`);
+        }
+        if (descriptor.value === undefined) {
+          throw new Error(`${path}.${key} must not be undefined`);
+        }
+        clone[key] = this.cloneJsonSafe(
+          descriptor.value,
+          `${path}.${key}`,
+          seen,
+        );
+      }
+      seen.delete(value);
+      return Object.freeze(clone) as T;
+    }
+    throw new Error(`${path} contains a non-JSON-safe value`);
+  }
+
+  private stableJson(value: unknown): string {
+    if (value === null || typeof value !== 'object') return JSON.stringify(value);
+    if (Array.isArray(value)) {
+      return `[${value.map((entry) => this.stableJson(entry)).join(',')}]`;
+    }
+    const record = value as Record<string, unknown>;
+    return `{${Object.keys(record)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${this.stableJson(record[key])}`)
+      .join(',')}}`;
+  }
+
+  private validateAcceptedEnvelopeAction(
+    action: IEmailAction,
+    path: string,
+  ): void {
+    if (!['forward', 'deliver', 'reject', 'process', 'store'].includes(action.type)) {
+      throw new Error(`${path}.type is unsupported`);
+    }
+    if (action.type === 'forward') {
+      if (!action.forward?.host?.trim()) {
+        throw new Error(`${path}.forward.host is required`);
+      }
+      if (
+        action.forward.port !== undefined
+        && (
+          !Number.isInteger(action.forward.port)
+          || action.forward.port < 1
+          || action.forward.port > 65_535
+        )
+      ) {
+        throw new Error(`${path}.forward.port is invalid`);
+      }
+    }
+    if (action.type === 'store') {
+      if (
+        !Number.isInteger(action.store?.retentionDays)
+        || (action.store?.retentionDays || 0) < 1
+      ) {
+        throw new Error(`${path}.store.retentionDays must be a positive integer`);
+      }
+    }
+    if (action.type === 'reject') {
+      if (
+        !Number.isInteger(action.reject?.code)
+        || (action.reject?.code || 0) < 400
+        || (action.reject?.code || 0) > 599
+        || !action.reject?.message?.trim()
+      ) {
+        throw new Error(`${path}.reject must contain a 4xx/5xx code and message`);
+      }
+    }
+  }
+
+  private normalizeAcceptedEnvelopePlan(
+    plan: readonly IAcceptedEnvelopeRecipientPlan[],
+  ): readonly IAcceptedEnvelopeRecipientPlan[] {
+    if (!Array.isArray(plan) || plan.length === 0) {
+      throw new Error('Accepted envelope dispatch plan must contain at least one recipient');
+    }
+    const keys = new Set<string>();
+    const normalized = plan.map((entry, index) => {
+      const path = `plan[${index}]`;
+      if (!entry || typeof entry !== 'object') {
+        throw new Error(`${path} must be an object`);
+      }
+      const atIndex = entry.recipient?.lastIndexOf('@') ?? -1;
+      if (
+        !entry.recipient?.trim()
+        || atIndex < 1
+        || atIndex === entry.recipient.length - 1
+      ) {
+        throw new Error(`${path}.recipient is invalid`);
+      }
+      if (entry.localDomain !== null && !entry.localDomain?.trim()) {
+        throw new Error(`${path}.localDomain is invalid`);
+      }
+      if (!entry.routeName?.trim()) {
+        throw new Error(`${path}.routeName is required`);
+      }
+      if (!['explicit-route', 'domain-policy'].includes(entry.source)) {
+        throw new Error(`${path}.source cannot represent an accepted route`);
+      }
+      if (!entry.idempotencyKey || entry.idempotencyKey.length > 512) {
+        throw new Error(`${path}.idempotencyKey must contain 1 to 512 characters`);
+      }
+      if (keys.has(entry.idempotencyKey)) {
+        throw new Error(`${path}.idempotencyKey is duplicated`);
+      }
+      keys.add(entry.idempotencyKey);
+      const action = this.cloneJsonSafe(entry.action, `${path}.action`);
+      this.validateAcceptedEnvelopeAction(action, `${path}.action`);
+      return Object.freeze({
+        recipient: entry.recipient,
+        localDomain: entry.localDomain,
+        routeName: entry.routeName,
+        source: entry.source,
+        action,
+        idempotencyKey: entry.idempotencyKey,
+      });
+    });
+    return Object.freeze(normalized);
+  }
+
+  /**
+   * Snapshot the already-resolved acceptance plan for durable consumer storage.
+   * No live route lookup is performed when the returned plan is dispatched.
+   */
+  public createAcceptedEnvelopeDispatchPlan(
+    context: IAcceptEnvelopeContext,
+    idempotencyKeys: readonly string[],
+  ): readonly IAcceptedEnvelopeRecipientPlan[] {
+    if (context.resolvedRecipientRoutes.length !== idempotencyKeys.length) {
+      throw new Error('One idempotency key is required for every resolved recipient route');
+    }
+    return this.normalizeAcceptedEnvelopePlan(
+      context.resolvedRecipientRoutes.map((resolution, index) => {
+        if (!resolution.route) {
+          throw new Error(
+            `Accepted recipient ${resolution.recipient} has no resolved route action`,
+          );
+        }
+        return {
+          recipient: resolution.recipient,
+          localDomain: resolution.localDomain,
+          routeName: resolution.route.name,
+          source: resolution.source,
+          action: resolution.route.action,
+          idempotencyKey: idempotencyKeys[index],
+        };
+      }),
+    );
+  }
+
+  private acceptedEnvelopeDispatchStorageKey(idempotencyKey: string): string {
+    const digest = plugins.crypto
+      .createHash('sha256')
+      .update('smartmta-accepted-envelope-dispatch-v1\0')
+      .update(idempotencyKey)
+      .digest('hex');
+    return `${ACCEPTED_ENVELOPE_DISPATCH_STORAGE_PREFIX}${digest}.json`;
+  }
+
+  private startAcceptedEnvelopeDispatchCleanup(): void {
+    if (this.acceptedEnvelopeDispatchCleanupTimer) return;
+    this.acceptedEnvelopeDispatchCleanupTimer = setInterval(() => {
+      void this.cleanupExpiredAcceptedEnvelopeDispatchResults();
+    }, ACCEPTED_ENVELOPE_DISPATCH_CLEANUP_INTERVAL_MS);
+    this.acceptedEnvelopeDispatchCleanupTimer.unref?.();
+  }
+
+  private async cleanupExpiredAcceptedEnvelopeDispatchResults(
+    limit = ACCEPTED_ENVELOPE_DISPATCH_CLEANUP_LIMIT,
+  ): Promise<void> {
+    if (!this.dcRouter.storageManager.listPage) return;
+    if (this.acceptedEnvelopeDispatchCleanupPromise) {
+      return this.acceptedEnvelopeDispatchCleanupPromise;
+    }
+    const cleanup = (async () => {
+      if (!Number.isInteger(limit) || limit < 1) {
+        throw new Error('Accepted-envelope cleanup limit must be a positive integer');
+      }
+      const now = Date.now();
+      const page = await this.dcRouter.storageManager.listPage!(
+        ACCEPTED_ENVELOPE_DISPATCH_STORAGE_PREFIX,
+        {
+          limit,
+          ...(this.acceptedEnvelopeDispatchCleanupCursor
+            ? { continuationToken: this.acceptedEnvelopeDispatchCleanupCursor }
+            : {}),
+        },
+      );
+      if (
+        !page
+        || !Array.isArray(page.keys)
+        || page.keys.length > limit
+        || page.keys.some((key) => (
+          typeof key !== 'string'
+          || !key.startsWith(ACCEPTED_ENVELOPE_DISPATCH_STORAGE_PREFIX)
+        ))
+        || new Set(page.keys).size !== page.keys.length
+        || (
+          page.continuationToken !== undefined
+          && (
+            typeof page.continuationToken !== 'string'
+            || page.continuationToken.length === 0
+            || page.continuationToken === this.acceptedEnvelopeDispatchCleanupCursor
+          )
+        )
+      ) {
+        throw new Error('Invalid paginated accepted-envelope checkpoint listing');
+      }
+      this.acceptedEnvelopeDispatchCleanupCursor = page.continuationToken;
+      for (const key of page.keys) {
+        const value = await this.dcRouter.storageManager.get(key);
+        if (!value) continue;
+        try {
+          if (!key.endsWith('.json')) {
+            throw new Error(`Invalid accepted-envelope checkpoint key: ${key}`);
+          }
+          const stored = JSON.parse(value) as Partial<IStoredAcceptedEnvelopeDispatchResult>;
+          if (
+            stored.schemaVersion !== 1
+            || typeof stored.fingerprint !== 'string'
+            || !/^[a-f0-9]{64}$/.test(stored.fingerprint)
+            || !Number.isFinite(stored.expiresAt)
+            || !stored.result
+            || typeof stored.result !== 'object'
+            || stored.expiresAt! <= now
+          ) {
+            await this.dcRouter.storageManager.delete(key);
+          }
+        } catch {
+          await this.dcRouter.storageManager.delete(key);
+        }
+      }
+    })();
+    this.acceptedEnvelopeDispatchCleanupPromise = cleanup
+      .catch((error) => {
+        logger.log(
+          'warn',
+          `Accepted-envelope dispatch checkpoint cleanup failed: ${getErrorMessage(error)}`,
+        );
+      })
+      .finally(() => {
+        this.acceptedEnvelopeDispatchCleanupPromise = undefined;
+      });
+    return this.acceptedEnvelopeDispatchCleanupPromise;
+  }
+
+  private async readAcceptedEnvelopeDispatchResult(
+    entry: IAcceptedEnvelopeRecipientPlan,
+    fingerprint: string,
+  ): Promise<IAcceptedEnvelopeRecipientDispatchResult | null> {
+    const key = this.acceptedEnvelopeDispatchStorageKey(entry.idempotencyKey);
+    const storedText = await this.dcRouter.storageManager.get(key);
+    if (!storedText) return null;
+    let stored: IStoredAcceptedEnvelopeDispatchResult;
+    try {
+      stored = JSON.parse(storedText) as IStoredAcceptedEnvelopeDispatchResult;
+    } catch {
+      throw new Error(`Accepted-envelope dispatch checkpoint is malformed for ${entry.recipient}`);
+    }
+    if (Number.isFinite(stored.expiresAt) && stored.expiresAt <= Date.now()) {
+      await this.dcRouter.storageManager.delete(key);
+      return null;
+    }
+    if (
+      stored?.schemaVersion !== 1
+      || stored.fingerprint !== fingerprint
+      || !Number.isFinite(stored.expiresAt)
+      || stored.result?.idempotencyKey !== entry.idempotencyKey
+      || stored.result?.recipient !== entry.recipient
+      || stored.result?.localDomain !== entry.localDomain
+      || stored.result?.routeName !== entry.routeName
+      || stored.result?.source !== entry.source
+      || stored.result?.actionType !== entry.action.type
+      || (stored.result as Record<string, unknown> | undefined)?.replayed !== undefined
+      || !['stored', 'queued', 'rejected'].includes(stored.result?.status)
+      || (
+        stored.result?.status === 'queued'
+        && (
+          typeof stored.result.queueId !== 'string'
+          || !stored.result.queueId
+        )
+      )
+      || (
+        stored.result?.status !== 'queued'
+        && stored.result?.queueId !== undefined
+      )
+      || (
+        stored.result?.status === 'rejected'
+        && !Number.isInteger(stored.result.smtpCode)
+      )
+    ) {
+      throw new Error(
+        `Accepted-envelope idempotency key was reused or has invalid state for ${entry.recipient}`,
+      );
+    }
+    return { ...stored.result, replayed: true };
+  }
+
+  private async writeAcceptedEnvelopeDispatchResult(
+    result: IAcceptedEnvelopeRecipientDispatchResult,
+    fingerprint: string,
+  ): Promise<void> {
+    const { replayed: _replayed, ...storedResult } = result;
+    const stored: IStoredAcceptedEnvelopeDispatchResult = {
+      schemaVersion: 1,
+      fingerprint,
+      expiresAt: Date.now() + ACCEPTED_ENVELOPE_IDEMPOTENCY_RETENTION_MS,
+      result: storedResult,
+    };
+    await this.dcRouter.storageManager.set(
+      this.acceptedEnvelopeDispatchStorageKey(result.idempotencyKey),
+      JSON.stringify(stored),
+    );
+  }
+
+  /**
+   * Dispatch a durably accepted raw envelope using only its persisted exact
+   * action snapshots. Each recipient receives an isolated Email and session.
+   * Queue-backed actions require managed queue storage and are replay-safe.
+   */
+  public async dispatchAcceptedEnvelope(
+    rawMessage: Uint8Array,
+    planArg: readonly IAcceptedEnvelopeRecipientPlan[],
+    metadataArg: IAcceptedEnvelopeDispatchMetadata,
+  ): Promise<IAcceptedEnvelopeDispatchResult> {
+    if (!(rawMessage instanceof Uint8Array) || rawMessage.byteLength === 0) {
+      throw new Error('Accepted envelope raw message must contain exact RFC822 bytes');
+    }
+    const rawCopy = Buffer.from(rawMessage);
+    const plan = this.normalizeAcceptedEnvelopePlan(planArg);
+    const metadata = this.cloneJsonSafe(metadataArg, 'metadata');
+    if (!metadata?.mailFrom && metadata?.mailFrom !== '') {
+      throw new Error('Accepted envelope metadata.mailFrom is required');
+    }
+    if (!this.dcRouter.storageManager.listPage) {
+      throw new Error(
+        'Accepted-envelope dispatch requires paginated small-state storage',
+      );
+    }
+    const hasQueueAction = plan.some((entry) => (
+      entry.action.type === 'forward'
+      || entry.action.type === 'deliver'
+      || entry.action.type === 'process'
+    ));
+    if (hasQueueAction) {
+      if (!this.deliveryQueue.hasManagedStorage()) {
+        throw new Error(
+          'Accepted-envelope queue actions require managed queue storage',
+        );
+      }
+      if (!this.deliveryQueue.hasPaginatedManagedStorage()) {
+        throw new Error(
+          'Accepted-envelope queue actions require paginated managed queue storage',
+        );
+      }
+    }
+
+    const rawDigest = plugins.crypto.createHash('sha256').update(rawCopy).digest('hex');
+    const fingerprints = plan.map((entry) => plugins.crypto
+      .createHash('sha256')
+      .update(this.stableJson({
+        rawDigest,
+        metadata,
+        entry,
+      }))
+      .digest('hex'));
+
+    const results: Array<IAcceptedEnvelopeRecipientDispatchResult | null> = [];
+    for (let index = 0; index < plan.length; index++) {
+      results.push(await this.readAcceptedEnvelopeDispatchResult(
+        plan[index],
+        fingerprints[index],
+      ));
+    }
+    if (results.every(Boolean)) {
+      return {
+        complete: true,
+        results: results as IAcceptedEnvelopeRecipientDispatchResult[],
+      };
+    }
+
+    const baseSession: IExtendedSmtpSession = {
+      id: metadata.session?.id || `accepted-envelope-${rawDigest.slice(0, 16)}`,
+      state: SmtpState.FINISHED,
+      mailFrom: metadata.mailFrom,
+      rcptTo: plan.map((entry) => entry.recipient),
+      emailData: '',
+      useTLS: !!metadata.session?.secure,
+      connectionEnded: true,
+      remoteAddress: metadata.session?.remoteAddress || '',
+      clientHostname: metadata.session?.clientHostname || '',
+      secure: !!metadata.session?.secure,
+      authenticated: !!metadata.session?.authenticated,
+      envelope: {
+        mailFrom: { address: metadata.mailFrom, args: {} },
+        rcptTo: plan.map((entry) => ({ address: entry.recipient, args: {} })),
+      },
+    };
+    if (metadata.session?.user) {
+      baseSession.user = structuredClone(metadata.session.user) as IExtendedSmtpSession['user'];
+    } else if (metadata.session?.authenticatedUser) {
+      baseSession.user = { username: metadata.session.authenticatedUser };
+    }
+    let parsedEmail: Email | undefined;
+
+    for (let index = 0; index < plan.length; index++) {
+      if (results[index]) continue;
+      const entry = plan[index];
+      const fingerprint = fingerprints[index];
+      const commonResult = {
+        recipient: entry.recipient,
+        localDomain: entry.localDomain,
+        routeName: entry.routeName,
+        source: entry.source,
+        actionType: entry.action.type,
+        idempotencyKey: entry.idempotencyKey,
+        replayed: false,
+      } as const;
+
+      try {
+        let result: IAcceptedEnvelopeRecipientDispatchResult;
+        if (entry.action.type === 'store') {
+          result = { ...commonResult, status: 'stored' };
+        } else {
+          parsedEmail ||= await this.createEmailFromBuffer(rawCopy, baseSession);
+          const route: IEmailRoute = Object.freeze({
+            name: entry.routeName,
+            match: Object.freeze({ recipients: entry.recipient }),
+            action: entry.action,
+          });
+          const email = this.cloneEmailForRoutingRecipient(parsedEmail, entry.recipient);
+          const session = this.scopeSessionForRoutingRecipient(baseSession, entry.recipient);
+          session.id = `${baseSession.id}:${index}`;
+          session.matchedRoute = route;
+          session.resolvedRecipientRoutes = [{
+            recipient: entry.recipient,
+            localDomain: entry.localDomain,
+            route,
+            source: entry.source,
+          }];
+          try {
+            const execution = await this.actionExecutor.executeActionWithResult(
+              entry.action,
+              email,
+              { email, session },
+              {
+                durableQueue: {
+                  idempotencyKey: entry.idempotencyKey,
+                  fingerprint,
+                },
+              },
+            );
+            if (execution.outcome !== 'queued' || !execution.queueId) {
+              throw new Error(
+                `Accepted-envelope ${entry.action.type} action did not durably enqueue`,
+              );
+            }
+            result = {
+              ...commonResult,
+              status: 'queued',
+              queueId: execution.queueId,
+            };
+          } catch (error) {
+            if (entry.action.type !== 'reject') throw error;
+            result = {
+              ...commonResult,
+              status: 'rejected',
+              smtpCode: Number((error as any)?.responseCode)
+                || entry.action.reject?.code
+                || 550,
+              message: getErrorMessage(error),
+            };
+          }
+        }
+        await this.writeAcceptedEnvelopeDispatchResult(result, fingerprint);
+        results[index] = result;
+      } catch (error) {
+        results[index] = {
+          ...commonResult,
+          status: 'failed',
+          message: getErrorMessage(error),
+        };
+      }
+    }
+
+    const finalResults = results as IAcceptedEnvelopeRecipientDispatchResult[];
+    return {
+      complete: finalResults.every((result) => result.status !== 'failed'),
+      results: finalResults,
+    };
+  }
+
   /**
    * Handle an emailReceived event from the Rust SMTP server.
    */
@@ -1013,18 +2251,71 @@ export class UnifiedEmailServer extends EventEmitter {
           mailFrom: { address: mailFrom, args: {} },
           rcptTo: rcptTo.map(addr => ({ address: addr, args: {} })),
         },
+        securityResults: data.securityResults,
       };
 
       if (authenticatedUser) {
         session.user = { username: authenticatedUser };
       }
 
-      // Attach pre-computed security results from Rust in-process pipeline
-      if (data.securityResults) {
-        (session as any)._precomputedSecurityResults = data.securityResults;
-      }
 
       const email = await this.createEmailFromBuffer(rawMessageBuffer, session);
+      const resolvedRecipientRoutes = await this.resolveDataRecipientRoutes(email, session);
+      const rejectedRecipients = resolvedRecipientRoutes.filter(
+        (resolution) => !resolution.decision.accepted,
+      );
+      if (rejectedRecipients.length > 0) {
+        for (const rejection of rejectedRecipients) {
+          await this.notifyRecipientRejected(
+            this.buildDataPolicyContext(session, rejection.recipient),
+            rejection.decision,
+            rejection,
+            rejection.rejectionReason || this.getRejectionReasonForResolution(rejection),
+          );
+        }
+        const primaryRejection = rejectedRecipients[0];
+        await this.rustBridge.sendEmailProcessingResult({
+          correlationId,
+          accepted: false,
+          smtpCode: primaryRejection.decision.smtpCode || 550,
+          smtpMessage: primaryRejection.decision.smtpMessage || 'Message not accepted',
+        });
+        return;
+      }
+
+      const hasStoreRoute = resolvedRecipientRoutes.some(
+        (resolution) => resolution.route?.action.type === 'store',
+      );
+      if (hasStoreRoute) {
+        try {
+          await this.acceptDurableEnvelope(
+            email,
+            rawMessageBuffer,
+            session,
+          );
+        } catch (acceptanceError) {
+          logger.log(
+            'error',
+            `Durable envelope acceptance failed: ${(acceptanceError as Error).message}`,
+          );
+          await this.rustBridge.sendEmailProcessingResult({
+            correlationId,
+            accepted: false,
+            smtpCode: 451,
+            smtpMessage: 'Envelope acceptance temporarily unavailable',
+          });
+          return;
+        }
+
+        await this.rustBridge.sendEmailProcessingResult({
+          correlationId,
+          accepted: true,
+          smtpCode: 250,
+          smtpMessage: '2.0.0 Message accepted for delivery',
+        });
+        return;
+      }
+
       let acceptanceDecision: IMessageAcceptanceDecision | undefined;
       if (this.options.hooks?.onMessageData) {
         let hookContext: IMessageAcceptanceContext | undefined;
@@ -1037,6 +2328,8 @@ export class UnifiedEmailServer extends EventEmitter {
                 email,
                 rawMessage: rawMessageBuffer,
                 session,
+                matchedRoute: session.matchedRoute,
+                resolvedRecipientRoutes: session.resolvedRecipientRoutes || [],
                 abortSignal,
               };
               return this.options.hooks!.onMessageData!(hookContext);
@@ -1257,28 +2550,28 @@ export class UnifiedEmailServer extends EventEmitter {
   private async verifyInboundSecurity(email: Email, session: IExtendedSmtpSession): Promise<void> {
     try {
       // Check for pre-computed results from Rust in-process security pipeline
-      const precomputed = (session as any)._precomputedSecurityResults;
-      let result: any;
+      const precomputed = session.securityResults;
 
       if (precomputed) {
         logger.log('info', 'Using pre-computed security results from Rust in-process pipeline');
-        result = precomputed;
-      } else {
+      }
+      const result: IInboundEmailSecurityResult | IEmailSecurityResult =
+        precomputed || await (async () => {
         // Fallback: IPC round-trip to Rust (for backward compat)
         const rawMessage = session.emailData || email.toRFC822String();
-        result = await this.rustBridge.verifyEmail({
+        return this.rustBridge.verifyEmail({
           rawMessage,
           ip: session.remoteAddress,
           heloDomain: session.clientHostname || '',
           hostname: this.options.hostname,
           mailFrom: session.envelope?.mailFrom?.address || session.mailFrom || '',
         });
-      }
+      })();
 
       // Apply DKIM result headers
       if (result.dkim && result.dkim.length > 0) {
         const dkimSummary = result.dkim
-          .map((d: any) => `${d.status}${d.domain ? ` (${d.domain})` : ''}`)
+          .map((d) => `${d.status}${d.domain ? ` (${d.domain})` : ''}`)
           .join(', ');
         email.addHeader('X-DKIM-Result', dkimSummary);
       }
@@ -1308,8 +2601,8 @@ export class UnifiedEmailServer extends EventEmitter {
       }
 
       // Apply content scan results (from pre-computed pipeline)
-      if (result.contentScan) {
-        const scan = result.contentScan;
+      if (precomputed?.contentScan) {
+        const scan = precomputed.contentScan;
         if (scan.threatScore > 0) {
           email.addHeader('X-Spam-Score', String(scan.threatScore));
           if (scan.threatType) {
@@ -1323,8 +2616,8 @@ export class UnifiedEmailServer extends EventEmitter {
       }
 
       // Apply IP reputation results (from pre-computed pipeline)
-      if (result.ipReputation) {
-        const rep = result.ipReputation;
+      if (precomputed?.ipReputation) {
+        const rep = precomputed.ipReputation;
         email.addHeader('X-IP-Reputation-Score', String(rep.score));
         if (rep.is_spam) {
           email.mightBeSpam = true;