@serve.zone/dcrouter 17.10.1 → 18.0.0

package/dist_ts/dns/manager.dns-authority.d.ts

@@ -0,0 +1,143 @@
+import type { IDnsAuthorityDrift, IDnsAuthoritySettings, IDnsDelegationProbe, TDnsAuthorityState } from '../../dist_ts_interfaces/data/dns-authority.js';
+/**
+ * Result of applying an authority change to the running process.
+ * Reconciliation is all-or-nothing: a partial application is rolled back.
+ */
+export interface IDnsAuthorityMutationResult {
+    success: boolean;
+    message?: string;
+    probe?: IDnsDelegationProbe;
+    settings?: IDnsAuthoritySettings;
+}
+/** Re-derives runtime state after the effective authority set changed. */
+export type TDnsAuthorityReconciler = (reasonArg: string) => Promise<void>;
+/**
+ * DnsAuthorityManager — owns which zones dcrouter may answer for
+ * authoritatively, and proves that claim rather than accepting it.
+ *
+ * Why this exists: `dnsScopes` was the last un-migrated bootstrap option in an
+ * otherwise DB-driven router. It was read once at startup and had no mutation
+ * path, so claiming a newly delegated zone required a restart — measured at
+ * 30–60 s of total public outage. But simply making the declared list editable
+ * through the ops API would have been worse than the disease: the domain
+ * ownership predicate accepts zone coverage as *proof* precisely because a
+ * caller cannot write it. A `setDnsScopes` mutation would let an operator append
+ * any domain and manufacture that proof — the identical self-assertion vector
+ * that `createDcrouterDomain` used to have.
+ *
+ * So a zone earns authority by delegation instead: its public NS records must
+ * name our `dnsNsDomains`. An ops-API caller cannot fake that without actually
+ * controlling the domain, so the proof stays unforgeable while becoming
+ * mutable at runtime. It is also the comparison that was missing — claimed
+ * authority versus real delegation, checked by the mechanism itself rather than
+ * by an audit bolted on afterwards.
+ *
+ * **There is exactly one source of authority: this database document.** An
+ * earlier revision kept bootstrap `dnsScopes` as an always-in-effect floor and
+ * unioned it with the verified set. That is gone. A floor is a second
+ * representation of the same fact, it can only be changed by a redeploy, and it
+ * cannot be revoked through the API — all three of which are the properties
+ * that produced the outage this path exists to prevent.
+ *
+ * Removing the floor makes the *unreadable database* case load-bearing, so it is
+ * handled explicitly rather than by accident. Three situations, three answers:
+ *
+ *  - **document missing** — a readable database that has never been seeded. The
+ *    authority set is known, and it is empty: claim nothing. Logged at `error`
+ *    with the remediation, and the startup drift audit enumerates every zone
+ *    delegated to us that we are refusing to serve, which is the worklist.
+ *  - **document present, no zones** — identical handling, different message:
+ *    somebody revoked everything, which is a legitimate state we must not
+ *    silently repopulate.
+ *  - **document unreadable** — the authority set is *unknown*. `start()` throws
+ *    rather than reporting an empty set, because rendering an unknown as "claim
+ *    nothing" is exactly how a transient database fault would take every zone
+ *    off the air. `DnsServerRuntime.setup()` then refuses to start on
+ *    `getState() === 'unavailable'`. That second check is not redundant:
+ *    `DnsServer.dependsOn('DnsManager')` only *orders* startup, and taskbuffer
+ *    starts later levels even when an earlier optional service failed, so the
+ *    consumer has to read the state itself. Both services stay failed and
+ *    dcrouter runs degraded until it is restarted with a readable database —
+ *    DNS down and visibly failed, rather than up and asserting nothing.
+ *
+ * Fail closed on authority, never silently on service: with an empty set the
+ * DNS server still starts, still serves DoH, and still picks zones up the moment
+ * one is verified — without a restart.
+ */
+export declare class DnsAuthorityManager {
+    private getExpectedNameservers;
+    private verifiedZones;
+    private updatedAt;
+    private updatedBy;
+    private state;
+    private reconciler?;
+    constructor(getExpectedNameservers: () => string[]);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /**
+     * Wire the callback that re-derives runtime state (zone handlers, route
+     * certificate warnings, private-route overlay) after the effective set changes.
+     */
+    setReconciler(reconciler?: TDnsAuthorityReconciler): void;
+    /**
+     * The authority set: delegation-verified zones, sorted so every consumer that
+     * needs a stable "first zone" (the DNSSEC signing zone, for one) gets the same
+     * answer across restarts regardless of database insertion order.
+     *
+     * This is what the ownership predicate consumes, and it is the only input to
+     * it. There is no bootstrap contribution.
+     */
+    getEffectiveZoneNames(): string[];
+    /** Whether the stored authority set was readable when it was last loaded. */
+    getState(): TDnsAuthorityState;
+    getSettings(): IDnsAuthoritySettings;
+    /**
+     * Ask the public DNS whether `zone` is delegated to our nameservers.
+     *
+     * Deliberately uses `strategy: 'doh'` — a single DNS-over-HTTPS attempt
+     * against a public resolver, with no system-resolver fallback. smartdns'
+     * `getNameServers()` uses `dns.resolveNs`, i.e. the *system* resolver, which on
+     * a dcrouter host may be dcrouter itself: it would happily answer with the very
+     * NS records we generated, making the probe self-confirming. An independent
+     * vantage point is the whole point of the proof.
+     *
+     * The three verdicts are kept distinct on purpose. A timeout is not evidence
+     * that a zone is not ours; collapsing 'undeterminable' into 'not-delegated'
+     * would let a transient resolver fault revoke authority.
+     */
+    probeDelegation(zoneArg: string): Promise<IDnsDelegationProbe>;
+    /**
+     * Claim authority over a zone, but only against a positive delegation proof.
+     * An undeterminable probe refuses the mutation — never assume either way.
+     */
+    verifyZone(zoneArg: string, verifiedBy: string): Promise<IDnsAuthorityMutationResult>;
+    /**
+     * Drop a verified zone. Every zone is revocable — there is no undroppable
+     * deployment-declared floor any more, so withdrawing authority never needs a
+     * redeploy and never leaves the router asserting a claim it cannot retract.
+     */
+    revokeZone(zoneArg: string, updatedBy: string): Promise<IDnsAuthorityMutationResult>;
+    /**
+     * Persist a new zone set and reconcile the running process against it.
+     *
+     * Fail closed: if reconciliation throws, the previous set is restored in the
+     * database and re-reconciled, so the router is never left half-converted.
+     * Reconciliation is idempotent, which is what makes the rollback safe.
+     */
+    private applyZones;
+    private persist;
+    /**
+     * Compare claimed authority against what is actually true, in every direction.
+     *
+     * This is the check whose absence let one zone sit declared in `dnsScopes`
+     * while four live zones were delegated to our nameservers and unclaimed.
+     *
+     * Advisory by design. It never mutates the authority set: a resolver blip at
+     * startup must not revoke authority for every zone and convert a transient
+     * fault into the outage this whole path exists to avoid. Undeterminable probes
+     * are skipped rather than reported as drift.
+     */
+    auditDelegationDrift(): Promise<IDnsAuthorityDrift[]>;
+    /** Run the audit and log every finding at `error`. Never throws. */
+    logDelegationDrift(): Promise<void>;
+}

