@serve.zone/dcrouter 34.0.0 → 34.2.0

package/dist_ts/index.js

@@ -4,6 +4,7 @@ export * from './00_commitinfo_data.js';
 export { UnifiedEmailServer } from '@push.rocks/smartmta';
 // DcRouter
 import { DcRouter } from './classes.dcrouter.js';
+import { runMigrateCommand } from './migrate-command.js';
 export * from './classes.dcrouter.js';
 // RADIUS module
 export * from './radius/index.js';
@@ -11,25 +12,37 @@ export * from './radius/index.js';
 export * from './remoteingress/index.js';
 // Web Push provider module
 export * from './webpush/index.js';
-export const runCli = async () => {
-    const args = process.argv.slice(2);
-    if (args.includes('--version') || args.includes('version')) {
-        console.log(commitinfo.version);
-        return;
-    }
-    if (args.includes('--help') || args.includes('-h') || args.includes('help')) {
-        console.log(`dcrouter ${commitinfo.version}
-
-Usage:
+const cliUsage = `Usage:
   dcrouter
   dcrouter --version
   dcrouter --help
+  dcrouter migrate --storage-path <absolute path> --to <version> [--db-name <name>] [--plan]
 
 Environment:
   DCROUTER_MODE=OCI_CONTAINER   Start with OCI container configuration
   DCROUTER_DNS_BIND_INTERFACE   Override the embedded DNS UDP bind address
   DATA_DIR=<path>               Override the writable dcrouter data directory
-`);
+`;
+export const runCli = async () => {
+    const args = process.argv.slice(2);
+    if (args[0] === 'migrate') {
+        process.exitCode = await runMigrateCommand(args.slice(1));
+        return;
+    }
+    if (args.includes('--version') || args.includes('version')) {
+        console.log(commitinfo.version);
+        return;
+    }
+    if (args.includes('--help') || args.includes('-h') || args.includes('help')) {
+        console.log(`dcrouter ${commitinfo.version}\n\n${cliUsage}`);
+        return;
+    }
+    // Only a bare `dcrouter` starts the router: an argument this release does not know (a command
+    // a later release added, a typo) must never start it against the data it was meant for.
+    if (args.length > 0) {
+        console.error(`dcrouter: unknown argument${args.length > 1 ? 's' : ''} ${args.map((argArg) => `"${argArg}"`).join(' ')}; `
+            + `nothing was started.\n\n${cliUsage}`);
+        process.exitCode = 2;
         return;
     }
     let options = {};
@@ -49,4 +62,4 @@ Environment:
     process.once('SIGINT', shutdown);
     process.once('SIGTERM', shutdown);
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/migrate-command.d.ts

@@ -0,0 +1,44 @@
+import * as plugins from './plugins.js';
+import type { IDowngradeMigrationRunResult } from '../dist_ts_migrations/index.js';
+/** The prefix of the one line `dcrouter migrate` ends with: the outcome as JSON. */
+export declare const migrateResultLinePrefix = "DCROUTER_MIGRATE_RESULT:";
+export declare const migrateCommandUsage = "Usage:\n  dcrouter migrate --storage-path <absolute path> --to <version> [--db-name <name>] [--plan]\n\nWalks the data of a stopped dcrouter back to an earlier data version, running each\nstep's down handler. Forward migrations happen when dcrouter starts.\n\n  --storage-path <path>   The embedded database's storage root (absolute; no default)\n  --to <version>          The data version to walk back to, a step boundary\n  --db-name <name>        The database inside the root (default: dcrouter)\n  --plan                  Report the steps the downgrade would run, change nothing\n\nThe root must not be in use: the command refuses a root a running dcrouter owns.\nThe last line of the output is DCROUTER_MIGRATE_RESULT:{json}.\n";
+/** A command line `dcrouter migrate` refuses before it opens anything. */
+export declare class MigrateCommandUsageError extends Error {
+    constructor(messageArg: string);
+}
+export interface IMigrateCommandOptions {
+    storagePath: string;
+    targetVersion: string;
+    dbName: string;
+    planOnly: boolean;
+}
+export type TMigrateCommandResult = ({
+    ok: true;
+    plan: boolean;
+    storagePath: string;
+    dbName: string;
+} & IDowngradeMigrationRunResult) | {
+    ok: false;
+    error: {
+        name: string;
+        code?: string;
+        message: string;
+    };
+};
+/**
+ * The stopped-root check's bounds: the largest every input admits (smartdb readme, "Offline
+ * Physical Namespace Inspection"). A root over any of them is refused, never partly inspected: a
+ * data file over `maximumDataFileBytes` fails the whole inspection with `ERESOURCE_LIMIT`
+ * (nosqldb 5.7.1 `rustdb-storage/src/offline_inspection/physical_namespace_inspection.rs:760`).
+ */
+export declare const offlineInspectionLimits: plugins.smartdb.ILocalSmartDbOfflinePhysicalNamespaceInspectionLimits;
+export declare function parseMigrateArguments(argsArg: string[]): IMigrateCommandOptions;
+/**
+ * Runs the downgrade offline: a stopped-root check first, then the engine, whose owner lock refuses
+ * a root a running dcrouter holds, then the reverse migration. Both handles are released before it
+ * returns, whatever happened.
+ */
+export declare function runMigrateCommandOptions(optionsArg: IMigrateCommandOptions): Promise<TMigrateCommandResult>;
+/** `dcrouter migrate …`; resolves to the process exit code and prints the result line last. */
+export declare function runMigrateCommand(argsArg: string[]): Promise<number>;

package/dist_ts/migrate-command.js

@@ -0,0 +1,181 @@
+import * as plugins from './plugins.js';
+import { createDowngradeMigrationRunner, DcRouterMigrationError } from '../dist_ts_migrations/index.js';
+/** The prefix of the one line `dcrouter migrate` ends with: the outcome as JSON. */
+export const migrateResultLinePrefix = 'DCROUTER_MIGRATE_RESULT:';
+export const migrateCommandUsage = `Usage:
+  dcrouter migrate --storage-path <absolute path> --to <version> [--db-name <name>] [--plan]
+
+Walks the data of a stopped dcrouter back to an earlier data version, running each
+step's down handler. Forward migrations happen when dcrouter starts.
+
+  --storage-path <path>   The embedded database's storage root (absolute; no default)
+  --to <version>          The data version to walk back to, a step boundary
+  --db-name <name>        The database inside the root (default: dcrouter)
+  --plan                  Report the steps the downgrade would run, change nothing
+
+The root must not be in use: the command refuses a root a running dcrouter owns.
+The last line of the output is ${migrateResultLinePrefix}{json}.
+`;
+/** A command line `dcrouter migrate` refuses before it opens anything. */
+export class MigrateCommandUsageError extends Error {
+    constructor(messageArg) {
+        super(messageArg);
+        this.name = 'MigrateCommandUsageError';
+    }
+}
+/**
+ * The stopped-root check's bounds: the largest every input admits (smartdb readme, "Offline
+ * Physical Namespace Inspection"). A root over any of them is refused, never partly inspected: a
+ * data file over `maximumDataFileBytes` fails the whole inspection with `ERESOURCE_LIMIT`
+ * (nosqldb 5.7.1 `rustdb-storage/src/offline_inspection/physical_namespace_inspection.rs:760`).
+ */
+export const offlineInspectionLimits = {
+    maximumEntries: 100_000,
+    maximumDatabases: 4_096,
+    maximumCollections: 10_000,
+    maximumIndexes: 100_000,
+    maximumDataFileBytes: 268_435_456,
+    maximumWalFileBytes: 67_108_864,
+    maximumIndexFileBytes: 16_777_216,
+    maximumTotalFileBytes: 1_099_511_627_776,
+    maximumRecordsPerCollection: 1_000_000,
+    maximumRecordBytes: 17_825_792,
+    maximumResultBytes: 16_777_216,
+};
+const offlineInspectionTimeoutMs = 10 * 60_000;
+export function parseMigrateArguments(argsArg) {
+    let storagePath;
+    let targetVersion;
+    let dbName = 'dcrouter';
+    let planOnly = false;
+    const valueOf = (indexArg, flagArg) => {
+        const value = argsArg[indexArg + 1];
+        if (value === undefined || value.startsWith('--')) {
+            throw new MigrateCommandUsageError(`${flagArg} needs a value.`);
+        }
+        return value;
+    };
+    for (let index = 0; index < argsArg.length; index++) {
+        const arg = argsArg[index];
+        switch (arg) {
+            case '--storage-path':
+                storagePath = valueOf(index++, arg);
+                break;
+            case '--to':
+                targetVersion = valueOf(index++, arg);
+                break;
+            case '--db-name':
+                dbName = valueOf(index++, arg);
+                break;
+            case '--plan':
+                planOnly = true;
+                break;
+            default:
+                throw new MigrateCommandUsageError(`Unknown argument "${arg}".`);
+        }
+    }
+    if (!storagePath)
+        throw new MigrateCommandUsageError('--storage-path is required.');
+    if (!plugins.path.isAbsolute(storagePath)) {
+        throw new MigrateCommandUsageError(`--storage-path must be an absolute path, not "${storagePath}".`);
+    }
+    if (!targetVersion)
+        throw new MigrateCommandUsageError('--to is required.');
+    return { storagePath: plugins.path.resolve(storagePath), targetVersion, dbName, planOnly };
+}
+/**
+ * Runs the downgrade offline: a stopped-root check first, then the engine, whose owner lock refuses
+ * a root a running dcrouter holds, then the reverse migration. Both handles are released before it
+ * returns, whatever happened.
+ */
+export async function runMigrateCommandOptions(optionsArg) {
+    // Refuses a root an engine holds (the sidecar takes the shared owner lock), a root that is not a
+    // current SmartDB root, and any file that does not validate, before the engine is started.
+    const inspection = await plugins.smartdb.LocalSmartDb.inspectOfflinePhysicalNamespaces({ folderPath: optionsArg.storagePath, limits: offlineInspectionLimits }, { timeoutMs: offlineInspectionTimeoutMs });
+    const databaseNames = inspection.databases.map((databaseArg) => databaseArg.name);
+    if (!databaseNames.includes(optionsArg.dbName)) {
+        throw new DcRouterMigrationError(`The storage root holds no database "${optionsArg.dbName}" (it holds ${databaseNames.length > 0
+            ? databaseNames.map((nameArg) => `"${nameArg}"`).join(', ')
+            : 'none'}). Nothing was changed.`);
+    }
+    const localSmartDb = new plugins.smartdb.LocalSmartDb({ folderPath: optionsArg.storagePath });
+    let db;
+    let failure;
+    try {
+        const { connectionUri } = await localSmartDb.start();
+        db = new plugins.smartdata.SmartdataDb({ mongoDbUrl: connectionUri, mongoDbName: optionsArg.dbName });
+        await db.init();
+        const runner = await createDowngradeMigrationRunner(db, optionsArg.targetVersion);
+        const result = optionsArg.planOnly ? await runner.plan() : await runner.run();
+        return {
+            ok: true,
+            plan: optionsArg.planOnly,
+            storagePath: optionsArg.storagePath,
+            dbName: optionsArg.dbName,
+            currentVersionBefore: result.currentVersionBefore,
+            currentVersionAfter: result.currentVersionAfter,
+            targetVersion: result.targetVersion,
+            wasUpToDate: result.wasUpToDate,
+            wasFreshInstall: result.wasFreshInstall,
+            totalDurationMs: result.totalDurationMs,
+            stepsApplied: result.stepsApplied.map(({ id, fromVersion, toVersion, status }) => ({ id, fromVersion, toVersion, status })),
+            stepsSkipped: result.stepsSkipped.map(({ id, fromVersion, toVersion, status }) => ({ id, fromVersion, toVersion, status })),
+        };
+    }
+    catch (error) {
+        failure = { error };
+        throw error;
+    }
+    finally {
+        // Both handles are released whatever happened. A cleanup failure after a failed migration is
+        // reported beside it, and the migration's own error stays the one the command answers with.
+        const cleanupErrors = [];
+        for (const release of [() => db?.close(), () => localSmartDb.stop()]) {
+            try {
+                await release();
+            }
+            catch (cleanupError) {
+                cleanupErrors.push(cleanupError);
+            }
+        }
+        if (cleanupErrors.length > 0 && !failure) {
+            throw new AggregateError(cleanupErrors, 'dcrouter migrate could not release the database');
+        }
+        for (const cleanupError of failure ? cleanupErrors : []) {
+            console.error(`dcrouter migrate: releasing the database also failed: ${describeMigrateError(cleanupError).message}`);
+        }
+    }
+}
+const describeMigrateError = (errorArg) => {
+    if (!(errorArg instanceof Error))
+        return { name: 'Error', message: String(errorArg) };
+    const code = errorArg.code;
+    return {
+        name: errorArg.name,
+        ...(typeof code === 'string' ? { code } : {}),
+        message: errorArg.message,
+    };
+};
+/** `dcrouter migrate …`; resolves to the process exit code and prints the result line last. */
+export async function runMigrateCommand(argsArg) {
+    if (argsArg.includes('--help') || argsArg.includes('-h')) {
+        console.log(migrateCommandUsage);
+        return 0;
+    }
+    let result;
+    let exitCode;
+    try {
+        result = await runMigrateCommandOptions(parseMigrateArguments(argsArg));
+        exitCode = 0;
+    }
+    catch (error) {
+        result = { ok: false, error: describeMigrateError(error) };
+        exitCode = error instanceof MigrateCommandUsageError ? 2 : 1;
+        console.error(`dcrouter migrate: ${result.error.message}`);
+        if (error instanceof MigrateCommandUsageError)
+            console.error(migrateCommandUsage);
+    }
+    console.log(`${migrateResultLinePrefix}${JSON.stringify(result)}`);
+    return exitCode;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migrate-command.js","sourceRoot":"","sources":["../../ts/migrate-command.ts"],"names":[],"mappings":"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"}

package/dist_ts/plugins.d.ts

@@ -55,8 +55,9 @@ export { cloudflare, };
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass, };
 import * as argon2 from 'argon2';
+import * as bson from 'bson';
 import * as lruCache from 'lru-cache';
 import ipaddr from 'ipaddr.js';
 import * as uuid from 'uuid';
 import webpush from 'web-push';
-export { argon2, lruCache, ipaddr, uuid, webpush, };
+export { argon2, bson, lruCache, ipaddr, uuid, webpush, };

package/dist_ts/plugins.js

@@ -66,9 +66,10 @@ import * as tsclass from '@tsclass/tsclass';
 export { tsclass, };
 // third party
 import * as argon2 from 'argon2';
+import * as bson from 'bson';
 import * as lruCache from 'lru-cache';
 import ipaddr from 'ipaddr.js';
 import * as uuid from 'uuid';
 import webpush from 'web-push';
-export { argon2, lruCache, ipaddr, uuid, webpush, };
-//# sourceMappingURL=data:application/json;base64,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
+export { argon2, bson, lruCache, ipaddr, uuid, webpush, };
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_interfaces/data/dns-authority.d.ts

@@ -13,10 +13,15 @@
  * The fix is not to make the declared list editable. A list an operator can
  * simply append to is self-assertion, which is precisely the failure mode that
  * let routes claim domains nobody verified we own. Instead a zone earns
- * authority by *proof*: its public delegation must name our nameservers. That
- * proof is unforgeable by an ops-API caller — you cannot point `example.com`'s
- * NS records at our nameservers unless you actually control the domain — and it
- * is the missing comparison between the two representations.
+ * authority by *proof*: its delegation in the parent zone must name our
+ * nameservers. That proof is unforgeable by an ops-API caller — you cannot point
+ * `example.com`'s delegation at our nameservers unless you actually control the
+ * domain — and it is the missing comparison between the two representations.
+ *
+ * The proof is read from the parent zone's own servers, asked without
+ * recursion, never from a recursive resolver: a recursive lookup of a zone
+ * delegated to us but not claimed yet reaches our servers, which REFUSE it, so
+ * it could never prove the delegation it is supposed to prove.
  *
  * `dnsScopes` is gone entirely. There is exactly one representation of DNS
  * authority now, it lives in the database, and it is the one that carries its
@@ -37,7 +42,10 @@ export interface IDnsAuthorityZone {
     origin: TDnsAuthorityZoneOrigin;
     /** When the delegation proof was observed. */
     verifiedAt?: number;
-    /** Nameservers observed at verification time — the evidence for the proof. */
+    /**
+     * The NS set the parent zone's servers delegated the zone to at verification
+     * time — the evidence for the proof.
+     */
     observedNameservers?: string[];
     /** Operator who performed the verification. */
     verifiedBy?: string;
@@ -62,20 +70,69 @@ export interface IDnsAuthoritySettings {
     updatedBy: string;
 }
 /**
- * Outcome of a delegation probe.
+ * Outcome of a delegation probe, decided by the parent zone's servers alone.
+ *
+ * - 'delegated': at least two of the parent's servers, reached through at least
+ *   two different parent nameserver names, gave the identical referral for the
+ *   zone, and its NS set names at least one of our nameservers. A referral that
+ *   carries a DS sets `dsPresent`, and such a zone cannot be claimed.
+ * - 'not-delegated': the same agreement on a referral that names none of our
+ *   nameservers, or on an authoritative "no such delegation" (NXDOMAIN or NODATA
+ *   with the parent's SOA). Also the verdict for an unusable zone name.
+ * - 'undeterminable': anything less — a failed lookup, fewer than two
+ *   conclusive answers, or any disagreement between them.
  *
  * 'undeterminable' is deliberately distinct from 'not-delegated': a resolver
  * timeout is not evidence that a zone is not ours. Conflating them would let a
  * transient network fault revoke authority, turning a blip into an outage.
  */
 export type TDnsDelegationVerdict = 'delegated' | 'not-delegated' | 'undeterminable';
+/**
+ * How the probe classified one parent server's answer to the non-recursive
+ * NS query for the zone.
+ *
+ * - 'referral': RCODE 0, AA=0, an empty answer section, and an authority
+ *   section whose NS records are all owned by the zone, with an OPT record that
+ *   echoes DO=1 (otherwise a missing DS would prove nothing).
+ * - 'negative': AA=1 NXDOMAIN or NODATA with an empty answer section and the
+ *   parent zone's SOA in the authority section.
+ * - 'inconclusive': everything else, including timeouts, REFUSED, any other
+ *   AA=1 answer (a server that hosts the parent and the child zone answers for
+ *   the child instead of referring) and referrals to any other name.
+ */
+export type TDnsDelegationParentOutcome = 'referral' | 'negative' | 'inconclusive';
+/** One parent server's answer to the non-recursive NS query for the zone. */
+export interface IDnsDelegationParentAnswer {
+    /** The parent server the probe asked, as `ip:port` (`[ip]:port` for IPv6). */
+    server: string;
+    /** The parent nameserver name this address belongs to. */
+    nameserver: string;
+    outcome: TDnsDelegationParentOutcome;
+    /** The referral's NS set, lowercased, trailing-dot stripped and sorted (referral only). */
+    nameservers?: string[];
+    /** Whether the referral carried a DS RRset for the zone (referral only). */
+    dsPresent?: boolean;
+    detail: string;
+}
 export interface IDnsDelegationProbe {
     zone: string;
     verdict: TDnsDelegationVerdict;
-    /** NS records observed for the zone, lowercased and trailing-dot stripped. */
+    /**
+     * The NS set the parent zone's servers delegate the zone to, lowercased and
+     * trailing-dot stripped; empty when there is no agreed referral.
+     */
     observedNameservers: string[];
     expectedNameservers: string[];
     detail: string;
+    /** The parent zone whose servers were asked; absent when it was not found. */
+    parentZone?: string;
+    /**
+     * Whether the agreed referral carried a DS for the zone. Set on a verdict
+     * that rests on a referral; a `delegated` zone with a DS cannot be claimed.
+     */
+    dsPresent?: boolean;
+    /** Every parent server's classified answer, when parent servers were asked. */
+    parentAnswers?: IDnsDelegationParentAnswer[];
 }
 /** A disagreement between claimed authority and what is actually true. */
 export type TDnsAuthorityDriftKind = 

package/dist_ts_interfaces/data/dns-authority.js

@@ -13,14 +13,19 @@
  * The fix is not to make the declared list editable. A list an operator can
  * simply append to is self-assertion, which is precisely the failure mode that
  * let routes claim domains nobody verified we own. Instead a zone earns
- * authority by *proof*: its public delegation must name our nameservers. That
- * proof is unforgeable by an ops-API caller — you cannot point `example.com`'s
- * NS records at our nameservers unless you actually control the domain — and it
- * is the missing comparison between the two representations.
+ * authority by *proof*: its delegation in the parent zone must name our
+ * nameservers. That proof is unforgeable by an ops-API caller — you cannot point
+ * `example.com`'s delegation at our nameservers unless you actually control the
+ * domain — and it is the missing comparison between the two representations.
+ *
+ * The proof is read from the parent zone's own servers, asked without
+ * recursion, never from a recursive resolver: a recursive lookup of a zone
+ * delegated to us but not claimed yet reaches our servers, which REFUSE it, so
+ * it could never prove the delegation it is supposed to prove.
  *
  * `dnsScopes` is gone entirely. There is exactly one representation of DNS
  * authority now, it lives in the database, and it is the one that carries its
  * own evidence.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5zLWF1dGhvcml0eS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX2ludGVyZmFjZXMvZGF0YS9kbnMtYXV0aG9yaXR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXVCRyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG5zLWF1dGhvcml0eS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzX2ludGVyZmFjZXMvZGF0YS9kbnMtYXV0aG9yaXR5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBNEJHIn0=

package/dist_ts_interfaces/requests/dns-authority.d.ts

@@ -12,8 +12,9 @@ export interface IReq_GetDnsAuthority extends plugins.typedrequestInterfaces.imp
     };
 }
 /**
- * Probe a zone's public delegation without changing anything. Lets an operator
- * see the evidence before claiming authority.
+ * Probe a zone's delegation in its parent zone without changing anything. Lets
+ * an operator see the evidence (the parent zone and each parent server's
+ * answer) before claiming authority.
  */
 export interface IReq_ProbeDnsAuthorityZone extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_ProbeDnsAuthorityZone> {
     method: 'probeDnsAuthorityZone';
@@ -27,9 +28,10 @@ export interface IReq_ProbeDnsAuthorityZone extends plugins.typedrequestInterfac
     };
 }
 /**
- * Claim authority over a zone. Succeeds only when the zone's public delegation
- * names our nameservers; the claim is then persisted and reconciled in-process,
- * with no restart.
+ * Claim authority over a zone. Succeeds only on a `delegated` probe without a
+ * DS: the parent zone's servers agree that the zone is delegated to our
+ * nameservers and publish no DS for it. The claim is then persisted and
+ * reconciled in-process, with no restart.
  */
 export interface IReq_VerifyDnsAuthorityZone extends plugins.typedrequestInterfaces.implementsTR<plugins.typedrequestInterfaces.ITypedRequest, IReq_VerifyDnsAuthorityZone> {
     method: 'verifyDnsAuthorityZone';

package/dist_ts_migrations/index.d.ts

@@ -28,6 +28,29 @@ export interface IMigrationRunner {
     getCurrentVersion(): Promise<string | null>;
     run(): Promise<IMigrationRunResult>;
 }
+/** The result of a downgrade run or plan, as `dcrouter migrate` reports it. */
+export interface IDowngradeMigrationRunResult extends IMigrationRunResult {
+    targetVersion: string;
+    wasUpToDate: boolean;
+    stepsApplied: Array<{
+        id: string;
+        fromVersion: string;
+        toVersion: string;
+        status: string;
+    }>;
+    /** The steps a plan would run; empty after a run. */
+    stepsSkipped: Array<{
+        id: string;
+        fromVersion: string;
+        toVersion: string;
+        status: string;
+    }>;
+}
+export interface IDowngradeMigrationRunner extends IMigrationRunner {
+    run(): Promise<IDowngradeMigrationRunResult>;
+    /** The reverse plan, without the lock and without writing anything. */
+    plan(): Promise<IDowngradeMigrationRunResult>;
+}
 export declare const dcRouterSchemaVersion = "34.0.0";
 export declare function createApplicationMigrationRunner(db: unknown, options?: IDcRouterMigrationOptions): Promise<IMigrationRunner>;
 export interface IDcRouterMigrationOptions {
@@ -60,3 +83,17 @@ export interface IDcRouterMigrationOptions {
  * @param targetVersion - The explicit schema or historical migration test target
  */
 export declare function createMigrationRunner(db: unknown, targetVersion: string, options?: IDcRouterMigrationOptions): Promise<IMigrationRunner>;
+/**
+ * Create the runner `dcrouter migrate` walks the ledger back with.
+ *
+ * It registers the whole chain through `dcRouterSchemaVersion`, so smartmigration plans the
+ * reverse run itself: it refuses a target that is not a step boundary (`TARGET_NOT_REACHABLE`) and
+ * a path across a step without `.down()` (`DOWNGRADE_STEP_IRREVERSIBLE`) before any handler runs.
+ * `run()` and `plan()` refuse by name, before that, a database without a ledger, a ledger a newer
+ * dcrouter wrote and a target ahead of the ledger: a forward migration is what starting dcrouter
+ * does. A target equal to the ledger is the no-op a repeated downgrade is.
+ *
+ * @param db - An initialized SmartdataDb on a storage root no dcrouter is running on
+ * @param targetVersion - The data version to walk the ledger back to
+ */
+export declare function createDowngradeMigrationRunner(db: unknown, targetVersion: string, options?: IDcRouterMigrationOptions): Promise<IDowngradeMigrationRunner>;