@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/cli/invoke.js

@@ -1,521 +0,0 @@
-import { resolve } from "node:path";
-import { resolveActor } from "./actor.js";
-import { isParsedAkumaCommand } from "./commands/akuma.js";
-import { invokeContractMutation } from "./commands/contract-invoke.js";
-import { assertExplicitRepoUse, CliUsageError, usageGuideForCommand, } from "./parse.js";
-import { isBlankInput } from "./usage.js";
-import { AKUMA_REQUESTS_ENV } from "../akuma/provider.js";
-import { canonicalBirthCwd } from "../akuma/call-input.js";
-import { bodyRequestExecution, executionChannel, localExecutionContext, } from "../akuma/requests.js";
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin)
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    return Buffer.concat(chunks).toString("utf8");
-}
-function selectedStdinDiagnostic(command) {
-    switch (command.command) {
-        case "bind":
-            if (command.forkOf !== undefined)
-                return undefined;
-            return `${command.command} requires a nonblank stdin document`;
-        case "arc":
-            return `${command.command} requires a nonblank stdin document`;
-        case "amend":
-            return command.stdin === true ? "amend requires a nonblank stdin document" : undefined;
-        case "review":
-            return command.summaryFromStdin === true ? "review requires a nonblank summary" : undefined;
-        case "call":
-        case "tell":
-            return command.prompt.kind === "stdin" ? `${command.command} requires a nonblank prompt` : undefined;
-        case "task":
-            switch (command.stdin) {
-                case "document":
-                    return "task add requires a nonblank stdin document";
-                case "compose":
-                    return "task compose requires a nonblank stdin document";
-                case "body":
-                    return "task update --body requires a nonblank value";
-                case "append":
-                    return "task update --append requires a nonblank value";
-                case "note":
-                    return "task update --note requires a nonblank value";
-                default:
-                    return undefined;
-            }
-        default:
-            return undefined;
-    }
-}
-async function withAcquiredStdin(command, runtime) {
-    const diagnostic = selectedStdinDiagnostic(command);
-    if (diagnostic === undefined)
-        return runtime;
-    const bytes = await (runtime.readStdin ?? readStdin)();
-    if (isBlankInput(bytes))
-        throw new CliUsageError(diagnostic);
-    return { ...runtime, readStdin: async () => bytes };
-}
-async function settingsAt(root, home) {
-    const { settings } = await import("../settings.js");
-    return settings({ ...(root === undefined ? {} : { root }), ...(home === undefined ? {} : { home }) });
-}
-function executionForEnvironment(environment) {
-    return environment[AKUMA_REQUESTS_ENV] === undefined
-        ? localExecutionContext()
-        : bodyRequestExecution({ directory: environment[AKUMA_REQUESTS_ENV] });
-}
-async function contractSettings(command, execution, world, home) {
-    const forwarded = executionChannel(execution).kind === "body-request" &&
-        (command.command === "audit" || command.command === "deliver" || command.command === "review");
-    if (forwarded)
-        return {};
-    const configuration = await settingsAt(world ?? undefined, home);
-    const { worktreeHooksFrom, SettingsError } = await import("../library/configuration.js");
-    return { configuration, hooks: consumeSettings(() => worktreeHooksFrom({ settings: configuration }), SettingsError) };
-}
-function consumeSettings(run, ErrorType) {
-    try {
-        return run();
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        if (error instanceof ErrorType)
-            throw new CliUsageError(error.message);
-        throw error;
-    }
-}
-function actorFromEdge(actor, environment) {
-    let resolved;
-    try {
-        resolved = resolveActor({ env: environment, ...(actor === undefined ? {} : { actor }) });
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        throw new CliUsageError(error instanceof Error ? error.message : String(error));
-    }
-    return resolved;
-}
-function taskActor(command, runtime, environment) {
-    return (runtime.actor ??
-        actorFromEdge(typeof command.flags.actor === "string" ? command.flags.actor : undefined, environment));
-}
-function gitPathFromEdge(environment) {
-    const value = environment.KEIYAKU_GIT_PATH;
-    if (value === undefined)
-        return undefined;
-    if (value.trim().length === 0)
-        throw new CliUsageError("KEIYAKU_GIT_PATH requires a nonblank value");
-    return value;
-}
-async function selectContract(repo, selector, scope) {
-    const { contractFromInput, resolveContextualContract } = await import("./selectors.js");
-    if (selector !== undefined && !selector.startsWith("@"))
-        return contractFromInput(repo, selector);
-    const { listCompleteContractBoard } = await import("../library/contract.js");
-    const id = resolveContextualContract(await listCompleteContractBoard(repo), selector, scope);
-    return contractFromInput(repo, id);
-}
-async function invokeAkumaFromEdge(parsed, input) {
-    try {
-        const { executionCwd, repo, edge } = input;
-        const path = await akumaWorldFor(parsed, input.located, input.candidate, input.establish);
-        const home = parsed.command === "call" ? input.home : undefined;
-        const configuration = parsed.command === "call" ? await settingsAt(path, home) : undefined;
-        if (parsed.command === "call" && parsed.contract !== undefined && repo === undefined) {
-            throw new Error("call with Contract requires a resolved Repo");
-        }
-        const { invokeAkuma } = await import("./commands/akuma-invoke.js");
-        const contract = parsed.command === "call" && parsed.contract !== undefined
-            ? (await import("./selectors.js")).contractFromInput(repo, parsed.contract, input.execution).contract
-            : undefined;
-        return await invokeAkuma(parsed, {
-            path,
-            ...(executionCwd === undefined ? {} : { executionCwd }),
-            ...(home === undefined ? {} : { home }),
-            ...(configuration === undefined ? {} : { settings: configuration }),
-            ...(contract === undefined ? (repo === undefined ? {} : { repo }) : { contract }),
-            environment: edge.environment,
-            readStdin: edge.readStdin,
-            execution: input.execution,
-            ...(edge.signal === undefined ? {} : { signal: edge.signal }),
-        });
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        const { AkumaWorldScopeError } = await import("../library/address.js");
-        if (error instanceof AkumaWorldScopeError)
-            throw error;
-        if (error instanceof TypeError)
-            throw new CliUsageError(error.message);
-        throw error;
-    }
-}
-async function akumaWorldFor(parsed, located, candidate, establish) {
-    const world = parsed.command === "call" ? (candidate ?? (await establish())) : located;
-    if (world === null)
-        throw new CliUsageError("no Keiyaku world contains the invocation cwd");
-    return world;
-}
-async function invokeCatalog(parsed, world, repo, home) {
-    try {
-        if (parsed.query.kind === "contracts") {
-            if (repo === undefined)
-                throw new Error("Contract catalog requires a resolved Repo");
-            const { Keiyaku } = await import("../library/keiyaku.js");
-            return {
-                kind: "catalog",
-                catalog: {
-                    kind: "contracts",
-                    ...(await Keiyaku.with().list({
-                        repo,
-                        ...(parsed.query.limit === undefined ? {} : { limit: parsed.query.limit }),
-                    })),
-                },
-            };
-        }
-        if (parsed.query.kind === "archetypes") {
-            const { listArchetypeDefinitions } = await import("../akuma/archetype.js");
-            return {
-                kind: "catalog",
-                catalog: {
-                    kind: "archetypes",
-                    ...(await listArchetypeDefinitions({
-                        ...(world === null ? {} : { project: world }),
-                        ...(parsed.query.limit === undefined ? {} : { limit: parsed.query.limit }),
-                        ...(home === undefined ? {} : { home }),
-                    })),
-                },
-            };
-        }
-        if (world === null)
-            throw new CliUsageError("no Keiyaku world contains the invocation cwd");
-        if (parsed.query.kind === "tasks") {
-            const { Tasks } = await import("../task/index.js");
-            const listed = await Tasks.of(world).list({
-                selection: "all",
-                namespace: parsed.query.namespace ?? [],
-                ...(parsed.query.limit === undefined ? {} : { limit: parsed.query.limit }),
-            });
-            if (listed.kind !== "accepted")
-                throw new Error("Task list did not return an accepted observation");
-            return {
-                kind: "catalog",
-                catalog: { kind: "tasks", root: world, ...listed.value },
-            };
-        }
-        const { Akumas } = await import("../library/akumas.js");
-        const listed = await Akumas.of(world).list({
-            ...(parsed.query.archetype === undefined ? {} : { archetype: parsed.query.archetype }),
-            ...(parsed.query.limit === undefined ? {} : { limit: parsed.query.limit }),
-        });
-        return {
-            kind: "catalog",
-            catalog: {
-                kind: "akuma",
-                root: world,
-                archetype: parsed.query.archetype ?? null,
-                ...listed,
-            },
-        };
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        if (error instanceof TypeError)
-            throw new CliUsageError(error.message);
-        throw error;
-    }
-}
-async function invokeStatus(parsed, world, repo) {
-    const selectors = "selectors" in parsed ? parsed.selectors : undefined;
-    if (selectors !== undefined) {
-        const { invokeStatusSet } = await import("./commands/status-set.js");
-        return await invokeStatusSet(selectors, world, repo);
-    }
-    if (parsed.akuma === true) {
-        if (world === null)
-            throw new CliUsageError("no Keiyaku world contains the invocation cwd");
-        return (await import("./commands/akuma-invoke.js")).invokeAkumaStatus(world, parsed.contract, undefined, repo);
-    }
-    const { kanshi, observeKanshi, selectKanshi } = await import("../kanshi/index.js");
-    if (parsed.contract === undefined) {
-        const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
-        return { kind: "status", report, selection: "world" };
-    }
-    if (parsed.contract.startsWith("@")) {
-        try {
-            const observation = await observeKanshi({ world, ...(repo === undefined ? {} : { repo }) });
-            const { resolveNamedAddress } = await import("../library/address.js");
-            const address = resolveNamedAddress({
-                selector: parsed.contract,
-                report: observation.report,
-                aliases: observation.aliases,
-            });
-            if (address.kind === "akuma") {
-                if (world === null)
-                    throw new CliUsageError("no Keiyaku world contains the invocation cwd");
-                return (await import("./commands/akuma-invoke.js")).invokeAkumaStatus(world, address.id, parsed.contract, repo);
-            }
-            if (repo === undefined)
-                throw new CliUsageError("cannot select a contract while the Contract world is absent");
-            return {
-                kind: "status",
-                report: await kanshi({ world, repo, contract: address.id }),
-                selection: "contract",
-            };
-        }
-        catch (error) {
-            if (error instanceof Error && "executionReceipt" in error)
-                throw error;
-            if (error instanceof TypeError)
-                throw new CliUsageError(error.message);
-            throw error;
-        }
-    }
-    if (parsed.contract.startsWith("kei/")) {
-        if (repo === undefined)
-            throw new CliUsageError("cannot select a contract while the Contract world is absent");
-        const { canonicalContractSelector } = await import("./selectors.js");
-        const contract = canonicalContractSelector(parsed.contract);
-        return {
-            kind: "status",
-            report: await kanshi({ world, repo, contract }),
-            selection: "contract",
-        };
-    }
-    const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
-    const { resolveKanshiContract } = await import("./selectors.js");
-    const contract = resolveKanshiContract(report, parsed.contract);
-    return { kind: "status", report: selectKanshi({ report, contract }), selection: "contract" };
-}
-async function invokeRegion(parsed, world, repo) {
-    const { kanshi, selectRegion } = await import("../kanshi/index.js");
-    const read = async (region) => {
-        try {
-            return await kanshi({ world, repo, region });
-        }
-        catch (error) {
-            if (error instanceof Error && "executionReceipt" in error)
-                throw error;
-            if (error instanceof TypeError)
-                throw new CliUsageError(error.message);
-            throw error;
-        }
-    };
-    if (parsed.paths !== undefined) {
-        const report = await read({ kind: "path", patterns: parsed.paths });
-        return { kind: "region", region: report.region ?? { kind: "absent" } };
-    }
-    if (parsed.contract === undefined) {
-        const report = await read({ kind: "declarations" });
-        return { kind: "region", region: report.region ?? { kind: "absent" } };
-    }
-    const report = await read({ kind: "declarations" });
-    const { resolveKanshiContract } = await import("./selectors.js");
-    const contract = resolveKanshiContract(report, parsed.contract);
-    if (report.contracts.kind !== "present" ||
-        report.contracts.value.rows.every((row) => row.id !== contract || row.disposition !== "active")) {
-        throw new CliUsageError(`unknown contract selector: ${parsed.contract}`);
-    }
-    if (report.region?.kind !== "present" || report.region.value.kind !== "declarations") {
-        return { kind: "region", region: report.region ?? { kind: "absent" } };
-    }
-    return {
-        kind: "region",
-        region: {
-            kind: "present",
-            value: selectRegion({
-                declarations: report.region.value.declarations,
-                selection: { kind: "contract", contract },
-            }),
-        },
-    };
-}
-async function invokeContractHistory(repo, contract) {
-    if (repo === undefined)
-        throw new Error("history kei/... requires a resolved Repo");
-    const { contractFromInput } = await import("./selectors.js");
-    const selected = contractFromInput(repo, contract);
-    try {
-        return { kind: "contract-history", history: await selected.contract.history() };
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        if (error instanceof TypeError)
-            throw new CliUsageError(error.message);
-        const { KeiyakuRefused } = await import("../library/keiyaku.js");
-        if (error instanceof KeiyakuRefused) {
-            return { kind: "refused", verb: "history", contract: selected.id, refusal: error.refusal };
-        }
-        throw error;
-    }
-}
-async function resolveInvocationCoordinates(invocation, runtime) {
-    const environment = runtime.environment ?? process.env, gitPath = gitPathFromEdge(environment);
-    const { resolveCliCoordinates } = await import("./coordinates.js");
-    return resolveCliCoordinates({
-        ...(runtime.cwd === undefined ? {} : { processCwd: runtime.cwd }),
-        ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
-        ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
-        ...(gitPath === undefined ? {} : { gitPath }),
-        command: invocation.command,
-    });
-}
-async function invokeTask(parsed, runtime, edge, execution, coordinates) {
-    const actor = taskActor(parsed, runtime, edge.environment);
-    return await (await import("./commands/task-invoke.js")).invokeTaskFromEdge({
-        parsed,
-        world: coordinates.world,
-        candidate: coordinates.candidateWorld,
-        context: coordinates.taskContext,
-        establish: coordinates.establishWorld,
-        readStdin: edge.readStdin,
-        actor,
-        execution,
-    });
-}
-async function callExecutionCwd(input) {
-    if (input.command.command !== "call")
-        return undefined;
-    if (input.workdir !== undefined) {
-        return await canonicalBirthCwd(resolve(input.cwd, input.workdir), `workdir is not an existing directory: ${input.workdir}`);
-    }
-    return input.cwd;
-}
-async function invokeParsedAkuma(input) {
-    const executionCwd = await callExecutionCwd({
-        command: input.parsed,
-        cwd: input.cwd,
-        ...(input.workdir === undefined ? {} : { workdir: input.workdir }),
-    });
-    return await invokeAkumaFromEdge(input.parsed, {
-        located: input.world,
-        candidate: input.candidate,
-        establish: input.establish,
-        ...(executionCwd === undefined ? {} : { executionCwd }),
-        ...(input.repo === undefined ? {} : { repo: input.repo }),
-        ...(input.home === undefined ? {} : { home: input.home }),
-        edge: input.edge,
-        execution: input.execution,
-    });
-}
-// eslint-disable-next-line complexity -- command dispatch keeps the CLI's existing boundary in one place.
-async function invokeParsed(invocation, runtime) {
-    const environment = runtime.environment ?? process.env;
-    const execution = executionForEnvironment(environment);
-    const coordinates = await resolveInvocationCoordinates(invocation, runtime);
-    const { cwd, repo, world, candidateWorld, establishWorld } = coordinates;
-    const edge = {
-        environment,
-        readStdin: runtime.readStdin ?? readStdin,
-        ...(runtime.signal === undefined ? {} : { signal: runtime.signal }),
-        ...(runtime.progress === undefined ? {} : { progress: runtime.progress }),
-    };
-    const parsed = invocation.command;
-    const mapped = edge.environment.KEIYAKU_HOME?.trim();
-    const home = mapped === undefined || mapped.length === 0 ? undefined : mapped;
-    if (parsed.command === "settings")
-        return { kind: "settings", value: await settingsAt(world ?? undefined, home) };
-    if (parsed.command === "nuke")
-        return await (await import("./commands/nuke.js")).invokeNuke(parsed, world);
-    if (parsed.command === "task")
-        return await invokeTask(parsed, runtime, edge, execution, coordinates);
-    if (parsed.command === "history" && "contract" in parsed)
-        return await invokeContractHistory(repo, parsed.contract);
-    if (isParsedAkumaCommand(parsed))
-        return await invokeParsedAkuma({
-            parsed,
-            cwd,
-            ...(invocation.workdir === undefined ? {} : { workdir: invocation.workdir }),
-            world,
-            candidate: candidateWorld,
-            establish: coordinates.establishWorld,
-            ...(repo === undefined ? {} : { repo }),
-            ...(home === undefined ? {} : { home }),
-            edge,
-            execution,
-        });
-    if (parsed.command === "ls")
-        return await invokeCatalog(parsed, world, repo, home);
-    if (parsed.command === "status")
-        return await invokeStatus(parsed, world, repo);
-    if (repo === undefined)
-        throw new Error(`${parsed.command} requires a resolved Repo`);
-    if (parsed.command === "region")
-        return invokeRegion(parsed, world, repo);
-    const scope = cwd;
-    const { configuration, hooks } = await contractSettings(parsed, execution, world, home);
-    if (parsed.command === "show") {
-        const selected = await selectContract(repo, parsed.contract, scope);
-        return { kind: "guidance", contract: selected.id, guidance: await selected.contract.guidance() };
-    }
-    if (parsed.command === "reconcile") {
-        if (parsed.contract === undefined) {
-            return {
-                kind: "observation",
-                command: "reconcile",
-                report: await repo.reconcile({ ...(hooks === undefined ? {} : { hooks }), retryHooks: parsed.retryHooks }),
-            };
-        }
-        const { contract } = await selectContract(repo, parsed.contract, scope);
-        return {
-            kind: "observation",
-            command: "reconcile",
-            ...(await contract.reconcile({ ...(hooks === undefined ? {} : { hooks }), retryHooks: parsed.retryHooks })),
-        };
-    }
-    return invokeContractMutation({
-        parsed,
-        repo,
-        edge,
-        scope,
-        ...(configuration === undefined ? {} : { configuration }),
-        ...(hooks === undefined ? {} : { hooks }),
-        establishWorld,
-        execution,
-    });
-}
-function withResolvedTaskActor(command, runtime) {
-    if (command.command !== "task" || (command.action !== "add" && command.action !== "compose"))
-        return runtime;
-    const actor = actorFromEdge(typeof command.flags.actor === "string" ? command.flags.actor : undefined, runtime.environment ?? process.env);
-    return actor === undefined ? runtime : { ...runtime, actor };
-}
-export async function invoke(invocation, runtime = {}) {
-    try {
-        const command = invocation.command;
-        assertExplicitRepoUse(command, invocation.repo);
-        if (command.command === "install") {
-            return (await import("./commands/install.js")).installHarnesses(command.harnesses, runtime.environment ?? process.env);
-        }
-        const acquiredRuntime = await withAcquiredStdin(command, withResolvedTaskActor(command, runtime));
-        if (command.command === "bind" && command.forkOf === undefined) {
-            const markdown = await (acquiredRuntime.readStdin ?? readStdin)();
-            const { admitMarkdownBindSyntax } = await import("./commands/contract-invoke.js");
-            await admitMarkdownBindSyntax({
-                markdown,
-                ...(runtime.cwd === undefined ? {} : { processCwd: runtime.cwd }),
-                ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
-            });
-        }
-        return await invokeParsed({
-            ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
-            ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
-            ...(invocation.workdir === undefined ? {} : { workdir: invocation.workdir }),
-            command,
-        }, acquiredRuntime);
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        if (error instanceof CliUsageError && error.guide === undefined) {
-            throw new CliUsageError(error.diagnostic, usageGuideForCommand(invocation.command));
-        }
-        throw error;
-    }
-}

