@starci/hfs 4.11.22 → 4.12.0

package/runtime/scripts/hfs/coverage-scope.mjs

@@ -16,102 +16,99 @@ import { braceVariants, globExpression } from '../lib/glob.mjs';
 import { declaredLogicOf, logicRolesOf } from './manifest-shape.mjs';
 import { byCodeUnit } from '../lib/list.mjs';
 import { trimTrailingSlashes } from './trailing-slashes.mjs';
-
 /** The component that holds the shared infrastructure: the platform tier and every capability more than one service app composes. */
 const PLATFORM_COMPONENT = 'platform';
 const SERVICE_APP_KINDS = new Set(['api', 'worker']);
 /** `text` with every `<placeholder>` (a `<`, at least one character, the next `>`) replaced by `*`; a `<` with no closing `>` stays. */
 export const star = (text) => {
-  const source = String(text);
-  let result = '';
-  let copied = 0;
-  let open = source.indexOf('<');
-  while (open !== -1) {
-    const close = source.indexOf('>', open + 1);
-    if (close === -1) break;
-    if (close === open + 1) {
-      open = source.indexOf('<', close);
-      continue;
+    const source = String(text);
+    let result = '';
+    let copied = 0;
+    let open = source.indexOf('<');
+    while (open !== -1) {
+        const close = source.indexOf('>', open + 1);
+        if (close === -1)
+            break;
+        if (close === open + 1) {
+            open = source.indexOf('<', close);
+            continue;
+        }
+        result += `${source.slice(copied, open)}*`;
+        copied = close + 1;
+        open = source.indexOf('<', copied);
     }
-    result += `${source.slice(copied, open)}*`;
-    copied = close + 1;
-    open = source.indexOf('<', copied);
-  }
-  return result + source.slice(copied);
+    return result + source.slice(copied);
 };
 export const segments = (dir, trimSlashes = false) => (trimSlashes ? trimTrailingSlashes(dir) : dir).split('/').filter(Boolean);
 const isDir = (path) => path.endsWith('/');
-
 /** True when directory pattern `inner` lies inside `outer` (an outer `*` segment matches any one inner segment) or is the same. */
 export function nested(inner, outer) {
-  const a = segments(inner, true);
-  const b = segments(outer, true);
-  return a.length >= b.length && b.every((segment, index) => segment === '*' ? true : segment === a[index]);
+    const a = segments(inner, true);
+    const b = segments(outer, true);
+    return a.length >= b.length && b.every((segment, index) => segment === '*' ? true : segment === a[index]);
 }
-
 /** The directory patterns (be-relative, placeholders as `*`, trailing slash) of a slot's path variants; a file pattern keeps its name. */
 const variantsOf = (slot) => braceVariants(slot.path).map(star);
-
 /**
  * The tracked slots of the be profile, in manifest order. A slot gated by a connection provider holds files only in an
  * app whose connection declares that provider (`providers`), so it takes no part in the scope of any other app.
  */
 const beSlots = (manifest, providers) => manifest.slots.filter((slot) => slot.profiles.includes('be') && slot.tracked === 'tracked' && (slot.provider === undefined || providers.includes(slot.provider)));
-
 function addRequiredPatterns(sonar, required, suffixes) {
-  const escapedSuffixes = suffixes.map((suffix) => suffix.replaceAll('-', String.raw`\-`)).join('|');
-  const isRole = new RegExp(String.raw`\.(?:${escapedSuffixes})\.ts$`);
-  for (const slot of required) {
-    for (const entry of [...(slot.requires ?? []), ...(slot.allows ?? [])]) {
-      addEntryPatterns(sonar, slot, entry, isRole);
+    const escapedSuffixes = suffixes.map((suffix) => suffix.replaceAll('-', String.raw `\-`)).join('|');
+    const isRole = new RegExp(String.raw `\.(?:${escapedSuffixes})\.ts$`);
+    for (const slot of required) {
+        for (const entry of [...(slot.requires ?? []), ...(slot.allows ?? [])]) {
+            addEntryPatterns(sonar, slot, entry, isRole);
+        }
     }
-  }
 }
-
 function addEntryPatterns(sonar, slot, entry, isRole) {
-  if (!entry.endsWith('.ts') || entry.includes('<role>') || declaredLogicOf(slot).includes(entry)) return;
-  for (const name of braceVariants(entry)) {
-    if (isRole.test(star(name).replaceAll('*', 'x'))) continue;
-    for (const dir of variantsOf(slot)) sonar.add(`be/${dir}${star(name)}`.replace(/\/\/+/g, '/'));
-  }
+    if (!entry.endsWith('.ts') || entry.includes('<role>') || declaredLogicOf(slot).includes(entry))
+        return;
+    for (const name of braceVariants(entry)) {
+        if (isRole.test(star(name).replaceAll('*', 'x')))
+            continue;
+        for (const dir of variantsOf(slot))
+            sonar.add(`be/${dir}${star(name)}`.replace(/\/\/+/g, '/'));
+    }
 }
-
 /** Whether `text` fits `pattern`, where each `*` stands for any run of characters. */
 function wildcardMatches(pattern, text) {
-  const parts = pattern.split('*');
-  if (!text.startsWith(parts[0])) return false;
-  let at = parts[0].length;
-  for (const part of parts.slice(1, -1)) {
-    const found = text.indexOf(part, at);
-    if (found < 0) return false;
-    at = found + part.length;
-  }
-  const last = parts.at(-1);
-  return parts.length === 1 ? text === pattern : text.length - last.length >= at && text.endsWith(last);
+    const parts = pattern.split('*');
+    if (!text.startsWith(parts[0]))
+        return false;
+    let at = parts[0].length;
+    for (const part of parts.slice(1, -1)) {
+        const found = text.indexOf(part, at);
+        if (found < 0)
+            return false;
+        at = found + part.length;
+    }
+    const last = parts.at(-1);
+    return parts.length === 1 ? text === pattern : text.length - last.length >= at && text.endsWith(last);
 }
-
 /** Whether glob segments `glob` match path-or-glob segments `entry` (`**` crosses directories, `*` stays inside one segment). */
 function segmentsCover(glob, entry) {
-  if (glob.length === 0) return entry.length === 0;
-  const [head, ...rest] = glob;
-  if (head === '**') return Array.from({ length: entry.length + 1 }, (_, skipped) => skipped).some((skipped) => segmentsCover(rest, entry.slice(skipped)));
-  if (entry.length === 0 || entry[0].includes('**')) return false;
-  const matches = head.includes('*') ? wildcardMatches(head, entry[0]) : head === entry[0];
-  return matches && segmentsCover(rest, entry.slice(1));
+    if (glob.length === 0)
+        return entry.length === 0;
+    const [head, ...rest] = glob;
+    if (head === '**')
+        return Array.from({ length: entry.length + 1 }, (_, skipped) => skipped).some((skipped) => segmentsCover(rest, entry.slice(skipped)));
+    if (entry.length === 0 || entry[0].includes('**'))
+        return false;
+    const matches = head.includes('*') ? wildcardMatches(head, entry[0]) : head === entry[0];
+    return matches && segmentsCover(rest, entry.slice(1));
 }
-
 /** The exclusion entries that no other entry already matches: a glob covered by a broader one adds nothing to the scope. */
 export const withoutCovered = (entries) => entries.filter((entry) => !entries.some((other) => other !== entry && segmentsCover(other.split('/'), entry.split('/'))));
-
 /** The directory a path pattern lives in (itself when it is one). */
 const dirOf = (path) => (isDir(path) ? path : path.slice(0, path.lastIndexOf('/') + 1));
-
 /** The unique directory patterns not nested inside another one. */
 const minimal = (patterns) => {
-  const unique = [...new Set(patterns)];
-  return unique.filter((pattern) => !unique.some((other) => other !== pattern && nested(pattern, other)));
+    const unique = [...new Set(patterns)];
+    return unique.filter((pattern) => !unique.some((other) => other !== pattern && nested(pattern, other)));
 };
-
 /**
  * The scope of an app's back end, derived from the manifest: { roles, roots, excludes, none, sonar, codecovPaths }.
  *   roles     ruleParams.be.logicRoles;
@@ -123,65 +120,63 @@ const minimal = (patterns) => {
  *   codecovPaths  the measured roots as `be/<root>**`.
  */
 export function coverageScope(manifest, providers = []) {
-  const roles = [...logicRolesOf(manifest)];
-  const slots = beSlots(manifest, providers);
-  const required = slots.filter((slot) => slot.coverage === 'required');
-  const none = slots.filter((slot) => slot.coverage === 'none');
-  const requiredDirs = required.flatMap((slot) => variantsOf(slot).map((dir) => {
-    if (!isDir(dir)) throw new Error(`slot ${slot.id} is coverage: required but its path ${slot.path} is not a directory`);
-    return dir;
-  }));
-  const roots = minimal(requiredDirs).sort(byCodeUnit);
-  const nonePaths = none.flatMap((slot) => variantsOf(slot));
-  for (const dir of nonePaths.filter(isDir)) if (requiredDirs.some((other) => nested(other, dir))) throw new Error(`a coverage: none directory ${dir} contains a coverage: required slot`);
-  const noneUnique = [...new Set(nonePaths)];
-  const noneMinimal = noneUnique.filter((path) => !noneUnique.some((other) => other !== path && isDir(other) && nested(dirOf(path), other)));
-  const excludes = noneMinimal.filter((path) => isDir(path) && roots.some((root) => nested(path, root))).sort(byCodeUnit);
-  const declared = required.flatMap((slot) => declaredLogicOf(slot).flatMap((file) => variantsOf(slot).map((dir) => `${dir}${file}`)));
-  const files = [...new Set(declared)].filter((file) => !noneMinimal.some((path) => isDir(path) && nested(dirOf(file), path))).sort(byCodeUnit);
-  const suffixes = manifest.ruleParams.be.suffixes;
-  const sonar = new Set(noneMinimal.map((path) => `be/${path}${isDir(path) ? '**' : ''}`));
-  for (const role of suffixes.filter((suffix) => !roles.includes(suffix))) sonar.add(`be/**/*.${role}.ts`);
-  addRequiredPatterns(sonar, required, suffixes);
-  sonar.add('fe/**');
-  noneMinimal.sort(byCodeUnit);
-  return { roles, roots, files, excludes, none: noneMinimal, sonar: withoutCovered([...sonar]).sort(byCodeUnit), codecovPaths: roots.map((root) => `be/${root}**`) };
+    const roles = [...logicRolesOf(manifest)];
+    const slots = beSlots(manifest, providers);
+    const required = slots.filter((slot) => slot.coverage === 'required');
+    const none = slots.filter((slot) => slot.coverage === 'none');
+    const requiredDirs = required.flatMap((slot) => variantsOf(slot).map((dir) => {
+        if (!isDir(dir))
+            throw new Error(`slot ${slot.id} is coverage: required but its path ${slot.path} is not a directory`);
+        return dir;
+    }));
+    const roots = minimal(requiredDirs).sort(byCodeUnit);
+    const nonePaths = none.flatMap((slot) => variantsOf(slot));
+    for (const dir of nonePaths.filter(isDir))
+        if (requiredDirs.some((other) => nested(other, dir)))
+            throw new Error(`a coverage: none directory ${dir} contains a coverage: required slot`);
+    const noneUnique = [...new Set(nonePaths)];
+    const noneMinimal = noneUnique.filter((path) => !noneUnique.some((other) => other !== path && isDir(other) && nested(dirOf(path), other)));
+    const excludes = noneMinimal.filter((path) => isDir(path) && roots.some((root) => nested(path, root))).sort(byCodeUnit);
+    const declared = required.flatMap((slot) => declaredLogicOf(slot).flatMap((file) => variantsOf(slot).map((dir) => `${dir}${file}`)));
+    const files = [...new Set(declared)].filter((file) => !noneMinimal.some((path) => isDir(path) && nested(dirOf(file), path))).sort(byCodeUnit);
+    const suffixes = manifest.ruleParams.be.suffixes;
+    const sonar = new Set(noneMinimal.map((path) => `be/${path}${isDir(path) ? '**' : ''}`));
+    for (const role of suffixes.filter((suffix) => !roles.includes(suffix)))
+        sonar.add(`be/**/*.${role}.ts`);
+    addRequiredPatterns(sonar, required, suffixes);
+    sonar.add('fe/**');
+    noneMinimal.sort(byCodeUnit);
+    return { roles, roots, files, excludes, none: noneMinimal, sonar: withoutCovered([...sonar]).sort(byCodeUnit), codecovPaths: roots.map((root) => `be/${root}**`) };
 }
-
 /** The glob a root measures: every file of a logic role below it (`src/modules/domain/*\/**\/*.{service,policy}.ts`). */
 export const rootGlob = (root, roles) => {
-  const roleGlob = roles.length === 1 ? roles[0] : `{${roles.join(',')}}`;
-  return `${root}**/*.${roleGlob}.ts`;
+    const roleGlob = roles.length === 1 ? roles[0] : `{${roles.join(',')}}`;
+    return `${root}**/*.${roleGlob}.ts`;
 };
-
 /** The jest coverage options of the rendered be/jest.config.js: { roots, roles, files, excludes }. */
 export function jestCoverage(manifest, providers = []) {
-  const { roots, roles, files, excludes } = coverageScope(manifest, providers);
-  return { roots, roles, files, excludes: excludes.map((dir) => `${dir}**`) };
+    const { roots, roles, files, excludes } = coverageScope(manifest, providers);
+    return { roots, roles, files, excludes: excludes.map((dir) => `${dir}**`) };
 }
-
 /** Sonar's sonar.coverage.exclusions of an app: the complement of the measured files, repository-relative from the app root. */
 export const sonarCoverageExclusions = (manifest, providers = []) => coverageScope(manifest, providers).sonar;
-
 /** The Codecov paths of an app: the measured roots, repository-relative from the app root. */
 export const codecovPaths = (manifest, providers = []) => coverageScope(manifest, providers).codecovPaths;
-
 /**
  * The capability a be-relative file belongs to inside a root, or null: the folder the root's last `*` stands for
  * (`src/modules/domain/*\/` and `src/modules/domain/order/order.service.ts` give `order`).
  */
 function capabilityOf(root, file) {
-  const parts = segments(root, true);
-  const at = parts.length - 1;
-  if (parts[at] !== '*') return null;
-  const own = file.split('/');
-  return parts.slice(0, at).every((part, index) => part === own[index]) && own.length > at + 1 ? own[at] : null;
+    const parts = segments(root, true);
+    const at = parts.length - 1;
+    if (parts[at] !== '*')
+        return null;
+    const own = file.split('/');
+    return parts.slice(0, at).every((part, index) => part === own[index]) && own.length > at + 1 ? own[at] : null;
 }
-
 function escapeImportPart(part) {
-  return part.replace(/[/.]/g, String.raw`\$&`);
+    return part.replace(/[/.]/g, String.raw `\$&`);
 }
-
 /**
  * The Codecov components of an app, [{ id, name, paths }] (paths repository-relative from the app root): one per service app (api or worker)
  * that composes the capabilities nothing else composes, then `platform`. A capability of a root whose last segment is a placeholder
@@ -189,60 +184,62 @@ function escapeImportPart(part) {
  * (`apps/<app>/`) imports `@modules/<tier>/<capability>`; when several import it, the service app named like the capability (the
  * `identity` service and the `identity` capability) owns it; one that nothing singles out belongs to platform, as does the whole platform tier. The measured roots of the tier `platform` are never split.
  *
- * @param {object} manifest the slot manifest
- * @param {{ files: string[], read: (file: string) => string, apps: Array<{name: string, kind: string}> }} source be-relative source files, a reader, the declared be apps
+ * @param manifest the slot manifest
+ * @param source be-relative source files, a reader, the declared be apps
  */
 export function coverageComponents(manifest, { files, read, apps, providers = [] }) {
-  const { roots } = coverageScope(manifest, providers);
-  const services = apps.filter((app) => SERVICE_APP_KINDS.has(app.kind));
-  const imports = new Map(services.map((app) => [app.name, files.filter((file) => file.startsWith(`apps/${app.name}/`) && /\.[cm]?ts$/.test(file)).map((file) => read(file)).join('\n')]));
-  const platformPaths = [];
-  const ownedBy = new Map(services.map((app) => [app.name, []]));
-  for (const root of roots) assignRoot({ root, files, services, imports, platformPaths, ownedBy });
-  const components = services.filter((app) => ownedBy.get(app.name).length).map((app) => {
-    const paths = ownedBy.get(app.name);
-    paths.sort(byCodeUnit);
-    return { id: app.name, name: app.name, paths };
-  });
-  if (platformPaths.length) platformPaths.sort(byCodeUnit);
-  return [
-    ...components,
-    ...(platformPaths.length ? [{ id: PLATFORM_COMPONENT, name: PLATFORM_COMPONENT, paths: platformPaths }] : []),
-  ];
+    const { roots } = coverageScope(manifest, providers);
+    const services = apps.filter((app) => SERVICE_APP_KINDS.has(app.kind));
+    const imports = new Map(services.map((app) => [app.name, files.filter((file) => file.startsWith(`apps/${app.name}/`) && /\.[cm]?ts$/.test(file)).map((file) => read(file)).join('\n')]));
+    const platformPaths = [];
+    const ownedBy = new Map(services.map((app) => [app.name, []]));
+    for (const root of roots)
+        assignRoot({ root, files, services, imports, platformPaths, ownedBy });
+    const components = services.filter((app) => ownedBy.get(app.name).length).map((app) => {
+        const paths = ownedBy.get(app.name);
+        paths.sort(byCodeUnit);
+        return { id: app.name, name: app.name, paths };
+    });
+    if (platformPaths.length)
+        platformPaths.sort(byCodeUnit);
+    return [
+        ...components,
+        ...(platformPaths.length ? [{ id: PLATFORM_COMPONENT, name: PLATFORM_COMPONENT, paths: platformPaths }] : []),
+    ];
 }
-
 /** Puts the measured root, or each capability below it, into the platform paths or the paths of the one service app that composes it. */
 function assignRoot({ root, files, services, imports, platformPaths, ownedBy }) {
-  const module = /^src\/modules\/(.+)\/\*\/$/.exec(root)?.[1] ?? null;
-  const capabilities = [...new Set(files.map((file) => capabilityOf(root, file)).filter(Boolean))].sort(byCodeUnit);
-  const base = root.slice(0, -2);
-  if (module === null || module === 'platform' || !capabilities.length) {
-    platformPaths.push(`be/${root}**`);
-    return;
-  }
-  for (const capability of capabilities) {
-    const spec = new RegExp(String.raw`from\s+["']@modules/${escapeImportPart(module)}/${escapeImportPart(capability)}["']`);
-    const importers = services.filter((app) => spec.test(imports.get(app.name)));
-    const owners = importers.length === 1 ? importers : importers.filter((app) => app.name === capability);
-    if (owners.length === 1) ownedBy.get(owners[0].name).push(`be/${base}${capability}/**`);
-    else platformPaths.push(`be/${base}${capability}/**`);
-  }
+    const module = /^src\/modules\/(.+)\/\*\/$/.exec(root)?.[1] ?? null;
+    const capabilities = [...new Set(files.map((file) => capabilityOf(root, file)).filter((name) => Boolean(name)))].sort(byCodeUnit);
+    const base = root.slice(0, -2);
+    if (module === null || module === 'platform' || !capabilities.length) {
+        platformPaths.push(`be/${root}**`);
+        return;
+    }
+    for (const capability of capabilities) {
+        const spec = new RegExp(String.raw `from\s+["']@modules/${escapeImportPart(module)}/${escapeImportPart(capability)}["']`);
+        const importers = services.filter((app) => spec.test(imports.get(app.name)));
+        const owners = importers.length === 1 ? importers : importers.filter((app) => app.name === capability);
+        if (owners.length === 1)
+            ownedBy.get(owners[0].name).push(`be/${base}${capability}/**`);
+        else
+            platformPaths.push(`be/${base}${capability}/**`);
+    }
 }
-
 /**
  * The one test of whether a be-relative file is measured, over a coverage scope: a declared logic file of `files`, or `<name>.<role>.ts`
  * of a logic role below a measured root and inside no none directory of it. isMeasured and R273 (rules/coverage-below.mjs) ask it.
  */
 export function measuredBy({ roots, roles, files, excludes }) {
-  const declared = files.map((file) => globExpression(file));
-  const rootGlobs = roots.map((dir) => globExpression(`${dir}**`));
-  const excludeGlobs = excludes.map((dir) => globExpression(`${dir}**`));
-  return (file) => {
-    if (declared.some((glob) => glob.test(file))) return true;
-    const role = /\.([a-z][a-z0-9-]*)\.ts$/.exec(file)?.[1];
-    return Boolean(role) && roles.includes(role) && rootGlobs.some((glob) => glob.test(file)) && !excludeGlobs.some((glob) => glob.test(file));
-  };
+    const declared = files.map((file) => globExpression(file));
+    const rootGlobs = roots.map((dir) => globExpression(`${dir}**`));
+    const excludeGlobs = excludes.map((dir) => globExpression(`${dir}**`));
+    return (file) => {
+        if (declared.some((glob) => glob.test(file)))
+            return true;
+        const role = /\.([a-z][a-z0-9-]*)\.ts$/.exec(file)?.[1];
+        return Boolean(role) && roles.includes(role) && rootGlobs.some((glob) => glob.test(file)) && !excludeGlobs.some((glob) => glob.test(file));
+    };
 }
-
 /** True when the be-relative `file` is measured by the scope of the whole manifest (measuredBy). */
 export const isMeasured = (manifest, file) => measuredBy(coverageScope(manifest))(file);

package/runtime/scripts/hfs/db-baseline-verb.d.mts

@@ -0,0 +1,84 @@
+import { DbVerbError } from './db-errors.mjs';
+export { DbVerbError };
+/** A history change: `stamp` recorded as applied (named `name`) or reverted. */
+export interface RepairOp {
+    kind: 'repair';
+    stamp: string;
+    status: string;
+    name?: string;
+}
+/** One database operation: a JSON rows query, a schema-only dump, or a history change. */
+export type DbOperation = {
+    kind: 'query';
+    sql: string;
+} | {
+    kind: 'dump';
+} | RepairOp;
+/** What a database port (or spawnSync) answers with. */
+export interface DbResult {
+    ok?: boolean;
+    status?: number | null;
+    stdout?: unknown;
+    error?: unknown;
+}
+/** The injectable ports of the db verbs: the environment, the psql runner and the git seam. */
+export interface DbPorts {
+    env?: NodeJS.ProcessEnv | undefined;
+    runPostgres?: ((root: string, op: DbOperation) => DbResult | null | undefined) | undefined;
+    git?: unknown;
+}
+/** The parsed options of a db verb (dbOptions refuses every flag outside the verb's list). */
+export interface DbOptions {
+    cwd?: string;
+    stamp?: string;
+    execute?: boolean;
+    'db-url-env'?: string;
+    squash?: boolean;
+    'drop-extension'?: string;
+    'drop-pgmq-queue'?: string;
+    'seed-tables'?: string;
+    image?: string;
+    map?: string;
+    json?: boolean;
+}
+/** One active or archived migration file. */
+export interface SqlFile {
+    file: string;
+    name: string;
+    stamp: string;
+}
+/** The injectable IO of a db verb. */
+export interface DbMainIo extends DbPorts {
+    cwd?: string | undefined;
+    stdout?: ((text: string) => unknown) | undefined;
+    stderr?: ((text: string) => unknown) | undefined;
+    now?: (() => Date) | undefined;
+}
+/** Strict shared options; unknown flags never reach the database CLI. */
+/** The options of `starci app db baseline` (dbOptions refuses every other). */
+export declare const BASELINE_OPTIONS: readonly string[];
+/** The boolean options of the dbOptions verbs; every other option takes a value. */
+export declare const DB_BOOLEAN_OPTIONS: readonly string[];
+export declare function dbOptions(argv: string[], allowed: readonly string[]): DbOptions;
+export declare function dbAppRoot(cwd: string, opts: DbOptions): string;
+/** A refusal that lists every offending file with the rule it broke, one distinct `<file>: <reason>` line each. */
+export declare const offendersError: (heading: string, offenders: string[]) => DbVerbError;
+/** Immediate SQL files only, never secrets or credential files, sorted by full name; every offender is named before the refusal. */
+export declare function dbSqlFiles(root: string, directory?: string): SqlFile[];
+/** The database of `--db-url-env` (default DATABASE_URL): the URL without its password and the password for PGPASSWORD. */
+export declare function connectionOf(env: NodeJS.ProcessEnv, urlEnv: string): {
+    url: string;
+    env: NodeJS.ProcessEnv;
+};
+/** The psql and pg_dump invocation of one operation: a JSON rows query, a schema-only dump, or one history row applied or reverted. */
+export declare function commandOf(op: DbOperation, url: string): [string, string[]];
+/** Runs one database operation through psql or pg_dump (ports.runPostgres in specs); raw failures and output are private. */
+export declare function runDbPostgres(root: string, op: DbOperation, ports?: DbPorts, urlEnv?: string): string;
+/** A history change: `stamp` recorded as applied (named `name`) or reverted. */
+export declare const repairOp: (stamp: string, status: string, name?: string) => RepairOp;
+/** The printed form of a history change. */
+export declare const repairLine: (op: RepairOp) => string;
+export declare const dbFailure: (verb: string, error: unknown, stderr: (text: string) => unknown) => number;
+export declare const excludedSchema: (name: string | undefined) => boolean;
+/** Numeric CLI exit code, injectable IO/clock/CLI; neither files nor history change without --execute. */
+export declare function dbBaselineMain(argv: string[], { cwd, stdout, stderr, now, ...ports }?: DbMainIo): number;