@astrosheep/keiyaku 4.5.28 → 4.6.1

package/build/src/akuma/fleet-execution.js

@@ -1,181 +0,0 @@
-import { AkumaDecodeError, AkumaProviderError } from "./akuma-errors.js";
-import { AkumaNotBornError, defaultWaitComplete } from "./akuma.js";
-import { createAkumaProduct } from "./akuma-product.js";
-import { readLiveStatus, waitForObservation } from "./akuma-observe.js";
-import { NO_DISPATCH_ASSOCIATION } from "./dispatch-association.js";
-import { EMPTY_CREATED_TASK_OBSERVATION } from "../task/created-observation.js";
-import { fleetResultSchemas, parseAkumaObservation, } from "./fleet-observation.js";
-function source(path) {
-    return createAkumaProduct(path);
-}
-function observationDiagnostic(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-const SHARED_ORDINARY_BUDGET = 30;
-function akumaOnlyObservation(status) {
-    return parseAkumaObservation({
-        status,
-        contract: NO_DISPATCH_ASSOCIATION,
-        createdTasks: EMPTY_CREATED_TASK_OBSERVATION,
-    });
-}
-async function observeWaitRound(path, ids, signal) {
-    signal?.throwIfAborted();
-    if (ids.length <= 1) {
-        const observations = await Promise.all(ids.map(async (id) => await readLiveStatus(path, id, { aperture: "monitoring" })));
-        return { observations, unobserved: [] };
-    }
-    let remaining = SHARED_ORDINARY_BUDGET;
-    const observations = [];
-    const unobserved = [];
-    for (const id of ids) {
-        signal?.throwIfAborted();
-        try {
-            const observed = await readLiveStatus(path, id, { aperture: "monitoring", ordinaryBudget: remaining });
-            observations.push(observed);
-            remaining -= observed.ordinarySelected;
-        }
-        catch (error) {
-            if (error instanceof AkumaNotBornError)
-                throw error;
-            unobserved.push({ id, diagnostic: observationDiagnostic(error) });
-        }
-    }
-    return { observations, unobserved };
-}
-function roundComplete(round, completion) {
-    const settled = round.observations.map((observation) => defaultWaitComplete(observation.status));
-    return (settled.length > 0 &&
-        (completion === "any" ? settled.some(Boolean) : round.unobserved.length === 0 && settled.every(Boolean)));
-}
-/** Canonical ids in the caller's selection order, appending any id the caller never named. */
-function selectionOrderedIds(ids, order) {
-    const present = new Set(ids);
-    const seen = new Set();
-    const ordered = [];
-    for (const id of order) {
-        if (present.has(id) && !seen.has(id)) {
-            seen.add(id);
-            ordered.push(id);
-        }
-    }
-    for (const id of ids) {
-        if (!seen.has(id)) {
-            seen.add(id);
-            ordered.push(id);
-        }
-    }
-    return ordered;
-}
-export async function executeWaitAkuma(input) {
-    // Identity facts are read once per observed Akuma, not once per 100ms round.
-    const facts = new Map();
-    if (input.onSelected !== undefined) {
-        for (const id of input.ids) {
-            input.signal?.throwIfAborted();
-            const known = input.identity === undefined ? undefined : await input.identity(id);
-            facts.set(id, known ?? { contract: NO_DISPATCH_ASSOCIATION });
-        }
-        const ordered = input.selectionOrder === undefined ? input.ids : selectionOrderedIds(input.ids, input.selectionOrder);
-        input.onSelected(ordered.map((id) => ({ id, ...facts.get(id) })));
-    }
-    const observeRound = async (round) => {
-        if (input.observe === undefined)
-            return;
-        const observed = [];
-        for (const observation of round.observations) {
-            input.signal?.throwIfAborted();
-            const { status, rows } = observation;
-            let known = facts.get(status.id);
-            if (known === undefined && input.identity !== undefined) {
-                known = await input.identity(status.id);
-                facts.set(status.id, known);
-            }
-            if (known === undefined) {
-                observed.push({ status, rows, contract: NO_DISPATCH_ASSOCIATION });
-                continue;
-            }
-            observed.push({ status, rows, ...known });
-        }
-        input.observe(observed);
-    };
-    const waited = await waitForObservation({
-        ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        observe: async () => await observeWaitRound(input.path, input.ids, input.signal),
-        complete: (round) => roundComplete(round, input.completion),
-        onObserve: async (round) => await observeRound(round),
-    });
-    return fleetResultSchemas.wait.parse({
-        mode: input.completion,
-        reason: waited.reason,
-        observations: waited.value.observations.map((observation) => akumaOnlyObservation(observation.status)),
-        unobserved: waited.value.unobserved,
-    });
-}
-export async function executeTellAkuma(input) {
-    input.signal?.throwIfAborted();
-    const handle = source(input.path).selectHandle({ id: input.id });
-    const tell = await handle.tell(input.body, input.tellId, input.recordedAt, undefined, {
-        ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-    });
-    input.signal?.throwIfAborted();
-    return fleetResultSchemas.tell.parse({
-        akuma: input.id,
-        tell,
-    });
-}
-function tellWaitObservation(observed) {
-    if (observed.outcome === null)
-        return observed.reason === "deadline" ? { reason: "deadline" } : { reason: "unanswered" };
-    if (observed.outcome.kind === "answered")
-        return { reason: "answered", answer: observed.outcome.answerJson ?? observed.outcome.answer };
-    if (observed.outcome.kind === "failed")
-        return { reason: "failed", diagnostic: observed.outcome.diagnostic };
-    throw new AkumaDecodeError(observed.outcome.diagnostic, observed.outcome.answer);
-}
-export async function executeTellWaitAkuma(input) {
-    input.signal?.throwIfAborted();
-    const handle = source(input.path).selectHandle({ id: input.id });
-    const admission = input.interrupt === true
-        ? await handle.admitInterrupt(input.body, {
-            ...(input.tellId === undefined ? {} : { tellId: input.tellId }),
-            ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
-            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        })
-        : await handle.admitTell(input.body, input.tellId, input.recordedAt, undefined, {
-            ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
-            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        });
-    if (admission.kind === "unavailable")
-        throw new AkumaProviderError(`Tell interrupt unavailable: ${admission.evidence}`);
-    if (admission.kind === "not-born")
-        throw new AkumaNotBornError(input.id);
-    await input.onObserve?.admitted?.(await handle.admittedReceipt(admission.tell.id), input.id);
-    // The wake runs behind the window; a settled wake is preferred, otherwise the
-    // receipt reports the admitted Tell as it stands when the window closes.
-    let settled;
-    void admission.wake.then((receipt) => {
-        settled = receipt;
-    }, () => undefined);
-    const observed = await handle.tellOutcome(admission.tell.id, {
-        timeoutMs: input.timeoutMs,
-        ...(input.signal === undefined ? {} : { signal: input.signal }),
-        ...(input.onObserve?.observe === undefined ? {} : { observe: input.onObserve.observe }),
-    });
-    const observation = tellWaitObservation(observed);
-    const tell = settled ?? (await handle.admittedReceipt(admission.tell.id));
-    return fleetResultSchemas.tellWait.parse({ akuma: input.id, tell, observation });
-}
-export async function executeKillAkuma(input) {
-    input.signal?.throwIfAborted();
-    const handles = input.ids.map((id) => source(input.path).selectHandle({ id }));
-    const evidence = await Promise.all(handles.map(async (handle) => await handle.kill(input.signal === undefined ? {} : { signal: input.signal })));
-    input.signal?.throwIfAborted();
-    return fleetResultSchemas.kill.parse({
-        results: input.ids.map((id, index) => ({ id, evidence: evidence[index] })),
-    });
-}

package/build/src/akuma/fleet-observation.js

@@ -1,91 +0,0 @@
-import { akumaIdSchema, akumaStatusSchema } from "./akuma.js";
-import { tellRowSchema } from "./projection.js";
-import { dispatchAssociationSchema } from "./dispatch-association.js";
-import { createdTaskObservationSchema } from "../task/created-observation.js";
-import { z } from "zod";
-const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
-const killEvidenceSchema = z.enum([
-    "killed",
-    "already-killed",
-    "already-stopped",
-    "hung",
-    "untidy",
-    "unavailable",
-]);
-const akumaObservationSchema = z
-    .object({
-    status: akumaStatusSchema,
-    contract: dispatchAssociationSchema,
-    createdTasks: createdTaskObservationSchema,
-})
-    .strict();
-const runLogReferenceSchema = z
-    .object({ path: z.string(), from: z.number().int().nonnegative(), to: z.number().int().nonnegative() })
-    .strict();
-const failedTellWakeSchema = z
-    .object({
-    kind: z.literal("failed"),
-    diagnostic: z.string(),
-    child: z
-        .object({ code: z.number().int().nullable(), signal: z.string().nullable(), log: runLogReferenceSchema })
-        .strict()
-        .optional(),
-})
-    .strict()
-    .transform(({ child, ...wake }) => (child === undefined ? wake : { ...wake, child }));
-const tellWakeSchema = z.union([
-    z.object({ kind: z.literal("told") }).strict(),
-    z.object({ kind: z.literal("held") }).strict(),
-    z.object({ kind: z.literal("pursuing"), bodySequence: z.number().int().nonnegative() }).strict(),
-    failedTellWakeSchema,
-]);
-const tellResultSchema = z
-    .object({
-    admission: z.object({ fact: z.literal("recorded"), tellId: nonblankTextSchema }).strict(),
-    row: tellRowSchema,
-    wake: tellWakeSchema,
-})
-    .strict();
-const akumaUnobservedSchema = z.object({ id: akumaIdSchema, diagnostic: z.string() }).strict();
-const akumaKillResultItemSchema = z.object({ id: akumaIdSchema, evidence: killEvidenceSchema }).strict();
-const akumaWaitResultSchema = z
-    .object({
-    mode: z.enum(["any", "all"]),
-    reason: z.enum(["completed", "deadline"]),
-    observations: z.array(akumaObservationSchema),
-    unobserved: z.array(akumaUnobservedSchema),
-})
-    .strict();
-const akumaKillResultSchema = z.object({ results: z.array(akumaKillResultItemSchema) }).strict();
-const akumaTellResultSchema = z.object({ akuma: akumaIdSchema, tell: tellResultSchema }).strict();
-const tellWaitObservationSchema = z.union([
-    z.object({ reason: z.literal("answered"), answer: z.unknown() }).strict(),
-    z.object({ reason: z.literal("failed"), diagnostic: z.string() }).strict(),
-    z.object({ reason: z.literal("unanswered") }).strict(),
-    z.object({ reason: z.literal("deadline") }).strict(),
-]);
-const akumaTellWaitResultSchema = z
-    .object({ akuma: akumaIdSchema, tell: tellResultSchema, observation: tellWaitObservationSchema })
-    .strict();
-export function parseAkumaObservation(value) {
-    return akumaObservationSchema.parse(value);
-}
-export function isWaitResult(value) {
-    return akumaWaitResultSchema.safeParse(value).success;
-}
-export function isKillResult(value) {
-    return akumaKillResultSchema.safeParse(value).success;
-}
-export function isTellResult(value) {
-    return akumaTellResultSchema.safeParse(value).success;
-}
-export function isTellWaitResult(value) {
-    return akumaTellWaitResultSchema.safeParse(value).success;
-}
-export const fleetResultSchemas = {
-    wait: akumaWaitResultSchema,
-    tell: akumaTellResultSchema,
-    tellWait: akumaTellWaitResultSchema,
-    kill: akumaKillResultSchema,
-    killEvidence: killEvidenceSchema,
-};

package/build/src/cli/accepted.d.ts

@@ -1,24 +0,0 @@
-import { type AmendResult, type AuditReport, type BindResult, type ContractId, type Delivery, type MutationResult, type Review } from "../index.js";
-import type { AcceptedAbandonResult, AcceptedAmendResult, AcceptedArcResult, AcceptedAuditResult, AcceptedBindResult, AcceptedDeliverResult, AcceptedResult, AcceptedReviewResult, InvocationResult } from "./result.js";
-type MutationObservation = Pick<MutationResult<unknown>, "facts" | "head" | "lags" | "settlementLags" | "recoverySnapshot" | "cleanup" | "executionStops">;
-type MutationCallOptions = Readonly<{
-    coordinate?: ContractId;
-    projectRefusal?: (refusal: unknown) => unknown;
-}>;
-export declare function acceptedBind(result: BindResult, coordinates: Readonly<{
-    target?: string;
-}>): AcceptedBindResult;
-export declare function acceptedAmend(result: AmendResult, coordinate: ContractId): AcceptedAmendResult;
-export declare function acceptedDeliver(result: MutationResult<Delivery>, coordinate: ContractId): AcceptedDeliverResult;
-export declare function acceptedReview(result: MutationResult<Review>, coordinate: ContractId): AcceptedReviewResult;
-export declare function acceptedArc(result: MutationResult<void>, coordinate: ContractId): AcceptedArcResult;
-export declare function acceptedAbandon(result: MutationResult<void>, coordinate: ContractId): AcceptedAbandonResult;
-export declare function acceptedAudit(result: MutationResult<AuditReport>, coordinate: ContractId): AcceptedAuditResult;
-export declare function resultFromMutationCall<const Verb extends AcceptedResult["verb"], Result extends MutationObservation>(verb: Verb, call: () => Promise<Result>, project: (result: Result) => Extract<AcceptedResult, {
-    verb: NoInfer<Verb>;
-}>, options?: MutationCallOptions): Promise<Extract<AcceptedResult, {
-    verb: Verb;
-}> | Extract<InvocationResult, {
-    kind: "refused" | "retry";
-}>>;
-export {};

package/build/src/cli/accepted.js

@@ -1,167 +0,0 @@
-import { executionReceipt, KeiyakuRefused, KeiyakuRetry, } from "../index.js";
-function acceptedFacts(result) {
-    return result.facts.map((fact) => fact.kind === "reintegrated"
-        ? { contract: fact.contract, entry: fact.entry, kind: fact.kind, data: fact.data }
-        : { contract: fact.contract, entry: fact.entry, kind: fact.kind });
-}
-function attestationFor(facts, gate, coordinate) {
-    return facts.findLast((fact) => fact.contract === coordinate && fact.kind === "attestation" && fact.data.gate === gate);
-}
-function acceptedEnvelope(result, coordinate) {
-    const contract = coordinate ?? result.facts[0]?.contract;
-    if (contract === undefined)
-        throw new Error("accepted mutation is missing its contract identity");
-    const firstLag = result.lags[0];
-    return {
-        kind: "accepted",
-        contract,
-        head: result.head,
-        facts: acceptedFacts(result),
-        settlementLags: result.settlementLags,
-        ...(result.recoverySnapshot === undefined ? {} : { recoverySnapshot: result.recoverySnapshot }),
-        ...(result.lags.length === 0 || firstLag === undefined ? {} : { lag: [firstLag, ...result.lags.slice(1)] }),
-        ...(result.cleanup.length === 0 ? {} : { cleanup: result.cleanup }),
-        ...(result.executionStops.length === 0 ? {} : { executionStops: result.executionStops }),
-    };
-}
-/**
- * The completed placement's movement identity — the reference it advanced and the head it advanced from — is part
- * of the public accepted shape, so a receipt states the movement without rebuilding it from facts or folded state.
- */
-function acceptedCompletion(completion) {
-    if (completion === undefined)
-        return undefined;
-    return {
-        integration: completion.integration,
-        ...(completion.predecessor === undefined ? {} : { predecessor: completion.predecessor }),
-        ...(completion.target === undefined ? {} : { target: completion.target }),
-        ...(completion.verification === undefined ? {} : { verification: completion.verification }),
-    };
-}
-function acceptedRegion(result) {
-    if (result.overlapFailure !== undefined)
-        return { overlapFailure: result.overlapFailure };
-    return { overlaps: result.overlaps };
-}
-function acceptedAmendRegion(result) {
-    if (result.overlapFailure !== undefined)
-        return { overlapFailure: result.overlapFailure };
-    if (result.overlaps !== undefined)
-        return { overlaps: result.overlaps };
-    return {};
-}
-export function acceptedBind(result, coordinates) {
-    return {
-        ...acceptedEnvelope(result, undefined),
-        verb: "bind",
-        ...(result.workspace === undefined ? {} : { workspace: result.workspace }),
-        target: coordinates.target ?? null,
-        ...(result.warnings === undefined ? {} : { warnings: result.warnings }),
-        ...acceptedRegion(result),
-    };
-}
-export function acceptedAmend(result, coordinate) {
-    return {
-        ...acceptedEnvelope(result, coordinate),
-        verb: "amend",
-        diff: result.documentDiff,
-        ...acceptedAmendRegion(result),
-    };
-}
-export function acceptedDeliver(result, coordinate) {
-    const value = result.value;
-    const attestation = attestationFor(result.facts, "verified", coordinate);
-    const completion = acceptedCompletion(value.completion);
-    const verificationVerdict = value.completion?.verification?.verdict ?? attestation?.data.verdict ?? value.verificationReuse?.verdict;
-    return {
-        ...acceptedEnvelope(result, coordinate),
-        verb: "deliver",
-        tenderSnapshot: value.tenderSnapshot,
-        integration: { changeId: value.integration.changeId },
-        ...(value.leading === undefined ? {} : { leading: value.leading }),
-        ...(completion === undefined ? {} : { completion }),
-        ...(verificationVerdict === undefined ? {} : { verificationVerdict }),
-        ...(value.verification === undefined ? {} : { verification: value.verification }),
-        ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),
-        ...(value.verificationSummary === undefined ? {} : { verificationSummary: value.verificationSummary }),
-        ...(value.placement === undefined ? {} : { placement: value.placement }),
-        ...(value.continuation === undefined ? {} : { continuation: value.continuation }),
-    };
-}
-export function acceptedReview(result, coordinate) {
-    const value = result.value;
-    const reviewAttestation = attestationFor(result.facts, "reviewed", coordinate);
-    if (reviewAttestation === undefined)
-        throw new Error("accepted review is missing its attestation fact");
-    const verificationAttestation = attestationFor(result.facts, "verified", coordinate);
-    const completion = acceptedCompletion(value.completion);
-    const verificationVerdict = value.completion?.verification?.verdict ??
-        verificationAttestation?.data.verdict ??
-        value.verificationReuse?.verdict;
-    return {
-        ...acceptedEnvelope(result, coordinate),
-        verb: "review",
-        verdict: reviewAttestation.data.verdict,
-        ...(completion === undefined ? {} : { completion }),
-        ...(verificationVerdict === undefined ? {} : { verificationVerdict }),
-        ...(value.verification === undefined ? {} : { verification: value.verification }),
-        ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),
-        ...(value.verificationSummary === undefined ? {} : { verificationSummary: value.verificationSummary }),
-        ...(value.placement === undefined ? {} : { placement: value.placement }),
-        ...(value.continuation === undefined ? {} : { continuation: value.continuation }),
-        ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
-    };
-}
-export function acceptedArc(result, coordinate) {
-    const arc = result.facts.find((fact) => fact.kind === "arc");
-    if (arc === undefined)
-        throw new Error("accepted arc is missing its arc fact");
-    return {
-        ...acceptedEnvelope(result, coordinate),
-        verb: "arc",
-        chapter: { seq: arc.data.seq, title: arc.data.title },
-    };
-}
-export function acceptedAbandon(result, coordinate) {
-    const abandoned = result.facts.find((fact) => fact.kind === "abandoned");
-    if (abandoned === undefined)
-        throw new Error("accepted abandon is missing its abandoned fact");
-    return {
-        ...acceptedEnvelope(result, coordinate),
-        verb: "abandon",
-        ...(abandoned.data.note === undefined ? {} : { note: abandoned.data.note }),
-    };
-}
-export function acceptedAudit(result, coordinate) {
-    return {
-        ...acceptedEnvelope(result, coordinate),
-        verb: "audit",
-        report: result.value,
-    };
-}
-export async function resultFromMutationCall(verb, call, project, options = {}) {
-    try {
-        return project(await call());
-    }
-    catch (error) {
-        if (executionReceipt(error) !== undefined)
-            throw error;
-        if (error instanceof KeiyakuRefused) {
-            return {
-                kind: "refused",
-                verb,
-                ...(options.coordinate === undefined ? {} : { contract: options.coordinate }),
-                refusal: options.projectRefusal === undefined ? error.refusal : options.projectRefusal(error.refusal),
-            };
-        }
-        if (error instanceof KeiyakuRetry) {
-            return {
-                kind: "retry",
-                verb,
-                ...(options.coordinate === undefined ? {} : { contract: options.coordinate }),
-                detail: error.reason,
-            };
-        }
-        throw error;
-    }
-}

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

