@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/cli/commands/akuma-invoke.js

@@ -1,375 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { squareAssignedParticipantName } from "@astrosheep/square";
-import { emitInitiatingPluginSignal } from "../../plugin/akuma-signals.js";
-import { decodeTellWaitObservation } from "../../akuma/fleet-execution.js";
-import { Akumas, } from "../../index.js";
-import { callObservationStream, inputWaitStream, waitObservationStream, } from "../render/akuma-activity.js";
-import { callObservationHead, tellWaitProgressStream, waitedTellProgress } from "../render/akuma.js";
-import { DEFAULT_CLI_COLUMNS } from "../render/terminal.js";
-import { tellWaitAkuma, waitAkuma } from "../../library/fleet.js";
-import { localExecutionContext } from "../../akuma/requests.js";
-import { Akuma, Schema } from "../../akuma/index.js";
-import { addressAkuma, resolveAkuma } from "../../library/address.js";
-import { executionChannel } from "../../akuma/requests.js";
-import { requestForwardedFleetTellAnswer } from "../../akuma/fleet-request.js";
-function akumas(input) {
-    return Akumas.of(input.path, { execution: input.execution ?? localExecutionContext() });
-}
-function callSignalOption(signal) {
-    return signal === undefined ? {} : { signal };
-}
-/** The display context the command result renders with, so live progress rows match the result. */
-function resultContext() {
-    const tty = process.stderr.isTTY === true;
-    return {
-        columns: tty && Number.isInteger(process.stderr.columns) ? process.stderr.columns : DEFAULT_CLI_COLUMNS,
-        color: tty && process.env.NO_COLOR === undefined,
-    };
-}
-function writeProgress(body) {
-    if (body.length === 0)
-        return;
-    process.stderr.write(body.endsWith("\n") ? body : `${body}\n`);
-}
-async function schemaFromFile(path) {
-    try {
-        const parsed = JSON.parse(await readFile(path, "utf8"));
-        return Schema.json(parsed, (value) => value);
-    }
-    catch (error) {
-        throw new Error(`cannot read JSON Schema file ${path}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-function inputAlias(selector) {
-    return selector.startsWith("@") ? selector : undefined;
-}
-async function promptBody(command, input) {
-    return command.prompt.kind === "stdin" ? await input.readStdin() : command.prompt.value;
-}
-/**
- * The live half of a local wait: each observation round opens every newly seen
- * Akuma with its identity frame, then prints only the rows that settled since
- * the previous round. The first sighting of an Akuma only establishes its
- * baseline, so an already settled Akuma prints no backlog rows. When the wait
- * ends, `conclude` prints its closing scoreboard on the same channel.
- */
-function waitObserver(stream, onSelected) {
-    return {
-        selected: (selected) => {
-            onSelected?.(selected);
-            stream.select(selected);
-        },
-        observe: (observed) => {
-            const lines = stream.observe(observed);
-            if (lines.length > 0)
-                writeProgress(lines.join("\n"));
-        },
-    };
-}
-async function invokeWait(command, input) {
-    const alias = command.akuma.length === 1 ? inputAlias(command.akuma[0]) : undefined;
-    const stream = command.output === "text" ? waitObservationStream(resultContext()) : undefined;
-    const startedAt = Date.now();
-    let selection;
-    const observer = stream === undefined
-        ? undefined
-        : waitObserver(stream, (selected) => {
-            selection = selected;
-        });
-    const result = await waitAkuma({
-        path: input.path,
-        akuma: command.akuma,
-        ...(input.repo === undefined ? {} : { repo: input.repo }),
-        ...(command.completion === undefined ? {} : { completion: command.completion }),
-        ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    }, input.execution ?? localExecutionContext(), observer);
-    const frozen = {
-        startedAt,
-        ...(selection === undefined ? {} : { selection }),
-    };
-    if (stream !== undefined && stream.streamed()) {
-        const closing = stream.conclude(result);
-        if (closing.length > 0)
-            writeProgress(closing);
-        return {
-            kind: "akuma",
-            action: "wait",
-            result,
-            streamed: true,
-            ...(alias === undefined ? {} : { alias }),
-            ...frozen,
-        };
-    }
-    return {
-        kind: "akuma",
-        action: "wait",
-        result,
-        ...(alias === undefined ? {} : { alias }),
-        ...frozen,
-    };
-}
-async function inputInitiator(input) {
-    let initiator;
-    try {
-        initiator = squareAssignedParticipantName(input.environment);
-    }
-    catch { }
-    if (initiator === undefined)
-        return {};
-    try {
-        await emitInitiatingPluginSignal({
-            world: input.path,
-            ...(input.settings === undefined ? {} : { settings: input.settings }),
-            initiator,
-            reportDiagnostic: (message) => process.stderr.write(`${message}\n`),
-        });
-    }
-    catch (error) {
-        process.stderr.write(`! plugin initiation: ${error instanceof Error ? error.message : String(error)}\n`);
-    }
-    return { initiator };
-}
-async function invokeWaitedTell(command, input, body) {
-    const schema = command.schema === undefined ? undefined : await schemaFromFile(command.schema);
-    const alias = inputAlias(command.akuma);
-    const channel = executionChannel(input.execution);
-    const progress = command.output === "text" && channel.kind === "local"
-        ? tellWaitProgressStream(undefined, alias, resultContext())
-        : undefined;
-    const result = await tellWaitAkuma({
-        ...(await inputInitiator(input)),
-        path: input.path,
-        akuma: command.akuma,
-        body,
-        timeoutMs: command.timeoutMs,
-        ...(schema === undefined ? {} : { schema }),
-        ...(command.interrupt ? { interrupt: true } : {}),
-        ...(input.repo === undefined ? {} : { repo: input.repo }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        ...(progress === undefined
-            ? {}
-            : {
-                observe: {
-                    admitted: (tell, id) => writeProgress(progress.admitted(tell, id).join("\n")),
-                    observe: (observation) => writeProgress(progress.observe(observation).join("\n")),
-                },
-            }),
-    }, input.execution ?? localExecutionContext());
-    const rendered = schema === undefined ? result : { ...result, observation: decodeTellWaitObservation(result.observation, schema) };
-    if (progress !== undefined)
-        writeProgress(progress.conclude(rendered).join("\n"));
-    else if (command.output === "text" && channel.kind === "body-request")
-        writeProgress(waitedTellProgress(rendered, alias, resultContext()));
-    return {
-        kind: "akuma",
-        action: "tell",
-        mode: "wait",
-        result: rendered,
-        body,
-        ...(alias === undefined ? {} : { alias }),
-        ...(schema === undefined ? {} : { structured: true }),
-    };
-}
-async function invokeTell(command, input) {
-    const body = await promptBody(command, input);
-    if (command.timeoutMs !== undefined)
-        return await invokeWaitedTell(command, input, body);
-    if (command.schema !== undefined) {
-        const schema = await schemaFromFile(command.schema);
-        const channel = executionChannel(input.execution);
-        const values = {
-            path: input.path,
-            akuma: command.akuma,
-            ...(input.repo === undefined ? {} : { repo: input.repo }),
-        };
-        // A forwarded answer lets the parent Fleet prove the target, so it resolves
-        // coordinates here and never reads this process's own Heart files.
-        const addressed = channel.kind === "body-request" ? await resolveAkuma(values) : await addressAkuma(values);
-        const initiator = await inputInitiator(input);
-        const answer = channel.kind === "body-request"
-            ? await requestForwardedFleetTellAnswer({
-                directory: channel.directory,
-                target: addressed.id,
-                body,
-                schema,
-                interrupt: command.interrupt,
-                ...initiator,
-                ...(input.signal === undefined ? {} : { signal: input.signal }),
-            })
-            : await Akuma.select(addressed.path, addressed.id).tell(body, {
-                schema,
-                ...initiator,
-                ...(command.interrupt ? { interrupt: true } : {}),
-                ...(input.signal === undefined ? {} : { signal: input.signal }),
-            });
-        const alias = inputAlias(command.akuma);
-        return {
-            kind: "akuma",
-            action: "tell",
-            mode: "schema",
-            result: answer,
-            body,
-            ...(alias === undefined ? {} : { alias }),
-        };
-    }
-    const initiator = await inputInitiator(input);
-    if (command.interrupt) {
-        const result = await akumas(input).interrupt({
-            ...initiator,
-            akuma: command.akuma,
-            body,
-            ...(input.repo === undefined ? {} : { repo: input.repo }),
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        });
-        const alias = inputAlias(command.akuma);
-        return {
-            kind: "akuma",
-            action: "tell",
-            mode: "interrupt",
-            result,
-            body,
-            ...(alias === undefined ? {} : { alias }),
-        };
-    }
-    const result = await akumas(input).tell({
-        ...initiator,
-        akuma: command.akuma,
-        body,
-        ...(input.repo === undefined ? {} : { repo: input.repo }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    });
-    const alias = inputAlias(command.akuma);
-    return { kind: "akuma", action: "tell", mode: "ordinary", result, body, ...(alias === undefined ? {} : { alias }) };
-}
-async function invokeHistory(command, input) {
-    const result = await akumas(input).history({
-        akuma: command.akuma,
-        ...(input.repo === undefined ? {} : { repo: input.repo }),
-        ...(command.before === undefined ? {} : { before: command.before }),
-        ...(command.since === undefined ? {} : { since: command.since }),
-        ...(command.limit === undefined ? {} : { limit: command.limit }),
-        ...(command.id === undefined ? {} : { id: command.id }),
-        last: command.last,
-    });
-    return {
-        kind: "akuma",
-        action: "history",
-        akuma: result.id,
-        historyResult: result,
-        ...(inputAlias(command.akuma) === undefined ? {} : { alias: command.akuma }),
-        ...(command.id !== undefined
-            ? { mode: "exact" }
-            : result.kind === "history"
-                ? { mode: "page", history: result.history }
-                : result.kind === "last"
-                    ? { mode: "last", answer: result.answer }
-                    : { mode: "no-answer" }),
-    };
-}
-async function invokeFork(command, input) {
-    return {
-        kind: "akuma",
-        action: "fork",
-        receipt: await akumas(input).fork({
-            akuma: command.akuma,
-            at: command.at,
-            ...(input.repo === undefined ? {} : { repo: input.repo }),
-        }),
-    };
-}
-async function invokeKill(command, input) {
-    const alias = command.akuma.length === 1 ? inputAlias(command.akuma[0]) : undefined;
-    return {
-        kind: "akuma",
-        action: "kill",
-        result: await akumas(input).kill({
-            akuma: command.akuma,
-            ...(input.repo === undefined ? {} : { repo: input.repo }),
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        }),
-        ...(alias === undefined ? {} : { alias }),
-    };
-}
-export async function invokeAkuma(command, input) {
-    switch (command.command) {
-        case "call": {
-            const body = await promptBody(command, input);
-            const schema = command.schema === undefined ? undefined : await schemaFromFile(command.schema);
-            const caller = akumas(input);
-            const request = {
-                ...(await inputInitiator(input)),
-                archetype: command.archetype,
-                body,
-                ...(input.home === undefined ? {} : { home: input.home }),
-                ...(input.settings === undefined ? {} : { settings: input.settings }),
-                ...(input.executionCwd === undefined ? {} : { cwd: input.executionCwd }),
-                ...(input.contract === undefined ? {} : { contract: input.contract }),
-                ...(command.alias === undefined ? {} : { alias: command.alias }),
-                ...(command.allowed === undefined ? {} : { allowed: command.allowed }),
-                ...(schema === undefined ? {} : { schema }),
-                ...callSignalOption(input.signal),
-            };
-            let stream;
-            const observing = command.mode === "wait" && command.output === "text";
-            const observe = observing
-                ? {
-                    admitted: (tell, id, head) => {
-                        stream = callObservationStream(resultContext(), callObservationHead({ akuma: id, ...head }), {
-                            admittedAt: tell.row.at,
-                        });
-                    },
-                    observe: (observation) => {
-                        const lines = stream?.observe(observation) ?? [];
-                        if (lines.length > 0)
-                            writeProgress(lines.join("\n"));
-                    },
-                }
-                : undefined;
-            const result = await caller.call({
-                ...request,
-                mode: command.mode,
-                ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
-                ...(observe === undefined ? {} : { observe }),
-            });
-            let streamed = stream !== undefined;
-            if (stream !== undefined) {
-                writeProgress(stream.conclude(result.observation));
-            }
-            else if (observing && result.observation.kind === "failed") {
-                const fallback = inputWaitStream(resultContext(), () => callObservationHead({
-                    akuma: result.akuma,
-                    dispatch: result.dispatch,
-                    alias: result.alias,
-                }), { cursor: "empty", answerSeparator: true });
-                writeProgress(fallback.conclude({ kind: "failed", diagnostic: result.observation.failure.diagnostic }));
-                streamed = true;
-            }
-            return {
-                kind: "akuma",
-                action: "call",
-                result,
-                world: input.path,
-                ...(streamed ? { streamed: true } : {}),
-            };
-        }
-        case "wait":
-            return await invokeWait(command, input);
-        case "tell":
-            return await invokeTell(command, input);
-        case "history":
-            return await invokeHistory(command, input);
-        case "fork":
-            return await invokeFork(command, input);
-        case "kill":
-            return await invokeKill(command, input);
-    }
-}
-export async function invokeAkumaStatus(path, akuma, alias, repo) {
-    return {
-        kind: "akuma",
-        action: "status",
-        status: await Akumas.of(path).status({ akuma, ...(repo === undefined ? {} : { repo }) }),
-        ...(alias === undefined ? {} : { alias }),
-    };
-}

package/build/src/cli/commands/contract-invoke.d.ts

@@ -1,34 +0,0 @@
-import type { ExecutionEvent } from "../../library/execution.js";
-import type { InvocationResult } from "../result.js";
-import type { ParsedCommand } from "../parse.js";
-import type { WorktreeHooks } from "../../library/configuration.js";
-import type { Repo } from "../../library/repo.js";
-import type { Settings } from "../../settings.js";
-import type { WorldRoot } from "../../world.js";
-import type { ExecutionContext } from "../../akuma/requests.js";
-type ContractMutation = Extract<ParsedCommand, {
-    command: "bind" | "amend" | "deliver" | "review" | "arc" | "abandon" | "audit";
-}>;
-type InvocationEdge = Readonly<{
-    environment: NodeJS.ProcessEnv;
-    readStdin: () => Promise<string>;
-    signal?: AbortSignal;
-    progress?: (events: AsyncIterable<ExecutionEvent>) => Promise<void>;
-}>;
-export type ContractMutationInput = Readonly<{
-    parsed: ContractMutation;
-    repo: Repo;
-    edge: InvocationEdge;
-    scope: string;
-    configuration?: Settings;
-    hooks?: WorktreeHooks;
-    establishWorld: () => Promise<WorldRoot>;
-    execution: ExecutionContext;
-}>;
-export declare function admitMarkdownBindSyntax(input: Readonly<{
-    markdown: string;
-    processCwd?: string;
-    cwd?: string;
-}>): Promise<void>;
-export declare function invokeContractMutation(input: ContractMutationInput): Promise<InvocationResult>;
-export {};

package/build/src/cli/commands/contract-invoke.js

@@ -1,259 +0,0 @@
-import { resolveActor } from "../actor.js";
-import { CliUsageError } from "../usage.js";
-async function consumeExecution(execution, edge) {
-    const observation = edge.progress === undefined ? undefined : Promise.resolve().then(() => edge.progress(execution.progress));
-    void observation?.catch(() => undefined);
-    try {
-        return await execution.result;
-    }
-    finally {
-        await observation?.catch(() => undefined);
-    }
-}
-function actorFromEdge(actor, environment) {
-    try {
-        return 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));
-    }
-}
-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;
-    }
-}
-async function selectedGates(value, names) {
-    const { gatesFrom, SettingsError } = await import("../../library/configuration.js");
-    return consumeSettings(() => gatesFrom({ settings: value, ...(names === undefined ? {} : { names }) }), SettingsError);
-}
-async function selectedGitPolicy(value) {
-    const { requireBranchesToBeUpToDateFrom, SettingsError } = await import("../../library/configuration.js");
-    return consumeSettings(() => requireBranchesToBeUpToDateFrom({ settings: value }), SettingsError);
-}
-async function selectContract(repo, selector, scope, library) {
-    const { contractFromInput, resolveContextualContract } = await import("../selectors.js");
-    const id = selector !== undefined && !selector.startsWith("@")
-        ? contractFromInput(repo, selector).id
-        : resolveContextualContract(await (await import("../../library/contract.js")).listCompleteContractBoard(repo), selector, scope);
-    return { id, contract: library.select({ repo, id }) };
-}
-function draftWarning(error) {
-    return { warning: `bind draft could not be preserved: ${error instanceof Error ? error.message : String(error)}` };
-}
-async function bindDraftReceipt(establishWorld, markdown) {
-    const { preserveBindDraft } = await import("../draft.js");
-    try {
-        return preserveBindDraft(await establishWorld(), markdown);
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        return draftWarning(error);
-    }
-}
-async function bindDraftReceiptAtCwd(input, markdown) {
-    const { preserveBindDraft } = await import("../draft.js");
-    try {
-        const { resolveInvocationCwd } = await import("../coordinates.js");
-        return await preserveBindDraft(await resolveInvocationCwd(input), markdown);
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        return draftWarning(error);
-    }
-}
-export async function admitMarkdownBindSyntax(input) {
-    try {
-        const { parseMarkdownBindDocument } = await import("../../library/contract.js");
-        parseMarkdownBindDocument(input.markdown);
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        if (!(error instanceof TypeError))
-            throw error;
-        const { BindDraftError } = await import("../draft.js");
-        throw new BindDraftError(error, await bindDraftReceiptAtCwd(input, input.markdown));
-    }
-}
-async function invokeBind(input) {
-    const { parsed, repo, edge, configuration, hooks, establishWorld } = input;
-    if (parsed.command !== "bind")
-        throw new Error("bind invocation requires bind syntax");
-    const actor = actorFromEdge(parsed.actor, edge.environment);
-    const { bindFromCommand } = await import("./bind.js");
-    const { acceptedBind, resultFromMutationCall } = await import("../accepted.js");
-    if (parsed.forkOf !== undefined) {
-        return resultFromMutationCall("bind", () => bindFromCommand({
-            command: parsed,
-            repo,
-            ...(actor === undefined ? {} : { actor }),
-            ...(hooks === undefined ? {} : { hooks }),
-        }), (accepted) => {
-            const bound = accepted.facts.find((fact) => fact.kind === "bind");
-            if (bound === undefined || bound.kind !== "bind")
-                throw new Error("accepted bind is missing its bind fact");
-            return acceptedBind(accepted, bound.data.coordinates);
-        });
-    }
-    if (configuration === undefined)
-        throw new Error("bind invocation requires Settings");
-    const markdown = await edge.readStdin();
-    const gates = await selectedGates(configuration, parsed.gates);
-    try {
-        const result = await resultFromMutationCall("bind", () => bindFromCommand({
-            command: parsed,
-            repo,
-            markdown,
-            gates,
-            ...(actor === undefined ? {} : { actor }),
-            ...(hooks === undefined ? {} : { hooks }),
-        }), (accepted) => {
-            const bound = accepted.facts.find((fact) => fact.kind === "bind");
-            if (bound === undefined || bound.kind !== "bind")
-                throw new Error("accepted bind is missing its bind fact");
-            return acceptedBind(accepted, bound.data.coordinates);
-        });
-        if (result.kind !== "refused")
-            return result;
-        return { ...result, draft: await bindDraftReceipt(establishWorld, markdown) };
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        if (!(error instanceof TypeError))
-            throw error;
-        const { BindDraftError } = await import("../draft.js");
-        throw new BindDraftError(error, await bindDraftReceipt(establishWorld, markdown));
-    }
-}
-function deliverRefusal(refusal) {
-    if (typeof refusal !== "object" || refusal === null || !("kind" in refusal) || refusal.kind !== "dirty-workspace") {
-        return refusal;
-    }
-    const submodules = "submodules" in refusal && Array.isArray(refusal.submodules) ? refusal.submodules : [];
-    return { ...refusal, option: { flag: "--include-dirty", available: submodules.length === 0 } };
-}
-async function existingSeat(input, parsed, library) {
-    const { repo, edge, scope, hooks } = input;
-    const { id, contract } = await selectContract(repo, parsed.contract, scope, library);
-    const actor = "actor" in parsed ? actorFromEdge(parsed.actor, edge.environment) : undefined;
-    return { contract, id, ...(actor === undefined ? {} : { actor }), ...(hooks === undefined ? {} : { hooks }) };
-}
-async function invokeDeliver(parsed, seat, edge) {
-    const { acceptedDeliver } = await import("../accepted.js");
-    try {
-        const delivered = await consumeExecution(seat.contract.startDelivery({
-            ...(parsed.message === undefined ? {} : { message: parsed.message }),
-            includeDirty: parsed.includeDirty,
-            materializeConflict: parsed.materializeConflict,
-            overwrite: parsed.overwrite,
-            ...(edge.signal === undefined ? {} : { signal: edge.signal }),
-        }), edge);
-        if (!("facts" in delivered))
-            return delivered;
-        return acceptedDeliver(delivered, seat.id);
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        const { KeiyakuRefused, KeiyakuRetry } = await import("../../library/keiyaku.js");
-        if (error instanceof KeiyakuRefused) {
-            return { kind: "refused", verb: "deliver", contract: seat.id, refusal: deliverRefusal(error.refusal) };
-        }
-        if (error instanceof KeiyakuRetry)
-            return { kind: "retry", verb: "deliver", contract: seat.id, detail: error.reason };
-        throw error;
-    }
-}
-async function invokeReview(parsed, seat, edge) {
-    const summary = parsed.summaryFromStdin === true ? await edge.readStdin() : parsed.summary;
-    const { acceptedReview, resultFromMutationCall } = await import("../accepted.js");
-    const input = {
-        verdict: parsed.verdict,
-        ...(summary === undefined ? {} : { summary }),
-        ...(edge.signal === undefined ? {} : { signal: edge.signal }),
-    };
-    return resultFromMutationCall("review", () => consumeExecution(seat.contract.startReview(input), edge), (result) => acceptedReview(result, seat.id), { coordinate: seat.id });
-}
-async function contractLibrary(input, parsed) {
-    const { configuration, edge, hooks } = input;
-    const { Keiyaku } = await import("../../library/keiyaku.js");
-    if (input.execution.channel.kind !== "local" || !["audit", "deliver", "review"].includes(parsed.command)) {
-        return Keiyaku.with({ execution: input.execution });
-    }
-    const requireBranchesToBeUpToDate = parsed.command !== "review" && configuration !== undefined ? await selectedGitPolicy(configuration) : false;
-    const actor = actorFromEdge(undefined, edge.environment);
-    return Keiyaku.with({
-        execution: input.execution,
-        ...(actor === undefined ? {} : { actor }),
-        ...(hooks === undefined ? {} : { hooks }),
-        requireBranchesToBeUpToDate,
-    });
-}
-export async function invokeContractMutation(input) {
-    const { parsed, repo, edge, configuration, hooks } = input;
-    if (parsed.command === "bind")
-        return invokeBind(input);
-    const seat = await existingSeat(input, parsed, await contractLibrary(input, parsed));
-    const { id, contract, actor } = seat;
-    switch (parsed.command) {
-        case "amend": {
-            if (configuration === undefined)
-                throw new Error("amend invocation requires Settings");
-            const markdown = parsed.stdin === true ? await edge.readStdin() : undefined;
-            const gates = parsed.gates === undefined ? undefined : await selectedGates(configuration, parsed.gates);
-            const { amendFromCommand } = await import("./amend.js");
-            const { acceptedAmend, resultFromMutationCall } = await import("../accepted.js");
-            return resultFromMutationCall("amend", () => amendFromCommand({
-                command: parsed,
-                repo,
-                contract,
-                ...(markdown === undefined ? {} : { markdown }),
-                gates,
-                ...(actor === undefined ? {} : { actor }),
-                ...(hooks === undefined ? {} : { hooks }),
-            }), (result) => acceptedAmend(result, id), { coordinate: id });
-        }
-        case "deliver":
-            return invokeDeliver(parsed, seat, edge);
-        case "review":
-            return invokeReview(parsed, seat, edge);
-        case "arc": {
-            const markdown = await edge.readStdin();
-            const { acceptedArc, resultFromMutationCall } = await import("../accepted.js");
-            return resultFromMutationCall("arc", () => contract.arc({
-                markdown,
-                ...(actor === undefined ? {} : { actor }),
-                ...(hooks === undefined ? {} : { hooks }),
-            }), (result) => acceptedArc(result, id), { coordinate: id });
-        }
-        case "abandon": {
-            const { acceptedAbandon, resultFromMutationCall } = await import("../accepted.js");
-            return resultFromMutationCall("abandon", () => contract.abandon({
-                ...(actor === undefined ? {} : { actor }),
-                ...(parsed.note === undefined ? {} : { note: parsed.note }),
-                ...(hooks === undefined ? {} : { hooks }),
-            }), (result) => acceptedAbandon(result, id), { coordinate: id });
-        }
-        case "audit": {
-            const { acceptedAudit, resultFromMutationCall } = await import("../accepted.js");
-            return resultFromMutationCall("audit", () => consumeExecution(contract.startAudit({
-                includeDirty: parsed.includeDirty,
-                showDiff: parsed.showDiff,
-                ...(edge.signal === undefined ? {} : { signal: edge.signal }),
-            }), edge), (result) => acceptedAudit(result, id), { coordinate: id });
-        }
-    }
-}

package/build/src/cli/commands/nuke.d.ts

@@ -1,10 +0,0 @@
-import { type NukeResult } from "../../index.js";
-import type { WorldRoot } from "../../world.js";
-import { type ParsedCommand } from "../parse.js";
-import type { InvocationResult } from "../result.js";
-export declare function invokeNuke(command: Extract<ParsedCommand, {
-    command: "nuke";
-}>, world: WorldRoot | null): Promise<Readonly<{
-    kind: "nuke";
-    result: NukeResult;
-}> | InvocationResult>;