@infinitedusky/indusk-mcp 1.67.0 → 1.70.0

package/dist/lib/release/route.js

@@ -0,0 +1,147 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, posix } from "node:path";
+import { planFolders } from "../promises/plan-folder.js";
+import { readPromises } from "../promises/registry.js";
+import { readImpl } from "../promises/rows.js";
+import { recordTestFailure } from "../promises/test-incident.js";
+import { ownerReopener } from "../promises/watch.js";
+import { openOrExtendBugfixPlan } from "./bugfix-plan.js";
+/** A test path as a row and a JUnit report both spell it: repo-relative, no `./`. */
+function normalise(path) {
+    return posix.normalize(path.trim()).replace(/^\.\//, "");
+}
+export function routeFailure(root, file) {
+    const want = normalise(file);
+    const rows = [];
+    const unreadable = [];
+    for (const folder of planFolders(root)) {
+        const implPath = join(folder.dir, "impl.md");
+        if (!existsSync(implPath))
+            continue;
+        const impl = readImpl(readFileSync(implPath, "utf-8"));
+        if (!impl.ok) {
+            unreadable.push(folder.plan);
+            continue;
+        }
+        for (const row of impl.trajectory.rows) {
+            if (!(row.test ?? []).some((t) => normalise(t) === want))
+                continue;
+            rows.push({
+                plan: folder.plan,
+                archived: folder.archived,
+                id: row.id,
+                promises: row.purpose?.promises ?? [],
+            });
+        }
+    }
+    return { promises: [...new Set(rows.flatMap((r) => r.promises))], rows, unreadable };
+}
+/**
+ * Route each failing file (ADR D6, D7): a file whose rows' `For` names a
+ * promise becomes an incident on each such promise — one per promise, every
+ * file it claims in it — opened or extended through `recordTestFailure`, and
+ * the owner reopened through the path `watch` uses. A file no promise in the
+ * registry claims goes to a draft bugfix plan, opened or extended (D8).
+ *
+ * promise: a-failing-slow-test-breaks-its-promise
+ */
+export async function routeFailures(root, settled, facts) {
+    const unrouted = {
+        failed: settled.failed,
+        incidents: [],
+        plans: [],
+        planProblems: [],
+        unreadable: [],
+    };
+    if (settled.failed.length === 0)
+        return unrouted;
+    const first = readPromises(root);
+    if (!first.ok) {
+        // A registry that cannot be read is no place to write an incident.
+        return {
+            ...unrouted,
+            refused: "missing" in first
+                ? `no promise registry at ${first.missing}`
+                : `the promise registry has malformed entries: ${first.problems.map((p) => p.file).join(", ")}`,
+        };
+    }
+    const { claims, unreadable } = claimsOf(root, settled.failed, first.registry.promises);
+    const incidents = [];
+    const byFile = new Map();
+    for (const [name, files] of claims) {
+        // Read again for each promise, since the incident one opened is on disk now.
+        const read = readPromises(root);
+        const registry = read.ok ? read.registry : first.registry;
+        const promise = live(registry.promises, name);
+        if (!promise)
+            continue;
+        const owner = await ownerReopener(root, promise);
+        const change = recordTestFailure(registry, promise, {
+            tests: files.map((file) => ({ file, names: settled.tests?.[file] ?? [] })),
+            release: { version: facts.version, commit: facts.commit },
+            suspects: facts.suspects,
+            now: facts.now,
+        }, owner.taken());
+        const reopen = owner.reopen(change.id, change.kind);
+        incidents.push({ ...change, promise: promise.name, owner: promise.owner, reopen });
+        for (const file of files)
+            byFile.set(file, [...(byFile.get(file) ?? []), change.id]);
+    }
+    const { failed, plans, planProblems } = await routeUnclaimed(root, settled, byFile, facts);
+    return { failed, incidents, plans, planProblems, unreadable };
+}
+/** Each failing file an incident claimed says so; every other one goes to its bugfix plan (D8). */
+async function routeUnclaimed(root, settled, incidentsByFile, facts) {
+    const plans = [];
+    const planProblems = [];
+    const failed = [];
+    for (const { file } of settled.failed) {
+        const ids = incidentsByFile.get(file);
+        if (ids) {
+            failed.push({ file, routed: ids.map((id) => `incident ${id}`).join(", ") });
+            continue;
+        }
+        try {
+            const plan = await openOrExtendBugfixPlan(root, {
+                file,
+                names: settled.tests?.[file] ?? [],
+                rows: routeFailure(root, file).rows,
+                release: { version: facts.version, commit: facts.commit },
+                suspects: facts.suspects,
+                now: facts.now,
+            });
+            if (!plans.some((p) => p.plan === plan.plan))
+                plans.push(plan);
+            failed.push({ file, routed: `plan ${plan.plan}` });
+        }
+        catch (err) {
+            planProblems.push(`${file}: ${err instanceof Error ? err.message : String(err)}`);
+            failed.push({ file, routed: "unrouted" });
+        }
+    }
+    return { failed, plans, planProblems };
+}
+/**
+ * Which live promise claims which failing files: each promise a naming row's
+ * `For` cell names, with every file it claims, and the impls that could not
+ * be read on the way.
+ */
+function claimsOf(root, failed, promises) {
+    const unreadable = new Set();
+    const claims = new Map();
+    for (const { file } of failed) {
+        const route = routeFailure(root, file);
+        for (const plan of route.unreadable)
+            unreadable.add(plan);
+        for (const name of route.promises) {
+            const promise = live(promises, name);
+            if (promise)
+                claims.set(promise.name, [...(claims.get(promise.name) ?? []), file]);
+        }
+    }
+    return { claims, unreadable: [...unreadable].sort() };
+}
+/** The registry's live promise a row names, by its name or an earlier one; none when retired or unknown. */
+function live(promises, name) {
+    return promises.find((p) => p.state !== "retired" && (p.name === name || p.aliases.includes(name)));
+}

package/dist/lib/release/run.d.ts

@@ -0,0 +1,87 @@
+import type { GreenRun } from "../checks/record.js";
+import type { WorkflowSteps } from "../config.js";
+/**
+ * `indusk release` as a function of its inputs (release-records-its-failures
+ * D1, D3): the declared release, run in the declared order. The commands, the
+ * clock, the code key and the green-run record arrive as `deps`, so the order
+ * and the outcome rules are unit-testable without a process, a git tree or a
+ * home directory.
+ *
+ * Order: slow tests if `when: before` (a red run stops here), the release
+ * `command` (a failure stops here: no slow tests after it), slow tests if
+ * `when: after`. A slow run a fully green run already covered is skipped.
+ * Outcome: `done_when: published` is done once the command succeeds;
+ * `done_when: green` only when the slow run is green (or was covered).
+ *
+ * Commands are what the project declares, run as written from the project
+ * root — never a path of dusk's own.
+ *
+ * promise: a-release-runs-as-its-project-declares
+ * promise: slow-checks-run-once-per-tree
+ * promise: landing-and-release-name-the-projects-commands
+ */
+export interface ReleaseDeps {
+    steps: WorkflowSteps;
+    /** Run a shell command from the project root; the exit code. */
+    exec(command: string): {
+        code: number;
+    };
+    now(): Date;
+    /** The key of the code the slow tests cover now, or `null` when there is no honest key. */
+    codeKey(): string | null;
+    /** The latest fully green run that covered `key`. */
+    coveringRun(key: string): GreenRun | null;
+    /** Record a fully green slow run, as `indusk checks slow` would. */
+    recordGreen(run: {
+        key: string;
+        at: string;
+        command: string;
+    }): void;
+    /**
+     * The seam where a red slow run's failures are read, rerun and routed
+     * (Build Phases 2–4). Absent: no failure is read, and a red run records
+     * `failed: []`.
+     */
+    settleFailures?(slow: SlowRun): SettledFailures;
+}
+/** One failing file and where it was routed: `incident <id>` or `plan <name>`. */
+export interface FailedFile {
+    file: string;
+    routed: string;
+}
+export interface SettledFailures {
+    failed: FailedFile[];
+    flakes: string[];
+    environment?: {
+        failed: number;
+        total: number;
+    };
+    /** The failed tests' names per failing file, from the report: what an incident names; not on the record. */
+    tests?: Record<string, string[]>;
+}
+export interface SlowRun {
+    command: string;
+    exit: number;
+    /** When the run began: a report older than this is an earlier run's. */
+    startedAt: Date;
+}
+export type SlowResult = "green" | "red" | "skipped" | "not run";
+export interface ReleaseOutcome {
+    /** `false` when the project declares no release command; nothing ran. */
+    declared: boolean;
+    published: boolean;
+    done: boolean;
+    slow: {
+        ran: boolean;
+        green: boolean;
+        skipped: boolean;
+        result: SlowResult;
+        /** The green run that covered the code, when the slow run was skipped. */
+        covering?: GreenRun;
+    };
+    /** What the run records on the release record. */
+    recorded: SettledFailures;
+    /** What a reader should look at when the release is published and not done, or a run was red. */
+    openFailures: string[];
+}
+export declare function runRelease(deps: ReleaseDeps): ReleaseOutcome;

package/dist/lib/release/run.js

@@ -0,0 +1,53 @@
+const EMPTY = { failed: [], flakes: [] };
+export function runRelease(deps) {
+    const release = deps.steps.release ?? {};
+    const slowSpec = release.slow_tests;
+    const outcome = {
+        declared: Boolean(release.command),
+        published: false,
+        done: false,
+        slow: { ran: false, green: false, skipped: false, result: "not run" },
+        recorded: EMPTY,
+        openFailures: [],
+    };
+    if (!release.command)
+        return outcome;
+    const runSlow = () => {
+        if (!slowSpec)
+            return true;
+        const key = deps.codeKey();
+        const covering = key ? deps.coveringRun(key) : null;
+        if (covering) {
+            outcome.slow = { ran: false, green: true, skipped: true, result: "skipped", covering };
+            return true;
+        }
+        const started = deps.now();
+        const at = started.toISOString();
+        const run = {
+            command: slowSpec.command,
+            exit: deps.exec(slowSpec.command).code,
+            startedAt: started,
+        };
+        const green = run.exit === 0;
+        outcome.slow = { ran: true, green, skipped: false, result: green ? "green" : "red" };
+        if (green) {
+            if (key && deps.codeKey() === key)
+                deps.recordGreen({ key, at, command: slowSpec.command });
+            return true;
+        }
+        outcome.recorded = deps.settleFailures?.(run) ?? EMPTY;
+        outcome.openFailures = outcome.recorded.failed.length
+            ? outcome.recorded.failed.map((f) => f.file)
+            : [slowSpec.command];
+        return false;
+    };
+    if (slowSpec?.when === "before" && !runSlow())
+        return outcome;
+    outcome.published = deps.exec(release.command).code === 0;
+    if (!outcome.published)
+        return outcome;
+    if (slowSpec?.when === "after")
+        runSlow();
+    outcome.done = release.done_when === "green" ? outcome.slow.green || !slowSpec : true;
+    return outcome;
+}

package/dist/lib/release/settle.d.ts

@@ -0,0 +1,16 @@
+import type { WorkflowSteps } from "../config.js";
+import type { SettledFailures } from "./run.js";
+/**
+ * A red slow run, settled (release-records-its-failures D4, D5): the failing
+ * files are read from the declared JUnit report; when more than half the
+ * report's files failed it is the environment and nothing else is said; else
+ * the failing files are run once more through `slow_tests.rerun` (`{files}`
+ * substituted) and the report is read again — a file the rerun does not leave
+ * failing is a flake.
+ *
+ * promise: a-failure-is-read-from-the-report
+ * promise: a-flake-opens-nothing
+ */
+export declare function settleFromReport(steps: WorkflowSteps, root: string, exec: (command: string) => {
+    code: number;
+}, since?: Date): SettledFailures;

package/dist/lib/release/settle.js

@@ -0,0 +1,45 @@
+import { failedFiles } from "./junit.js";
+/**
+ * A red slow run, settled (release-records-its-failures D4, D5): the failing
+ * files are read from the declared JUnit report; when more than half the
+ * report's files failed it is the environment and nothing else is said; else
+ * the failing files are run once more through `slow_tests.rerun` (`{files}`
+ * substituted) and the report is read again — a file the rerun does not leave
+ * failing is a flake.
+ *
+ * promise: a-failure-is-read-from-the-report
+ * promise: a-flake-opens-nothing
+ */
+export function settleFromReport(steps, root, exec, since) {
+    const spec = steps.release?.slow_tests;
+    if (!spec)
+        return { failed: [], flakes: [] };
+    const first = failedFiles(spec.report, root, since);
+    if (!first.readable || first.files.size === 0)
+        return { failed: [], flakes: [] };
+    if (first.files.size * 2 > first.total) {
+        return {
+            failed: [],
+            flakes: [],
+            environment: { failed: first.files.size, total: first.total },
+        };
+    }
+    const names = [...first.files.keys()].sort();
+    let still = names;
+    let last = first;
+    if (spec.rerun) {
+        exec(spec.rerun.replaceAll("{files}", names.map(shellQuote).join(" ")));
+        const second = failedFiles(spec.report, root, since);
+        if (second.readable) {
+            still = names.filter((f) => !second.passed.has(f));
+            last = second;
+        }
+    }
+    return {
+        failed: still.map((file) => ({ file, routed: "unrouted" })),
+        flakes: names.filter((f) => !still.includes(f)),
+        tests: Object.fromEntries(still.map((f) => [f, last.files.get(f) ?? first.files.get(f) ?? []])),
+    };
+}
+/** One shell word: single-quoted, an embedded quote as `'\''`. */
+const shellQuote = (text) => `'${text.replaceAll("'", "'\\''")}'`;

package/dist/lib/release/suspects.d.ts

@@ -0,0 +1,13 @@
+import type { GreenRun } from "../checks/record.js";
+import type { WorkflowSteps } from "../config.js";
+import type { Suspects } from "../promises/test-incident.js";
+/**
+ * The commits that may have broken the slow tests (release-records-its-failures
+ * D9): `git log <sha>..HEAD` over the release's `covers` paths (the whole
+ * repository when it declares none), from the commit the last green slow run
+ * was made on. A run recorded without a `sha`, or a `sha` git no longer has,
+ * names none and says why — never a guess at a range.
+ *
+ * promise: a-failing-slow-test-breaks-its-promise
+ */
+export declare function suspectsSince(root: string, steps: WorkflowSteps, green: GreenRun | null): Suspects;

package/dist/lib/release/suspects.js

@@ -0,0 +1,33 @@
+import { gitSync } from "../bookkeeping/git.js";
+/**
+ * The commits that may have broken the slow tests (release-records-its-failures
+ * D9): `git log <sha>..HEAD` over the release's `covers` paths (the whole
+ * repository when it declares none), from the commit the last green slow run
+ * was made on. A run recorded without a `sha`, or a `sha` git no longer has,
+ * names none and says why — never a guess at a range.
+ *
+ * promise: a-failing-slow-test-breaks-its-promise
+ */
+export function suspectsSince(root, steps, green) {
+    const covers = steps.release?.covers ?? ["."];
+    if (!green)
+        return { since: null, unnamed: "no green slow run is recorded", covers, commits: [] };
+    if (!green.sha || green.sha === "unknown") {
+        return {
+            since: null,
+            unnamed: `the last green slow run (${green.at}) recorded no commit to count from`,
+            covers,
+            commits: [],
+        };
+    }
+    const log = gitSync(root, "log", "--format=%h %s", `${green.sha}..HEAD`, "--", ...covers);
+    if (log.code !== 0) {
+        return {
+            since: null,
+            unnamed: `git could not list the commits since ${green.sha.slice(0, 7)}, the last green slow run's`,
+            covers,
+            commits: [],
+        };
+    }
+    return { since: green.sha, covers, commits: log.out.split("\n").filter(Boolean) };
+}

package/dist/lib/rituals/skip.d.ts

@@ -0,0 +1,20 @@
+export interface SkipCheck {
+    skipped: boolean;
+    reason: string | null;
+}
+/**
+ * Whether the impl (full file content, frontmatter included) opts out of a
+ * ritual. Opt-out requires both fields in frontmatter:
+ *
+ *   <ritual>: skipped
+ *   <ritual>_reason: "a non-empty reason"
+ *
+ * Returns `{ skipped: true, reason }` only if both are present and the reason
+ * is non-empty after trimming. Any other state — a bare flag, a flag set to
+ * anything but `skipped`, a missing, empty or non-string reason, another
+ * ritual's pair, unparsable frontmatter — returns `{ skipped: false, reason: null }`.
+ *
+ * The two-field shape keeps the reason unambiguous against YAML parsers:
+ * colons inside quoted YAML strings are fragile across parsers.
+ */
+export declare function isRitualSkipped(implContent: string, ritual: "falsification" | "cleanup" | "audit"): SkipCheck;

package/dist/lib/rituals/skip.js

@@ -0,0 +1,33 @@
+import matter from "gray-matter";
+/**
+ * Whether the impl (full file content, frontmatter included) opts out of a
+ * ritual. Opt-out requires both fields in frontmatter:
+ *
+ *   <ritual>: skipped
+ *   <ritual>_reason: "a non-empty reason"
+ *
+ * Returns `{ skipped: true, reason }` only if both are present and the reason
+ * is non-empty after trimming. Any other state — a bare flag, a flag set to
+ * anything but `skipped`, a missing, empty or non-string reason, another
+ * ritual's pair, unparsable frontmatter — returns `{ skipped: false, reason: null }`.
+ *
+ * The two-field shape keeps the reason unambiguous against YAML parsers:
+ * colons inside quoted YAML strings are fragile across parsers.
+ */
+export function isRitualSkipped(implContent, ritual) {
+    try {
+        const { data } = matter(implContent);
+        if (data[ritual] !== "skipped")
+            return { skipped: false, reason: null };
+        const reasonRaw = data[`${ritual}_reason`];
+        if (typeof reasonRaw !== "string")
+            return { skipped: false, reason: null };
+        const reason = reasonRaw.trim();
+        if (!reason)
+            return { skipped: false, reason: null };
+        return { skipped: true, reason };
+    }
+    catch {
+        return { skipped: false, reason: null };
+    }
+}

package/dist/lib/server/connect.d.ts

@@ -0,0 +1,51 @@
+import type { LineWriter } from "./redact.js";
+import type { SecretsFile } from "./secrets-file.js";
+/**
+ * `indusk server connect`: point a project at a recording server the person
+ * runs, wherever it runs (server-provisioning, ADR D1, D4, D6).
+ *
+ * The server is read back first — a mark sent through its intake and found
+ * through its query API, at the addresses the project will use. Only then is
+ * anything written: the project's `promises.jaeger` names the server and the
+ * *name* of the credential's variable, and the value goes to the machine's
+ * secrets file. A server that does not answer is never named; a project that
+ * names one reads *watcher blind* forever after.
+ *
+ * promise: a-project-connects-to-its-server-in-one-command
+ * promise: a-server-is-read-back-before-the-command-ends
+ */
+export interface ConnectInput {
+    projectRoot: string;
+    projectName: string;
+    queryUrl: string;
+    otlpUrl: string;
+    credential: string;
+}
+export interface ConnectDeps {
+    probe(target: {
+        queryUrl: string;
+        otlpUrl: string;
+        credential: string;
+    }): Promise<void>;
+    secrets: SecretsFile;
+    out: LineWriter;
+}
+export interface Connected {
+    credentialEnv: string;
+}
+/**
+ * The variable a project's credential is stored under: one per project, so
+ * two projects never share one. The name is for people; the suffix is a short
+ * hash of where the project lives — its repository, so every worktree of one
+ * repository shares it, or the folder when it is not one. Two projects in
+ * folders of the same name shared a variable before, and connecting one
+ * replaced the other's credential (server-provisioning A25).
+ */
+export declare function credentialEnvFor(projectRoot: string, projectName: string): string;
+export declare function connect(input: ConnectInput, deps: ConnectDeps): Promise<Connected>;
+/** The real read-back: the heartbeat probe every promise read already runs. */
+export declare function probeServer(project: string): (target: {
+    queryUrl: string;
+    otlpUrl: string;
+    credential: string;
+}) => Promise<void>;

package/dist/lib/server/connect.js

@@ -0,0 +1,60 @@
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { dirname } from "node:path";
+import { readConfig, writeConfig } from "../config.js";
+import { probeWatcher } from "../promises/probe.js";
+import { jaegerEndpoint } from "../promises/telemetry.js";
+import { gitCommonDirOf } from "../worktree/layout.js";
+/**
+ * The variable a project's credential is stored under: one per project, so
+ * two projects never share one. The name is for people; the suffix is a short
+ * hash of where the project lives — its repository, so every worktree of one
+ * repository shares it, or the folder when it is not one. Two projects in
+ * folders of the same name shared a variable before, and connecting one
+ * replaced the other's credential (server-provisioning A25).
+ */
+export function credentialEnvFor(projectRoot, projectName) {
+    const slug = projectName
+        .toUpperCase()
+        .replace(/[^A-Z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    const common = gitCommonDirOf(projectRoot);
+    const where = common ? dirname(common) : projectRoot;
+    let real = where;
+    try {
+        real = realpathSync(where);
+    }
+    catch {
+        // A path that cannot be resolved still names itself.
+    }
+    const hash = createHash("sha256").update(real).digest("hex").slice(0, 6).toUpperCase();
+    return `INDUSK_SERVER_${slug || "PROJECT"}_${hash}_CREDENTIAL`;
+}
+export async function connect(input, deps) {
+    const config = readConfig(input.projectRoot);
+    if (!config) {
+        throw new Error(`no InDusk config at ${input.projectRoot} — run \`indusk init\` there first`);
+    }
+    deps.out.line(`Reading the server back: a mark through ${input.otlpUrl}, found through ${input.queryUrl} …`);
+    await deps.probe({
+        queryUrl: input.queryUrl,
+        otlpUrl: input.otlpUrl,
+        credential: input.credential,
+    });
+    const credentialEnv = credentialEnvFor(input.projectRoot, input.projectName);
+    deps.secrets.set(credentialEnv, input.credential);
+    writeConfig(input.projectRoot, {
+        ...config,
+        promises: {
+            ...(config.promises ?? { domains: [] }),
+            jaeger: { url: input.queryUrl, otlp_url: input.otlpUrl, credential_env: credentialEnv },
+        },
+    });
+    deps.out.line(`Connected: production reads ${input.queryUrl}.`);
+    deps.out.line(`The credential is stored as ${credentialEnv} in ${deps.secrets.path}; the project names the variable, never the value.`);
+    return { credentialEnv };
+}
+/** The real read-back: the heartbeat probe every promise read already runs. */
+export function probeServer(project) {
+    return (target) => probeWatcher({ endpoint: jaegerEndpoint(target.queryUrl, target.credential), intakeUrl: target.otlpUrl }, { project });
+}

package/dist/lib/server/deploy.d.ts

@@ -0,0 +1,64 @@
+import { type Connected, type ConnectInput } from "./connect.js";
+import type { FlyCli } from "./fly.js";
+import { type LineWriter } from "./redact.js";
+import type { SecretsFile } from "./secrets-file.js";
+/**
+ * `indusk server deploy`: one command creates a project's recording server
+ * in the person's own Fly account and connects the project to it
+ * (server-provisioning ADR D1–D6).
+ *
+ * It reads what exists, plans the missing steps, runs them through the
+ * person's `fly`, records which app is this project's server, and ends by
+ * connecting — which reads the server back before naming it. Every line it
+ * prints, Fly's output included, goes through a writer that knows the
+ * password and the webhook.
+ *
+ * promise: a-fly-deploy-is-one-command
+ * promise: the-recording-server-runs-from-a-published-image
+ */
+export declare const IMAGE = "ghcr.io/infinitedusky/indusk-always-on";
+export declare const SERVER_USER = "indusk";
+export interface DeployInput {
+    projectRoot: string;
+    projectName: string;
+    app?: string;
+    org?: string;
+    region?: string;
+    version: string;
+    slackWebhook?: string | null;
+    rotate?: boolean;
+    /**
+     * A packed tarball to build the image from on this machine, for a version no
+     * release has published yet (the live check, a server change under test).
+     * Without it, deploy pulls the published image and never builds (A20).
+     */
+    buildFrom?: string;
+}
+export interface DeployDeps {
+    fly: FlyCli;
+    connect(input: ConnectInput, out: LineWriter): Promise<Connected>;
+    secrets: SecretsFile;
+    /** Where every line goes, before redaction. */
+    print(line: string): void;
+    /** A new server password. */
+    random(): string;
+    /** A directory for the generated Fly config. */
+    tempDir(): string;
+    /**
+     * A suffix that makes each `--build-from` tag new: Fly's registry outlives
+     * a destroyed app, and a reused tag deployed the previous build (A8).
+     */
+    stamp?(): string;
+    /** Build the server image from a tarball through the package's template, tagged `tag`, and push it to the app's Fly registry. */
+    buildImage?(tarball: string, tag: string): Promise<void>;
+    /** The wait between read-back attempts while a new server comes up. */
+    sleep?(ms: number): Promise<void>;
+    now?(): number;
+}
+export declare class DeployRefused extends Error {
+    constructor(message: string);
+}
+export declare function defaultAppName(projectName: string): string;
+export declare function deploy(input: DeployInput, deps: DeployDeps): Promise<void>;
+/** How long a new server may take to become reachable: its addresses and certificate. */
+export declare const REACHABLE_WITHIN_MS: number;