@serve.zone/dcrouter 16.4.1 → 16.5.0

package/ts/email/classes.mail-edge-eligibility.ts

@@ -0,0 +1,205 @@
+import { REMOTE_INGRESS_MAIL_TAG } from '../../ts_interfaces/data/remoteingress.js';
+import type { IRemoteIngress } from '../../ts_interfaces/data/remoteingress.js';
+import type { EmailDomainDoc } from '../db/documents/classes.email-domain.doc.js';
+import type { DcRouter } from '../classes.dcrouter.js';
+
+export const MAIL_EGRESS_IDENTITY_MAX_AGE_MS = 45_000;
+
+export interface IMailEgressIdentity {
+  edgeId: string;
+  family: 4 | 6;
+  address: string;
+  heloHostname: string;
+  proof: 'sourceBound';
+  /** Edge-side time at which the configured source address was successfully bound. */
+  observedAt: number;
+  /** Hub-side heartbeat receipt time. */
+  hubReceivedAt: number;
+}
+
+export interface IMailEgressIdentitySnapshot {
+  supported: boolean;
+  reason?: string;
+  identities: IMailEgressIdentity[];
+}
+
+/** Boundary implemented against a released RemoteIngress identity-proof API. */
+export interface IEgressIdentitySource {
+  getSnapshot(): Promise<IMailEgressIdentitySnapshot>;
+}
+
+/**
+ * Reads the versioned RemoteIngress identity capability through TunnelManager.
+ * Older hubs do not expose `egressIdentityV1`; they remain explicitly
+ * unsupported instead of falling back to configured or peer addresses.
+ */
+export class ReleasedRemoteIngressEgressIdentitySource implements IEgressIdentitySource {
+  constructor(private dcRouterRef: DcRouter) {}
+
+  public async getSnapshot(): Promise<IMailEgressIdentitySnapshot> {
+    const status = await this.dcRouterRef.tunnelManager?.getAuthoritativeHubStatus();
+    const connectedEdges = status?.connectedEdges ?? [];
+    const capableEdges = connectedEdges.filter((edge) => (
+      Array.isArray(edge.capabilities) && edge.capabilities.includes('egressIdentityV1')
+    ));
+    if (capableEdges.length > 0) {
+      const identities: IMailEgressIdentity[] = [];
+      for (const edge of capableEdges) {
+        const report = edge.egressIdentity;
+        if (!report || report.proofMethod !== 'localSocketBind') continue;
+        for (const [family, observation] of [[4, report.ipv4], [6, report.ipv6]] as const) {
+          if (!observation || observation.stale === true) continue;
+          if (
+            typeof observation.address !== 'string'
+            || !Number.isFinite(observation.edgeObservedAtUnixMs)
+            || !Number.isFinite(observation.hubReceivedAtUnixMs)
+          ) continue;
+          const configured = this.dcRouterRef.remoteIngressManager?.getEdge(String(edge.edgeId));
+          const heloHostname = configured?.mailHostname?.trim();
+          if (!heloHostname) continue;
+          identities.push({
+            edgeId: String(edge.edgeId),
+            family,
+            address: observation.address,
+            heloHostname,
+            proof: 'sourceBound',
+            observedAt: observation.edgeObservedAtUnixMs,
+            hubReceivedAt: observation.hubReceivedAtUnixMs,
+          });
+        }
+      }
+      return { supported: true, identities };
+    }
+    return {
+      supported: false,
+      reason: 'RemoteIngress egress identity proof is unavailable until the capability release is consumed',
+      identities: [],
+    };
+  }
+}
+
+export interface IEligibleMailEdge {
+  edge: IRemoteIngress;
+  hostname: string;
+  identities: IMailEgressIdentity[];
+}
+
+export interface IMailEdgeEligibilityResult {
+  supported: boolean;
+  reason?: string;
+  edges: IEligibleMailEdge[];
+}
+
+/** Shared topology predicate used by DNS publication and outbound selection. */
+export class MailEdgeEligibility {
+  private lastUnscopedResult: IMailEdgeEligibilityResult = {
+    supported: false,
+    reason: 'mail edge eligibility has not been evaluated yet',
+    edges: [],
+  };
+
+  constructor(
+    private dcRouterRef: DcRouter,
+    private identitySource: IEgressIdentitySource,
+  ) {}
+
+  public async resolveForDomain(doc?: EmailDomainDoc): Promise<IMailEdgeEligibilityResult> {
+    const snapshot = await this.identitySource.getSnapshot();
+    if (!snapshot.supported) {
+      return this.recordUnscoped(doc, { supported: false, reason: snapshot.reason, edges: [] });
+    }
+
+    const manager = this.dcRouterRef.remoteIngressManager;
+    const tunnelManager = this.dcRouterRef.tunnelManager;
+    if (!manager || !tunnelManager) {
+      return this.recordUnscoped(doc, { supported: true, reason: 'RemoteIngress hub is not running', edges: [] });
+    }
+
+    const pin = doc?.remoteIngress?.edgeFilter || [];
+    const pinIds = pin.length > 0
+      ? new Set(manager.resolveEdgesByFilter(pin).map((edge) => edge.id))
+      : undefined;
+    const identitiesByEdge = new Map<string, IMailEgressIdentity[]>();
+    const now = Date.now();
+    for (const identity of snapshot.identities) {
+      if (identity.proof !== 'sourceBound') continue;
+      if (now - identity.observedAt > MAIL_EGRESS_IDENTITY_MAX_AGE_MS) continue;
+      if (now - identity.hubReceivedAt > MAIL_EGRESS_IDENTITY_MAX_AGE_MS) continue;
+      const entries = identitiesByEdge.get(identity.edgeId) || [];
+      entries.push(identity);
+      identitiesByEdge.set(identity.edgeId, entries);
+    }
+
+    const edges: IEligibleMailEdge[] = [];
+    for (const edge of manager.getAllEdges()) {
+      if (!edge.enabled || !edge.tags?.includes(REMOTE_INGRESS_MAIL_TAG)) continue;
+      // A domain pin narrows the mail-tagged pool; it never replaces the mail tag.
+      if (pinIds && !pinIds.has(edge.id)) continue;
+      if (!edge.egress?.enabled || !edge.egress.allowedPorts?.includes(25)) continue;
+      const status = tunnelManager.getEdgeStatus(edge.id);
+      if (!status?.connected || !status.lastHeartbeat) continue;
+      if (now - status.lastHeartbeat > MAIL_EGRESS_IDENTITY_MAX_AGE_MS) continue;
+      if (status.egressEnabled !== true || !status.capabilities?.includes('egressTcpV1')) continue;
+      const nativeQuic = status.transportMode === 'quic'
+        || (status.transportMode === 'quicWithFallback' && status.fallbackUsed === false);
+      if (!nativeQuic) continue;
+      const hostname = edge.mailHostname?.toLowerCase().replace(/\.$/, '');
+      if (!hostname) continue;
+
+      const identities = (identitiesByEdge.get(edge.id) || []).filter((identity) => {
+        if (identity.heloHostname.toLowerCase().replace(/\.$/, '') !== hostname) return false;
+        return identity.family === 4
+          ? Boolean(edge.publicIp && edge.publicIp === identity.address)
+          : Boolean(edge.publicIpV6 && edge.publicIpV6 === identity.address);
+      });
+      if (identities.length > 0) {
+        edges.push({ edge, hostname, identities });
+      }
+    }
+
+    edges.sort((left, right) => left.edge.id.localeCompare(right.edge.id));
+    return this.recordUnscoped(doc, {
+      supported: true,
+      ...(edges.length === 0 ? { reason: 'no live mail-tagged edge has a fresh source-bound identity' } : {}),
+      edges,
+    });
+  }
+
+  public getLastUnscopedResult(): IMailEdgeEligibilityResult {
+    return this.lastUnscopedResult;
+  }
+
+  private recordUnscoped(
+    doc: EmailDomainDoc | undefined,
+    result: IMailEdgeEligibilityResult,
+  ): IMailEdgeEligibilityResult {
+    if (!doc) this.lastUnscopedResult = result;
+    return result;
+  }
+
+  public async resolveActiveForDomain(doc: EmailDomainDoc): Promise<IMailEdgeEligibilityResult> {
+    const live = await this.resolveForDomain(doc);
+    const active = doc.reconciliation?.activeRevision;
+    if (!live.supported || !active) {
+      return {
+        supported: live.supported,
+        reason: live.reason || 'email domain has no validated active DNS revision',
+        edges: [],
+      };
+    }
+    const activeByEdge = new Map(active.edgeIdentities.map((identity) => [identity.edgeId, identity]));
+    const edges = live.edges.filter((candidate) => {
+      const activeIdentity = activeByEdge.get(candidate.edge.id);
+      if (!activeIdentity || activeIdentity.hostname !== candidate.hostname) return false;
+      return candidate.identities.length > 0 && candidate.identities.every((identity) => (
+        (identity.family === 4 && identity.address === activeIdentity.ipv4)
+        || (identity.family === 6 && identity.address === activeIdentity.ipv6)
+      ));
+    });
+    return {
+      supported: live.supported,
+      ...(edges.length === 0 ? { reason: 'no live edge is present in the validated active DNS revision' } : {}),
+      edges,
+    };
+  }
+}

