@serve.zone/dcrouter 18.1.0 → 18.2.0

package/dist_ts/email/classes.accepted-email-spool.d.ts

@@ -77,6 +77,27 @@ export declare class AcceptedEmailSpool {
     private smtpTransactionListeners;
     private emailQueuePersistedListeners;
     constructor(dcRouterRef: DcRouter);
+    /**
+     * Direction is decided by the RECIPIENT, never by whether the session
+     * authenticated. Authentication grants permission to relay; it does not make
+     * a message addressed to a mailbox we host into outbound mail. A message with
+     * at least one locally hosted recipient is inbound — a local mailbox receives
+     * it — and only an envelope addressed exclusively to remote recipients is
+     * outbound.
+     *
+     * `IResolvedRecipientRoute.localDomain` is smartmta's own per-recipient
+     * verdict (non-null exactly when the domain registry hosts the domain), so
+     * the classification uses the same truth the routing decision used. When an
+     * acceptance context carries no resolution the envelope recipients are
+     * classified against the live registry instead — never against the session,
+     * which is the mistake being fixed.
+     */
+    private deriveDirectionFromResolvedRoutes;
+    /**
+     * Recipient-derived direction for programmatic submitters, which have no SMTP
+     * recipient resolution to consult. Falls back to the live domain registry.
+     */
+    private deriveDirectionFromRecipients;
     acceptMessage(context: IMessageAcceptanceContext, processAfterAccept?: boolean): Promise<IMessageAcceptanceDecision>;
     acceptRawMessage(optionsArg: IAcceptRawEmailOptions): Promise<IMessageAcceptanceDecision & {
         spoolItemId: string;
@@ -88,6 +109,50 @@ export declare class AcceptedEmailSpool {
      * exact-plan executor. Store recipients are fulfilled by the anchor itself.
      */
     acceptEnvelope(context: IAcceptEnvelopeContext, emailServer: UnifiedEmailServer): Promise<void>;
+    /**
+     * Session metadata for `dispatchAcceptedEnvelope`. It feeds the per-recipient
+     * idempotency fingerprint, so it must be JSON-round-trip stable: a replay
+     * reconstructed from persisted state has to produce byte-identical metadata
+     * or upstream refuses it as an idempotency-key reuse.
+     */
+    private buildEnvelopeDispatchMetadata;
+    /**
+     * Dispatch (or redispatch) the non-store recipients of a durably accepted
+     * envelope.
+     *
+     * The raw bytes handed to upstream are the exact bytes persisted for this row,
+     * because upstream fingerprints every recipient over the raw message: a later
+     * replay with different bytes would be rejected as an idempotency-key reuse
+     * rather than retried. Recipients that already succeeded are short-circuited
+     * by upstream's checkpoints, and `failed` results are deliberately not
+     * checkpointed upstream, so an identical replay retries exactly those.
+     *
+     * A `failed` recipient leaves the row non-terminal so the spool retries it;
+     * a `rejected` recipient is a permanent per-recipient refusal and is recorded
+     * durably instead of being retried. Either way the outcome is persisted — a
+     * relay recipient is never silently dropped after the SMTP 250.
+     */
+    private dispatchEnvelopeRecipients;
+    /**
+     * Persist a dispatch attempt's outcome on the durable-envelope row.
+     *
+     * The row's status tracks the stored envelope, not the relay: it goes
+     * `deferred` only while relay recipients still need a redispatch, and returns
+     * to its acceptance status once none do. Relay progress itself lives in
+     * `routeData.envelopeDispatch`, so a relay failure can never mark a row whose
+     * local copy stored successfully as failed.
+     */
+    private persistEnvelopeDispatchOutcome;
+    /**
+     * Take exclusive ownership of a durably accepted envelope row in the spool.
+     *
+     * Runs before live-queue postponement and before the normal spool handoff: a
+     * relay sibling that did enqueue would otherwise postpone this row forever,
+     * and the normal handoff would re-run route evaluation and duplicate a
+     * delivery the stored copy already fulfilled.
+     */
+    private handleDurableEnvelopeRow;
+    private trackAcceptedInboundEmail;
     /**
      * Synthesizes the inbound SMTP transaction for the email log from the
      * acceptance context: the receiving session where WE are the server. The
@@ -131,6 +196,8 @@ export declare class AcceptedEmailSpool {
     private clearSpoolTimer;
     private setDcRouterCacheIdHeader;
     private isCachedEmailTerminal;
+    /** Whether this row was durably accepted through the envelope acceptance path. */
+    private isDurableEnvelopeRow;
     /** The CachedEmail row a live queue item was spooled from (via the cache-id header). */
     getCachedEmailIdFromQueueItem(item: TSmartMtaQueueItemLike): string | undefined;
     private postponeLiveSmartMtaOwnedEmail;