@serve.zone/dcrouter 17.10.2 → 18.0.1

package/dist_ts/db/documents/index.d.ts

@@ -21,6 +21,7 @@ export * from './classes.accounting-session.doc.js';
 export * from './classes.dns-provider.doc.js';
 export * from './classes.domain.doc.js';
 export * from './classes.dns-record.doc.js';
+export * from './classes.dns-authority.doc.js';
 export * from './classes.acme-config.doc.js';
 export * from './classes.email-domain.doc.js';
 export * from './classes.email-server-settings.doc.js';

package/dist_ts/db/documents/index.js

@@ -28,6 +28,7 @@ export * from './classes.accounting-session.doc.js';
 export * from './classes.dns-provider.doc.js';
 export * from './classes.domain.doc.js';
 export * from './classes.dns-record.doc.js';
+export * from './classes.dns-authority.doc.js';
 // ACME configuration (singleton)
 export * from './classes.acme-config.doc.js';
 // Email domain management
@@ -39,4 +40,4 @@ export * from './classes.webpush-admission.doc.js';
 export * from './classes.webpush-spool.doc.js';
 export * from './classes.smartmta-storage.doc.js';
 export * from './classes.ops-config-event.doc.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9kYi9kb2N1bWVudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsOEJBQThCO0FBQzlCLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyx3Q0FBd0MsQ0FBQztBQUV2RCwwQkFBMEI7QUFDMUIsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsaUNBQWlDLENBQUM7QUFFaEQsdUJBQXVCO0FBQ3ZCLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyw2QkFBNkIsQ0FBQztBQUU1QywrQkFBK0I7QUFDL0IsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsK0JBQStCLENBQUM7QUFFOUMsa0NBQWtDO0FBQ2xDLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyw4Q0FBOEMsQ0FBQztBQUU3RCwwQkFBMEI7QUFDMUIsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLHFDQUFxQyxDQUFDO0FBRXBELDJDQUEyQztBQUMzQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw2QkFBNkIsQ0FBQztBQUU1QyxpQ0FBaUM7QUFDakMsY0FBYyw4QkFBOEIsQ0FBQztBQUU3QywwQkFBMEI7QUFDMUIsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLHdDQUF3QyxDQUFDO0FBRXZELDhCQUE4QjtBQUM5QixjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsbUNBQW1DLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9kYi9kb2N1bWVudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsOEJBQThCO0FBQzlCLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyx3Q0FBd0MsQ0FBQztBQUV2RCwwQkFBMEI7QUFDMUIsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsaUNBQWlDLENBQUM7QUFFaEQsdUJBQXVCO0FBQ3ZCLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyw2QkFBNkIsQ0FBQztBQUU1QywrQkFBK0I7QUFDL0IsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsK0JBQStCLENBQUM7QUFFOUMsa0NBQWtDO0FBQ2xDLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyw4Q0FBOEMsQ0FBQztBQUU3RCwwQkFBMEI7QUFDMUIsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLHFDQUFxQyxDQUFDO0FBRXBELDJDQUEyQztBQUMzQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLGdDQUFnQyxDQUFDO0FBRS9DLGlDQUFpQztBQUNqQyxjQUFjLDhCQUE4QixDQUFDO0FBRTdDLDBCQUEwQjtBQUMxQixjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsd0NBQXdDLENBQUM7QUFFdkQsOEJBQThCO0FBQzlCLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxtQ0FBbUMsQ0FBQyJ9

package/dist_ts/dns/classes.dns-server-runtime.d.ts

@@ -1,6 +1,17 @@
 import * as plugins from '../plugins.js';
 import type { DcRouter } from '../classes.dcrouter.js';
 import type { IDcRouterRouteConfig } from '../../dist_ts_interfaces/data/remoteingress.js';
+/**
+ * The zone smartdns is handed when the authority set is empty.
+ *
+ * smartdns falls back to `[dnssecZone]` whenever `authoritativeZones` is empty,
+ * so this value decides what an *unauthoritative* dcrouter would claim. It has
+ * to be a name that can never match a real question, or a database that has not
+ * been seeded yet would quietly start asserting authority over whatever
+ * placeholder we picked. `.invalid` is reserved by RFC 2606 and is guaranteed
+ * never to be delegated to anybody.
+ */
+export declare const NO_AUTHORITY_SENTINEL_ZONE = "no-authority.invalid";
 /**
  * Sets up and feeds the embedded authoritative smartdns server: validates the
  * DNS configuration, generates authoritative/email/DKIM records, applies
@@ -15,19 +26,103 @@ export declare class DnsServerRuntime {
     private batchTimer;
     private privateRouteHostnames;
     private privateRouteTargetIp?;
+    /**
+     * The array instance handed to smartdns as `authoritativeZones`.
+     *
+     * smartdns keeps the options object by reference and re-reads this array on
+     * every query, so mutating it in place changes the authority set of a
+     * *running* server.
+     *
+     * **This is a consumer-side shim, and it is sequenced for replacement.**
+     * `authoritativeZones` is a public option, but "the array is retained by
+     * reference and re-read per query" is storage behaviour, not a documented
+     * contract. The proper fix is a `setAuthoritativeZones()` on smartdns' own
+     * `DnsServer`; it cannot be written here because that release does not exist
+     * yet, and the only alternative available today — re-creating the server to
+     * change its zones — drops UDP/TCP 53, which is the 30–60 s public outage
+     * this entire path exists to remove.
+     *
+     * Guarded two ways until the setter ships: `assertLiveAuthorityZones()` logs
+     * at `error` if the reference is no longer shared after construction, and a
+     * test asserts that identity against the installed smartdns so a release that
+     * starts copying the array fails the suite rather than production.
+     */
+    private readonly authoritativeZones;
     constructor(dcRouterRef: DcRouter);
+    /** The authority set, from the database and nowhere else. */
+    private effectiveAuthorityZones;
     /**
      * Create the DNS server, start it on UDP, wire metrics/logging, and
      * register all generated records.
      */
     setup(): Promise<void>;
     private attachDnsServer;
