@push.rocks/smartmta 8.1.0 → 8.2.0

package/dist_ts/mail/interfaces.storage.d.ts

@@ -9,6 +9,20 @@ export interface IStorageManager {
     get(key: string): Promise<string | null>;
     set(key: string, value: string): Promise<void>;
     list(prefix: string): Promise<string[]>;
+    /**
+     * Return at most `limit` keys from one backend-bounded page.
+     *
+     * Continuation tokens are opaque, scoped to the supplied prefix, and must
+     * only be passed back to the same storage implementation. A returned token
+     * must advance a non-overlapping traversal, remain valid after any keys in
+     * its page are deleted, and eventually exhaust an otherwise stable prefix.
+     * Offset-based tokens do not satisfy this deletion-stability requirement.
+     *
+     * This optional method preserves compatibility for existing callers;
+     * features which need bounded cleanup must require it explicitly and must
+     * never fall back to list().
+     */
+    listPage?(prefix: string, options: IStorageListPageOptions): Promise<IStorageListPageResult>;
     delete(key: string): Promise<void>;
 }
 /** Blob storage for queued messages and template attachments. */
@@ -16,22 +30,42 @@ export interface IBlobStorageManager {
     get(key: string): Promise<Buffer | null>;
     set(key: string, value: Buffer): Promise<void>;
     list(prefix: string): Promise<string[]>;
+    /** Backend-bounded counterpart to list(); see IStorageManager.listPage. */
+    listPage?(prefix: string, options: IStorageListPageOptions): Promise<IStorageListPageResult>;
     delete(key: string): Promise<void>;
 }
+export interface IStorageListPageOptions {
+    /** Positive maximum number of keys the backend may return. */
+    readonly limit: number;
+    /** Opaque token returned by the immediately preceding page. */
+    readonly continuationToken?: string;
+}
+export interface IStorageListPageResult {
+    /** Unique keys under the requested prefix; length must not exceed limit. */
+    readonly keys: string[];
+    /** Omitted when the prefix has been exhausted. */
+    readonly continuationToken?: string;
+}
+/** Hard upper bound for one SmartMTA storage listing page. */
+export declare const SMARTMTA_STORAGE_LIST_PAGE_MAX_LIMIT = 1000;
 /** In-memory small-state store for tests and explicitly non-durable runtimes. */
 export declare class MemoryStorageManager implements IStorageManager {
     private readonly entries;
+    private readonly sortedKeys;
     get(key: string): Promise<string | null>;
     set(key: string, value: string): Promise<void>;
     list(prefix: string): Promise<string[]>;
+    listPage(prefix: string, options: IStorageListPageOptions): Promise<IStorageListPageResult>;
     delete(key: string): Promise<void>;
 }
 /** In-memory blob store for tests and explicitly non-durable runtimes. */
 export declare class MemoryBlobStorageManager implements IBlobStorageManager {
     private readonly entries;
+    private readonly sortedKeys;
     get(key: string): Promise<Buffer | null>;
     set(key: string, value: Buffer): Promise<void>;
     list(prefix: string): Promise<string[]>;
+    listPage(prefix: string, options: IStorageListPageOptions): Promise<IStorageListPageResult>;
     delete(key: string): Promise<void>;
 }
 /** @deprecated Use IStorageManager. */

package/dist_ts/mail/interfaces.storage.js