package/ts/email/classes.mail-egress-coordinator.ts

@@ -4,9 +4,9 @@ import type {
 } from '@push.rocks/smartmta';
 import * as plugins from '../plugins.js';
 import { logger } from '../logger.js';
-import { REMOTE_INGRESS_MAIL_TAG } from '../../ts_interfaces/data/remoteingress.js';
 import type { IEmailOutboundEgressStatus, TEmailOutboundMode } from '../../ts_interfaces/data/email-settings.js';
 import type { DcRouter } from '../classes.dcrouter.js';
+import type { MailEdgeEligibility } from './classes.mail-edge-eligibility.js';
 
 /**
  * Routes outbound SMTP deliveries over RemoteIngress edges: resolves the
@@ -17,7 +17,10 @@ import type { DcRouter } from '../classes.dcrouter.js';
 export class MailEgressCoordinator {
   private dnsClient?: plugins.smartdns.dnsClientMod.Smartdns;
 
-  constructor(private dcRouterRef: DcRouter) {}
+  constructor(
+    private dcRouterRef: DcRouter,
+    private edgeEligibility: MailEdgeEligibility,
+  ) {}
 
   /**
    * smartmta connectionProxyProvider. Wired unconditionally so the outbound
@@ -30,6 +33,11 @@ export class MailEgressCoordinator {
   ): Promise<IOutboundConnectionProxy | null> {
     const mode = this.resolveOutboundModeStrict();
     if (mode === 'direct') {
+      if (context.senderDomain && await this.dcRouterRef.emailDomainManager?.getByDomain(context.senderDomain)) {
+        throw new Error(
+          `Managed sender domain ${context.senderDomain} has no validated direct-egress identity policy; refusing direct hub delivery`,
+        );
+      }
       return null;
     }
     return await this.createRemoteIngressConnectionProxy(context);
@@ -54,11 +62,14 @@ export class MailEgressCoordinator {
    * Readiness of the RemoteIngress outbound mail egress path (mail-tagged edges).
    */
   public getOutboundEgressStatus(): IEmailOutboundEgressStatus {
-    const tunnelManager = this.dcRouterRef.tunnelManager;
-    if (!tunnelManager) {
-      return { ready: false, eligibleEdgeCount: 0, reason: 'RemoteIngress hub is not running' };
-    }
-    return tunnelManager.getEgressReadiness([REMOTE_INGRESS_MAIL_TAG]);
+    const eligibility = this.edgeEligibility.getLastUnscopedResult();
+    return {
+      ready: eligibility.supported && eligibility.edges.length > 0,
+      eligibleEdgeCount: eligibility.edges.length,
+      ...(eligibility.edges.length === 0
+        ? { reason: eligibility.reason || 'no validated RemoteIngress mail edge is available' }
+        : {}),
+    };
   }
 
   /**
@@ -89,15 +100,19 @@ export class MailEgressCoordinator {
 
     await this.assertTargetIsNotOwnMailEdge(context);
 
-    // Per-domain pinning: a sender domain with a configured edgeFilter uses only
-    // matching edges; everything else uses the mail-tagged edge pool.
-    let edgeFilter: string[] = [REMOTE_INGRESS_MAIL_TAG];
-    if (context.senderDomain && this.dcRouterRef.emailDomainManager) {
-      const domain = await this.dcRouterRef.emailDomainManager.getByDomain(context.senderDomain);
-      if (domain?.remoteIngress?.edgeFilter?.length) {
-        edgeFilter = domain.remoteIngress.edgeFilter;
-      }
+    const managedDoc = context.senderDomain
+      ? await (await import('../db/documents/classes.email-domain.doc.js')).EmailDomainDoc.findByDomain(context.senderDomain)
+      : null;
+    const eligible = managedDoc
+      ? await this.edgeEligibility.resolveActiveForDomain(managedDoc)
+      : await this.edgeEligibility.resolveForDomain();
+    if (!eligible.supported || eligible.edges.length === 0) {
+      throw new Error(
+        `Outbound SMTP is not eligible${context.senderDomain ? ` for ${context.senderDomain}` : ''}: ${eligible.reason || 'no validated mail edge'}`,
+      );
     }
+    const eligibleById = new Map(eligible.edges.map((candidate) => [candidate.edge.id, candidate]));
+    const edgeFilter = [...eligibleById.keys()];
 
     const connectionTimeoutMs = this.dcRouterRef.options.emailConfig?.outbound?.connectionTimeout ?? 30_000;
     const proxy = await tunnelManager.startEgressTcpProxy({
@@ -108,12 +123,17 @@ export class MailEgressCoordinator {
       acceptTimeoutMs: connectionTimeoutMs,
       edgeFilter,
     });
+    const selected = eligibleById.get(proxy.edgeId);
+    if (!selected) {
+      await tunnelManager.stopEgressTcpProxy(proxy.proxyId).catch(() => undefined);
+      throw new Error(`RemoteIngress selected edge ${proxy.edgeId} outside the validated mail pool`);
+    }
     let closed = false;
     return {
       connectHost: proxy.listenHost,
       connectPort: proxy.listenPort,
       poolKey: `remoteIngress:${proxy.edgeId}:${context.host}:${context.port}`,
-      ehloHostname: this.dcRouterRef.remoteIngressManager?.getEdge(proxy.edgeId)?.mailHostname,
+      ehloHostname: selected.hostname,
       close: async () => {
         if (closed) {
           return;
@@ -138,11 +158,11 @@ export class MailEgressCoordinator {
    * allowed to become an availability hazard.
    */
   private async assertTargetIsNotOwnMailEdge(context: IOutboundConnectionProxyContext): Promise<void> {
-    const edgeIps = new Set(
-      (this.dcRouterRef.remoteIngressManager?.getAllEdges?.() || [])
-        .map((edge) => edge.publicIp)
-        .filter((ip): ip is string => Boolean(ip)),
-    );
+    const edgeIps = new Set<string>();
+    for (const edge of this.dcRouterRef.remoteIngressManager?.getAllEdges?.() || []) {
+      if (edge.publicIp) edgeIps.add(edge.publicIp);
+      if (edge.publicIpV6) edgeIps.add(edge.publicIpV6);
+    }
     if (edgeIps.size === 0) {
       return;
     }
@@ -155,8 +175,11 @@ export class MailEgressCoordinator {
         if (!this.dnsClient) {
           this.dnsClient = new plugins.smartdns.dnsClientMod.Smartdns({});
         }
-        const records = await this.dnsClient.getRecordsA(context.host);
-        targetIps = (records || []).map((record) => record.value);
+        const [aRecords, aaaaRecords] = await Promise.all([
+          this.dnsClient.getRecordsA(context.host),
+          this.dnsClient.getRecordsAAAA(context.host),
+        ]);
+        targetIps = [...(aRecords || []), ...(aaaaRecords || [])].map((record) => record.value);
       } catch {
         return;
       }

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

@@ -158,6 +158,10 @@ export class WorkAppMailManager {
     const smtpPassword = shouldRotateSmtpPassword
       ? this.generateSmtpPassword()
       : existingIdentity.smtpPassword;
+    const requestedSmtpEnabled = request.smtpEnabled ?? existingIdentity?.smtp.enabled ?? true;
+    const outboundReadiness = requestedSmtpEnabled
+      ? await this.dcRouterRef.emailDomainManager?.getOutboundReadiness(domain)
+      : { ready: false, reason: 'outbound identity disabled', edgeIds: [] };
     const identity: IStoredWorkAppMailIdentity = {
       id: existingIdentity?.id || plugins.smartunique.shortId(),
       externalKey,
@@ -170,7 +174,7 @@ export class WorkAppMailManager {
       inboundTarget: this.resolveNextInboundTarget(request, existingIdentity),
       inbound: this.toLegacyInboundRouteIfSmtpForward(this.resolveNextInboundTarget(request, existingIdentity)),
       smtp: {
-        enabled: request.smtpEnabled ?? existingIdentity?.smtp.enabled ?? true,
+        enabled: requestedSmtpEnabled,
         username: existingIdentity?.smtp.username || this.buildSmtpUsername(externalKey),
       },
       createdAt: existingIdentity?.createdAt || now,
@@ -197,9 +201,12 @@ export class WorkAppMailManager {
       identity: this.toPublicIdentity(identity),
     };
 
-    if (existingIndex < 0 || request.resetSmtpPassword) {
+    if ((existingIndex < 0 || request.resetSmtpPassword) && outboundReadiness?.ready) {
       response.smtpCredentials = this.buildSmtpCredentials(identity);
     }
+    if (requestedSmtpEnabled && !outboundReadiness?.ready) {
+      response.message = `Outbound identity is persisted but remains gated: ${outboundReadiness?.reason || 'email domain is not active'}`;
+    }
 
     return response;
   }
@@ -313,6 +320,11 @@ export class WorkAppMailManager {
     if (!identity.enabled || !identity.smtp.enabled) {
       return { success: false, message: 'Mail credential is disabled' };
     }
+    try {
+      await this.assertIdentityOutboundReady(identity);
+    } catch (error: unknown) {
+      return { success: false, message: (error as Error).message };
+    }
 
     const now = Date.now();
     identities[identityIndex] = {
@@ -344,6 +356,11 @@ export class WorkAppMailManager {
     if (!identity || !identity.enabled || !identity.smtp.enabled) {
       return this.rejectSenderAuthorization('Managed SMTP credential is not active');
     }
+    try {
+      await this.assertIdentityOutboundReady(identity);
+    } catch (error: unknown) {
+      return this.rejectSenderAuthorization((error as Error).message);
+    }
 
     const envelopeFrom = this.normalizeMailboxAddress(
       context.session.envelope?.mailFrom?.address || context.session.mailFrom || '',
@@ -373,6 +390,7 @@ export class WorkAppMailManager {
         messageArg.from,
         outboundIdentityIdArg,
       );
+      await this.assertIdentityOutboundReady(identity);
       const rawMessage = this.buildOutboundRawMessage(identity, messageArg);
       const recipients = this.getMessageRecipients(messageArg);
       const session = this.buildAuthenticatedSession(identity, messageArg.from, recipients, rawMessage);
@@ -555,7 +573,8 @@ export class WorkAppMailManager {
     emailConfig: TConfig,
   ): Promise<TConfig> {
     const identities = await this.readStoredIdentities();
-    return this.mergeIdentitiesIntoEmailConfig(emailConfig, identities);
+    const readyDomains = await this.getReadyOutboundDomains(identities);
+    return this.mergeIdentitiesIntoEmailConfig(emailConfig, identities, readyDomains);
   }
 
   public async applyStoredIdentitiesToRuntime(
@@ -564,10 +583,9 @@ export class WorkAppMailManager {
     const emailConfig = this.dcRouterRef.options.emailConfig as IUnifiedEmailServerOptions | undefined;
     if (!emailConfig) return;
 
-    const nextConfig = this.mergeIdentitiesIntoEmailConfig(
-      emailConfig,
-      identities || await this.readStoredIdentities(),
-    );
+    const nextIdentities = identities || await this.readStoredIdentities();
+    const readyDomains = await this.getReadyOutboundDomains(nextIdentities);
+    const nextConfig = this.mergeIdentitiesIntoEmailConfig(emailConfig, nextIdentities, readyDomains);
 
     this.dcRouterRef.options.emailConfig = nextConfig;
     if (this.dcRouterRef.emailServer) {
@@ -603,6 +621,7 @@ export class WorkAppMailManager {
   private mergeIdentitiesIntoEmailConfig<TConfig extends IUnifiedEmailServerOptions>(
     emailConfig: TConfig,
     identities: IStoredWorkAppMailIdentity[],
+    readyDomains: Set<string>,
   ): TConfig {
     const generatedRoutes = identities
       .filter((identity) => {
@@ -611,12 +630,12 @@ export class WorkAppMailManager {
       })
       .map((identity) => this.buildInboundRoute(identity));
     const generatedOutboundRoutes = identities
-      .filter((identity) => identity.enabled && identity.smtp.enabled)
-      .map((identity) => this.buildOutboundRoute(identity));
+      .filter((identity) => identity.enabled && identity.smtp.enabled && readyDomains.has(identity.domain))
+      .map((identity) => this.buildOutboundRoute(identity, emailConfig));
     const configuredRoutes = (emailConfig.routes || [])
       .filter((route) => !this.isManagedMailRouteName(route.name));
     const generatedUsers = identities
-      .filter((identity) => identity.enabled && identity.smtp.enabled)
+      .filter((identity) => identity.enabled && identity.smtp.enabled && readyDomains.has(identity.domain))
       .map((identity) => ({
         username: identity.smtp.username,
         password: identity.smtpPassword,
@@ -679,7 +698,10 @@ export class WorkAppMailManager {
     };
   }
 
-  private buildOutboundRoute(identity: IStoredWorkAppMailIdentity): IEmailRoute {
+  private buildOutboundRoute(
+    identity: IStoredWorkAppMailIdentity,
+    emailConfig: IUnifiedEmailServerOptions,
+  ): IEmailRoute {
     return {
       name: this.buildOutboundRouteName(identity.externalKey),
       priority: 900,
@@ -699,7 +721,7 @@ export class WorkAppMailManager {
             dkimSign: true,
             dkimOptions: {
               domainName: identity.domain,
-              keySelector: 'default',
+              keySelector: this.getActiveDkimSelector(identity.domain, emailConfig),
             },
           },
         },
@@ -726,6 +748,40 @@ export class WorkAppMailManager {
     await emailDomainManager.ensureEmailDomainForDomainName(domain);
   }
 
+  private async getReadyOutboundDomains(
+    identities: IStoredWorkAppMailIdentity[],
+  ): Promise<Set<string>> {
+    const ready = new Set<string>();
+    const requestedDomains = [...new Set(
+      identities
+        .filter((identity) => identity.enabled && identity.smtp.enabled)
+        .map((identity) => identity.domain),
+    )];
+    for (const domain of requestedDomains) {
+      const readiness = await this.dcRouterRef.emailDomainManager?.getOutboundReadiness(domain);
+      if (readiness?.ready) ready.add(domain);
+    }
+    return ready;
+  }
+
+  private getActiveDkimSelector(
+    domain: string,
+    emailConfig: IUnifiedEmailServerOptions = this.dcRouterRef.options.emailConfig as IUnifiedEmailServerOptions,
+  ): string {
+    return emailConfig?.domains
+      ?.find((domainConfig) => domainConfig.domain.toLowerCase() === domain.toLowerCase())
+      ?.dkim?.selector || 'default';
+  }
+
+  private async assertIdentityOutboundReady(identity: IStoredWorkAppMailIdentity): Promise<void> {
+    const readiness = await this.dcRouterRef.emailDomainManager?.getOutboundReadiness(identity.domain);
+    if (!readiness?.ready) {
+      throw new Error(
+        `Outbound mail for ${identity.domain} is gated until DNS and egress identity validation succeeds: ${readiness?.reason || 'EmailDomainManager unavailable'}`,
+      );
+    }
+  }
+
   private normalizeOwnership(
     ownership: interfaces.data.IWorkAppMailOwnership,
   ): interfaces.data.IWorkAppMailOwnership {
@@ -1257,7 +1313,7 @@ export class WorkAppMailManager {
       allowedFromPatterns: [{ type: 'exactAddress', domain: identityArg.domain, localPart: identityArg.localPart }],
       defaultFrom: identityArg.address,
       domain: identityArg.domain,
-      dkimSelector: 'default',
+      dkimSelector: this.getActiveDkimSelector(identityArg.domain),
       credential: this.toMailCredentialPublic(identityArg),
       createdAt: identityArg.createdAt,
       updatedAt: identityArg.updatedAt,

package/ts/email/index.ts

@@ -3,6 +3,7 @@ export * from './classes.email-domain.manager.js';
 export * from './classes.email-route-builder.js';
 export * from './classes.mail-dns-sync.js';
 export * from './classes.mail-egress-coordinator.js';
+export * from './classes.mail-edge-eligibility.js';
 export * from './classes.email-settings.manager.js';
 export * from './classes.smartmta-storage-manager.js';
 export * from './classes.workapp-mail-manager.js';