+    /**
+     * Re-derive the running server's authoritative zone set from the database.
+     *
+     * This is the half of authority that registering handlers cannot express.
+     * smartdns decides the *response kind* from `authoritativeZones` alone: a name
+     * inside a configured zone gets an answer or an authoritative negative, and a
+     * name outside every configured zone gets REFUSED — even when a handler is
+     * registered and answers other qtypes for that exact name. That asymmetry is
+     * the live production defect. `social.io` and `hard.global` are delegated to
+     * us and have handlers, so `A` is answered with the `aa` bit, while `AAAA` and
+     * `SOA` for the same name are REFUSED, and public recursives turn a REFUSED
+     * arm of a dual-stack lookup into SERVFAIL. Verifying a zone therefore has to
+     * update this set, not just register handlers, or the zone stays half-served.
+     *
+     * Idempotent, and safe to call on every authority reconcile.
+     *
+     * @returns the zone set now in effect.
+     */
+    syncAuthorityZones(reasonArg: string): string[];
+    /**
+     * Prove smartdns kept our array rather than copying it.
+     *
+     * If this ever fails, authority silently freezes at its boot-time value and
+     * every runtime verification stops taking effect until a restart — a failure
+     * that is invisible from the outside because the server keeps answering
+     * correctly for the zones it started with. Logged rather than thrown: a frozen
+     * authority set is a degradation, and taking DNS down entirely over it would
+     * be worse than the fault it reports.
+     */
+    private assertLiveAuthorityZones;
     /**
      * Keep an internal-only A-record overlay for exact route hostnames whose
      * compiled source policy is private or whose only ingress is SmartVPN.
      * Public routes compile without clientIp restrictions and are never added.
+     *
+     * Every hostname must clear the domain-ownership gate first. This overlay is
+     * only "internal" by intent, never by mechanism: smartdns marks any answer a
+     * registered handler produces authoritative, and the server listens on a public
+     * UDP/TCP 53. Ungated, a single route was enough to make dcrouter publicly hand
+     * out an RFC1918 address, with the `aa` flag, for a domain whose real
+     * delegation belonged to somebody else.
+     */
+    syncPrivateRouteOverrides(routesArg: IDcRouterRouteConfig[]): Promise<void>;
+    /**
+     * Drop overlay hostnames whose zone ownership cannot be proven, logging each
+     * rejection at `error` with the reason. Fails closed: if the ownership inputs
+     * cannot be read, no hostname is served rather than all of them.
+     */
+    private filterOwnedPrivateRouteHostnames;
+    /**
+     * SEQUENCED BEHIND A SMARTDNS RELEASE — this registration must become
+     * `{ authority: 'non-authoritative', owner: 'private-route-overlay' }`.
+     *
+     * The overlay is a split-horizon answer by intent: it hands out an internal
+     * address for a hostname whose zone we own, and it deliberately matches `*`
+     * so it can cover any owned hostname. Under the hardened smartdns authority
+     * model, a handler left at the default `authoritative` mode is *suppressed*
+     * for any name outside every configured `authoritativeZones` entry. Overlay
+     * hostnames proven by `provider-zone` are exactly that — owned, but not in
+     * the delegation-verified set — so on that smartdns they would stop being
+     * answered entirely, silently.
+     *
+     * The options parameter does not exist in the installed smartdns (7.12.1) and
+     * the change adding it is unreleased, so this cannot be written yet. It must
+     * land in the same change that takes the smartdns bump.
      */
-    syncPrivateRouteOverrides(routesArg: IDcRouterRouteConfig[]): void;
     private registerPrivateRouteHandler;
     private normalizePrivateRouteHostname;
     /**
@@ -44,6 +139,19 @@ export declare class DnsServerRuntime {
     private generateEmailDnsRecords;
     private loadDkimRecords;
     private getManagedEmailDomainNames;
+    /**
+     * Nameserver A records (glue) only.
+     *
+     * Generated apex NS records used to be emitted here, one static set per
+     * bootstrap `dnsScopes` entry, registered once at setup and never revisited.
+     * Under database-sourced authority that is wrong twice over: a zone verified
+     * after startup would never get them, and a zone whose authority was revoked
+     * would keep them until an unrelated restart. `DnsManager` owns generated apex
+     * NS for every authoritative zone now — it already did for every zone that was
+     * not in `dnsScopes` — and reconciles them in-process in both directions.
+     * A verified zone with no `DomainDoc` behind it therefore serves no apex NS,
+     * which the `verified-but-unhosted` drift finding reports at `error`.
+     */
     private generateAuthoritativeRecords;
     private extractDomain;
     private applyProxyIpReplacement;

package/dist_ts/dns/classes.dns-server-runtime.js

@@ -1,6 +1,18 @@
 import * as plugins from '../plugins.js';
 import { logger } from '../logger.js';
 import { buildEmailDnsRecords } from '../email/index.js';
+import { resolveDomainOwnership, } from './domain-ownership.js';
+/**
+ * The zone smartdns is handed when the authority set is empty.
+ *
+ * smartdns falls back to `[dnssecZone]` whenever `authoritativeZones` is empty,
+ * so this value decides what an *unauthoritative* dcrouter would claim. It has
+ * to be a name that can never match a real question, or a database that has not
+ * been seeded yet would quietly start asserting authority over whatever
+ * placeholder we picked. `.invalid` is reserved by RFC 2606 and is guaranteed
+ * never to be delegated to anybody.
+ */
+export const NO_AUTHORITY_SENTINEL_ZONE = 'no-authority.invalid';
 /**
  * Sets up and feeds the embedded authoritative smartdns server: validates the
  * DNS configuration, generates authoritative/email/DKIM records, applies
@@ -16,9 +28,35 @@ export class DnsServerRuntime {
     batchTimer = null;
     privateRouteHostnames = new Set();
     privateRouteTargetIp;
+    /**
+     * The array instance handed to smartdns as `authoritativeZones`.
+     *
+     * smartdns keeps the options object by reference and re-reads this array on
+     * every query, so mutating it in place changes the authority set of a
+     * *running* server.
+     *
+     * **This is a consumer-side shim, and it is sequenced for replacement.**
+     * `authoritativeZones` is a public option, but "the array is retained by
+     * reference and re-read per query" is storage behaviour, not a documented
+     * contract. The proper fix is a `setAuthoritativeZones()` on smartdns' own
+     * `DnsServer`; it cannot be written here because that release does not exist
+     * yet, and the only alternative available today — re-creating the server to
+     * change its zones — drops UDP/TCP 53, which is the 30–60 s public outage
+     * this entire path exists to remove.
+     *
+     * Guarded two ways until the setter ships: `assertLiveAuthorityZones()` logs
+     * at `error` if the reference is no longer shared after construction, and a
+     * test asserts that identity against the installed smartdns so a release that
+     * starts copying the array fails the suite rather than production.
+     */
+    authoritativeZones = [];
     constructor(dcRouterRef) {
         this.dcRouterRef = dcRouterRef;
     }