@@ -1,34 +1,120 @@
+/** Hard upper bound for one SmartMTA storage listing page. */
+export const SMARTMTA_STORAGE_LIST_PAGE_MAX_LIMIT = 1_000;
+function assertValidListPageOptions(options) {
+    if (!Number.isInteger(options.limit)
+        || options.limit < 1
+        || options.limit > SMARTMTA_STORAGE_LIST_PAGE_MAX_LIMIT) {
+        throw new Error(`Storage list page limit must be an integer from 1 to ${SMARTMTA_STORAGE_LIST_PAGE_MAX_LIMIT}`);
+    }
+    if (options.continuationToken !== undefined
+        && (typeof options.continuationToken !== 'string'
+            || options.continuationToken.length === 0)) {
+        throw new Error('Storage list page continuation token must be a non-empty string');
+    }
+}
+function lowerBound(sortedKeys, target) {
+    let low = 0;
+    let high = sortedKeys.length;
+    while (low < high) {
+        const middle = low + Math.floor((high - low) / 2);
+        if (sortedKeys[middle] < target)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
+function upperBound(sortedKeys, target) {
+    let low = 0;
+    let high = sortedKeys.length;
+    while (low < high) {
+        const middle = low + Math.floor((high - low) / 2);
+        if (sortedKeys[middle] <= target)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    return low;
+}
+function insertSortedKey(sortedKeys, key) {
+    sortedKeys.splice(lowerBound(sortedKeys, key), 0, key);
+}
+function removeSortedKey(sortedKeys, key) {
+    const index = lowerBound(sortedKeys, key);
+    if (sortedKeys[index] === key)
+        sortedKeys.splice(index, 1);
+}
+function listSortedPrefixPage(sortedKeys, prefix, options) {
+    assertValidListPageOptions(options);
+    if (options.continuationToken !== undefined
+        && !options.continuationToken.startsWith(prefix)) {
+        throw new Error('Storage list page continuation token does not belong to the prefix');
+    }
+    let index = options.continuationToken === undefined
+        ? lowerBound(sortedKeys, prefix)
+        : Math.max(lowerBound(sortedKeys, prefix), upperBound(sortedKeys, options.continuationToken));
+    const keys = [];
+    while (index < sortedKeys.length && keys.length < options.limit) {
+        const key = sortedKeys[index];
+        if (!key.startsWith(prefix))
+            break;
+        keys.push(key);
+        index++;
+    }
+    const hasMore = (index < sortedKeys.length
+        && sortedKeys[index].startsWith(prefix));
+    return {
+        keys,
+        ...(hasMore && keys.length > 0
+            ? { continuationToken: keys[keys.length - 1] }
+            : {}),
+    };
+}
 /** In-memory small-state store for tests and explicitly non-durable runtimes. */
 export class MemoryStorageManager {
     entries = new Map();
+    sortedKeys = [];
     async get(key) {
         return this.entries.get(key) ?? null;
     }
     async set(key, value) {
+        if (!this.entries.has(key))
+            insertSortedKey(this.sortedKeys, key);
         this.entries.set(key, value);
     }
     async list(prefix) {
         return [...this.entries.keys()].filter((key) => key.startsWith(prefix)).sort();
     }
+    async listPage(prefix, options) {
+        return listSortedPrefixPage(this.sortedKeys, prefix, options);
+    }
     async delete(key) {
-        this.entries.delete(key);
+        if (this.entries.delete(key))
+            removeSortedKey(this.sortedKeys, key);
     }
 }
 /** In-memory blob store for tests and explicitly non-durable runtimes. */
 export class MemoryBlobStorageManager {
     entries = new Map();
+    sortedKeys = [];
     async get(key) {
         const value = this.entries.get(key);
         return value ? Buffer.from(value) : null;
     }
     async set(key, value) {
+        if (!this.entries.has(key))
+            insertSortedKey(this.sortedKeys, key);
         this.entries.set(key, Buffer.from(value));
     }
     async list(prefix) {
         return [...this.entries.keys()].filter((key) => key.startsWith(prefix)).sort();
     }
+    async listPage(prefix, options) {
+        return listSortedPrefixPage(this.sortedKeys, prefix, options);
+    }
     async delete(key) {
-        this.entries.delete(key);
+        if (this.entries.delete(key))
+            removeSortedKey(this.sortedKeys, key);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5zdG9yYWdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvbWFpbC9pbnRlcmZhY2VzLnN0b3JhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBc0JBLGlGQUFpRjtBQUNqRixNQUFNLE9BQU8sb0JBQW9CO0lBQ2QsT0FBTyxHQUFHLElBQUksR0FBRyxFQUFrQixDQUFDO0lBRTlDLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBVztRQUMxQixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxJQUFJLElBQUksQ0FBQztJQUN2QyxDQUFDO0lBRU0sS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFXLEVBQUUsS0FBYTtRQUN6QyxJQUFJLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUVNLEtBQUssQ0FBQyxJQUFJLENBQUMsTUFBYztRQUM5QixPQUFPLENBQUMsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsR0FBRyxFQUFFLEVBQUUsQ0FBQyxHQUFHLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDakYsQ0FBQztJQUVNLEtBQUssQ0FBQyxNQUFNLENBQUMsR0FBVztRQUM3QixJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUMzQixDQUFDO0NBQ0Y7QUFFRCwwRUFBMEU7QUFDMUUsTUFBTSxPQUFPLHdCQUF3QjtJQUNsQixPQUFPLEdBQUcsSUFBSSxHQUFHLEVBQWtCLENBQUM7SUFFOUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFXO1FBQzFCLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3BDLE9BQU8sS0FBSyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUM7SUFDM0MsQ0FBQztJQUVNLEtBQUssQ0FBQyxHQUFHLENBQUMsR0FBVyxFQUFFLEtBQWE7UUFDekMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztJQUM1QyxDQUFDO0lBRU0sS0FBSyxDQUFDLElBQUksQ0FBQyxNQUFjO1FBQzlCLE9BQU8sQ0FBQyxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNqRixDQUFDO0lBRU0sS0FBSyxDQUFDLE1BQU0sQ0FBQyxHQUFXO1FBQzdCLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzNCLENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -19,6 +19,20 @@ export interface IActionExecutorDeps {
     bounceManager: BounceManager;
     deliveryQueue: UnifiedDeliveryQueue;
 }
+export interface IActionExecutionOptions {
+    /**
+     * Queue the action with a deterministic durable id instead of performing
+     * direct delivery. Used when replaying an already-accepted envelope.
+     */
+    durableQueue?: {
+        idempotencyKey: string;
+        fingerprint: string;
+    };
+}
+export interface IActionExecutionResult {
+    outcome: 'completed' | 'queued';
+    queueId?: string;
+}
 /**
  * Executes email routing actions (forward, process, deliver, reject)
  */
@@ -27,6 +41,7 @@ export declare class EmailActionExecutor {
     constructor(deps: IActionExecutorDeps);
     private suppressPermanentRcptFailures;
     executeAction(action: IEmailAction, email: Email, context: IEmailContext): Promise<void>;
+    executeActionWithResult(action: IEmailAction, email: Email, context: IEmailContext, options?: IActionExecutionOptions): Promise<IActionExecutionResult>;
     private handleForwardAction;
     private handleProcessAction;
     private handleDeliverAction;

package/dist_ts/mail/routing/classes.email.action.executor.js

@@ -31,26 +31,26 @@ export class EmailActionExecutor {
         }
     }
     async executeAction(action, email, context) {
+        await this.executeActionWithResult(action, email, context);
+    }
+    async executeActionWithResult(action, email, context, options = {}) {
         switch (action.type) {
             case 'forward':
-                await this.handleForwardAction(action, email, context);
-                break;
+                return this.handleForwardAction(action, email, context, options);
             case 'process':
-                await this.handleProcessAction(action, email, context);
-                break;
+                return this.handleProcessAction(action, email, context, options);
             case 'deliver':
-                await this.handleDeliverAction(action, email, context);
-                break;
+                return this.handleDeliverAction(action, email, context, options);
             case 'store':
                 throw new Error('Store actions require raw SMTP context and an awaited hooks.onAcceptEnvelope handler');
             case 'reject':
                 await this.handleRejectAction(action, email, context);
-                break;
+                throw new Error('Reject action unexpectedly returned');
             default:
                 throw new Error(`Unknown action type: ${action.type}`);
         }
     }
-    async handleForwardAction(action, email, context) {
+    async handleForwardAction(action, email, context, options) {
         if (!action.forward) {
             throw new Error('Forward action requires forward configuration');
         }
@@ -66,6 +66,14 @@ export class EmailActionExecutor {
         email.headers['X-Forwarded-For'] = context.session.remoteAddress || 'unknown';
         email.headers['X-Forwarded-To'] = email.to.join(', ');
         email.headers['X-Forwarded-Date'] = new Date().toISOString();
+        if (options.durableQueue) {
+            const queueId = await this.deps.deliveryQueue.enqueue(email, 'forward', context.session.matchedRoute, {
+                idempotencyKey: options.durableQueue.idempotencyKey,
+                idempotencyFingerprint: options.durableQueue.fingerprint,
+                requireDurable: true,
+            });
+            return { outcome: 'queued', queueId };
+        }
         try {
             // Send email via Rust SMTP client
             const result = await this.deps.sendOutboundEmail(host, port, email, {
@@ -87,6 +95,7 @@ export class EmailActionExecutor {
                 },
                 success: true
             }));
+            return { outcome: 'completed' };
         }
         catch (error) {
             const errorMessage = getErrorMessage(error);
@@ -123,7 +132,7 @@ export class EmailActionExecutor {
             throw error;
         }
     }
-    async handleProcessAction(action, email, context) {
+    async handleProcessAction(action, email, context, options) {
         logger.log('info', `Processing email with action options`);
         // Apply scanning if requested
         if (action.process?.scan) {
@@ -131,14 +140,28 @@ export class EmailActionExecutor {
         }
         // Queue for delivery
         const queue = action.process?.queue || 'normal';
-        await this.deps.deliveryQueue.enqueue(email, 'process', context.session.matchedRoute);
+        const queueId = await this.deps.deliveryQueue.enqueue(email, 'process', context.session.matchedRoute, options.durableQueue
+            ? {
+                idempotencyKey: options.durableQueue.idempotencyKey,
+                idempotencyFingerprint: options.durableQueue.fingerprint,
+                requireDurable: true,
+            }
+            : {});
         logger.log('info', `Email queued for delivery in ${queue} queue`);
+        return { outcome: 'queued', queueId };
     }
-    async handleDeliverAction(_action, email, context) {
+    async handleDeliverAction(_action, email, context, options) {
         logger.log('info', `Delivering email locally`);
         // Queue for local delivery
-        await this.deps.deliveryQueue.enqueue(email, 'mta', context.session.matchedRoute);
+        const queueId = await this.deps.deliveryQueue.enqueue(email, 'mta', context.session.matchedRoute, options.durableQueue
+            ? {
+                idempotencyKey: options.durableQueue.idempotencyKey,
+                idempotencyFingerprint: options.durableQueue.fingerprint,
+                requireDurable: true,
+            }
+            : {});
         logger.log('info', 'Email queued for local delivery');
+        return { outcome: 'queued', queueId };
     }
     async handleRejectAction(action, _email, context) {
         const code = action.reject?.code || 550;
@@ -165,4 +188,4 @@ export class EmailActionExecutor {
         throw error;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.email.action.executor.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.email.action.executor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EACL,iBAAiB,GAGlB,MAAM,8CAA8C,CAAC;AAgBtD;;GAEG;AACH,MAAM,OAAO,mBAAmB;IACV;IAApB,YAAoB,IAAyB;QAAzB,SAAI,GAAJ,IAAI,CAAqB;IAAG,CAAC;IAEzC,KAAK,CAAC,6BAA6B,CACzC,KAAY,EACZ,OAA+B;QAE/B,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,YAAY,GAAG,GAAG;gBAAE,SAAS;YAC3D,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAC9C,MAAM,CAAC,SAAS,EAChB,gCAAgC,MAAM,CAAC,YAAY,EAAE,EACrD;oBACE,MAAM,EAAE,KAAK,CAAC,IAAI;oBAClB,eAAe,EAAE,KAAK,CAAC,OAAO,CAAC,YAAY,CAAW;oBACtD,UAAU,EAAE,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC;iBACxC,CACF,CAAC;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,GAAG,CACR,OAAO,EACP,gDAAgD,MAAM,CAAC,SAAS,KAAM,KAAe,CAAC,OAAO,EAAE,CAChG,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,MAAoB,EAAE,KAAY,EAAE,OAAsB;QAC5E,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;YACpB,KAAK,SAAS;gBACZ,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;gBACvD,MAAM;YACR,KAAK,SAAS;gBACZ,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;gBACvD,MAAM;YACR,KAAK,SAAS;gBACZ,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;gBACvD,MAAM;YACR,KAAK,OAAO;gBACV,MAAM,IAAI,KAAK,CACb,sFAAsF,CACvF,CAAC;YACJ,KAAK,QAAQ;gBACX,MAAM,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;gBACtD,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,wBAAyB,MAAc,CAAC,IAAI,EAAE,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAAC,MAAoB,EAAE,KAAY,EAAE,OAAsB;QAC1F,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACnE,CAAC;QAED,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC;QAE7D,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,uBAAuB,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC;QAE1D,yBAAyB;QACzB,IAAI,UAAU,EAAE,CAAC;YACf,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,CAAC;gBACtD,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;YAC7B,CAAC;QACH,CAAC;QAED,kCAAkC;QAClC,KAAK,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,aAAa,IAAI,SAAS,CAAC;QAC9E,KAAK,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtD,KAAK,CAAC,OAAO,CAAC,kBAAkB,CAAC,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAE7D,IAAI,CAAC;YACH,kCAAkC;YAClC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE;gBAClE,IAAI,EAAE,IAAkD;aACzD,CAAC,CAAC;YACH,MAAM,IAAI,CAAC,6BAA6B,CAAC,KAAK,EAAE,MAAM,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC;YAE/E,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,mCAAmC,IAAI,IAAI,IAAI,EAAE,CAAC,CAAC;YAEtE,MAAM,kBAAkB,CAAC,8BAA8B,EAAE,GAAG,EAAE,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC;gBACnG,KAAK,EAAE,gBAAgB,CAAC,IAAI;gBAC5B,IAAI,EAAE,iBAAiB,CAAC,gBAAgB;gBACxC,OAAO,EAAE,8BAA8B;gBACvC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,aAAa;gBACxC,OAAO,EAAE;oBACP,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE;oBAC7B,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,IAAI;oBAC7C,UAAU,EAAE,IAAI;oBAChB,UAAU,EAAE,IAAI;oBAChB,UAAU,EAAE,KAAK,CAAC,EAAE;iBACrB;gBACD,OAAO,EAAE,IAAI;aACd,CAAC,CAAC,CAAC;QACN,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;YAC5C,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,4BAA4B,YAAY,EAAE,CAAC,CAAC;YAEhE,MAAM,kBAAkB,CAAC,8BAA8B,EAAE,GAAG,EAAE,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC;gBACnG,KAAK,EAAE,gBAAgB,CAAC,KAAK;gBAC7B,IAAI,EAAE,iBAAiB,CAAC,gBAAgB;gBACxC,OAAO,EAAE,yBAAyB;gBAClC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,aAAa;gBACxC,OAAO,EAAE;oBACP,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE;oBAC7B,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,IAAI;oBAC7C,UAAU,EAAE,IAAI;oBAChB,UAAU,EAAE,IAAI;oBAChB,KAAK,EAAE,YAAY;iBACpB;gBACD,OAAO,EAAE,KAAK;aACf,CAAC,CAAC,CAAC;YAEJ,MAAM,SAAS,GAAG,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAChD,IACE,CAAC,SAAS,CAAC,SAAS;mBACjB,SAAS,CAAC,SAAS,KAAK,UAAU;mBAClC,SAAS,CAAC,KAAK,KAAK,SAAS;mBAC7B,CACD,CAAC,OAAO,SAAS,CAAC,QAAQ,KAAK,QAAQ,IAAI,SAAS,CAAC,QAAQ,IAAI,GAAG,CAAC;uBAClE,SAAS,CAAC,gBAAgB,CAAC,IAAI,CAChC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,IAAI,MAAM,CAAC,YAAY,IAAI,GAAG,CAC3D,CACF,EACD,CAAC;gBACD,MAAM,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC;oBAC5D,CAAC,CAAC,SAAS,CAAC,gBAAgB;oBAC5B,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;wBACvC,SAAS;wBACT,QAAQ,EAAE,KAAK;wBACf,YAAY,EAAE,SAAS,CAAC,QAAS;qBAClC,CAAC,CAAC,CAAC;gBACR,MAAM,IAAI,CAAC,6BAA6B,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;YACpE,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAAC,MAAoB,EAAE,KAAY,EAAE,OAAsB;QAC1F,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,sCAAsC,CAAC,CAAC;QAE3D,8BAA8B;QAC9B,IAAI,MAAM,CAAC,OAAO,EAAE,IAAI,EAAE,CAAC;YACzB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAC;QACnD,CAAC;QAED,qBAAqB;QACrB,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,EAAE,KAAK,IAAI,QAAQ,CAAC;QAChD,MAAM,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,YAAa,CAAC,CAAC;QAEvF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,gCAAgC,KAAK,QAAQ,CAAC,CAAC;IACpE,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAAC,OAAqB,EAAE,KAAY,EAAE,OAAsB;QAC3F,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC,CAAC;QAE/C,2BAA2B;QAC3B,MAAM,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,YAAa,CAAC,CAAC;QAEnF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,iCAAiC,CAAC,CAAC;IACxD,CAAC;IAEO,KAAK,CAAC,kBAAkB,CAAC,MAAoB,EAAE,MAAa,EAAE,OAAsB;QAC1F,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,IAAI,GAAG,CAAC;QACxC,MAAM,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,IAAI,kBAAkB,CAAC;QAE7D,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,6BAA6B,IAAI,KAAK,OAAO,EAAE,CAAC,CAAC;QAEpE,MAAM,kBAAkB,CAAC,gCAAgC,EAAE,GAAG,EAAE,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC;YACrG,KAAK,EAAE,gBAAgB,CAAC,IAAI;YAC5B,IAAI,EAAE,iBAAiB,CAAC,gBAAgB;YACxC,OAAO,EAAE,gCAAgC;YACzC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,aAAa;YACxC,OAAO,EAAE;gBACP,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE;gBAC7B,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,IAAI;gBAC7C,UAAU,EAAE,IAAI;gBAChB,aAAa,EAAE,OAAO;gBACtB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,EAAE,EAAE,MAAM,CAAC,EAAE;aACd;YACD,OAAO,EAAE,KAAK;SACf,CAAC,CAAC,CAAC;QAEJ,yCAAyC;QACzC,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;QAChC,KAAa,CAAC,YAAY,GAAG,IAAI,CAAC;QACnC,MAAM,KAAK,CAAC;IACd,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.email.action.executor.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.email.action.executor.ts"],"names":[],"mappings":"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"}

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

@@ -2,7 +2,7 @@ import { EventEmitter } from 'events';
 import { DKIMCreator } from '../security/classes.dkimcreator.js';
 import type { IStorageManager } from '../interfaces.storage.js';
 import type { IInboundEmailSecurityResult } from '../../security/classes.rustsecuritybridge.js';
-import type { IEmailRoute, IEmailDomainConfig } from './interfaces.js';
+import type { IEmailRoute, IEmailAction, IEmailDomainConfig } from './interfaces.js';
 import { Email } from '../core/classes.email.js';
 import { DomainRegistry } from './classes.domain.registry.js';
 import { BounceType, BounceCategory } from '../core/classes.bouncemanager.js';
@@ -75,6 +75,16 @@ export interface IMessageAcceptanceContext {
     resolvedRecipientRoutes: IResolvedRecipientRoute[];
     abortSignal?: AbortSignal;
 }
+/**
+ * Throw from `hooks.onAcceptEnvelope` to REJECT the envelope with a permanent
+ * SMTP status (e.g. DMARC policy enforcement) instead of the generic 451
+ * temporary failure used for infrastructure errors.
+ */
+export declare class AcceptEnvelopeRejectionError extends Error {
+    readonly smtpCode: number;
+    readonly smtpMessage: string;
+    constructor(smtpCode: number, smtpMessage: string);
+}
 /**
  * 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.
@@ -96,6 +106,53 @@ export interface IAcceptEnvelopeContext {
     /** 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[];
+}
 export interface IMessageAcceptanceDecision extends ISmtpDecision {
     /** Continue SmartMTA's built-in route processing after the consumer accepted responsibility. */
     continueProcessing?: boolean;
@@ -280,6 +337,9 @@ export declare class UnifiedEmailServer extends EventEmitter {
     private bridgeEmailReceivedHandler?;
     private bridgeAuthRequestHandler?;
     private bridgeScramCredentialRequestHandler?;
+    private acceptedEnvelopeDispatchCleanupTimer?;
+    private acceptedEnvelopeDispatchCleanupPromise?;
+    private acceptedEnvelopeDispatchCleanupCursor?;
     constructor(dcRouter: DcRouter, options: IUnifiedEmailServerOptions);
     onRecipientRejected(listener: (event: IRecipientRejectedEvent) => Promise<void> | void): this;
     offRecipientRejected(listener: (event: IRecipientRejectedEvent) => Promise<void> | void): this;
@@ -346,6 +406,26 @@ export declare class UnifiedEmailServer extends EventEmitter {
     private buildDataPolicyContext;
     private resolveDataRecipientRoutes;
     private acceptDurableEnvelope;
+    private cloneJsonSafe;
+    private stableJson;
+    private validateAcceptedEnvelopeAction;
+    private normalizeAcceptedEnvelopePlan;
+    /**
+     * Snapshot the already-resolved acceptance plan for durable consumer storage.
+     * No live route lookup is performed when the returned plan is dispatched.
+     */
+    createAcceptedEnvelopeDispatchPlan(context: IAcceptEnvelopeContext, idempotencyKeys: readonly string[]): readonly IAcceptedEnvelopeRecipientPlan[];
+    private acceptedEnvelopeDispatchStorageKey;
+    private startAcceptedEnvelopeDispatchCleanup;
+    private cleanupExpiredAcceptedEnvelopeDispatchResults;
+    private readAcceptedEnvelopeDispatchResult;
+    private writeAcceptedEnvelopeDispatchResult;
+    /**
+     * 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.
+     */
+    dispatchAcceptedEnvelope(rawMessage: Uint8Array, planArg: readonly IAcceptedEnvelopeRecipientPlan[], metadataArg: IAcceptedEnvelopeDispatchMetadata): Promise<IAcceptedEnvelopeDispatchResult>;
     /**
      * Handle an emailReceived event from the Rust SMTP server.
      */