@serve.zone/dcrouter 18.0.1 → 18.1.0

package/dist_ts/email/classes.smtp-account.manager.js

@@ -0,0 +1,507 @@
+import { assertValidAuthAccounts } from '@push.rocks/smartmta';
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+import { SmtpAccountDoc } from '../db/index.js';
+import { isWorkAppManagedMailRouteName, isWorkAppManagedSmtpUsername, } from './classes.workapp-mail-manager.js';
+import { deriveSmtpScramVerifier, generateSmtpAccountPassword } from './smtp-scram.js';
+/** Route names generated (and owned wholesale) by SmtpAccountManager. */
+export function isSmtpAccountRouteName(routeName) {
+    return routeName.startsWith('smtp-account-');
+}
+const SMTP_ACCOUNT_USERNAME_PATTERN = /^[a-z0-9][a-z0-9._-]{2,63}$/;
+/** Literal domain label chain — no wildcards, at least one dot. */
+const SMTP_ACCOUNT_DOMAIN_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/;
+/** Address pattern: optional '*' glob in the local part only, literal domain. */
+const SMTP_ACCOUNT_ADDRESS_LOCAL_PATTERN = /^[a-z0-9*][a-z0-9.*_+-]*$/;
+/**
+ * SmtpAccountManager — operator-managed authenticated SMTP submission
+ * accounts, backed by SmtpAccountDoc rows holding hashed SCRAM verifiers only.
+ *
+ * Single composition owner of the email runtime `auth` block and route list:
+ * every runtime application of auth/routes goes through composeEmailConfig /
+ * applyToRuntime here. WorkAppMailManager identities feed in as an explicit
+ * contribution; nothing else writes `auth` wholesale.
+ *
+ * Accounts are served from an in-memory map loaded at start() — the SMTP auth
+ * path (smartmta's Rust bridge, 5s callback timeout) never touches the DB.
+ */
+export class SmtpAccountManager {
+    dcRouterRef;
+    accounts = new Map();
+    started = false;
+    mutationChain = Promise.resolve();
+    /** Explicit upstream capability marker; absence is deliberately fail-closed. */
+    get authAccountsCapability() {
+        return plugins.smartmta.smartMtaCapabilities?.smtpAuthAccountsAndScopes === true;
+    }
+    constructor(dcRouterRef) {
+        this.dcRouterRef = dcRouterRef;
+    }
+    async start() {
+        const docs = await SmtpAccountDoc.findAll();
+        this.accounts = new Map(docs.map((doc) => [doc.id, doc]));
+        this.started = true;
+        if (this.accounts.size > 0) {
+            logger.log('info', `SmtpAccountManager loaded ${this.accounts.size} SMTP account(s)`);
+        }
+    }
+    async stop() {
+        this.accounts.clear();
+        this.started = false;
+    }
+    isStarted() {
+        return this.started;
+    }
+    getAccountCount() {
+        return this.accounts.size;
+    }
+    // ==========================================================================
+    // Composition — the single owner of auth + route-list assembly
+    // ==========================================================================
+    /**
+     * Compose the runtime email config: operator-configured routes/users plus
+     * the workapp identity contribution plus DB-backed SMTP accounts and their
+     * generated relay routes. Idempotent — previously generated entries are
+     * stripped by their reserved name prefixes before re-adding.
+     */
+    async composeEmailConfig(emailConfig, workappContribution) {
+        const contribution = workappContribution
+            ?? await this.dcRouterRef.workAppMailManager.getStoredIdentityContribution(emailConfig);
+        if (!this.authAccountsCapability) {
+            // Fail closed: without the smartmta capability the accounts field would
+            // be silently ignored (or rejected), so never pretend they are active —
+            // any pre-existing accounts entry is dropped from the composed auth too.
+            if (this.accounts.size > 0) {
+                logger.log('error', `SmartMTA is missing the smtpAuthAccountsAndScopes capability — ${this.accounts.size} stored SMTP account(s) are NOT active`);
+            }
+            const authWithoutAccounts = { ...(emailConfig.auth || {}) };
+            delete authWithoutAccounts.accounts;
+            return {
+                ...emailConfig,
+                routes: [
+                    ...(emailConfig.routes || [])
+                        .filter((route) => !isWorkAppManagedMailRouteName(route.name) && !isSmtpAccountRouteName(route.name)),
+                    ...contribution.routes,
+                ],
+                auth: {
+                    ...authWithoutAccounts,
+                    users: [
+                        ...(emailConfig.auth?.users || []).filter((user) => !isWorkAppManagedSmtpUsername(user.username)),
+                        ...contribution.users,
+                    ],
+                },
+            };
+        }
+        const accountDocs = [...this.accounts.values()]
+            .sort((a, b) => a.username.localeCompare(b.username));
+        const smtpAccounts = [];
+        const accountRoutes = [];
+        for (const doc of accountDocs) {
+            const account = this.buildAuthAccount(doc);
+            try {
+                // smartmta's own validator — construction and updateOptions throw on
+                // invalid accounts, so a bad DB row must never reach the push.
+                // Validated per account so one row cannot take the whole auth block
+                // down.
+                assertValidAuthAccounts([account]);
+            }
+            catch (error) {
+                const message = error.message;
+                logger.log('error', `SMTP account ${doc.username} excluded from runtime auth (invalid stored configuration): ${message}`);
+                this.recordAccountConflictEvent(doc.username, message);
+                continue;
+            }
+            smtpAccounts.push(account);
+            if (doc.enabled) {
+                accountRoutes.push(...this.buildAccountRoutes(doc));
+            }
+        }
+        const configuredRoutes = (emailConfig.routes || [])
+            .filter((route) => !isWorkAppManagedMailRouteName(route.name) && !isSmtpAccountRouteName(route.name));
+        const configuredUsers = (emailConfig.auth?.users || [])
+            .filter((user) => !isWorkAppManagedSmtpUsername(user.username));
+        return {
+            ...emailConfig,
+            routes: [...configuredRoutes, ...contribution.routes, ...accountRoutes],
+            auth: {
+                ...(emailConfig.auth || {}),
+                users: [...configuredUsers, ...contribution.users],
+                accounts: smtpAccounts,
+            },
+        };
+    }
+    /**
+     * Recompose from the live runtime options and push the result: replace the
+     * whole `auth` block (smartmta toggles listener AUTH live) and re-apply the
+     * route list.
+     */
+    async applyToRuntime(workappContribution) {
+        const emailConfig = this.dcRouterRef.options.emailConfig;
+        if (!emailConfig)
+            return;
+        const nextConfig = await this.composeEmailConfig(emailConfig, workappContribution);
+        this.dcRouterRef.options.emailConfig = nextConfig;
+        if (this.dcRouterRef.emailServer) {
+            this.dcRouterRef.emailServer.updateOptions({ auth: nextConfig.auth });
+            await this.dcRouterRef.updateEmailRoutes(nextConfig.routes);
+        }
+    }
+    buildAuthAccount(doc) {
+        const senders = [
+            ...(doc.senderScope?.addresses || []),
+            ...(doc.senderScope?.domains || []).map((domain) => `*@${domain}`),
+        ];
+        const recipientsRestricted = doc.recipientScope?.mode === 'restricted';
+        const recipientPatterns = [
+            ...(doc.recipientScope?.addresses || []),
+            ...(doc.recipientScope?.domains || []).map((domain) => `*@${domain}`),
+        ];
+        let scope;
+        if (senders.length > 0 || recipientsRestricted) {
+            scope = {
+                // Unrestricted senders with restricted recipients still needs a scope
+                // block; '*' matches every sender including the null sender.
+                senders: senders.length > 0 ? senders : ['*'],
+                ...(recipientsRestricted
+                    ? { recipients: { mode: 'patterns', patterns: recipientPatterns } }
+                    : {}),
+            };
+        }
+        return {
+            username: doc.username,
+            enabled: doc.enabled,
+            credential: { verifier: doc.credentialVerifier },
+            ...(scope ? { scope } : {}),
+        };
+    }
+    /**
+     * One generated relay route per (account × sender-scope domain), name
+     * `smtp-account-<id>-<domainHash>`, priority 850 — below workapp
+     * per-address routes (900), above operator-configured DB routes.
+     *
+     * Accounts without a sender scope generate no routes: their relay
+     * permission stays exactly whatever operator-configured routes grant
+     * (this is what keeps the legacy-user migration from widening relay).
+     *
+     * DKIM policy rides on `process.dkim` only — smartmta ≥9.1 resolves the
+     * active selector per sender domain from its domain registry, so no
+     * selector is snapshotted into routes and rotation stays owned by
+     * EmailDomainManager/mail-dns-sync.
+     */
+    buildAccountRoutes(doc) {
+        const senderDomains = this.collectSenderDomainPatterns(doc.senderScope);
+        const routes = [];
+        for (const [domain, patterns] of senderDomains) {
+            routes.push({
+                name: `smtp-account-${doc.id}-${this.hashDomain(domain)}`,
+                priority: 850,
+                match: {
+                    authenticated: true,
+                    authenticatedUser: doc.username,
+                    senders: patterns,
+                },
+                action: {
+                    type: 'process',
+                    allowRelay: true,
+                    process: {
+                        dkim: Boolean(doc.mailPolicy?.dkimSign),
+                        queue: doc.mailPolicy?.queue ?? 'normal',
+                    },
+                },
+            });
+        }
+        return routes;
+    }
+    /** Map of sender-scope domain -> the scope patterns belonging to it. */
+    collectSenderDomainPatterns(senderScope) {
+        const byDomain = new Map();
+        for (const domain of senderScope?.domains || []) {
+            const key = domain.toLowerCase();
+            byDomain.set(key, [...(byDomain.get(key) || []), `*@${key}`]);
+        }
+        for (const address of senderScope?.addresses || []) {
+            const domainPart = address.split('@')[1]?.toLowerCase();
+            if (!domainPart)
+                continue;
+            byDomain.set(domainPart, [...(byDomain.get(domainPart) || []), address.toLowerCase()]);
+        }
+        return byDomain;
+    }
+    hashDomain(domain) {
+        return plugins.crypto.createHash('sha256').update(domain.toLowerCase()).digest('hex').slice(0, 8);
+    }
+    recordAccountConflictEvent(username, message) {
+        const opsEventManager = this.dcRouterRef.opsEventManager;
+        if (!opsEventManager)
+            return;
+        opsEventManager.recordEvent({
+            severity: 'error',
+            category: 'smtp-accounts',
+            title: 'SMTP account excluded from runtime authentication',
+            detail: `Stored SMTP account '${username}' failed validation and was excluded from the composed auth block: ${message}`,
+            context: { recordName: username },
+        }).catch((error) => {
+            logger.log('warn', `Failed to record SMTP account conflict event for ${username}: ${error.message}`);
+        });
+    }
+    // ==========================================================================
+    // CRUD
+    // ==========================================================================
+    async listAccounts() {
+        const docs = [...this.accounts.values()]
+            .sort((a, b) => a.username.localeCompare(b.username));
+        const accounts = [];
+        for (const doc of docs) {
+            accounts.push(await this.decorateWithDomainReadiness(doc));
+        }
+        return accounts;
+    }
+    async createAccount(options) {
+        return await this.runMutationExclusive(async () => {
+            if (!this.authAccountsCapability) {
+                throw new Error('SmartMTA runtime does not support SMTP auth accounts (smtpAuthAccountsAndScopes capability missing)');
+            }
+            const username = this.normalizeUsername(options.username);
+            const senderScope = this.normalizeSenderScope(options.senderScope);
+            const recipientScope = this.normalizeRecipientScope(options.recipientScope);
+            const mailPolicy = this.normalizeMailPolicy(options.mailPolicy);
+            await this.assertDkimPolicyAllowed(mailPolicy, senderScope, username);
+            if ([...this.accounts.values()].some((doc) => doc.username === username)
+                || await SmtpAccountDoc.findByUsername(username)) {
+                throw new Error(`SMTP account username is already taken: ${username}`);
+            }
+            const password = generateSmtpAccountPassword();
+            const now = Date.now();
+            const doc = new SmtpAccountDoc();
+            doc.id = `smtpacct_${now.toString(36)}_${plugins.crypto.randomBytes(6).toString('hex')}`;
+            doc.username = username;
+            doc.description = (options.description || '').trim();
+            doc.enabled = true;
+            doc.credentialVerifier = deriveSmtpScramVerifier(password);
+            doc.senderScope = senderScope;
+            doc.recipientScope = recipientScope;
+            doc.mailPolicy = mailPolicy;
+            doc.createdAt = now;
+            doc.updatedAt = now;
+            doc.createdBy = options.createdBy;
+            await doc.save();
+            this.accounts.set(doc.id, doc);
+            await this.applyToRuntime();
+            const warnings = await this.collectSenderDomainWarnings(senderScope);
+            logger.log('info', `SMTP account '${username}' created by ${options.createdBy} (id: ${doc.id})`);
+            return { account: await this.decorateWithDomainReadiness(doc), password, warnings };
+        });
+    }
+    async updateAccount(id, updates, updatedBy) {
+        return await this.runMutationExclusive(async () => {
+            const doc = this.requireAccount(id);
+            const senderScope = updates.senderScope !== undefined
+                ? this.normalizeSenderScope(updates.senderScope)
+                : doc.senderScope;
+            const recipientScope = updates.recipientScope !== undefined
+                ? this.normalizeRecipientScope(updates.recipientScope)
+                : doc.recipientScope;
+            const mailPolicy = updates.mailPolicy !== undefined
+                ? this.normalizeMailPolicy(updates.mailPolicy)
+                : doc.mailPolicy;
+            await this.assertDkimPolicyAllowed(mailPolicy, senderScope, doc.username);
+            if (updates.description !== undefined) {
+                doc.description = updates.description.trim();
+            }
+            doc.senderScope = senderScope;
+            doc.recipientScope = recipientScope;
+            doc.mailPolicy = mailPolicy;
+            doc.updatedAt = Date.now();
+            await doc.save();
+            this.accounts.set(doc.id, doc);
+            await this.applyToRuntime();
+            const warnings = await this.collectSenderDomainWarnings(senderScope);
+            logger.log('info', `SMTP account '${doc.username}' updated by ${updatedBy}`);
+            return { account: await this.decorateWithDomainReadiness(doc), warnings };
+        });
+    }
+    async toggleAccount(id, enabled, updatedBy) {
+        return await this.runMutationExclusive(async () => {
+            const doc = this.requireAccount(id);
+            doc.enabled = enabled;
+            doc.updatedAt = Date.now();
+            await doc.save();
+            this.accounts.set(doc.id, doc);
+            await this.applyToRuntime();
+            logger.log('info', `SMTP account '${doc.username}' ${enabled ? 'enabled' : 'disabled'} by ${updatedBy}`);
+            return { account: await this.decorateWithDomainReadiness(doc), warnings: [] };
+        });
+    }
+    async rotatePassword(id, rotatedBy) {
+        return await this.runMutationExclusive(async () => {
+            const doc = this.requireAccount(id);
+            const password = generateSmtpAccountPassword();
+            doc.credentialVerifier = deriveSmtpScramVerifier(password);
+            doc.lastRotatedAt = Date.now();
+            doc.updatedAt = doc.lastRotatedAt;
+            await doc.save();
+            this.accounts.set(doc.id, doc);
+            await this.applyToRuntime();
+            logger.log('info', `SMTP account '${doc.username}' password rotated by ${rotatedBy}`);
+            return { account: await this.decorateWithDomainReadiness(doc), password, warnings: [] };
+        });
+    }
+    async deleteAccount(id, deletedBy) {
+        return await this.runMutationExclusive(async () => {
+            const doc = this.requireAccount(id);
+            await doc.delete();
+            this.accounts.delete(id);
+            await this.applyToRuntime();
+            logger.log('info', `SMTP account '${doc.username}' deleted by ${deletedBy}`);
+        });
+    }
+    // ==========================================================================
+    // Validation / normalization
+    // ==========================================================================
+    requireAccount(id) {
+        const doc = this.accounts.get(id);
+        if (!doc) {
+            throw new Error(`SMTP account not found: ${id}`);
+        }
+        return doc;
+    }
+    normalizeUsername(usernameArg) {
+        const username = (usernameArg || '').trim().toLowerCase();
+        if (!SMTP_ACCOUNT_USERNAME_PATTERN.test(username)) {
+            throw new Error('SMTP account username must be 3-64 characters of a-z, 0-9, dot, underscore, or dash, starting alphanumeric');
+        }
+        if (isWorkAppManagedSmtpUsername(username)) {
+            throw new Error(`SMTP account usernames may not use the reserved 'workapp-' prefix: ${username}`);
+        }
+        return username;
+    }
+    normalizeDomain(domainArg, context) {
+        const domain = (domainArg || '').trim().toLowerCase();
+        if (!SMTP_ACCOUNT_DOMAIN_PATTERN.test(domain)) {
+            throw new Error(`Invalid ${context} domain (wildcards are not allowed in domains): ${domainArg}`);
+        }
+        return domain;
+    }
+    normalizeAddressPattern(addressArg, context) {
+        const address = (addressArg || '').trim().toLowerCase();
+        const parts = address.split('@');
+        if (parts.length !== 2
+            || !SMTP_ACCOUNT_ADDRESS_LOCAL_PATTERN.test(parts[0])
+            || !SMTP_ACCOUNT_DOMAIN_PATTERN.test(parts[1])) {
+            throw new Error(`Invalid ${context} address pattern ('local@domain', '*' allowed in the local part only): ${addressArg}`);
+        }
+        return address;
+    }
+    normalizeSenderScope(scopeArg) {
+        return {
+            addresses: this.dedupe((scopeArg?.addresses || []).map((address) => this.normalizeAddressPattern(address, 'sender scope'))),
+            domains: this.dedupe((scopeArg?.domains || []).map((domain) => this.normalizeDomain(domain, 'sender scope'))),
+        };
+    }
+    normalizeRecipientScope(scopeArg) {
+        const mode = scopeArg?.mode === 'restricted' ? 'restricted' : 'any';
+        const addresses = this.dedupe((scopeArg?.addresses || []).map((address) => this.normalizeAddressPattern(address, 'recipient scope')));
+        const domains = this.dedupe((scopeArg?.domains || []).map((domain) => this.normalizeDomain(domain, 'recipient scope')));
+        if (mode === 'restricted' && addresses.length === 0 && domains.length === 0) {
+            throw new Error('A restricted recipient scope requires at least one address or domain (an empty list would silently deny all mail)');
+        }
+        return { mode, addresses, domains };
+    }
+    normalizeMailPolicy(policyArg) {
+        const queue = policyArg?.queue;
+        if (queue !== undefined && !['normal', 'priority', 'bulk'].includes(queue)) {
+            throw new Error(`Invalid mail policy queue: ${queue}`);
+        }
+        return {
+            dkimSign: Boolean(policyArg?.dkimSign),
+            ...(queue ? { queue } : {}),
+        };
+    }
+    /**
+     * DKIM signing fails at configuration time, never at delivery time: it is
+     * only allowed when every sender-scope domain is a managed email domain
+     * that is outbound-ready with active DKIM material.
+     */
+    async assertDkimPolicyAllowed(mailPolicy, senderScope, username) {
+        if (!mailPolicy.dkimSign)
+            return;
+        const senderDomains = [...this.collectSenderDomainPatterns(senderScope).keys()];
+        if (senderDomains.length === 0) {
+            throw new Error(`DKIM signing for SMTP account '${username}' requires an explicit sender scope naming the domain(s) to sign for`);
+        }
+        const emailDomainManager = this.dcRouterRef.emailDomainManager;
+        if (!emailDomainManager) {
+            throw new Error('DKIM signing requires the email domain manager, which is not available');
+        }
+        for (const domain of senderDomains) {
+            if (!await emailDomainManager.getByDomain(domain)) {
+                throw new Error(`DKIM signing requires managed email domains; '${domain}' is not managed by dcrouter`);
+            }
+            const readiness = await emailDomainManager.getOutboundReadiness(domain);
+            if (!readiness.ready || !readiness.selector) {
+                throw new Error(`DKIM signing requires outbound-ready DKIM material for '${domain}': ${readiness.reason || 'no active DKIM selector'}`);
+            }
+        }
+    }
+    /** Warn-and-allow: sender domains outside managed email domains are permitted but flagged. */
+    async collectSenderDomainWarnings(senderScope) {
+        const warnings = [];
+        const emailDomainManager = this.dcRouterRef.emailDomainManager;
+        if (!emailDomainManager)
+            return warnings;
+        for (const domain of this.collectSenderDomainPatterns(senderScope).keys()) {
+            try {
+                if (!await emailDomainManager.getByDomain(domain)) {
+                    warnings.push(`Sender domain '${domain}' is not a managed email domain — outbound DNS alignment (SPF/DKIM/DMARC) is not managed by dcrouter`);
+                }
+            }
+            catch (error) {
+                warnings.push(`Could not verify sender domain '${domain}': ${error.message}`);
+            }
+        }
+        return warnings;
+    }
+    async decorateWithDomainReadiness(doc) {
+        const info = doc.toApiObject();
+        const emailDomainManager = this.dcRouterRef.emailDomainManager;
+        const senderDomains = [...this.collectSenderDomainPatterns(doc.senderScope).keys()];
+        if (!emailDomainManager || senderDomains.length === 0)
+            return info;
+        const domainReadiness = [];
+        for (const domain of senderDomains) {
+            try {
+                if (!await emailDomainManager.getByDomain(domain)) {
+                    domainReadiness.push({
+                        domain,
+                        ready: !doc.mailPolicy?.dkimSign,
+                        reason: 'not a managed email domain',
+                    });
+                    continue;
+                }
+                const readiness = await emailDomainManager.getOutboundReadiness(domain);
+                domainReadiness.push({
+                    domain,
+                    ready: readiness.ready,
+                    ...(readiness.reason ? { reason: readiness.reason } : {}),
+                });
+            }
+            catch (error) {
+                domainReadiness.push({
+                    domain,
+                    ready: false,
+                    reason: `readiness check failed: ${error.message}`,
+                });
+            }
+        }
+        return { ...info, domainReadiness };
+    }
+    dedupe(values) {
+        return [...new Set(values)];
+    }
+    async runMutationExclusive(action) {
+        const run = this.mutationChain.then(action, action);
+        this.mutationChain = run.catch(() => undefined);
+        return await run;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.smtp-account.manager.js","sourceRoot":"","sources":["../../../ts/email/classes.smtp-account.manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/email/classes.workapp-mail-manager.d.ts

@@ -1,4 +1,4 @@
-import type { IExtendedSmtpSession, IMessageAcceptanceContext, IMessageAcceptanceDecision, IUnifiedEmailServerOptions } from '@push.rocks/smartmta';
+import type { IEmailRoute, IExtendedSmtpSession, IMessageAcceptanceContext, IMessageAcceptanceDecision, IUnifiedEmailServerOptions } from '@push.rocks/smartmta';
 import type { Buffer } from 'node:buffer';
 import * as plugins from '../plugins.js';
 import { CachedEmail } from '../db/index.js';
@@ -47,6 +47,22 @@ interface IStoredWorkAppMailIdentity {
     smtpPassword: string;
     smtpLastRotatedAt?: number;
 }
+/**
+ * WorkApp-generated routes and SMTP users contributed to the composed email
+ * runtime config. Consumed by SmtpAccountManager, the single owner of the
+ * final `auth` block and route-list composition.
+ */
+export interface IWorkAppMailRuntimeContribution {
+    routes: IEmailRoute[];
+    users: Array<{
+        username: string;
+        password: string;
+    }>;
+}
+/** Route names generated (and owned wholesale) by WorkAppMailManager. */
+export declare function isWorkAppManagedMailRouteName(routeName: string): boolean;
+/** SMTP usernames generated (and owned wholesale) by WorkAppMailManager. */
+export declare function isWorkAppManagedSmtpUsername(username: string): boolean;
 export declare class WorkAppMailManager {
     private dcRouterRef;
     private readonly storageKey;
@@ -79,12 +95,16 @@ export declare class WorkAppMailManager {
     deliverCachedEmailToTypedEndpoint(cachedEmailArg: CachedEmail, rawMessageArg: Buffer | plugins.buffer.Buffer, sessionArg: IExtendedSmtpSession): Promise<boolean>;
     deleteMailAddressBinding(id: string, createdBy: string): Promise<TMailAddressBindingDeleteResponse>;
     private deleteMailAddressBindingInner;
-    applyStoredIdentitiesToEmailConfig<TConfig extends IUnifiedEmailServerOptions>(emailConfig: TConfig): Promise<TConfig>;
+    /**
+     * Compute the workapp-generated routes and SMTP users for the given
+     * candidate email config. Pure contribution — the final composition of
+     * routes and the `auth` block is owned exclusively by SmtpAccountManager.
+     */
+    getStoredIdentityContribution(emailConfig: IUnifiedEmailServerOptions, identities?: IStoredWorkAppMailIdentity[] | undefined): Promise<IWorkAppMailRuntimeContribution>;
     applyStoredIdentitiesToRuntime(identities?: IStoredWorkAppMailIdentity[] | undefined): Promise<void>;
     private readStoredIdentities;
     private writeStoredIdentities;
     private getRequiredStorageManager;
-    private mergeIdentitiesIntoEmailConfig;
     private buildInboundRoute;
     private buildOutboundRoute;
     private ensureEmailDomainConfigured;
@@ -143,7 +163,6 @@ export declare class WorkAppMailManager {
     private buildOutboundRouteName;
     private hashExternalKey;
     private generateSmtpPassword;
-    private isManagedMailRouteName;
     private isManagedSmtpUsername;
     private buildSmtpCredentials;
     private toMailCredentialPublic;