+    /** The authority set, from the database and nowhere else. */
+    effectiveAuthorityZones() {
+        return this.dcRouterRef.dnsAuthorityManager?.getEffectiveZoneNames() || [];
+    }
     /**
      * Create the DNS server, start it on UDP, wire metrics/logging, and
      * register all generated records.
@@ -28,8 +66,34 @@ export class DnsServerRuntime {
         if (!options.dnsNsDomains || options.dnsNsDomains.length === 0) {
             throw new Error('dnsNsDomains is required for DNS server setup');
         }
-        if (!options.dnsScopes || options.dnsScopes.length === 0) {
-            throw new Error('dnsScopes is required for DNS server setup');
+        // Refuse to start when the authority set is *unknown*.
+        //
+        // This guard is load-bearing and cannot be delegated to the service graph.
+        // `DnsServer.dependsOn('DnsManager')` only orders startup levels — taskbuffer
+        // starts later levels even when an earlier optional service failed — so
+        // without this check an unreadable authority document would leave
+        // `dnsAuthorityManager` undefined, `effectiveAuthorityZones()` would return
+        // `[]`, and the server would come up REFUSING every query. That is exactly
+        // the collapse of "unknown" into "claim nothing" that the three-state model
+        // exists to prevent, and it would be indistinguishable from a legitimately
+        // empty database.
+        const authorityManager = this.dcRouterRef.dnsAuthorityManager;
+        if (!authorityManager || authorityManager.getState() === 'unavailable') {
+            throw new Error('DNS authority is unknown (the authority manager is '
+                + `${authorityManager ? 'unavailable' : 'not initialized'}), so the DNS server will not start. `
+                + 'dcrouter serves DNS authority from the database alone; answering with an empty authority set would '
+                + 'assert "we are authoritative for nothing", which is a claim an unreadable database cannot back. '
+                + 'Restore database access and restart.');
+        }
+        // A *known*-empty set is different, and must not stop the server: DoH
+        // routes, the private-route overlay and, above all, the ability to pick up
+        // a zone the moment it is verified all depend on the server being up.
+        // Fail closed on *authority*, never silently on *service*.
+        const bootAuthorityZones = this.syncAuthorityZones('DNS server setup');
+        if (bootAuthorityZones.length === 0) {
+            logger.log('error', 'DNS server is starting with an empty authority set: no zone has been delegation-verified, so every '
+                + 'query will be REFUSED until one is. This is what an unseeded database looks like — read the startup '
+                + 'delegation drift audit for the list of zones delegated to us that we are refusing to serve.', { zone: 'dns' });
         }
         const primaryNameserver = options.dnsNsDomains[0];
         logger.log('info', `Setting up DNS server with primary nameserver: ${primaryNameserver}`);
@@ -59,13 +123,19 @@ export class DnsServerRuntime {
             udpBindInterface: vmIpAddress,
             httpsPort: 443, // Required but won't bind due to manual mode
             manualHttpsMode: true, // Enable manual HTTPS socket handling
-            dnssecZone: options.dnsScopes[0],
-            authoritativeZones: options.dnsScopes,
+            // The DNSSEC signing zone is baked into the Rust config at start and
+            // cannot be changed without a restart, so it is taken from the boot-time
+            // authority set — sorted, therefore stable across restarts rather than
+            // dependent on database insertion order.
+            dnssecZone: bootAuthorityZones[0] || NO_AUTHORITY_SENTINEL_ZONE,
+            // Live array, mutated in place by syncAuthorityZones(). See the field.
+            authoritativeZones: this.authoritativeZones,
             primaryNameserver: primaryNameserver, // Automatically generates correct SOA records
             // For now, use self-signed cert until we integrate with Let's Encrypt
             httpsKey: '',
             httpsCert: ''
         });
+        this.assertLiveAuthorityZones(dnsServer);
         this.dcRouterRef.dnsServer = dnsServer;
         this.registerPrivateRouteHandler(dnsServer);
         // Start the DNS server. smartdns owns UDP and DNS-over-TCP; dcrouter
@@ -148,13 +218,67 @@ export class DnsServerRuntime {
         await this.dcRouterRef.dnsManager.attachDnsServer(dnsServer);
         this.dcRouterRef.mailDnsSync?.requestSync('DNS server attached');
     }
+    /**
+     * Re-derive the running server's authoritative zone set from the database.
+     *
+     * This is the half of authority that registering handlers cannot express.
+     * smartdns decides the *response kind* from `authoritativeZones` alone: a name
+     * inside a configured zone gets an answer or an authoritative negative, and a
+     * name outside every configured zone gets REFUSED — even when a handler is
+     * registered and answers other qtypes for that exact name. That asymmetry is
+     * the live production defect. `social.io` and `hard.global` are delegated to
+     * us and have handlers, so `A` is answered with the `aa` bit, while `AAAA` and
+     * `SOA` for the same name are REFUSED, and public recursives turn a REFUSED
+     * arm of a dual-stack lookup into SERVFAIL. Verifying a zone therefore has to
+     * update this set, not just register handlers, or the zone stays half-served.
+     *
+     * Idempotent, and safe to call on every authority reconcile.
+     *
+     * @returns the zone set now in effect.
+     */
+    syncAuthorityZones(reasonArg) {
+        const nextZones = this.effectiveAuthorityZones();
+        const changed = nextZones.length !== this.authoritativeZones.length
+            || nextZones.some((zone, index) => zone !== this.authoritativeZones[index]);
+        // In place: smartdns holds this exact array and re-reads it per query.
+        this.authoritativeZones.splice(0, this.authoritativeZones.length, ...nextZones);
+        if (changed) {
+            logger.log('info', `DNS authoritative zone set is now [${nextZones.join(', ') || 'empty'}] (${reasonArg})`, { zone: 'dns' });
+        }
+        return nextZones;
+    }
+    /**
+     * Prove smartdns kept our array rather than copying it.
+     *
+     * If this ever fails, authority silently freezes at its boot-time value and
+     * every runtime verification stops taking effect until a restart — a failure
+     * that is invisible from the outside because the server keeps answering
+     * correctly for the zones it started with. Logged rather than thrown: a frozen
+     * authority set is a degradation, and taking DNS down entirely over it would
+     * be worse than the fault it reports.
+     */
+    assertLiveAuthorityZones(dnsServerArg) {
+        const heldZones = dnsServerArg.options?.authoritativeZones;
+        if (heldZones === this.authoritativeZones)
+            return;
+        logger.log('error', 'smartdns did not retain the authoritative zone array by reference, so DNS authority can no longer be '
+            + 'reconciled without restarting the DNS server. Zones verified at runtime will register handlers but '
+            + 'keep answering REFUSED for every qtype they do not handle until dcrouter is restarted.', { zone: 'dns' });
+    }
     /**
      * Keep an internal-only A-record overlay for exact route hostnames whose
      * compiled source policy is private or whose only ingress is SmartVPN.
      * Public routes compile without clientIp restrictions and are never added.
+     *
+     * Every hostname must clear the domain-ownership gate first. This overlay is
+     * only "internal" by intent, never by mechanism: smartdns marks any answer a
+     * registered handler produces authoritative, and the server listens on a public
+     * UDP/TCP 53. Ungated, a single route was enough to make dcrouter publicly hand
+     * out an RFC1918 address, with the `aa` flag, for a domain whose real
+     * delegation belonged to somebody else.
      */