package/build/src/cli/render/board.d.ts

@@ -1,3 +0,0 @@
-import type { ObservationResult } from "../result.js";
-export declare function worldObservationFailureText(result: ObservationResult): string | undefined;
-export declare function renderObservation(result: ObservationResult): string;

package/build/src/cli/render/board.js

@@ -1,25 +0,0 @@
-import { safeText } from "./terminal.js";
-import { namedValueLines } from "./value.js";
-export function worldObservationFailureText(result) {
-    if (result.command !== "reconcile")
-        return undefined;
-    const report = result.report;
-    if (typeof report !== "object" ||
-        report === null ||
-        !("kind" in report) ||
-        report.kind !== "world-observation-failed" ||
-        !("diagnostic" in report) ||
-        typeof report.diagnostic !== "string") {
-        return undefined;
-    }
-    return `× observation  ${result.command}\n  diagnostic  ${report.diagnostic}`;
-}
-export function renderObservation(result) {
-    const failed = worldObservationFailureText(result);
-    if (failed !== undefined)
-        return failed;
-    const facts = Object.entries(result)
-        .filter(([key]) => key !== "kind" && key !== "command")
-        .flatMap(([key, value]) => namedValueLines(key, value, "  "));
-    return [`observation  ${safeText(result.command)}`, ...facts].join("\n");
-}