@@ -1,114 +0,0 @@
-import { type AkuId } from "../../akuma/identity.js";
-import { type ActivityHistory } from "../../akuma/akuma.js";
-import { Keiyaku, type AkumaKillResult, type AkumaHistoryResult, type AkumaObservation, type AkumaTellResult, type AkumaWaitResult, type CallResult, type ForkResult, type Keiyaku as KeiyakuContract, type Repo } from "../../index.js";
-import { type WaitSelectedIdentity } from "../render/akuma-activity.js";
-import type { Settings } from "../../settings.js";
-import type { WorldRoot } from "../../world.js";
-import type { InvokedAkumaCommand } from "./akuma.js";
-import { type ExecutionContext } from "../../akuma/requests.js";
-import type { AkumaTellWaitResult } from "../../akuma/fleet-observation.js";
-export type AkumaInvocationResult = Readonly<{
-    kind: "akuma";
-    action: "call";
-    result: CallResult;
-    world: WorldRoot;
-    schemaAnswer?: unknown;
-    streamed?: boolean;
-}> | Readonly<{
-    kind: "akuma";
-    action: "status";
-    status: AkumaObservation;
-    alias?: string;
-}> | Readonly<{
-    kind: "akuma";
-    action: "wait";
-    result: AkumaWaitResult;
-    alias?: string;
-    streamed?: boolean;
-    /** The moment this invocation began waiting, so a non-streamed scoreboard asserts real waiting. */
-    startedAt?: number;
-    /** The frozen selected set, so a non-streamed render names each target as the caller selected it. */
-    selection?: readonly WaitSelectedIdentity[];
-}> | Readonly<{
-    kind: "akuma";
-    action: "tell";
-    mode: "ordinary";
-    result: AkumaTellResult;
-    body: string;
-    alias?: string;
-}> | Readonly<{
-    kind: "akuma";
-    action: "tell";
-    mode: "schema";
-    result: unknown;
-    body: string;
-    alias?: string;
-}> | Readonly<{
-    kind: "akuma";
-    action: "tell";
-    mode: "wait";
-    result: AkumaTellWaitResult;
-    body: string;
-    alias?: string;
-}> | Readonly<{
-    kind: "akuma";
-    action: "tell";
-    mode: "interrupt";
-    result: Awaited<ReturnType<typeof Keiyaku.interrupt>>;
-    body: string;
-    alias?: string;
-}> | Readonly<{
-    kind: "akuma";
-    action: "history";
-    akuma: AkuId;
-    mode: "page";
-    history: ActivityHistory;
-    historyResult: AkumaHistoryResult;
-    alias?: string;
-}> | Readonly<{
-    kind: "akuma";
-    action: "history";
-    akuma: AkuId;
-    mode: "last";
-    answer: string;
-    historyResult: AkumaHistoryResult;
-    alias?: string;
-}> | Readonly<{
-    kind: "akuma";
-    action: "history";
-    akuma: AkuId;
-    mode: "no-answer";
-    historyResult: AkumaHistoryResult;
-    alias?: string;
-}> | Readonly<{
-    kind: "akuma";
-    action: "history";
-    akuma: AkuId;
-    mode: "exact";
-    historyResult: AkumaHistoryResult;
-    alias?: string;
-}> | Readonly<{
-    kind: "akuma";
-    action: "fork";
-    receipt: ForkResult;
-}> | Readonly<{
-    kind: "akuma";
-    action: "kill";
-    result: AkumaKillResult;
-    alias?: string;
-}>;
-type InvokeInput = Readonly<{
-    path: WorldRoot;
-    executionCwd?: string;
-    home?: string;
-    settings?: Settings;
-    contract?: KeiyakuContract;
-    repo?: Repo;
-    environment: NodeJS.ProcessEnv;
-    readStdin(): Promise<string>;
-    execution?: ExecutionContext;
-    signal?: AbortSignal;
-}>;
-export declare function invokeAkuma(command: InvokedAkumaCommand, input: InvokeInput): Promise<AkumaInvocationResult>;
-export declare function invokeAkumaStatus(path: WorldRoot, akuma: string, alias?: string, repo?: Repo): Promise<AkumaInvocationResult>;
-export {};