-    syncPrivateRouteOverrides(routesArg) {
-        const nextHostnames = new Set();
+    async syncPrivateRouteOverrides(routesArg) {
+        const candidateHostnames = new Set();
         for (const route of routesArg) {
             if (route.action?.type !== 'forward')
                 continue;
@@ -181,9 +305,10 @@ export class DnsServerRuntime {
             for (const domainArg of domainEntries) {
                 const hostname = this.normalizePrivateRouteHostname(domainArg);
                 if (hostname)
-                    nextHostnames.add(hostname);
+                    candidateHostnames.add(hostname);
             }
         }
+        const nextHostnames = await this.filterOwnedPrivateRouteHostnames(candidateHostnames);
         const changed = nextHostnames.size !== this.privateRouteHostnames.size
             || [...nextHostnames].some((hostnameArg) => !this.privateRouteHostnames.has(hostnameArg));
         this.privateRouteHostnames = nextHostnames;
@@ -191,6 +316,57 @@ export class DnsServerRuntime {
             logger.log('info', `DNS private-route overlay now serves ${nextHostnames.size} exact hostname(s)`, { zone: 'dns' });
         }
     }
+    /**
+     * Drop overlay hostnames whose zone ownership cannot be proven, logging each
+     * rejection at `error` with the reason. Fails closed: if the ownership inputs
+     * cannot be read, no hostname is served rather than all of them.
+     */
+    async filterOwnedPrivateRouteHostnames(candidateHostnames) {
+        if (candidateHostnames.size === 0) {
+            return new Set();
+        }
+        // The delegation-verified authority set, so a zone verified at runtime
+        // starts serving its overlay entries without a restart.
+        const authorityZones = this.dcRouterRef.dnsManager?.getAuthorityZones()
+            || this.effectiveAuthorityZones();
+        let zones;
+        try {
+            zones = (await this.dcRouterRef.dnsManager?.listOwnershipZones()) || [];
+        }
+        catch (error) {
+            logger.log('error', `DNS private-route overlay: cannot read managed zones (${error.message}); `
+                + `refusing to serve ${candidateHostnames.size} private route hostname(s) rather than answering for unverified domains`, { zone: 'dns' });
+            return new Set();
+        }
+        const ownedHostnames = new Set();
+        for (const hostname of candidateHostnames) {
+            const ownership = resolveDomainOwnership({ fqdn: hostname, zones, authorityZones });
+            if (ownership.verified) {
+                ownedHostnames.add(hostname);
+                continue;
+            }
+            logger.log('error', `DNS private-route overlay: refusing to answer for '${hostname}' — ${ownership.detail}. `
+                + 'dcrouter answers authoritatively on a public port, so serving this would claim a domain we cannot prove we own.', { zone: 'dns', ownershipReason: ownership.reason });
+        }
+        return ownedHostnames;
+    }
+    /**
+     * SEQUENCED BEHIND A SMARTDNS RELEASE — this registration must become
+     * `{ authority: 'non-authoritative', owner: 'private-route-overlay' }`.
+     *
+     * The overlay is a split-horizon answer by intent: it hands out an internal
+     * address for a hostname whose zone we own, and it deliberately matches `*`
+     * so it can cover any owned hostname. Under the hardened smartdns authority
+     * model, a handler left at the default `authoritative` mode is *suppressed*
+     * for any name outside every configured `authoritativeZones` entry. Overlay
+     * hostnames proven by `provider-zone` are exactly that — owned, but not in
+     * the delegation-verified set — so on that smartdns they would stop being
+     * answered entirely, silently.
+     *
+     * The options parameter does not exist in the installed smartdns (7.12.1) and
+     * the change adding it is unreleased, so this cannot be written yet. It must
+     * land in the same change that takes the smartdns bump.
+     */
     registerPrivateRouteHandler(dnsServerArg) {
         dnsServerArg.registerHandler('*', ['A'], (questionArg) => {
             const hostname = this.normalizePrivateRouteHostname(questionArg.name);
@@ -322,26 +498,28 @@ export class DnsServerRuntime {
     }
     async validateConfiguration() {
         const options = this.dcRouterRef.options;
-        if (!options.dnsNsDomains || !options.dnsScopes) {
+        if (!options.dnsNsDomains) {
             return;
         }
+        const authorityZones = this.effectiveAuthorityZones();
         logger.log('info', 'Validating DNS configuration...');
-        // Check if email domains with internal-dns are in dnsScopes
+        const covered = (nameArg) => authorityZones.some((zone) => nameArg === zone || nameArg.endsWith(`.${zone}`));
+        // Email domains served from the embedded DNS need the zone to be ours.
         if (options.emailConfig?.domains) {
             for (const domainConfig of options.emailConfig.domains) {
-                if (domainConfig.dnsMode === 'internal-dns' &&
-                    !options.dnsScopes.includes(domainConfig.domain)) {
-                    logger.log('warn', `Email domain '${domainConfig.domain}' with internal-dns mode is not in dnsScopes. It should be added to dnsScopes.`);
+                if (domainConfig.dnsMode === 'internal-dns' && !covered(domainConfig.domain.toLowerCase())) {
+                    logger.log('warn', `Email domain '${domainConfig.domain}' uses internal-dns but its zone is not delegation-verified, `
+                        + 'so dcrouter will REFUSE queries for it. Verify the zone (dns-authority:write) to serve it.');
                 }
             }
         }
-        // Validate user-provided DNS records are within scopes
+        // Validate caller-provided DNS records fall inside a zone we may answer for
         if (options.dnsRecords) {
             for (const record of options.dnsRecords) {
-                const recordDomain = this.extractDomain(record.name);
-                const isInScope = options.dnsScopes.some(scope => recordDomain === scope || recordDomain.endsWith(`.${scope}`));
-                if (!isInScope) {
-                    logger.log('warn', `DNS record for '${record.name}' is outside defined scopes [${options.dnsScopes.join(', ')}]`);
+                const recordDomain = this.extractDomain(record.name).toLowerCase();
+                if (!covered(recordDomain)) {
+                    logger.log('warn', `DNS record for '${record.name}' is outside every delegation-verified zone `
+                        + `[${authorityZones.join(', ') || 'none'}] and will be REFUSED`);
                 }
             }
         }
@@ -408,10 +586,23 @@ export class DnsServerRuntime {
         return new Set((await this.dcRouterRef.emailDomainManager?.getAll() || [])
             .map((domainArg) => domainArg.domain.toLowerCase()));
     }
+    /**
+     * Nameserver A records (glue) only.
+     *
+     * Generated apex NS records used to be emitted here, one static set per
+     * bootstrap `dnsScopes` entry, registered once at setup and never revisited.
+     * Under database-sourced authority that is wrong twice over: a zone verified
+     * after startup would never get them, and a zone whose authority was revoked
+     * would keep them until an unrelated restart. `DnsManager` owns generated apex
+     * NS for every authoritative zone now — it already did for every zone that was
+     * not in `dnsScopes` — and reconciles them in-process in both directions.
+     * A verified zone with no `DomainDoc` behind it therefore serves no apex NS,
+     * which the `verified-but-unhosted` drift finding reports at `error`.
+     */
     async generateAuthoritativeRecords() {
         const options = this.dcRouterRef.options;
         const records = [];
-        if (!options.dnsNsDomains || !options.dnsScopes) {
+        if (!options.dnsNsDomains) {
             return records;
         }
         // Determine the public IP for nameserver A records
@@ -463,21 +654,8 @@ export class DnsServerRuntime {
             }
             logger.log('info', `Generated A records for ${options.dnsNsDomains.length} nameservers`);
         }
-        // Generate NS records for each domain in scopes
-        for (const domain of options.dnsScopes) {
-            // Add NS records for all nameservers
-            for (const nsDomain of options.dnsNsDomains) {
-                records.push({
-                    name: domain,
-                    type: 'NS',
-                    value: nsDomain,
-                    ttl: 3600
-                });
-            }
-            // SOA records are now automatically generated by smartdns DnsServer
-            // with the primaryNameserver configuration option
-        }
-        logger.log('info', `Generated ${records.length} total records (A + NS) for ${options.dnsScopes.length} domains`);
+        // Apex NS records are owned by DnsManager (see the doc comment above), and
+        // SOA is synthesized by smartdns from `primaryNameserver`.
         return records;
     }
     extractDomain(recordName) {
@@ -527,4 +705,4 @@ export class DnsServerRuntime {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dns-server-runtime.js","sourceRoot":"","sources":["../../../ts/dns/classes.dns-server-runtime.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dns-server-runtime.js","sourceRoot":"","sources":["../../../ts/dns/classes.dns-server-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,OAAO,EACL,sBAAsB,GAEvB,MAAM,uBAAuB,CAAC;AAI/B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,sBAAsB,CAAC;AAEjE;;;;;GAKG;AACH,MAAM,OAAO,gBAAgB;IAiCP;IAhCpB,yCAAyC;IACjC,eAAe,GAAG,CAAC,CAAC,CAAC,iCAAiC;IACtD,cAAc,GAAG,CAAC,CAAC,CAAC,6BAA6B;IACjD,UAAU,GAAG,CAAC,CAAC;IACf,UAAU,GAAyC,IAAI,CAAC;IAExD,qBAAqB,GAAG,IAAI,GAAG,EAAU,CAAC;IAC1C,oBAAoB,CAAU;IAEtC;;;;;;;;;;;;;;;;;;;;OAoBG;IACc,kBAAkB,GAAa,EAAE,CAAC;IAEnD,YAAoB,WAAqB;QAArB,gBAAW,GAAX,WAAW,CAAU;IAAG,CAAC;IAE7C,6DAA6D;IACrD,uBAAuB;QAC7B,OAAO,IAAI,CAAC,WAAW,CAAC,mBAAmB,EAAE,qBAAqB,EAAE,IAAI,EAAE,CAAC;IAC7E,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,KAAK;QAChB,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;QACzC,IAAI,CAAC,OAAO,CAAC,YAAY,IAAI,OAAO,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC/D,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;QACnE,CAAC;QAED,uDAAuD;QACvD,EAAE;QACF,2EAA2E;QAC3E,8EAA8E;QAC9E,wEAAwE;QACxE,kEAAkE;QAClE,4EAA4E;QAC5E,2EAA2E;QAC3E,4EAA4E;QAC5E,2EAA2E;QAC3E,kBAAkB;QAClB,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,CAAC,mBAAmB,CAAC;QAC9D,IAAI,CAAC,gBAAgB,IAAI,gBAAgB,CAAC,QAAQ,EAAE,KAAK,aAAa,EAAE,CAAC;YACvE,MAAM,IAAI,KAAK,CACb,qDAAqD;kBACjD,GAAG,gBAAgB,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,iBAAiB,uCAAuC;kBAC9F,qGAAqG;kBACrG,kGAAkG;kBAClG,sCAAsC,CAC3C,CAAC;QACJ,CAAC;QAED,sEAAsE;QACtE,2EAA2E;QAC3E,sEAAsE;QACtE,2DAA2D;QAC3D,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC;QACvE,IAAI,kBAAkB,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACpC,MAAM,CAAC,GAAG,CACR,OAAO,EACP,qGAAqG;kBACjG,sGAAsG;kBACtG,6FAA6F,EACjG,EAAE,IAAI,EAAE,KAAK,EAAE,CAChB,CAAC;QACJ,CAAC;QAED,MAAM,iBAAiB,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QAClD,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,kDAAkD,iBAAiB,EAAE,CAAC,CAAC;QAE1F,oCAAoC;QACpC,MAAM,iBAAiB,GAAG,OAAO,CAAC,EAAE,CAAC,iBAAiB,EAGrD,CAAC;QACF,IAAI,WAAW,GAAG,OAAO,CAAC,gBAAgB,IAAI,SAAS,CAAC,CAAC,4BAA4B;QAErF,wFAAwF;QACxF,IAAI,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAC9B,aAAa,EAAE,KAAK,MAAM,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,CAAC;gBACnF,IAAI,UAAU,EAAE,CAAC;oBACf,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE,CAAC;wBAC/B,IAAI,CAAC,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;4BAC/C,WAAW,GAAG,KAAK,CAAC,OAAO,CAAC;4BAC5B,MAAM,aAAa,CAAC;wBACtB,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,CAAC,oBAAoB,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC;eACpD,WAAW,KAAK,SAAS,IAAI,WAAW,KAAK,IAAI;YACpD,CAAC,CAAC,WAAW;YACb,CAAC,CAAC,SAAS,CAAC;QACd,oDAAoD;QACpD,MAAM,SAAS,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,SAAS,CAAC;YAC5D,OAAO,EAAE,EAAE;YACX,gBAAgB,EAAE,WAAW;YAC7B,SAAS,EAAE,GAAG,EAAE,6CAA6C;YAC7D,eAAe,EAAE,IAAI,EAAE,sCAAsC;YAC7D,qEAAqE;YACrE,yEAAyE;YACzE,uEAAuE;YACvE,yCAAyC;YACzC,UAAU,EAAE,kBAAkB,CAAC,CAAC,CAAC,IAAI,0BAA0B;YAC/D,uEAAuE;YACvE,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;YAC3C,iBAAiB,EAAE,iBAAiB,EAAE,8CAA8C;YACpF,sEAAsE;YACtE,QAAQ,EAAE,EAAE;YACZ,SAAS,EAAE,EAAE;SACd,CAAC,CAAC;QACH,IAAI,CAAC,wBAAwB,CAAC,SAAS,CAAC,CAAC;QACzC,IAAI,CAAC,WAAW,CAAC,SAAS,GAAG,SAAS,CAAC;QACvC,IAAI,CAAC,2BAA2B,CAAC,SAAS,CAAC,CAAC;QAE5C,qEAAqE;QACrE,oEAAoE;QACpE,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;QACxB,IAAI,CAAC;YACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,iCAAiC,WAAW,KAAK,CAAC,CAAC;YAEtE,iFAAiF;YACjF,IAAI,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;gBACpC,MAAM,aAAa,GAAG,GAAG,EAAE;oBACzB,IAAI,IAAI,CAAC,UAAU,GAAG,CAAC,EAAE,CAAC;wBACxB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,IAAI,CAAC,UAAU,mCAAmC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;wBAChG,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;oBACtB,CAAC;oBACD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;gBACzB,CAAC,CAAC;gBAEF,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAA4D,EAAE,EAAE;oBACrF,mBAAmB;oBACnB,KAAK,MAAM,QAAQ,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;wBACvC,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,aAAa,CAC5C,QAAQ,CAAC,IAAI,EACb,QAAQ,CAAC,IAAI,EACb,KAAK,EACL,KAAK,CAAC,cAAc,EACpB,KAAK,CAAC,QAAQ,CACf,CAAC;oBACJ,CAAC;oBAED,4DAA4D;oBAC5D,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;oBAC7C,IAAI,MAAM,KAAK,IAAI,CAAC,eAAe,EAAE,CAAC;wBACpC,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC;wBAC9B,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;oBAC1B,CAAC;oBAED,IAAI,IAAI,CAAC,cAAc,GAAG,CAAC,EAAE,CAAC;wBAC5B,IAAI,CAAC,cAAc,EAAE,CAAC;wBACtB,MAAM,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;wBAC3E,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,OAAO,KAAK,KAAK,CAAC,cAAc,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,YAAY,GAAG,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;oBAC1I,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,UAAU,EAAE,CAAC;wBAClB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;4BACrB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;wBACpD,CAAC;oBACH,CAAC;gBACH,CAAC,CAAC,CAAC;YACL,CAAC;YAED,6BAA6B;YAC7B,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAEnC,8CAA8C;YAC9C,MAAM,oBAAoB,GAAG,MAAM,IAAI,CAAC,4BAA4B,EAAE,CAAC;YAEvE,6BAA6B;YAC7B,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAE7D,wEAAwE;YACxE,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,eAAe,EAAE,CAAC;YAEjD,oEAAoE;YACpE,MAAM,UAAU,GAAqB,CAAC,GAAG,oBAAoB,EAAE,GAAG,eAAe,EAAE,GAAG,WAAW,CAAC,CAAC;YACnG,IAAI,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACxD,UAAU,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;YACzC,CAAC;YAED,2CAA2C;YAC3C,MAAM,IAAI,CAAC,uBAAuB,CAAC,UAAU,CAAC,CAAC;YAE/C,2BAA2B;YAC3B,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC1B,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;gBACjC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,UAAU,CAAC,MAAM,iBAAiB,oBAAoB,CAAC,MAAM,mBAAmB,eAAe,CAAC,MAAM,WAAW,WAAW,CAAC,MAAM,UAAU,OAAO,CAAC,UAAU,EAAE,MAAM,IAAI,CAAC,gBAAgB,CAAC,CAAC;YACjO,CAAC;YAED,iEAAiE;YACjE,8CAA8C;YAC9C,MAAM,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QACxC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,SAAS,CAAC,kBAAkB,EAAE,CAAC;YAC/B,MAAM,SAAS,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,SAAgB,EAAE,EAAE;gBAChD,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,kDAAkD,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;YAC5F,CAAC,CAAC,CAAC;YACH,IAAI,IAAI,CAAC,WAAW,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;gBAC7C,IAAI,CAAC,WAAW,CAAC,SAAS,GAAG,SAAS,CAAC;YACzC,CAAC;YACD,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC1B,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,eAAe,CAC3B,SAAkD;QAElD,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU;YAAE,OAAO;QACzC,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QAC7D,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,WAAW,CAAC,qBAAqB,CAAC,CAAC;IACnE,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACI,kBAAkB,CAAC,SAAiB;QACzC,MAAM,SAAS,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACjD,MAAM,OAAO,GAAG,SAAS,CAAC,MAAM,KAAK,IAAI,CAAC,kBAAkB,CAAC,MAAM;eAC9D,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,KAAK,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;QAC9E,uEAAuE;QACvE,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC;QAChF,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,CAAC,GAAG,CACR,MAAM,EACN,sCAAsC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,OAAO,MAAM,SAAS,GAAG,EACvF,EAAE,IAAI,EAAE,KAAK,EAAE,CAChB,CAAC;QACJ,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;;;;;;;OASG;IACK,wBAAwB,CAC9B,YAAqD;QAErD,MAAM,SAAS,GAAI,YAEjB,CAAC,OAAO,EAAE,kBAAkB,CAAC;QAC/B,IAAI,SAAS,KAAK,IAAI,CAAC,kBAAkB;YAAE,OAAO;QAClD,MAAM,CAAC,GAAG,CACR,OAAO,EACP,uGAAuG;cACnG,qGAAqG;cACrG,wFAAwF,EAC5F,EAAE,IAAI,EAAE,KAAK,EAAE,CAChB,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;OAWG;IACI,KAAK,CAAC,yBAAyB,CAAC,SAAiC;QACtE,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAU,CAAC;QAC7C,KAAK,MAAM,KAAK,IAAI,SAAS,EAAE,CAAC;YAC9B,IAAI,KAAK,CAAC,MAAM,EAAE,IAAI,KAAK,SAAS;gBAAE,SAAS;YAC/C,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;YAC9B,IAAI,CAAC,OAAO,EAAE,SAAS,IAAI,CAAC,OAAO,EAAE,QAAQ;gBAAE,SAAS;YAExD,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,EAAE,QAAQ,CAAC;YACvC,MAAM,eAAe,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;gBAC7C,CAAC,CAAC,QAAQ;gBACV,CAAC,CAAC,EAAE,CAAC;YACP,MAAM,0BAA0B,GAAG,eAAe;iBAC/C,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;iBAClC,MAAM,CAAC,OAAO,CAAC;iBACf,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,KAAK,GAAG,CAAC,CAAC;YACxC,MAAM,cAAc,GAAG,OAAO,CAAC,QAAQ,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;YAC9D,IAAI,CAAC,0BAA0B,IAAI,CAAC,cAAc;gBAAE,SAAS;YAE7D,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC;YACrC,MAAM,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;gBAC1C,CAAC,CAAC,OAAO;gBACT,CAAC,CAAC,OAAO,OAAO,KAAK,QAAQ;oBAC3B,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC;oBACpB,CAAC,CAAC,EAAE,CAAC;YACT,KAAK,MAAM,SAAS,IAAI,aAAa,EAAE,CAAC;gBACtC,MAAM,QAAQ,GAAG,IAAI,CAAC,6BAA6B,CAAC,SAAS,CAAC,CAAC;gBAC/D,IAAI,QAAQ;oBAAE,kBAAkB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;QAED,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,gCAAgC,CAAC,kBAAkB,CAAC,CAAC;QAEtF,MAAM,OAAO,GAAG,aAAa,CAAC,IAAI,KAAK,IAAI,CAAC,qBAAqB,CAAC,IAAI;eACjE,CAAC,GAAG,aAAa,CAAC,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;QAC5F,IAAI,CAAC,qBAAqB,GAAG,aAAa,CAAC;QAC3C,IAAI,OAAO,EAAE,CAAC;YACZ,MAAM,CAAC,GAAG,CACR,MAAM,EACN,wCAAwC,aAAa,CAAC,IAAI,oBAAoB,EAC9E,EAAE,IAAI,EAAE,KAAK,EAAE,CAChB,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,gCAAgC,CAC5C,kBAA+B;QAE/B,IAAI,kBAAkB,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YAClC,OAAO,IAAI,GAAG,EAAU,CAAC;QAC3B,CAAC;QACD,uEAAuE;QACvE,wDAAwD;QACxD,MAAM,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,iBAAiB,EAAE;eAClE,IAAI,CAAC,uBAAuB,EAAE,CAAC;QACpC,IAAI,KAA6B,CAAC;QAClC,IAAI,CAAC;YACH,KAAK,GAAG,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,EAAE,CAAC,IAAI,EAAE,CAAC;QAC1E,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,MAAM,CAAC,GAAG,CACR,OAAO,EACP,yDAA0D,KAAe,CAAC,OAAO,KAAK;kBAClF,qBAAqB,kBAAkB,CAAC,IAAI,yEAAyE,EACzH,EAAE,IAAI,EAAE,KAAK,EAAE,CAChB,CAAC;YACF,OAAO,IAAI,GAAG,EAAU,CAAC;QAC3B,CAAC;QAED,MAAM,cAAc,GAAG,IAAI,GAAG,EAAU,CAAC;QACzC,KAAK,MAAM,QAAQ,IAAI,kBAAkB,EAAE,CAAC;YAC1C,MAAM,SAAS,GAAG,sBAAsB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,cAAc,EAAE,CAAC,CAAC;YACpF,IAAI,SAAS,CAAC,QAAQ,EAAE,CAAC;gBACvB,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;gBAC7B,SAAS;YACX,CAAC;YACD,MAAM,CAAC,GAAG,CACR,OAAO,EACP,sDAAsD,QAAQ,OAAO,SAAS,CAAC,MAAM,IAAI;kBACrF,iHAAiH,EACrH,EAAE,IAAI,EAAE,KAAK,EAAE,eAAe,EAAE,SAAS,CAAC,MAAM,EAAE,CACnD,CAAC;QACJ,CAAC;QACD,OAAO,cAAc,CAAC;IACxB,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACK,2BAA2B,CACjC,YAAqD;QAErD,YAAY,CAAC,eAAe,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,WAAW,EAAE,EAAE;YACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,6BAA6B,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YACtE,IACE,CAAC,QAAQ;mBACN,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG;mBACtC,CAAC,IAAI,CAAC,oBAAoB;mBAC1B,CAAC,IAAI,CAAC,qBAAqB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAC5C,CAAC;gBACD,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,GAAG;gBACT,KAAK,EAAE,IAAI;gBACX,GAAG,EAAE,EAAE;gBACP,IAAI,EAAE,IAAI,CAAC,oBAAoB;aAChC,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,6BAA6B,CAAC,WAAmB;QACvD,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACrE,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC;YAAE,OAAO,SAAS,CAAC;QACpF,IAAI,QAAQ,CAAC,MAAM,GAAG,GAAG;YAAE,OAAO,SAAS,CAAC;QAC5C,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACnC,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,EAAE;eAC1D,CAAC,mCAAmC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAAE,OAAO,SAAS,CAAC;QAC5E,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;OAEG;IACI,mBAAmB;QACxB,OAAO,KAAK,EAAE,MAA0B,EAAE,EAAE;YAC1C,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC;gBAChC,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,0DAA0D,CAAC,CAAC;gBAChF,MAAM,CAAC,GAAG,EAAE,CAAC;gBACb,OAAO;YACT,CAAC;YAED,wDAAwD;YACxD,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;gBACzB,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,qBAAqB,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;gBACxD,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;oBACtB,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,CAAC;YACH,CAAC,CAAC,CAAC;YAEH,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,iDAAiD,CAAC,CAAC;YAEvE,IAAI,CAAC;gBACH,gDAAgD;gBAChD,0CAA0C;gBAC1C,MAAO,IAAI,CAAC,WAAW,CAAC,SAAiB,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;YACtE,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,6BAA8B,KAAe,CAAC,OAAO,EAAE,CAAC,CAAC;gBAC7E,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;oBACtB,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,CAAC;YACH,CAAC;QACH,CAAC,CAAC;IACJ,CAAC;IAED,8EAA8E;IACvE,kBAAkB;QACvB,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,YAAY,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC9B,IAAI,IAAI,CAAC,UAAU,GAAG,CAAC,EAAE,CAAC;gBACxB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,IAAI,CAAC,UAAU,kCAAkC,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;YACjG,CAAC;YACD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC;YACpB,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC;YACzB,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC;IAED,8EAA8E;IACvE,KAAK,CAAC,IAAI;QACf,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAEO,eAAe,CAAC,OAAyB;QAC/C,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;QAC7C,IAAI,CAAC,SAAS;YAAE,OAAO;QAEvB,8CAA8C;QAC9C,kFAAkF;QAClF,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,4CAA4C;YAC5C,SAAS,CAAC,eAAe,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,EAAE,EAAE;gBACjE,6CAA6C;gBAC7C,IAAI,QAAQ,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,EAAE,CAAC;oBACnE,OAAO;wBACL,IAAI,EAAE,MAAM,CAAC,IAAI;wBACjB,IAAI,EAAE,MAAM,CAAC,IAAI;wBACjB,KAAK,EAAE,IAAI;wBACX,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,GAAG;wBACtB,IAAI,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC;qBACtD,CAAC;gBACJ,CAAC;gBAED,OAAO,IAAI,CAAC;YACd,CAAC,CAAC,CAAC;QACL,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,cAAc,OAAO,CAAC,MAAM,gCAAgC,CAAC,CAAC;IACnF,CAAC;IAEO,eAAe,CAAC,IAAY,EAAE,KAAa;QACjD,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,GAAG;gBACN,OAAO,KAAK,CAAC,CAAC,uBAAuB;YACvC,KAAK,IAAI;gBACP,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC9C,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC;YACpD,KAAK,KAAK;gBACR,OAAO,KAAK,CAAC;YACf,KAAK,IAAI;gBACP,OAAO,KAAK,CAAC;YACf,KAAK,KAAK;gBACR,yEAAyE;gBACzE,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC/B,OAAO;oBACL,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;oBACf,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;oBACf,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBAC1B,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBAC3B,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBACzB,MAAM,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;oBAC1B,OAAO,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;iBAC5B,CAAC;YACJ;gBACE,OAAO,KAAK,CAAC;QACjB,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,qBAAqB;QACjC,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;QACzC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;YAC1B,OAAO;QACT,CAAC;QACD,MAAM,cAAc,GAAG,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAEtD,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,iCAAiC,CAAC,CAAC;QACtD,MAAM,OAAO,GAAG,CAAC,OAAe,EAAW,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CACzE,OAAO,KAAK,IAAI,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,CAAC;QAEpD,uEAAuE;QACvE,IAAI,OAAO,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC;YACjC,KAAK,MAAM,YAAY,IAAI,OAAO,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;gBACvD,IAAI,YAAY,CAAC,OAAO,KAAK,cAAc,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;oBAC3F,MAAM,CAAC,GAAG,CACR,MAAM,EACN,iBAAiB,YAAY,CAAC,MAAM,+DAA+D;0BAC/F,4FAA4F,CACjG,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;QAED,4EAA4E;QAC5E,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YACvB,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;gBACxC,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;gBACnE,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;oBAC3B,MAAM,CAAC,GAAG,CACR,MAAM,EACN,mBAAmB,MAAM,CAAC,IAAI,8CAA8C;0BACxE,IAAI,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM,uBAAuB,CACnE,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,uBAAuB;QACnC,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;QACzC,MAAM,OAAO,GAAqB,EAAE,CAAC;QAErC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC;YAClC,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAEpE,wCAAwC;QACxC,MAAM,kBAAkB,GAAG,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,MAAM,CAC3D,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,KAAK,cAAc;eACtC,CAAC,mBAAmB,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAC3D,CAAC;QAEF,KAAK,MAAM,YAAY,IAAI,kBAAkB,EAAE,CAAC;YAC9C,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC;YACnC,MAAM,GAAG,GAAG,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,IAAI,IAAI,CAAC;YACpD,MAAM,eAAe,GAAG,oBAAoB,CAAC;gBAC3C,MAAM;gBACN,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,QAAQ;gBACtC,UAAU,EAAE,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,UAAU;aACnD,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC;YAE7D,KAAK,MAAM,MAAM,IAAI,eAAe,EAAE,CAAC;gBACrC,OAAO,CAAC,IAAI,CAAC;oBACX,IAAI,EAAE,MAAM,CAAC,IAAI;oBACjB,IAAI,EAAE,MAAM,CAAC,IAAI;oBACjB,KAAK,EAAE,MAAM,CAAC,KAAK;oBACnB,GAAG;iBACJ,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,OAAO,CAAC,MAAM,0BAA0B,kBAAkB,CAAC,MAAM,uBAAuB,CAAC,CAAC;QAC1H,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,KAAK,CAAC,eAAe;QAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;QACzC,MAAM,OAAO,GAAqB,EAAE,CAAC;QACrC,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,WAAW,EAAE,CAAC;YAChF,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,MAAM,mBAAmB,GAAG,MAAM,IAAI,CAAC,0BAA0B,EAAE,CAAC;QAEpE,KAAK,MAAM,YAAY,IAAI,OAAO,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;YACvD,IACE,YAAY,CAAC,OAAO,KAAK,cAAc;mBACpC,mBAAmB,CAAC,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,EAC7D,CAAC;gBACD,SAAS;YACX,CAAC;YACD,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,EAAE,QAAQ,IAAI,SAAS,CAAC;YAC1D,IAAI,CAAC;gBACH,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,WAAW,CAAC,uBAAuB,CACvF,YAAY,CAAC,MAAM,EACnB,QAAQ,CACT,CAAC;gBACF,OAAO,CAAC,IAAI,CAAC;oBACX,IAAI,EAAE,UAAU,CAAC,IAAI;oBACrB,IAAI,EAAE,KAAK;oBACX,KAAK,EAAE,UAAU,CAAC,KAAK;oBACvB,GAAG,EAAE,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,GAAG,IAAI,IAAI;iBAC7C,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,MAAM,CAAC,GAAG,CACR,OAAO,EACP,mDAAmD,QAAQ,eAAe,YAAY,CAAC,MAAM,KAAM,KAAe,CAAC,OAAO,EAAE,CAC7H,CAAC;YACJ,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,KAAK,CAAC,0BAA0B;QACtC,OAAO,IAAI,GAAG,CACZ,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,kBAAkB,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;aACxD,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CACtD,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;OAYG;IACK,KAAK,CAAC,4BAA4B;QACxC,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;QACzC,MAAM,OAAO,GAAqB,EAAE,CAAC;QAErC,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;YAC1B,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,mDAAmD;QACnD,IAAI,QAAQ,GAAkB,IAAI,CAAC;QAEnC,2DAA2D;QAC3D,IAAI,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpD,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,qBAAqB;YACrD,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,4CAA4C,QAAQ,EAAE,CAAC,CAAC;QAC7E,CAAC;aAAM,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YAC5B,sCAAsC;YACtC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;YAC5B,IAAI,CAAC,WAAW,CAAC,gBAAgB,GAAG,QAAQ,CAAC;YAC7C,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,eAAe,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;YACrF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,wDAAwD,QAAQ,EAAE,CAAC,CAAC;QACzF,CAAC;aAAM,CAAC;YACN,6CAA6C;YAC7C,IAAI,CAAC;gBACH,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,uCAAuC,CAAC,CAAC;gBAC5D,MAAM,YAAY,GAAG,IAAI,OAAO,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC;gBAC7D,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,YAAY,EAAE,CAAC;gBAEpD,IAAI,SAAS,CAAC,EAAE,EAAE,CAAC;oBACjB,QAAQ,GAAG,SAAS,CAAC,EAAE,CAAC;oBACxB,IAAI,CAAC,WAAW,CAAC,gBAAgB,GAAG,QAAQ,CAAC;oBAC7C,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,eAAe,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;oBACrF,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,gCAAgC,QAAQ,EAAE,CAAC,CAAC;gBACjE,CAAC;qBAAM,CAAC;oBACN,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,6CAA6C,CAAC,CAAC;gBACpE,CAAC;YACH,CAAC;YAAC,OAAO,KAAc,EAAE,CAAC;gBACxB,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,sCAAuC,KAAe,CAAC,OAAO,EAAE,CAAC,CAAC;YACxF,CAAC;YAED,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,+GAA+G,CAAC,CAAC;YACtI,CAAC;QACH,CAAC;QAED,4DAA4D;QAC5D,IAAI,QAAQ,EAAE,CAAC;YACb,KAAK,MAAM,QAAQ,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;gBAC5C,OAAO,CAAC,IAAI,CAAC;oBACX,IAAI,EAAE,QAAQ;oBACd,IAAI,EAAE,GAAG;oBACT,KAAK,EAAE,QAAQ;oBACf,GAAG,EAAE,IAAI;iBACV,CAAC,CAAC;YACL,CAAC;YACD,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,2BAA2B,OAAO,CAAC,YAAY,CAAC,MAAM,cAAc,CAAC,CAAC;QAC3F,CAAC;QAED,2EAA2E;QAC3E,2DAA2D;QAC3D,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,aAAa,CAAC,UAAkB;QACtC,mBAAmB;QACnB,IAAI,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;YAChC,UAAU,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;QACvC,CAAC;QACD,OAAO,UAAU,CAAC;IACpB,CAAC;IAEO,KAAK,CAAC,uBAAuB,CAAC,OAAyB;QAC7D,MAAM,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;QACzC,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvD,OAAO,CAAC,4CAA4C;QACtD,CAAC;QAED,yBAAyB;QACzB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACnD,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,kEAAkE,CAAC,CAAC;YACvF,OAAO;QACT,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,6CAA6C,QAAQ,gBAAgB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAEvH,IAAI,UAAU,GAAG,CAAC,CAAC;QACnB,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,MAAM,CAAC,IAAI,KAAK,GAAG;gBACnB,MAAM,CAAC,KAAK,KAAK,QAAQ;gBACzB,MAAM,CAAC,eAAe,KAAK,KAAK,EAAE,CAAC;gBACrC,gCAAgC;gBAChC,MAAM,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBACvE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,0BAA0B,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,KAAK,MAAM,OAAO,EAAE,CAAC,CAAC;gBAC1F,MAAM,CAAC,KAAK,GAAG,OAAO,CAAC;gBACvB,UAAU,EAAE,CAAC;YACf,CAAC;QACH,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,oBAAoB;QAChC,IAAI,CAAC;YACH,MAAM,YAAY,GAAG,IAAI,OAAO,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC;YAC7D,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,YAAY,EAAE,CAAC;YAEpD,IAAI,SAAS,CAAC,EAAE,EAAE,CAAC;gBACjB,OAAO,SAAS,CAAC,EAAE,CAAC;YACtB,CAAC;YAED,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAc,EAAE,CAAC;YACxB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,+BAAgC,KAAe,CAAC,OAAO,EAAE,CAAC,CAAC;YAC9E,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;CACF"}