package/dist_ts/dns/manager.dns-authority.js

@@ -0,0 +1,481 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+import { DnsAuthorityDoc, DomainDoc } from '../db/documents/index.js';
+const normalizeZone = (zoneArg) => zoneArg.trim().toLowerCase().replace(/\.$/, '');
+/** Strip the trailing dot smartdns/DoH returns on NS values. */
+const normalizeNameserver = (nameserverArg) => nameserverArg.trim().toLowerCase().replace(/\.$/, '');
+const isUsableZoneName = (zoneArg) => {
+    if (!zoneArg || zoneArg.length > 253)
+        return false;
+    if (zoneArg.includes('*') || zoneArg.includes(' ') || zoneArg.includes(','))
+        return false;
+    const labels = zoneArg.split('.');
+    if (labels.length < 2)
+        return false;
+    return labels.every((labelArg) => Boolean(labelArg)
+        && labelArg.length <= 63
+        && /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(labelArg));
+};
+/**
+ * DnsAuthorityManager — owns which zones dcrouter may answer for
+ * authoritatively, and proves that claim rather than accepting it.
+ *
+ * Why this exists: `dnsScopes` was the last un-migrated bootstrap option in an
+ * otherwise DB-driven router. It was read once at startup and had no mutation
+ * path, so claiming a newly delegated zone required a restart — measured at
+ * 30–60 s of total public outage. But simply making the declared list editable
+ * through the ops API would have been worse than the disease: the domain
+ * ownership predicate accepts zone coverage as *proof* precisely because a
+ * caller cannot write it. A `setDnsScopes` mutation would let an operator append
+ * any domain and manufacture that proof — the identical self-assertion vector
+ * that `createDcrouterDomain` used to have.
+ *
+ * So a zone earns authority by delegation instead: its public NS records must
+ * name our `dnsNsDomains`. An ops-API caller cannot fake that without actually
+ * controlling the domain, so the proof stays unforgeable while becoming
+ * mutable at runtime. It is also the comparison that was missing — claimed
+ * authority versus real delegation, checked by the mechanism itself rather than
+ * by an audit bolted on afterwards.
+ *
+ * **There is exactly one source of authority: this database document.** An
+ * earlier revision kept bootstrap `dnsScopes` as an always-in-effect floor and
+ * unioned it with the verified set. That is gone. A floor is a second
+ * representation of the same fact, it can only be changed by a redeploy, and it
+ * cannot be revoked through the API — all three of which are the properties
+ * that produced the outage this path exists to prevent.
+ *
+ * Removing the floor makes the *unreadable database* case load-bearing, so it is
+ * handled explicitly rather than by accident. Three situations, three answers:
+ *
+ *  - **document missing** — a readable database that has never been seeded. The
+ *    authority set is known, and it is empty: claim nothing. Logged at `error`
+ *    with the remediation, and the startup drift audit enumerates every zone
+ *    delegated to us that we are refusing to serve, which is the worklist.
+ *  - **document present, no zones** — identical handling, different message:
+ *    somebody revoked everything, which is a legitimate state we must not
+ *    silently repopulate.
+ *  - **document unreadable** — the authority set is *unknown*. `start()` throws
+ *    rather than reporting an empty set, because rendering an unknown as "claim
+ *    nothing" is exactly how a transient database fault would take every zone
+ *    off the air. `DnsServerRuntime.setup()` then refuses to start on
+ *    `getState() === 'unavailable'`. That second check is not redundant:
+ *    `DnsServer.dependsOn('DnsManager')` only *orders* startup, and taskbuffer
+ *    starts later levels even when an earlier optional service failed, so the
+ *    consumer has to read the state itself. Both services stay failed and
+ *    dcrouter runs degraded until it is restarted with a readable database —
+ *    DNS down and visibly failed, rather than up and asserting nothing.
+ *
+ * Fail closed on authority, never silently on service: with an empty set the
+ * DNS server still starts, still serves DoH, and still picks zones up the moment
+ * one is verified — without a restart.
+ */
+export class DnsAuthorityManager {
+    getExpectedNameservers;
+    verifiedZones = [];
+    updatedAt = 0;
+    updatedBy = '';
+    state = 'unavailable';
+    reconciler;
+    constructor(getExpectedNameservers) {
+        this.getExpectedNameservers = getExpectedNameservers;
+    }
+    // ==========================================================================
+    // Lifecycle
+    // ==========================================================================
+    async start() {
+        let doc;
+        try {
+            doc = await DnsAuthorityDoc.load();
+        }
+        catch (error) {
+            // An unknown authority set is not an empty one. Refuse to start rather
+            // than let every consumer read "no zones" as "revoke everything".
+            this.state = 'unavailable';
+            this.verifiedZones = [];
+            throw new Error(`DnsAuthorityManager: the stored DNS authority set is unreadable (${error.message}). `
+                + 'dcrouter serves DNS authority from the database alone, so an unreadable document leaves authority '
+                + 'unknown — refusing to start rather than claiming nothing for every zone.');
+        }
+        this.state = 'loaded';
+        this.verifiedZones = doc?.verifiedZones ? [...doc.verifiedZones] : [];
+        this.updatedAt = doc?.updatedAt ?? 0;
+        this.updatedBy = doc?.updatedBy ?? '';
+        if (this.verifiedZones.length > 0) {
+            logger.log('info', `DnsAuthorityManager: ${this.verifiedZones.length} delegation-verified zone(s) loaded `
+                + `(${this.verifiedZones.map((entry) => normalizeZone(entry.zone)).join(', ')})`, { zone: 'dns' });
+            return;
+        }
+        // Known-empty. Loud, because every zone is unserved until something is
+        // verified, and because this is the state a first deploy lands in.
+        logger.log('error', doc
+            ? 'DnsAuthorityManager: the DNS authority document exists but lists no verified zones. '
+                + 'dcrouter is authoritative for nothing and will REFUSE every query until a zone is verified.'
+            : 'DnsAuthorityManager: no DNS authority document exists yet. dcrouter is authoritative for nothing '
+                + 'and will REFUSE every query until a zone is verified. Seed the document, or claim each delegated '
+                + 'zone with dns-authority:write (probe first, then verify).', { zone: 'dns', authorityState: 'empty' });
+    }
+    async stop() {
+        this.verifiedZones = [];
+        this.state = 'unavailable';
+        this.reconciler = undefined;
+    }
+    /**
+     * Wire the callback that re-derives runtime state (zone handlers, route
+     * certificate warnings, private-route overlay) after the effective set changes.
+     */
+    setReconciler(reconciler) {
+        this.reconciler = reconciler;
+    }
+    // ==========================================================================
+    // Reads
+    // ==========================================================================
+    /**
+     * The authority set: delegation-verified zones, sorted so every consumer that
+     * needs a stable "first zone" (the DNSSEC signing zone, for one) gets the same
+     * answer across restarts regardless of database insertion order.
+     *
+     * This is what the ownership predicate consumes, and it is the only input to
+     * it. There is no bootstrap contribution.
+     */
+    getEffectiveZoneNames() {
+        const zones = new Set();
+        for (const verified of this.verifiedZones) {
+            const normalized = normalizeZone(verified.zone);
+            if (normalized)
+                zones.add(normalized);
+        }
+        return [...zones].sort();
+    }
+    /** Whether the stored authority set was readable when it was last loaded. */
+    getState() {
+        return this.state;
+    }
+    getSettings() {
+        return {
+            zones: this.verifiedZones
+                .map((entry) => ({ ...entry, zone: normalizeZone(entry.zone), origin: 'verified' }))
+                .sort((a, b) => a.zone.localeCompare(b.zone)),
+            state: this.state,
+            expectedNameservers: this.getExpectedNameservers().map(normalizeNameserver).filter(Boolean),
+            updatedAt: this.updatedAt,
+            updatedBy: this.updatedBy,
+        };
+    }
+    // ==========================================================================
+    // Delegation probe
+    // ==========================================================================
+    /**
+     * Ask the public DNS whether `zone` is delegated to our nameservers.
+     *
+     * Deliberately uses `strategy: 'doh'` — a single DNS-over-HTTPS attempt
+     * against a public resolver, with no system-resolver fallback. smartdns'
+     * `getNameServers()` uses `dns.resolveNs`, i.e. the *system* resolver, which on
+     * a dcrouter host may be dcrouter itself: it would happily answer with the very
+     * NS records we generated, making the probe self-confirming. An independent
+     * vantage point is the whole point of the proof.
+     *
+     * The three verdicts are kept distinct on purpose. A timeout is not evidence
+     * that a zone is not ours; collapsing 'undeterminable' into 'not-delegated'
+     * would let a transient resolver fault revoke authority.
+     */
+    async probeDelegation(zoneArg) {
+        const zone = normalizeZone(zoneArg);
+        const expectedNameservers = this.getExpectedNameservers()
+            .map(normalizeNameserver)
+            .filter(Boolean);
+        if (!isUsableZoneName(zone)) {
+            return {
+                zone,
+                verdict: 'not-delegated',
+                observedNameservers: [],
+                expectedNameservers,
+                detail: `'${zoneArg}' is not a usable zone name`,
+            };
+        }
+        if (expectedNameservers.length === 0) {
+            return {
+                zone,
+                verdict: 'undeterminable',
+                observedNameservers: [],
+                expectedNameservers,
+                detail: 'dnsNsDomains is not configured, so there is no nameserver identity to prove delegation against',
+            };
+        }
+        const smartdnsClient = new plugins.smartdns.dnsClientMod.Smartdns({
+            strategy: 'doh',
+            allowDohFallback: false,
+            timeoutMs: 10_000,
+        });
+        let result;
+        try {
+            result = await smartdnsClient.queryRecords(zone, 'NS');
+        }
+        catch (error) {
+            return {
+                zone,
+                verdict: 'undeterminable',
+                observedNameservers: [],
+                expectedNameservers,
+                detail: `delegation lookup threw: ${error.message}`,
+            };
+        }
+        if (result.status === 'error') {
+            return {
+                zone,
+                verdict: 'undeterminable',
+                observedNameservers: [],
+                expectedNameservers,
+                detail: `delegation lookup failed (${result.error.kind}/${result.error.code}): ${result.error.message}`,
+            };
+        }
+        if (result.status === 'missing') {
+            return {
+                zone,
+                verdict: 'not-delegated',
+                observedNameservers: [],
+                expectedNameservers,
+                detail: result.missingReason === 'nxdomain'
+                    ? `${zone} does not exist in public DNS`
+                    : `${zone} has no NS records in public DNS`,
+            };
+        }
+        const observedNameservers = [...new Set(result.records
+                .map((record) => normalizeNameserver(String(record.value ?? '')))
+                .filter((nameserver) => Boolean(nameserver)))];
+        const matches = observedNameservers.filter((observed) => expectedNameservers.includes(observed));
+        if (matches.length === 0) {
+            return {
+                zone,
+                verdict: 'not-delegated',
+                observedNameservers,
+                expectedNameservers,
+                detail: `${zone} is delegated to ${observedNameservers.join(', ') || 'nothing'}, which does not include any of our nameservers (${expectedNameservers.join(', ')})`,
+            };
+        }
+        return {
+            zone,
+            verdict: 'delegated',
+            observedNameservers,
+            expectedNameservers,
+            detail: `${zone} is delegated to ${matches.join(', ')}`,
+        };
+    }
+    // ==========================================================================
+    // Mutations
+    // ==========================================================================
+    /**
+     * Claim authority over a zone, but only against a positive delegation proof.
+     * An undeterminable probe refuses the mutation — never assume either way.
+     */
+    async verifyZone(zoneArg, verifiedBy) {
+        const zone = normalizeZone(zoneArg);
+        if (!isUsableZoneName(zone)) {
+            return { success: false, message: `'${zoneArg}' is not a usable zone name` };
+        }
+        const probe = await this.probeDelegation(zone);
+        if (probe.verdict !== 'delegated') {
+            return {
+                success: false,
+                probe,
+                message: probe.verdict === 'undeterminable'
+                    ? `Cannot verify ${zone}: ${probe.detail}. Authority is not claimed on an undeterminable probe.`
+                    : `Cannot verify ${zone}: ${probe.detail}`,
+            };
+        }
+        const entry = {
+            zone,
+            origin: 'verified',
+            verifiedAt: Date.now(),
+            observedNameservers: probe.observedNameservers,
+            verifiedBy,
+        };
+        const nextZones = [
+            ...this.verifiedZones.filter((candidate) => normalizeZone(candidate.zone) !== zone),
+            entry,
+        ];
+        const applied = await this.applyZones(nextZones, verifiedBy, `authority claimed for ${zone}`);
+        if (!applied.success) {
+            return { ...applied, probe };
+        }
+        logger.log('info', `DnsAuthorityManager: ${zone} verified as ours (delegated to ${probe.observedNameservers.join(', ')}) and applied without a restart`, { zone: 'dns', verifiedBy });
+        return { success: true, probe, settings: this.getSettings() };
+    }
+    /**
+     * Drop a verified zone. Every zone is revocable — there is no undroppable
+     * deployment-declared floor any more, so withdrawing authority never needs a
+     * redeploy and never leaves the router asserting a claim it cannot retract.
+     */
+    async revokeZone(zoneArg, updatedBy) {
+        const zone = normalizeZone(zoneArg);
+        if (!this.verifiedZones.some((candidate) => normalizeZone(candidate.zone) === zone)) {
+            return { success: false, message: `${zone} is not a verified zone` };
+        }
+        const nextZones = this.verifiedZones.filter((candidate) => normalizeZone(candidate.zone) !== zone);
+        const applied = await this.applyZones(nextZones, updatedBy, `authority revoked for ${zone}`);
+        if (!applied.success) {
+            return applied;
+        }
+        logger.log('info', `DnsAuthorityManager: authority over ${zone} revoked and torn down in-process`, {
+            zone: 'dns',
+            updatedBy,
+        });
+        return { success: true, settings: this.getSettings() };
+    }
+    /**
+     * Persist a new zone set and reconcile the running process against it.
+     *
+     * Fail closed: if reconciliation throws, the previous set is restored in the
+     * database and re-reconciled, so the router is never left half-converted.
+     * Reconciliation is idempotent, which is what makes the rollback safe.
+     */
+    async applyZones(nextZones, updatedBy, reason) {
+        const previousZones = [...this.verifiedZones];
+        const previousUpdatedAt = this.updatedAt;
+        const previousUpdatedBy = this.updatedBy;
+        this.verifiedZones = nextZones;
+        this.updatedAt = Date.now();
+        this.updatedBy = updatedBy;
+        try {
+            await this.persist();
+        }
+        catch (error) {
+            this.verifiedZones = previousZones;
+            this.updatedAt = previousUpdatedAt;
+            this.updatedBy = previousUpdatedBy;
+            return { success: false, message: `Failed to persist DNS authority: ${error.message}` };
+        }
+        try {
+            await this.reconciler?.(reason);
+        }
+        catch (error) {
+            const applyError = error.message;
+            this.verifiedZones = previousZones;
+            this.updatedAt = previousUpdatedAt;
+            this.updatedBy = previousUpdatedBy;
+            let rollbackNote = '';
+            try {
+                await this.persist();
+                await this.reconciler?.(`rollback of ${reason}`);
+            }
+            catch (rollbackError) {
+                rollbackNote = ` Rollback also failed: ${rollbackError.message}. `
+                    + 'Runtime DNS state may be inconsistent — restart dcrouter to rebuild it deterministically.';
+                logger.log('error', `DnsAuthorityManager: rollback failed after ${reason}.${rollbackNote}`, {
+                    zone: 'dns',
+                });
+            }
+            return {
+                success: false,
+                message: `Failed to apply DNS authority change (${reason}): ${applyError}. `
+                    + `The change was rolled back and nothing was left half-applied.${rollbackNote}`,
+            };
+        }
+        return { success: true, settings: this.getSettings() };
+    }
+    async persist() {
+        let doc = await DnsAuthorityDoc.load();
+        if (!doc) {
+            doc = new DnsAuthorityDoc();
+            doc.settingsId = 'dns-authority-settings';
+        }
+        doc.verifiedZones = this.verifiedZones;
+        doc.updatedAt = this.updatedAt;
+        doc.updatedBy = this.updatedBy;
+        await doc.save();
+    }
+    // ==========================================================================
+    // Drift audit
+    // ==========================================================================
+    /**
+     * Compare claimed authority against what is actually true, in every direction.
+     *
+     * This is the check whose absence let one zone sit declared in `dnsScopes`
+     * while four live zones were delegated to our nameservers and unclaimed.
+     *
+     * Advisory by design. It never mutates the authority set: a resolver blip at
+     * startup must not revoke authority for every zone and convert a transient
+     * fault into the outage this whole path exists to avoid. Undeterminable probes
+     * are skipped rather than reported as drift.
+     */
+    async auditDelegationDrift() {
+        const drift = [];
+        const effectiveZones = new Set(this.getEffectiveZoneNames());
+        const domains = await DomainDoc.findAll();
+        const hostedZones = new Set(domains
+            .filter((domainArg) => domainArg.source === 'dcrouter')
+            .map((domainArg) => normalizeZone(domainArg.name))
+            .filter(Boolean));
+        // Direction 1: a dcrouter-hosted zone delegated to us but not claimed.
+        for (const zone of [...hostedZones].filter((zone) => !effectiveZones.has(zone))) {
+            const probe = await this.probeDelegation(zone);
+            if (probe.verdict !== 'delegated')
+                continue;
+            drift.push({
+                zone,
+                kind: 'delegated-but-unclaimed',
+                observedNameservers: probe.observedNameservers,
+                expectedNameservers: probe.expectedNameservers,
+                detail: `${zone} is delegated to ${probe.observedNameservers.join(', ')} but is not in the authority set, `
+                    + 'so dcrouter refuses to serve it authoritatively and will not request certificates for it',
+            });
+        }
+        // Direction 2: a verified zone whose delegation moved away from us.
+        for (const verified of this.verifiedZones) {
+            const zone = normalizeZone(verified.zone);
+            const probe = await this.probeDelegation(zone);
+            if (probe.verdict !== 'not-delegated')
+                continue;
+            drift.push({
+                zone,
+                kind: 'claimed-but-not-delegated',
+                observedNameservers: probe.observedNameservers,
+                expectedNameservers: probe.expectedNameservers,
+                detail: `${zone} was verified at ${verified.verifiedAt ? new Date(verified.verifiedAt).toISOString() : 'an unknown time'} `
+                    + `but its delegation now names ${probe.observedNameservers.join(', ') || 'nothing'}; `
+                    + 'dcrouter is still claiming authority over a zone that is no longer delegated to it',
+            });
+        }
+        // Direction 3: a claimed zone with nothing behind it. Records and generated
+        // apex NS both hang off a dcrouter-hosted DomainDoc, so authority without
+        // one is a zone we answer for and have nothing to say about — a lame
+        // delegation of our own making. Cheap to detect and impossible to notice
+        // otherwise, because the zone REFUSES nothing and answers nothing.
+        for (const zone of effectiveZones) {
+            if (hostedZones.has(zone))
+                continue;
+            drift.push({
+                zone,
+                kind: 'verified-but-unhosted',
+                observedNameservers: [],
+                expectedNameservers: this.getExpectedNameservers().map(normalizeNameserver).filter(Boolean),
+                detail: `${zone} is in the authority set but has no dcrouter-hosted domain, so no records and no `
+                    + 'generated apex NS are served for it; create the domain in the DNS manager or revoke the authority claim',
+            });
+        }
+        return drift;
+    }
+    /** Run the audit and log every finding at `error`. Never throws. */
+    async logDelegationDrift() {
+        let drift;
+        try {
+            drift = await this.auditDelegationDrift();
+        }
+        catch (error) {
+            logger.log('warn', `DnsAuthorityManager: delegation drift audit could not complete: ${error.message}`, { zone: 'dns' });
+            return;
+        }
+        for (const entry of drift) {
+            logger.log('error', `DNS authority drift (${entry.kind}): ${entry.detail}`, {
+                zone: 'dns',
+                driftKind: entry.kind,
+                driftZone: entry.zone,
+            });
+        }
+        if (drift.length === 0) {
+            logger.log('info', 'DnsAuthorityManager: declared authority matches observed delegation', {
+                zone: 'dns',
+            });
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manager.dns-authority.js","sourceRoot":"","sources":["../../../ts/dns/manager.dns-authority.ts"],"names":[],"mappings":"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"}