@push.rocks/smartmta 6.5.0 → 6.5.1

package/changelog.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 2026-07-15 - 6.5.1
+
+### Fixes
+
+- prevent advisory DNS validation from blocking SMTP readiness (dns)
+  - Provision deterministic local DNS records before SMTP startup, then validate public DNS in bounded background work.
+  - Cancel active DNS resolvers during shutdown and ignore stale validation completions across lifecycle transitions.
+  - Avoid duplicate local DNS handler registration during same-instance reinitialization.
+  - Add regression coverage for timeouts, cancellation, storage independence, readiness ordering, and idempotent provisioning.
+  - Upgrade @git.zone/cli to ^2.23.0.
+
 ## 2026-07-08 - 6.5.0
 
 ### Features

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartmta',
-    version: '6.5.0',
+    version: '6.5.1',
     description: 'A high-performance, enterprise-grade Mail Transfer Agent (MTA) built from scratch in TypeScript with Rust acceleration.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxzQkFBc0I7SUFDNUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHlIQUF5SDtDQUN2SSxDQUFBIn0=

package/dist_ts/mail/routing/classes.dns.manager.d.ts

@@ -18,6 +18,16 @@ export interface IDnsValidationResult {
     warnings: string[];
     requiredChanges: string[];
 }
+interface IDnsResolver {
+    setServers(servers: string[]): void;
+    resolveMx(domain: string): Promise<Array<{
+        exchange: string;
+        priority: number;
+    }>>;
+    resolveTxt(domain: string): Promise<string[][]>;
+    resolveNs(domain: string): Promise<string[]>;
+    cancel(): void;
+}
 /**
  * Manages DNS configuration for email domains
  * Handles both validation and creation of DNS records
@@ -25,15 +35,19 @@ export interface IDnsValidationResult {
 export declare class DnsManager {
     private dcRouter;
     private storageManager;
-    constructor(dcRouter: IDcRouterLike);
+    private resolverFactory;
+    private activeResolvers;
+    private activeValidation?;
+    private validationRunId;
+    constructor(dcRouter: IDcRouterLike, resolverFactory?: () => IDnsResolver);
     /**
      * Validate all domain configurations
      */
-    validateAllDomains(domainConfigs: IEmailDomainConfig[]): Promise<Map<string, IDnsValidationResult>>;
+    validateAllDomains(domainConfigs: IEmailDomainConfig[], abortSignal?: AbortSignal): Promise<Map<string, IDnsValidationResult>>;
     /**
      * Validate a single domain configuration
      */
-    validateDomain(config: IEmailDomainConfig): Promise<IDnsValidationResult>;
+    validateDomain(config: IEmailDomainConfig, abortSignal?: AbortSignal): Promise<IDnsValidationResult>;
     /**
      * Validate forward mode configuration
      */