package/build/src/cli/render/status-set.d.ts

@@ -1,5 +0,0 @@
-import type { InvocationResult } from "../result.js";
-import type { TextRenderContext } from "./terminal.js";
-export declare function renderStatusSetText(result: Extract<InvocationResult, {
-    kind: "status-set";
-}>, context?: TextRenderContext): string;

package/build/src/cli/render/status-set.js

@@ -1,19 +0,0 @@
-import { renderAkumaText } from "./akuma.js";
-import { renderKanshiText } from "./kanshi.js";
-export function renderStatusSetText(result, context) {
-    if (result.entries.length === 0)
-        return "status  none";
-    return result.entries
-        .map((entry) => {
-        const body = entry.kind === "contract"
-            ? renderKanshiText(entry.report, context, "contract")
-            : renderAkumaText({ command: "status", contract: entry.selector, akuma: true, output: "text" }, {
-                kind: "akuma",
-                action: "status",
-                status: entry.status,
-                ...(entry.alias === undefined ? {} : { alias: entry.alias }),
-            }, context);
-        return body;
-    })
-        .join("\n\n");
-}

package/build/src/cli/render/text.d.ts

@@ -1,3 +0,0 @@
-import type { InvocationResult } from "../result.js";
-import type { TextRenderContext } from "./terminal.js";
-export declare function renderText(result: InvocationResult, context?: TextRenderContext): string;