@@ -54,13 +68,22 @@ export declare class DnsManager {
      * Resolve NS records for a domain
      */
     private resolveNs;
+    private createTrackedResolver;
+    private cancelActiveResolvers;
     /**
      * Get base domain from email domain (e.g., mail.example.com -> example.com)
      */
     private getBaseDomain;
+    /** Provision deterministic local DNS records without performing network lookups. */
+    provisionLocalDnsRecords(domainConfigs: IEmailDomainConfig[], dkimCreator?: any): Promise<void>;
+    /** Validate public DNS state with a single bounded, cancellable validation run. */
+    validateAndReportDnsRecords(domainConfigs: IEmailDomainConfig[], timeoutMs?: number): Promise<void>;
+    /** Cancel the current validation run and all DNS requests owned by it. */
+    cancelValidation(): void;
+    private reportValidationResults;
     /**
-     * Ensure all DNS records are created for configured domains
-     * This is the main entry point for DNS record management
+     * Ensure DNS records and validate public DNS state.
+     * Prefer the split lifecycle methods when validation must not block readiness.
      */
     ensureDnsRecords(domainConfigs: IEmailDomainConfig[], dkimCreator?: any): Promise<void>;
     /**

package/dist_ts/mail/routing/classes.dns.manager.js

@@ -7,32 +7,41 @@ import { logger } from '../../logger.js';
 export class DnsManager {
     dcRouter;
     storageManager;
-    constructor(dcRouter) {
+    resolverFactory;
+    activeResolvers = new Set();
+    activeValidation;
+    validationRunId = 0;
+    constructor(dcRouter, resolverFactory = () => new plugins.dns.promises.Resolver()) {
         this.dcRouter = dcRouter;
         this.storageManager = dcRouter.storageManager;
+        this.resolverFactory = resolverFactory;
     }
     /**
      * Validate all domain configurations
      */
-    async validateAllDomains(domainConfigs) {
-        const results = new Map();
-        for (const config of domainConfigs) {
-            const result = await this.validateDomain(config);
-            results.set(config.domain, result);
+    async validateAllDomains(domainConfigs, abortSignal) {
+        if (abortSignal?.aborted) {
+            return new Map();
         }
-        return results;
+        const results = await Promise.all(domainConfigs.map(async (config) => {
+            return [config.domain, await this.validateDomain(config, abortSignal)];
+        }));
+        if (abortSignal?.aborted) {
+            return new Map();
+        }
+        return new Map(results);
     }
     /**
      * Validate a single domain configuration
      */
-    async validateDomain(config) {
+    async validateDomain(config, abortSignal) {
         switch (config.dnsMode) {
             case 'forward':
                 return this.validateForwardMode(config);
             case 'internal-dns':
-                return this.validateInternalDnsMode(config);
+                return this.validateInternalDnsMode(config, abortSignal);
             case 'external-dns':
-                return this.validateExternalDnsMode(config);
+                return this.validateExternalDnsMode(config, abortSignal);
             default:
                 return {
                     valid: false,
@@ -63,7 +72,7 @@ export class DnsManager {
     /**
      * Validate internal DNS mode configuration
      */
-    async validateInternalDnsMode(config) {
+    async validateInternalDnsMode(config, abortSignal) {
         const result = {
             valid: true,
             errors: [],
@@ -104,7 +113,10 @@ export class DnsManager {
         const primaryNameserver = dnsNsDomains[0];
         // Check NS delegation
         try {
-            const nsRecords = await this.resolveNs(config.domain);
+            const nsRecords = await this.resolveNs(config.domain, abortSignal);
+            if (abortSignal?.aborted) {
+                return result;
+            }
             const delegatedNameservers = dnsNsDomains.filter(ns => nsRecords.includes(ns));
             const isDelegated = delegatedNameservers.length > 0;
             if (!isDelegated) {
@@ -124,6 +136,9 @@ export class DnsManager {
             }
         }
         catch (error) {
+            if (abortSignal?.aborted) {
+                return result;
+            }
             result.warnings.push(`Could not verify NS delegation for ${config.domain}: ${error.message}`);
         }
         return result;
@@ -131,7 +146,7 @@ export class DnsManager {
     /**
      * Validate external DNS mode configuration
      */
-    async validateExternalDnsMode(config) {
+    async validateExternalDnsMode(config, abortSignal) {
         const result = {
             valid: true,
             errors: [],
@@ -140,7 +155,10 @@ export class DnsManager {
         };
         try {
             // Get current DNS records
-            const records = await this.checkDnsRecords(config);
+            const records = await this.checkDnsRecords(config, abortSignal);
+            if (abortSignal?.aborted) {
+                return result;
+            }
             const requiredRecords = config.dns?.external?.requiredRecords || ['MX', 'SPF', 'DKIM', 'DMARC'];
             // Check MX record
             if (requiredRecords.includes('MX') && !records.mx?.length) {
@@ -153,17 +171,7 @@ export class DnsManager {
             // Check DKIM record
             if (requiredRecords.includes('DKIM') && !records.dkim) {
                 const selector = config.dkim?.selector || 'default';
-                const dkimPublicKey = await this.storageManager.get(`/email/dkim/${config.domain}/public.key`);
-                if (dkimPublicKey) {
-                    const publicKeyBase64 = dkimPublicKey
-                        .replace(/-----BEGIN PUBLIC KEY-----/g, '')
-                        .replace(/-----END PUBLIC KEY-----/g, '')
-                        .replace(/\s/g, '');
-                    result.requiredChanges.push(`Add TXT record: ${selector}._domainkey.${config.domain} -> "v=DKIM1; k=rsa; p=${publicKeyBase64}"`);
-                }
-                else {
-                    result.warnings.push(`DKIM public key not found for ${config.domain}. It will be generated on first use.`);
-                }
+                result.requiredChanges.push(`Add TXT record: ${selector}._domainkey.${config.domain} -> "v=DKIM1; k=rsa; p=<generated-public-key>"`);
             }
             // Check DMARC record
             if (requiredRecords.includes('DMARC') && !records.dmarc) {
@@ -178,6 +186,9 @@ export class DnsManager {
             }
         }
         catch (error) {
+            if (abortSignal?.aborted) {
+                return result;
+            }
             result.errors.push(`DNS validation failed: ${error.message}`);
             result.valid = false;
         }
@@ -186,71 +197,111 @@ export class DnsManager {
     /**
      * Check DNS records for a domain
      */
-    async checkDnsRecords(config) {
+    async checkDnsRecords(config, abortSignal) {
         const records = {};
         const baseDomain = this.getBaseDomain(config.domain);
         const selector = config.dkim?.selector || 'default';
         // Use custom DNS servers if specified
-        const resolver = new plugins.dns.promises.Resolver();
+        const resolver = this.createTrackedResolver();
         if (config.dns?.external?.servers?.length) {
             resolver.setServers(config.dns.external.servers);
         }
-        // Check MX records
         try {
-            const mxRecords = await resolver.resolveMx(baseDomain);
-            records.mx = mxRecords.map(mx => mx.exchange);
-        }
-        catch (error) {
-            logger.log('debug', `No MX records found for ${baseDomain}`);
-        }
-        // Check SPF record
-        try {
-            const txtRecords = await resolver.resolveTxt(baseDomain);
-            const spfRecord = txtRecords.find(records => records.some(record => record.startsWith('v=spf1')));
-            if (spfRecord) {
-                records.spf = spfRecord.join('');
-            }
-        }
-        catch (error) {
-            logger.log('debug', `No SPF record found for ${baseDomain}`);
-        }
-        // Check DKIM record
-        try {
-            const dkimRecords = await resolver.resolveTxt(`${selector}._domainkey.${config.domain}`);
-            const dkimRecord = dkimRecords.find(records => records.some(record => record.includes('v=DKIM1')));
-            if (dkimRecord) {
-                records.dkim = dkimRecord.join('');
-            }
-        }
-        catch (error) {
-            logger.log('debug', `No DKIM record found for ${selector}._domainkey.${config.domain}`);
-        }
-        // Check DMARC record
-        try {
-            const dmarcRecords = await resolver.resolveTxt(`_dmarc.${baseDomain}`);
-            const dmarcRecord = dmarcRecords.find(records => records.some(record => record.startsWith('v=DMARC1')));
-            if (dmarcRecord) {
-                records.dmarc = dmarcRecord.join('');
-            }
+            await Promise.all([
+                (async () => {
+                    try {
+                        const mxRecords = await resolver.resolveMx(baseDomain);
+                        records.mx = mxRecords.map(mx => mx.exchange);
+                    }
+                    catch {
+                        if (!abortSignal?.aborted) {
+                            logger.log('debug', `No MX records found for ${baseDomain}`);
+                        }
+                    }
+                })(),
+                (async () => {
+                    try {
+                        const txtRecords = await resolver.resolveTxt(baseDomain);
+                        const spfRecord = txtRecords.find(txtParts => txtParts.some(record => record.startsWith('v=spf1')));
+                        if (spfRecord) {
+                            records.spf = spfRecord.join('');
+                        }
+                    }
+                    catch {
+                        if (!abortSignal?.aborted) {
+                            logger.log('debug', `No SPF record found for ${baseDomain}`);
+                        }
+                    }
+                })(),
+                (async () => {
+                    try {
+                        const dkimRecords = await resolver.resolveTxt(`${selector}._domainkey.${config.domain}`);
+                        const dkimRecord = dkimRecords.find(txtParts => txtParts.some(record => record.includes('v=DKIM1')));
+                        if (dkimRecord) {
+                            records.dkim = dkimRecord.join('');
+                        }
+                    }
+                    catch {
+                        if (!abortSignal?.aborted) {
+                            logger.log('debug', `No DKIM record found for ${selector}._domainkey.${config.domain}`);
+                        }
+                    }
+                })(),
+                (async () => {
+                    try {
+                        const dmarcRecords = await resolver.resolveTxt(`_dmarc.${baseDomain}`);
+                        const dmarcRecord = dmarcRecords.find(txtParts => txtParts.some(record => record.startsWith('v=DMARC1')));
+                        if (dmarcRecord) {
+                            records.dmarc = dmarcRecord.join('');
+                        }
+                    }
+                    catch {
+                        if (!abortSignal?.aborted) {
+                            logger.log('debug', `No DMARC record found for _dmarc.${baseDomain}`);
+                        }
+                    }
+                })(),
+            ]);
         }
-        catch (error) {
-            logger.log('debug', `No DMARC record found for _dmarc.${baseDomain}`);
+        finally {
+            this.activeResolvers.delete(resolver);
         }
         return records;
     }
     /**
      * Resolve NS records for a domain
      */
-    async resolveNs(domain) {
+    async resolveNs(domain, abortSignal) {
+        const resolver = this.createTrackedResolver();
         try {
-            const resolver = new plugins.dns.promises.Resolver();
             const nsRecords = await resolver.resolveNs(domain);
             return nsRecords;
         }
         catch (error) {
-            logger.log('warn', `Failed to resolve NS records for ${domain}: ${error.message}`);
+            if (!abortSignal?.aborted) {
+                logger.log('warn', `Failed to resolve NS records for ${domain}: ${error.message}`);
+            }
             return [];
         }
+        finally {
+            this.activeResolvers.delete(resolver);
+        }
+    }
+    createTrackedResolver() {
+        const resolver = this.resolverFactory();
+        this.activeResolvers.add(resolver);
+        return resolver;
+    }
+    cancelActiveResolvers() {
+        for (const resolver of this.activeResolvers) {
+            try {
+                resolver.cancel();
+            }
+            catch {
+                // Resolver may already have completed or been cancelled.
+            }
+        }
+        this.activeResolvers.clear();
     }
     /**
      * Get base domain from email domain (e.g., mail.example.com -> example.com)
@@ -268,15 +319,9 @@ export class DnsManager {
         }
         return parts.slice(-2).join('.');
     }
-    /**
-     * Ensure all DNS records are created for configured domains
-     * This is the main entry point for DNS record management
-     */
-    async ensureDnsRecords(domainConfigs, dkimCreator) {
-        logger.log('info', `Ensuring DNS records for ${domainConfigs.length} domains`);
-        // First, validate all domains
-        const validationResults = await this.validateAllDomains(domainConfigs);
-        // Then create records for internal-dns domains
+    /** Provision deterministic local DNS records without performing network lookups. */
+    async provisionLocalDnsRecords(domainConfigs, dkimCreator) {
+        logger.log('info', `Provisioning local DNS records for ${domainConfigs.length} domains`);
         const internalDnsDomains = domainConfigs.filter(config => config.dnsMode === 'internal-dns');
         if (internalDnsDomains.length > 0) {
             await this.createInternalDnsRecords(internalDnsDomains);
@@ -285,7 +330,65 @@ export class DnsManager {
                 await this.createDkimRecords(domainConfigs, dkimCreator);
             }
         }
-        // Log validation results for external-dns domains
+    }
+    /** Validate public DNS state with a single bounded, cancellable validation run. */
+    async validateAndReportDnsRecords(domainConfigs, timeoutMs = 30_000) {
+        this.cancelValidation();
+        const runId = ++this.validationRunId;
+        const abortController = new AbortController();
+        let cancelRun;
+        const cancellationPromise = new Promise((resolve) => {
+            cancelRun = () => resolve({ kind: 'cancelled' });
+        });
+        this.activeValidation = { id: runId, abortController, cancel: cancelRun };
+        let timeout;
+        const timeoutPromise = new Promise((resolve) => {
+            timeout = setTimeout(() => {
+                abortController.abort();
+                this.cancelActiveResolvers();
+                resolve({ kind: 'timeout' });
+            }, timeoutMs);
+        });
+        const validationPromise = this.validateAllDomains(domainConfigs, abortController.signal).then((results) => ({
+            kind: 'completed',
+            results,
+        }));
+        try {
+            const outcome = await Promise.race([
+                validationPromise,
+                timeoutPromise,
+                cancellationPromise,
+            ]);
+            if (outcome.kind === 'cancelled') {
+                return;
+            }
+            if (outcome.kind === 'timeout') {
+                throw new Error(`DNS validation timed out after ${timeoutMs} ms`);
+            }
+            if (this.activeValidation?.id !== runId) {
+                return;
+            }
+            this.reportValidationResults(domainConfigs, outcome.results);
+        }
+        finally {
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            if (this.activeValidation?.id === runId) {
+                this.activeValidation = undefined;
+                this.cancelActiveResolvers();
+            }
+        }
+    }
+    /** Cancel the current validation run and all DNS requests owned by it. */
+    cancelValidation() {
+        const activeValidation = this.activeValidation;
+        this.activeValidation = undefined;
+        activeValidation?.abortController.abort();
+        activeValidation?.cancel();
+        this.cancelActiveResolvers();
+    }
+    reportValidationResults(domainConfigs, validationResults) {
         for (const [domain, result] of validationResults) {
             const config = domainConfigs.find(c => c.domain === domain);
             if (config?.dnsMode === 'external-dns' && result.requiredChanges.length > 0) {
@@ -293,6 +396,14 @@ export class DnsManager {
             }
         }
     }
+    /**
+     * Ensure DNS records and validate public DNS state.
+     * Prefer the split lifecycle methods when validation must not block readiness.
+     */
+    async ensureDnsRecords(domainConfigs, dkimCreator) {
+        await this.provisionLocalDnsRecords(domainConfigs, dkimCreator);
+        await this.validateAndReportDnsRecords(domainConfigs);
+    }
     /**
      * Create DNS records for internal-dns mode domains
      */
@@ -412,4 +523,4 @@ export class DnsManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dns.manager.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.dns.manager.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dns.manager.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.dns.manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAG5C,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AA2CzC;;;GAGG;AACH,MAAM,OAAO,UAAU;IACb,QAAQ,CAAgB;IACxB,cAAc,CAAsB;IACpC,eAAe,CAAqB;IACpC,eAAe,GAAG,IAAI,GAAG,EAAgB,CAAC;IAC1C,gBAAgB,CAAqB;IACrC,eAAe,GAAG,CAAC,CAAC;IAE5B,YACE,QAAuB,EACvB,kBAAsC,GAAG,EAAE,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,EAAE;QAE/E,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC,cAAc,CAAC;QAC9C,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,kBAAkB,CACtB,aAAmC,EACnC,WAAyB;QAEzB,IAAI,WAAW,EAAE,OAAO,EAAE,CAAC;YACzB,OAAO,IAAI,GAAG,EAAE,CAAC;QACnB,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YACnE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,CAAC,CAAU,CAAC;QAClF,CAAC,CAAC,CAAC,CAAC;QAEJ,IAAI,WAAW,EAAE,OAAO,EAAE,CAAC;YACzB,OAAO,IAAI,GAAG,EAAE,CAAC;QACnB,CAAC;QACD,OAAO,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,cAAc,CAClB,MAA0B,EAC1B,WAAyB;QAEzB,QAAQ,MAAM,CAAC,OAAO,EAAE,CAAC;YACvB,KAAK,SAAS;gBACZ,OAAO,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC;YAC1C,KAAK,cAAc;gBACjB,OAAO,IAAI,CAAC,uBAAuB,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;YAC3D,KAAK,cAAc;gBACjB,OAAO,IAAI,CAAC,uBAAuB,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;YAC3D;gBACE,OAAO;oBACL,KAAK,EAAE,KAAK;oBACZ,MAAM,EAAE,CAAC,qBAAqB,MAAM,CAAC,OAAO,EAAE,CAAC;oBAC/C,QAAQ,EAAE,EAAE;oBACZ,eAAe,EAAE,EAAE;iBACpB,CAAC;QACN,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,mBAAmB,CAAC,MAA0B;QAC1D,MAAM,MAAM,GAAyB;YACnC,KAAK,EAAE,IAAI;YACX,MAAM,EAAE,EAAE;YACV,QAAQ,EAAE,EAAE;YACZ,eAAe,EAAE,EAAE;SACpB,CAAC;QAEF,yDAAyD;QACzD,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,iBAAiB,EAAE,CAAC;YAC5C,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,mDAAmD,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;QACzF,CAAC;QAED,gDAAgD;QAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,CAClB,WAAW,MAAM,CAAC,MAAM,kGAAkG,CAC3H,CAAC;QAEF,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,uBAAuB,CACnC,MAA0B,EAC1B,WAAyB;QAEzB,MAAM,MAAM,GAAyB;YACnC,KAAK,EAAE,IAAI;YACX,MAAM,EAAE,EAAE;YACV,QAAQ,EAAE,EAAE;YACZ,eAAe,EAAE,EAAE;SACpB,CAAC;QAEF,uCAAuC;QACvC,MAAM,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;QACzD,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;QAEnD,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/C,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;YACrB,MAAM,CAAC,MAAM,CAAC,IAAI,CAChB,WAAW,MAAM,CAAC,MAAM,6FAA6F,CACtH,CAAC;YACF,OAAO,CAAC,KAAK,CACX,oBAAoB,MAAM,CAAC,MAAM,wCAAwC;gBACzE,6DAA6D;gBAC7D,8DAA8D;gBAC9D,sEAAsE,CACvE,CAAC;YACF,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzC,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;YACrB,MAAM,CAAC,MAAM,CAAC,IAAI,CAChB,WAAW,MAAM,CAAC,MAAM,0FAA0F,CACnH,CAAC;YACF,OAAO,CAAC,KAAK,CACX,oBAAoB,MAAM,CAAC,MAAM,wCAAwC;gBACzE,0DAA0D;gBAC1D,kEAAkE;gBAClE,gEAAgE,CACjE,CAAC;YACF,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,4CAA4C;QAC5C,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;YACvC,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;YACrB,MAAM,CAAC,MAAM,CAAC,IAAI,CAChB,WAAW,MAAM,CAAC,MAAM,wEAAwE,CACjG,CAAC;YACF,OAAO,CAAC,KAAK,CACX,oBAAoB,MAAM,CAAC,MAAM,wCAAwC;gBACzE,yCAAyC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM;gBACnE,kEAAkE;gBAClE,iCAAiC,MAAM,CAAC,MAAM,IAAI,CACnD,CAAC;YACF,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,MAAM,iBAAiB,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;QAE1C,sBAAsB;QACtB,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;YACnE,IAAI,WAAW,EAAE,OAAO,EAAE,CAAC;gBACzB,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,MAAM,oBAAoB,GAAG,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;YAC/E,MAAM,WAAW,GAAG,oBAAoB,CAAC,MAAM,GAAG,CAAC,CAAC;YAEpD,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,MAAM,CAAC,QAAQ,CAAC,IAAI,CAClB,+BAA+B,MAAM,CAAC,MAAM,4CAA4C,CACzF,CAAC;gBACF,YAAY,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;oBACxB,MAAM,CAAC,eAAe,CAAC,IAAI,CACzB,kBAAkB,MAAM,CAAC,MAAM,QAAQ,EAAE,GAAG,CAC7C,CAAC;gBACJ,CAAC,CAAC,CAAC;gBAEH,OAAO,CAAC,GAAG,CACT,kCAAkC,MAAM,CAAC,MAAM,KAAK;oBACpD,kDAAkD;oBAClD,yDAAyD;oBACzD,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,QAAQ,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI;oBACzE,kDAAkD;oBAClD,4DAA4D,CAC7D,CAAC;YACJ,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,GAAG,CACT,6BAA6B,MAAM,CAAC,MAAM,QAAQ,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CACrF,CAAC;YACJ,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,WAAW,EAAE,OAAO,EAAE,CAAC;gBACzB,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,MAAM,CAAC,QAAQ,CAAC,IAAI,CAClB,sCAAsC,MAAM,CAAC,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE,CACxE,CAAC;QACJ,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,uBAAuB,CACnC,MAA0B,EAC1B,WAAyB;QAEzB,MAAM,MAAM,GAAyB;YACnC,KAAK,EAAE,IAAI;YACX,MAAM,EAAE,EAAE;YACV,QAAQ,EAAE,EAAE;YACZ,eAAe,EAAE,EAAE;SACpB,CAAC;QAEF,IAAI,CAAC;YACH,0BAA0B;YAC1B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;YAChE,IAAI,WAAW,EAAE,OAAO,EAAE,CAAC;gBACzB,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,eAAe,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;YAEhG,kBAAkB;YAClB,IAAI,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC;gBAC1D,MAAM,CAAC,eAAe,CAAC,IAAI,CACzB,kBAAkB,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,MAAM,CAAC,MAAM,gBAAgB,CACxF,CAAC;YACJ,CAAC;YAED,mBAAmB;YACnB,IAAI,eAAe,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;gBACpD,MAAM,CAAC,eAAe,CAAC,IAAI,CACzB,mBAAmB,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,wBAAwB,CAC7E,CAAC;YACJ,CAAC;YAED,oBAAoB;YACpB,IAAI,eAAe,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;gBACtD,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,EAAE,QAAQ,IAAI,SAAS,CAAC;gBACpD,MAAM,CAAC,eAAe,CAAC,IAAI,CACzB,mBAAmB,QAAQ,eAAe,MAAM,CAAC,MAAM,gDAAgD,CACxG,CAAC;YACJ,CAAC;YAED,qBAAqB;YACrB,IAAI,eAAe,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;gBACxD,MAAM,CAAC,eAAe,CAAC,IAAI,CACzB,0BAA0B,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,2CAA2C,MAAM,CAAC,MAAM,GAAG,CACvH,CAAC;YACJ,CAAC;YAED,oCAAoC;YACpC,IAAI,MAAM,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACtC,OAAO,CAAC,GAAG,CACT,qCAAqC,MAAM,CAAC,MAAM,KAAK;oBACvD,kDAAkD;oBAClD,MAAM,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;oBAC3E,kDAAkD,CACnD,CAAC;YACJ,CAAC;QAEH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,WAAW,EAAE,OAAO,EAAE,CAAC;gBACzB,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,0BAA0B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC9D,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;QACvB,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,eAAe,CAC3B,MAA0B,EAC1B,WAAyB;QAEzB,MAAM,OAAO,GAAgB,EAAE,CAAC;QAChC,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACrD,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,EAAE,QAAQ,IAAI,SAAS,CAAC;QAEpD,sCAAsC;QACtC,MAAM,QAAQ,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC9C,IAAI,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;YAC1C,QAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACnD,CAAC;QAED,IAAI,CAAC;YACH,MAAM,OAAO,CAAC,GAAG,CAAC;gBAChB,CAAC,KAAK,IAAI,EAAE;oBACV,IAAI,CAAC;wBACH,MAAM,SAAS,GAAG,MAAM,QAAQ,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;wBACvD,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;oBAChD,CAAC;oBAAC,MAAM,CAAC;wBACP,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC;4BAC1B,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,2BAA2B,UAAU,EAAE,CAAC,CAAC;wBAC/D,CAAC;oBACH,CAAC;gBACH,CAAC,CAAC,EAAE;gBACJ,CAAC,KAAK,IAAI,EAAE;oBACV,IAAI,CAAC;wBACH,MAAM,UAAU,GAAG,MAAM,QAAQ,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;wBACzD,MAAM,SAAS,GAAG,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAC3C,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CACrD,CAAC;wBACF,IAAI,SAAS,EAAE,CAAC;4BACd,OAAO,CAAC,GAAG,GAAG,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;wBACnC,CAAC;oBACH,CAAC;oBAAC,MAAM,CAAC;wBACP,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC;4BAC1B,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,2BAA2B,UAAU,EAAE,CAAC,CAAC;wBAC/D,CAAC;oBACH,CAAC;gBACH,CAAC,CAAC,EAAE;gBACJ,CAAC,KAAK,IAAI,EAAE;oBACV,IAAI,CAAC;wBACH,MAAM,WAAW,GAAG,MAAM,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,eAAe,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;wBACzF,MAAM,UAAU,GAAG,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAC7C,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CACpD,CAAC;wBACF,IAAI,UAAU,EAAE,CAAC;4BACf,OAAO,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;wBACrC,CAAC;oBACH,CAAC;oBAAC,MAAM,CAAC;wBACP,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC;4BAC1B,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,4BAA4B,QAAQ,eAAe,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;wBAC1F,CAAC;oBACH,CAAC;gBACH,CAAC,CAAC,EAAE;gBACJ,CAAC,KAAK,IAAI,EAAE;oBACV,IAAI,CAAC;wBACH,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,UAAU,CAAC,UAAU,UAAU,EAAE,CAAC,CAAC;wBACvE,MAAM,WAAW,GAAG,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAC/C,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CACvD,CAAC;wBACF,IAAI,WAAW,EAAE,CAAC;4BAChB,OAAO,CAAC,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;wBACvC,CAAC;oBACH,CAAC;oBAAC,MAAM,CAAC;wBACP,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC;4BAC1B,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,oCAAoC,UAAU,EAAE,CAAC,CAAC;wBACxE,CAAC;oBACH,CAAC;gBACH,CAAC,CAAC,EAAE;aACL,CAAC,CAAC;QACL,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACxC,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,SAAS,CAAC,MAAc,EAAE,WAAyB;QAC/D,MAAM,QAAQ,GAAG,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC9C,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,MAAM,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACnD,OAAO,SAAS,CAAC;QACnB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC;gBAC1B,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,oCAAoC,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACrF,CAAC;YACD,OAAO,EAAE,CAAC;QACZ,CAAC;gBAAS,CAAC;YACT,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAEO,qBAAqB;QAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACxC,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACnC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,qBAAqB;QAC3B,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YAC5C,IAAI,CAAC;gBACH,QAAQ,CAAC,MAAM,EAAE,CAAC;YACpB,CAAC;YAAC,MAAM,CAAC;gBACP,yDAAyD;YAC3D,CAAC;QACH,CAAC;QACD,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;IAC/B,CAAC;IAED;;OAEG;IACK,aAAa,CAAC,MAAc;QAClC,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;YACtB,OAAO,MAAM,CAAC;QAChB,CAAC;QAED,2DAA2D;QAC3D,4DAA4D;QAC5D,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAChF,wCAAwC;YACxC,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACnC,CAAC;QAED,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAED,oFAAoF;IACpF,KAAK,CAAC,wBAAwB,CAAC,aAAmC,EAAE,WAAiB;QACnF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,sCAAsC,aAAa,CAAC,MAAM,UAAU,CAAC,CAAC;QAEzF,MAAM,kBAAkB,GAAG,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,KAAK,cAAc,CAAC,CAAC;QAC7F,IAAI,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAClC,MAAM,IAAI,CAAC,wBAAwB,CAAC,kBAAkB,CAAC,CAAC;YAExD,iDAAiD;YACjD,IAAI,WAAW,EAAE,CAAC;gBAChB,MAAM,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC;IACH,CAAC;IAED,mFAAmF;IACnF,KAAK,CAAC,2BAA2B,CAC/B,aAAmC,EACnC,SAAS,GAAG,MAAM;QAElB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAExB,MAAM,KAAK,GAAG,EAAE,IAAI,CAAC,eAAe,CAAC;QACrC,MAAM,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;QAC9C,IAAI,SAAsB,CAAC;QAC3B,MAAM,mBAAmB,GAAG,IAAI,OAAO,CAAwB,CAAC,OAAO,EAAE,EAAE;YACzE,SAAS,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;QACnD,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,gBAAgB,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC;QAE1E,IAAI,OAAmC,CAAC;QACxC,MAAM,cAAc,GAAG,IAAI,OAAO,CAAsB,CAAC,OAAO,EAAE,EAAE;YAClE,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;gBACxB,eAAe,CAAC,KAAK,EAAE,CAAC;gBACxB,IAAI,CAAC,qBAAqB,EAAE,CAAC;gBAC7B,OAAO,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;YAC/B,CAAC,EAAE,SAAS,CAAC,CAAC;QAChB,CAAC,CAAC,CAAC;QACH,MAAM,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAC/C,aAAa,EACb,eAAe,CAAC,MAAM,CACvB,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YACnB,IAAI,EAAE,WAAoB;YAC1B,OAAO;SACR,CAAC,CAAC,CAAC;QAEJ,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC;gBACjC,iBAAiB;gBACjB,cAAc;gBACd,mBAAmB;aACpB,CAAC,CAAC;YAEH,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;gBACjC,OAAO;YACT,CAAC;YACD,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC/B,MAAM,IAAI,KAAK,CAAC,kCAAkC,SAAS,KAAK,CAAC,CAAC;YACpE,CAAC;YACD,IAAI,IAAI,CAAC,gBAAgB,EAAE,EAAE,KAAK,KAAK,EAAE,CAAC;gBACxC,OAAO;YACT,CAAC;YAED,IAAI,CAAC,uBAAuB,CAAC,aAAa,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;QAC/D,CAAC;gBAAS,CAAC;YACT,IAAI,OAAO,EAAE,CAAC;gBACZ,YAAY,CAAC,OAAO,CAAC,CAAC;YACxB,CAAC;YACD,IAAI,IAAI,CAAC,gBAAgB,EAAE,EAAE,KAAK,KAAK,EAAE,CAAC;gBACxC,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC;gBAClC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,CAAC;QACH,CAAC;IACH,CAAC;IAED,0EAA0E;IAC1E,gBAAgB;QACd,MAAM,gBAAgB,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAC/C,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC;QAClC,gBAAgB,EAAE,eAAe,CAAC,KAAK,EAAE,CAAC;QAC1C,gBAAgB,EAAE,MAAM,EAAE,CAAC;QAC3B,IAAI,CAAC,qBAAqB,EAAE,CAAC;IAC/B,CAAC;IAEO,uBAAuB,CAC7B,aAAmC,EACnC,iBAAoD;QAEpD,KAAK,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI,iBAAiB,EAAE,CAAC;YACjD,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC;YAC5D,IAAI,MAAM,EAAE,OAAO,KAAK,cAAc,IAAI,MAAM,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC5E,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,2CAA2C,MAAM,EAAE,CAAC,CAAC;YAC1E,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,gBAAgB,CAAC,aAAmC,EAAE,WAAiB;QAC3E,MAAM,IAAI,CAAC,wBAAwB,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;QAChE,MAAM,IAAI,CAAC,2BAA2B,CAAC,aAAa,CAAC,CAAC;IACxD,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,wBAAwB,CAAC,aAAmC;QACxE,mCAAmC;QACnC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;YAC7B,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,iEAAiE,CAAC,CAAC;YACtF,OAAO;QACT,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,4BAA4B,aAAa,CAAC,MAAM,uBAAuB,CAAC,CAAC;QAE5F,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;YACzC,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC;YACnC,MAAM,GAAG,GAAG,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,IAAI,IAAI,CAAC;YACpD,MAAM,UAAU,GAAG,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,UAAU,IAAI,EAAE,CAAC;YAEhE,IAAI,CAAC;gBACH,4DAA4D;gBAC5D,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,eAAe,CACrC,MAAM,EACN,CAAC,IAAI,CAAC,EACN,GAAG,EAAE,CAAC,CAAC;oBACL,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,IAAI;oBACV,KAAK,EAAE,IAAI;oBACX,GAAG,EAAE,GAAG;oBACR,IAAI,EAAE;wBACJ,QAAQ,EAAE,UAAU;wBACpB,QAAQ,EAAE,MAAM;qBACjB;iBACF,CAAC,CACH,CAAC;gBACF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,4BAA4B,MAAM,OAAO,MAAM,cAAc,UAAU,GAAG,CAAC,CAAC;gBAE/F,oCAAoC;gBACpC,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAC3B,cAAc,MAAM,KAAK,EACzB,IAAI,CAAC,SAAS,CAAC;oBACb,IAAI,EAAE,IAAI;oBACV,QAAQ,EAAE,UAAU;oBACpB,QAAQ,EAAE,MAAM;oBAChB,GAAG,EAAE,GAAG;iBACT,CAAC,CACH,CAAC;gBAEF,4DAA4D;gBAC5D,MAAM,SAAS,GAAG,kBAAkB,CAAC;gBACrC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,eAAe,CACrC,MAAM,EACN,CAAC,KAAK,CAAC,EACP,GAAG,EAAE,CAAC,CAAC;oBACL,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,KAAK;oBACX,KAAK,EAAE,IAAI;oBACX,GAAG,EAAE,GAAG;oBACR,IAAI,EAAE,SAAS;iBAChB,CAAC,CACH,CAAC;gBACF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,6BAA6B,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC;gBAE1E,qCAAqC;gBACrC,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAC3B,cAAc,MAAM,MAAM,EAC1B,IAAI,CAAC,SAAS,CAAC;oBACb,IAAI,EAAE,KAAK;oBACX,IAAI,EAAE,SAAS;oBACf,GAAG,EAAE,GAAG;iBACT,CAAC,CACH,CAAC;gBAEF,sEAAsE;gBACtE,MAAM,WAAW,GAAG,sCAAsC,MAAM,EAAE,CAAC;gBACnE,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,eAAe,CACrC,UAAU,MAAM,EAAE,EAClB,CAAC,KAAK,CAAC,EACP,GAAG,EAAE,CAAC,CAAC;oBACL,IAAI,EAAE,UAAU,MAAM,EAAE;oBACxB,IAAI,EAAE,KAAK;oBACX,KAAK,EAAE,IAAI;oBACX,GAAG,EAAE,GAAG;oBACR,IAAI,EAAE,WAAW;iBAClB,CAAC,CACH,CAAC;gBACF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,sCAAsC,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC;gBAErF,uCAAuC;gBACvC,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAC3B,cAAc,MAAM,QAAQ,EAC5B,IAAI,CAAC,SAAS,CAAC;oBACb,IAAI,EAAE,KAAK;oBACX,IAAI,EAAE,UAAU,MAAM,EAAE;oBACxB,IAAI,EAAE,WAAW;oBACjB,GAAG,EAAE,GAAG;iBACT,CAAC,CACH,CAAC;gBAEF,qCAAqC;gBACrC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,6BAA6B,MAAM;UACpD,MAAM,cAAc,UAAU;WAC7B,SAAS;aACP,WAAW;kDAC0B,CAAC,CAAC;YAE9C,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,oCAAoC,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACtF,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,iBAAiB,CAAC,aAAmC,EAAE,WAAgB;QACnF,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;YACzC,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC;YACnC,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,EAAE,QAAQ,IAAI,SAAS,CAAC;YAE1D,IAAI,CAAC;gBACH,uCAAuC;gBACvC,MAAM,SAAS,GAAG,MAAM,WAAW,CAAC,qBAAqB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;gBAE5E,qDAAqD;gBACrD,IAAI,YAAY,CAAC,OAAO,KAAK,cAAc,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;oBACvE,MAAM,GAAG,GAAG,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,IAAI,IAAI,CAAC;oBAEpD,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,eAAe,CACrC,GAAG,QAAQ,eAAe,MAAM,EAAE,EAClC,CAAC,KAAK,CAAC,EACP,GAAG,EAAE,CAAC,CAAC;wBACL,IAAI,EAAE,GAAG,QAAQ,eAAe,MAAM,EAAE;wBACxC,IAAI,EAAE,KAAK;wBACX,KAAK,EAAE,IAAI;wBACX,GAAG,EAAE,GAAG;wBACR,IAAI,EAAE,SAAS,CAAC,KAAK;qBACtB,CAAC,CACH,CAAC;oBAEF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,kCAAkC,QAAQ,eAAe,MAAM,EAAE,CAAC,CAAC;oBAEtF,sCAAsC;oBACtC,MAAM,IAAI,CAAC,cAAc,CAAC,GAAG,CAC3B,cAAc,MAAM,OAAO,EAC3B,IAAI,CAAC,SAAS,CAAC;wBACb,IAAI,EAAE,KAAK;wBACX,IAAI,EAAE,GAAG,QAAQ,eAAe,MAAM,EAAE;wBACxC,IAAI,EAAE,SAAS,CAAC,KAAK;wBACrB,GAAG,EAAE,GAAG;qBACT,CAAC,CACH,CAAC;gBACJ,CAAC;gBAED,+DAA+D;gBAC/D,IAAI,YAAY,CAAC,OAAO,KAAK,cAAc,EAAE,CAAC;oBAC5C,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,iCAAiC,SAAS,CAAC,IAAI,QAAQ,SAAS,CAAC,KAAK,GAAG,CAAC,CAAC;gBAChG,CAAC;YAEH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,wCAAwC,MAAM,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACzF,CAAC;QACH,CAAC;IACH,CAAC;CACF"}

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

@@ -201,6 +201,10 @@ export declare class UnifiedEmailServer extends EventEmitter {
     private rateLimiter;
     private actionExecutor;
     private dkimManager;
+    private dnsManager;
+    private dnsValidationTask?;
+    private dnsValidationGeneration;
+    private localDnsProvisioned;
     private bridgeStateChangeHandler?;
     private bridgeRcptToRequestHandler?;
     private bridgeEmailReceivedHandler?;
@@ -236,6 +240,8 @@ export declare class UnifiedEmailServer extends EventEmitter {
     private startDeliveryPipeline;
     private startRustBridge;
     private initializeDkimAndDns;
+    private startDnsValidation;
+    private stopDnsValidation;
     private registerBridgeEventHandlers;
     private unregisterBridgeStateHandler;
     private unregisterBridgeEventHandlers;