package/build/src/cli/render/text.js

@@ -1,33 +0,0 @@
-import { renderObservation } from "./board.js";
-import { renderAccepted, renderContractHistory, renderRetry } from "./contract.js";
-import { renderKanshiText } from "./kanshi.js";
-import { renderConflictMaterialized, renderRefusal } from "./refusal.js";
-import { renderCatalogText } from "./catalog.js";
-import { renderNukeText } from "./nuke.js";
-import { renderRegionText } from "./region.js";
-import { renderStatusSetText } from "./status-set.js";
-export function renderText(result, context) {
-    if (result.kind === "guidance")
-        return result.guidance;
-    if (result.kind === "status")
-        return renderKanshiText(result.report, context, result.selection);
-    if (result.kind === "status-set")
-        return renderStatusSetText(result, context);
-    if (result.kind === "catalog")
-        return renderCatalogText(result.catalog);
-    if (result.kind === "contract-history")
-        return renderContractHistory(result.history);
-    if (result.kind === "region")
-        return renderRegionText(result.region);
-    if (result.kind === "nuke")
-        return renderNukeText(result.result);
-    if (result.kind === "accepted")
-        return renderAccepted(result, context);
-    if (result.kind === "refused")
-        return renderRefusal(result, context);
-    if (result.kind === "retry")
-        return renderRetry(result, context);
-    if (result.kind === "integration-conflict-materialized")
-        return renderConflictMaterialized(result, context);
-    return renderObservation(result);
-}