@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/library/contract-operations.js

@@ -1,7 +1,8 @@
 import { contractId, snapshotId } from "../core/facts/types.js";
 import { requestBodyCommand } from "../akuma/request-rendezvous.js";
-import { eraseRequestCommand } from "../akuma/request-wire.js";
-import { auditReportSchema, auditResultSchema, decodeContractLiveFailure, deliveryResultSchema, encodeContractLiveFailure, reviewResultSchema, } from "./contract-forwarding-result.js";
+import { eraseRequestCommand, } from "../akuma/request-wire.js";
+import { auditReportSchema, auditResultSchema, deliveryResultSchema, reviewResultSchema, } from "./mutation.js";
+import { decodeContractLiveFailure, encodeContractLiveFailure } from "./refusal.js";
 import { isAbsolute, resolve } from "node:path";
 import { z } from "zod";
 const absolutePathSchema = z.string().refine((value) => isAbsolute(value) && resolve(value) === value);
@@ -85,31 +86,6 @@ const contractServiceSchema = z.union([
     materializedHandoffServiceSchema,
     reviewReferenceSchema,
 ]);
-function decodeContractExecutionContext(value) {
-    const context = contractPayload(value);
-    if (context === null ||
-        typeof context.requester !== "string" ||
-        context.requester.trim() === "" ||
-        !isAbortSignal(context.signal) ||
-        !isContractRequestPort(context.upstream))
-        throw new Error("invalid Contract execution context");
-    return { requester: context.requester, signal: context.signal, upstream: context.upstream };
-}
-function isAbortSignal(value) {
-    return (value !== null &&
-        typeof value === "object" &&
-        typeof value.throwIfAborted === "function");
-}
-function isContractRequestPort(value) {
-    const port = contractPayload(value);
-    return (port !== null &&
-        (typeof port.audit === "function" || typeof port.deliver === "function" || typeof port.review === "function"));
-}
-function contractPayload(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-}
 function decodeContractRequest(action, value) {
     const schema = action === "contract.audit"
         ? auditRequestSchema
@@ -145,11 +121,13 @@ function decodeContractReference(action, value) {
         throw new Error(`malformed stored Contract service evidence for ${action}`);
     return parsed.data;
 }
-async function executeContractRequest(request, context) {
+async function executeContractRequest(request, facts, port) {
     if (request.action === "contract.audit") {
-        if (typeof context.upstream.audit !== "function")
-            throw new Error("invalid Contract execution context");
-        const served = await context.upstream.audit({ ...request, requester: context.requester, signal: context.signal });
+        const served = await port.audit({
+            ...request,
+            requester: facts.requester,
+            signal: facts.signal,
+        });
         if (served.auditReport === undefined)
             throw new Error(`Contract ${request.action} completed without durable service evidence`);
         return {
@@ -163,9 +141,11 @@ async function executeContractRequest(request, context) {
         };
     }
     if (request.action === "contract.deliver") {
-        if (typeof context.upstream.deliver !== "function")
-            throw new Error("invalid Contract execution context");
-        const served = await context.upstream.deliver({ ...request, requester: context.requester, signal: context.signal });
+        const served = await port.deliver({
+            ...request,
+            requester: facts.requester,
+            signal: facts.signal,
+        });
         if ("kind" in served.result && served.result.kind === "integration-conflict-materialized") {
             return {
                 result: served.result,
@@ -191,9 +171,11 @@ async function executeContractRequest(request, context) {
             },
         };
     }
-    if (typeof context.upstream.review !== "function")
-        throw new Error("invalid Contract execution context");
-    const served = await context.upstream.review({ ...request, requester: context.requester, signal: context.signal });
+    const served = await port.review({
+        ...request,
+        requester: facts.requester,
+        signal: facts.signal,
+    });
     if (served.reviewFactId === undefined)
         throw new Error(`Contract ${request.action} completed without durable service evidence`);
     return {
@@ -217,7 +199,7 @@ function decodedContractResult(action, value) {
         throw new Error(`transport integrity: Contract ${action} returned an invalid live result`);
     return parsed.data;
 }
-export function contractRequestCommand(action) {
+export function contractRequestProtocol(action) {
     return {
         action,
         encodeRequest: (request) => {
@@ -229,24 +211,29 @@ export function contractRequestCommand(action) {
         decodeResult: (value) => decodedContractResult(action, value),
         encodeFailure: encodeContractLiveFailure,
         decodeFailure: decodeContractLiveFailure,
+        decodeReference: (reference) => decodeContractReference(action, reference),
+        isPermitted: (allowed) => allowed.includes(action),
+    };
+}
+export function contractRequestCommand(action, port) {
+    return {
+        completion: "service",
+        protocol: contractRequestProtocol(action),
         encodeService: (service) => service,
         decodeService: (service) => decodeContractService(action, service),
         projectService: (service) => projectContractService(action, service),
-        decodeReference: (reference) => decodeContractReference(action, reference),
-        isPermitted: (allowed) => allowed.includes(action),
-        decodeExecutionContext: decodeContractExecutionContext,
-        execute: executeContractRequest,
+        execute: async (request, facts) => await executeContractRequest(request, facts, port),
     };
 }
-export function contractRequestCommands() {
+export function contractRequestCommands(port) {
     return {
-        "contract.audit": eraseRequestCommand(contractRequestCommand("contract.audit")),
-        "contract.deliver": eraseRequestCommand(contractRequestCommand("contract.deliver")),
-        "contract.review": eraseRequestCommand(contractRequestCommand("contract.review")),
+        "contract.audit": eraseRequestCommand(contractRequestCommand("contract.audit", port)),
+        "contract.deliver": eraseRequestCommand(contractRequestCommand("contract.deliver", port)),
+        "contract.review": eraseRequestCommand(contractRequestCommand("contract.review", port)),
     };
 }
 export async function requestForwardedContractLive(input) {
-    const command = contractRequestCommand(input.action);
+    const command = contractRequestProtocol(input.action);
     const response = await requestBodyCommand({
         directory: input.directory,
         command,

package/build/src/library/contract.d.ts

@@ -4,15 +4,18 @@ import type { RegionOverlap } from "./region.js";
 import { type ChangeId, type FactKind, type ContractId, type ContractState, type SnapshotId } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { type PlacementStop, type VerificationStop, type DeliveryPreparationRefusal } from "../protocol/operations.js";
-import type { ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow, AfterEndpointObservation, ContractAfterEdge, ContractDependent, ContractWorkspaceObservation } from "../protocol/read/status.js";
+import type { ContractBoard, ContractCatalogue, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow, AfterEndpointObservation, ContractAfterEdge, ContractDependent, ContractWorkspaceObservation } from "../protocol/read/status.js";
 import type { AuditReport } from "../protocol/audit.js";
 import type { IntegrationConflictMaterialized, VerificationReuse } from "../protocol/deliver.js";
 import type { TaskId } from "../task/identity.js";
+import { type Repo } from "./repo.js";
 import { type ExecutionContext } from "../akuma/requests.js";
 import type { AuditInput } from "./audit.js";
 import { Delivery } from "./delivery.js";
 import { type ContinuationReport } from "./continuation.js";
 import type { MutationResult } from "./mutation.js";
+export { projectMutationFinality } from "./mutation.js";
+export type { MutationFinality, MutationFinalityInput, MutationFinalitySurface, MutationPendingSurface, } from "./mutation.js";
 export { KeiyakuHandle } from "./contract-handle.js";
 import { KeiyakuHandle } from "./contract-handle.js";
 import type { AbandonInput, AmendInput, AmendResult, ArcInput, BindInput, BindResult, ContractListInput, ContractObservationInput, DeliverInput, ForkBindInput, KeiyakuOfInput, LocalContractComposition, MarkdownBindInput, ReconcileReport, ReviewInput, ContractHistory, ContractHistoryEvent, Fact, Lag, TopologyEffect } from "./contract-types.js";
@@ -22,7 +25,7 @@ export { KeiyakuRefused } from "./refusal.js";
 export { KeiyakuRetry, type KeiyakuRefusal, type KeiyakuRetryReason };
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
 export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
-export type { AbandonInput, AmendInput, AmendResult, ArcInput, AuditInput, AuditReport, ChangeId, ContinuationReport, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractAfterEdge, ContractId, ContractHistory, ContractHistoryEvent, ContractDependent, ContractObservation, ContractPhase, ContractRow, ContractState, ContractWorkspaceObservation, BindInput, BindResult, ContractListInput, ContractObservationInput, DeliverInput, ForkBindInput, KeiyakuOfInput, MarkdownBindInput, ReconcileReport, ReviewInput, DeliveryPreparationRefusal, Fact, FactKind, IntegrationConflictMaterialized, Lag, LocalContractComposition, MutationResult, PlacementStop, RegionOverlap, SnapshotId, TaskId, TopologyEffect, VerificationReuse, VerificationStop, };
+export type { AbandonInput, AmendInput, AmendResult, ArcInput, AuditInput, AuditReport, ChangeId, ContinuationReport, ContractBoard, ContractCatalogue, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractAfterEdge, ContractId, ContractHistory, ContractHistoryEvent, ContractDependent, ContractObservation, ContractPhase, ContractRow, ContractState, ContractWorkspaceObservation, BindInput, BindResult, ContractListInput, ContractObservationInput, DeliverInput, ForkBindInput, KeiyakuOfInput, MarkdownBindInput, ReconcileReport, ReviewInput, DeliveryPreparationRefusal, Fact, FactKind, IntegrationConflictMaterialized, Lag, LocalContractComposition, MutationResult, PlacementStop, RegionOverlap, SnapshotId, TaskId, TopologyEffect, VerificationReuse, VerificationStop, };
 export type { AfterEndpointObservation };
 export type ActorId = string;
 export type AttestationVerdict = OperationAttestationVerdict;
@@ -38,7 +41,13 @@ export type LocalContractCompositionCapture = Readonly<{
 export declare function captureLocalContractComposition(input?: LocalContractComposition): LocalContractCompositionCapture;
 export declare function keiyakuOf(input: KeiyakuOfInput, execution?: ExecutionContext, composition?: LocalContractCompositionCapture): Keiyaku;
 export declare function listKeiyaku(input: ContractListInput): Promise<ContractBoard>;
+/** Internal bounded catalogue composition; the public Contract board remains complete. */
+export declare function listContractCatalogue(input: Readonly<{
+    repo: Repo;
+    limit?: number;
+}>): Promise<ContractCatalogue>;
 export declare function observeKeiyaku(input: ContractObservationInput): Promise<ContractObservation>;
 export declare function bindKeiyaku(input: BindInput, execution?: ExecutionContext, composition?: LocalContractCompositionCapture): Promise<BindResult>;
+export { parseMarkdownBindDocument } from "./contract-bind.js";
 /** Internal CLI composition; not exported from the package root. */
 export declare function bindFromCli(input: BindInput, execution?: ExecutionContext): Promise<BindResult>;

package/build/src/library/contract.js

@@ -3,11 +3,12 @@ import { actorOption, optionalBoolean, requireInput } from "./input.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { contractId, } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { contractObservationOperation, contractsOperation, } from "../protocol/operations.js";
+import { contractCatalogueOperation, contractObservationOperation, contractsOperation, } from "../protocol/operations.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { scopeForRepo } from "./repo.js";
 import { localExecutionContext } from "../akuma/requests.js";
 import { Delivery } from "./delivery.js";
+export { projectMutationFinality } from "./mutation.js";
 import { bindFromCli as bindFromCliImplementation, bindKeiyaku as bindKeiyakuImplementation } from "./contract-bind.js";
 export { KeiyakuHandle } from "./contract-handle.js";
 import { KeiyakuHandle } from "./contract-handle.js";
@@ -44,6 +45,24 @@ export async function listKeiyaku(input) {
     const scope = scopeForRepo(values.repo);
     return withGitDecodeChannel(scope, (channel) => contractsOperation({ scope, channel }));
 }
+/** Internal bounded catalogue composition; the public Contract board remains complete. */
+export async function listContractCatalogue(input) {
+    const values = requireInput(input, "Contract catalogue input");
+    for (const key of Object.keys(values)) {
+        if (key !== "repo" && key !== "limit")
+            throw new TypeError(`Contract catalogue input has unknown field: ${key}`);
+    }
+    const limit = values.limit;
+    if (limit !== undefined && typeof limit !== "number") {
+        throw new TypeError("Contract catalogue limit must be a number");
+    }
+    const scope = scopeForRepo(values.repo);
+    return withGitDecodeChannel(scope, (channel) => contractCatalogueOperation({
+        scope,
+        channel,
+        ...(limit === undefined ? {} : { limit }),
+    }));
+}
 export async function observeKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.observe input");
     for (const key of Object.keys(values))
@@ -64,6 +83,7 @@ export async function observeKeiyaku(input) {
 export async function bindKeiyaku(input, execution = localExecutionContext(), composition = captureLocalContractComposition()) {
     return bindKeiyakuImplementation(input, (id, scope) => new KeiyakuHandle(id, scope, execution, composition));
 }
+export { parseMarkdownBindDocument } from "./contract-bind.js";
 /** Internal CLI composition; not exported from the package root. */
 export async function bindFromCli(input, execution = localExecutionContext()) {
     const composition = captureLocalContractComposition();

package/build/src/library/delivery.d.ts

@@ -1,9 +1,12 @@
 import type { SnapshotId } from "../core/facts/types.js";
 import type { DeliverValue as ProtocolDeliverValue } from "../protocol/deliver.js";
-import type { ContinuationReport } from "./continuation.js";
+import { type ContinuationReport } from "./continuation.js";
+import { z } from "zod";
 export type DeliveryValue = ProtocolDeliverValue & Readonly<{
     continuation?: ContinuationReport;
 }>;
+export declare function decodeDeliveryValue(value: unknown): DeliveryValue;
+export declare const deliveryValueSchema: z.ZodType<DeliveryValue, unknown, z.core.$ZodTypeInternals<DeliveryValue, unknown>>;
 declare class DeliveryHandle {
     private readonly readDiff;
     readonly completion?: DeliveryValue["completion"];

package/build/src/library/delivery.js

@@ -1,3 +1,50 @@
+import { decodeDeliverData } from "../core/facts/codec.js";
+import { decodeCompletionEvidence } from "../protocol/result-codec.js";
+import { decodeContinuationReport } from "./continuation.js";
+import { ownerSchema } from "./result-codec.js";
+export function decodeDeliveryValue(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("malformed delivery value");
+    const object = value;
+    const allowed = new Set([
+        "tenderSnapshot",
+        "integration",
+        "method",
+        "policy",
+        "completion",
+        "verification",
+        "verificationReuse",
+        "verificationSummary",
+        "placement",
+        "cleanup",
+        "leak",
+        "continuation",
+    ]);
+    for (const key of Object.keys(object))
+        if (!allowed.has(key))
+            throw new Error("malformed delivery value");
+    const identity = decodeDeliverData({
+        tenderSnapshot: object.tenderSnapshot,
+        integration: object.integration,
+        method: object.method,
+        policy: object.policy,
+    });
+    const evidence = decodeCompletionEvidence({
+        ...(object.completion === undefined ? {} : { completion: object.completion }),
+        ...(object.verification === undefined ? {} : { verification: object.verification }),
+        ...(object.verificationReuse === undefined ? {} : { verificationReuse: object.verificationReuse }),
+        ...(object.verificationSummary === undefined ? {} : { verificationSummary: object.verificationSummary }),
+        ...(object.placement === undefined ? {} : { placement: object.placement }),
+        ...(object.cleanup === undefined ? {} : { cleanup: object.cleanup }),
+        ...(object.leak === undefined ? {} : { leak: object.leak }),
+    });
+    return {
+        ...identity,
+        ...evidence,
+        ...(object.continuation === undefined ? {} : { continuation: decodeContinuationReport(object.continuation) }),
+    };
+}
+export const deliveryValueSchema = ownerSchema(decodeDeliveryValue, "expected delivery value");
 class DeliveryHandle {
     readDiff;
     constructor(identity, readDiff, outcomes = {}) {

package/build/src/library/fleet.d.ts

@@ -1,12 +1,9 @@
-import { type ActivityHistory, type OutcomeRow, type AkumaStatus, type InterruptReceipt, type KillEvidence } from "../akuma/index.js";
+/** @architectureCompositionRoot */
+import { type ActivityHistory, type OutcomeRow, type AkumaStatus, type InterruptReceipt } from "../akuma/index.js";
 import { type ExecutionContext } from "../akuma/requests.js";
-import { type ErasedRequestCommand, type RequestCommand } from "../akuma/request-wire.js";
-import type { WorldRoot } from "../world.js";
+import { type DispatchAssociation } from "../dispatch/index.js";
 import { type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
-import { type AkumaKillResult, type AkumaObservation, type AkumaObservationStage, type AkumaTellResult, type AkumaWaitResult, type DispatchAssociation } from "./fleet-result.js";
-export type { AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellResult, AkumaUnobserved, AkumaWaitResult, CreatedTaskObservation, DispatchAssociation, } from "./fleet-result.js";
-import { type Repo } from "./repo.js";
-import { z } from "zod";
+import { type AkumaKillResult, type AkumaObservation, type AkumaObservationStage, type AkumaTellResult, type AkumaWaitResult } from "../akuma/fleet-observation.js";
 export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
     completion?: "any" | "all";
     timeoutMs?: number;
@@ -55,135 +52,6 @@ export type AkumaHistoryResult = Readonly<{
     id: AkumaStatus["id"];
     contract: DispatchAssociation;
 }>;
-type WaitExecutionInput = Readonly<{
-    path: WorldRoot;
-    ids: readonly AkumaStatus["id"][];
-    completion: "any" | "all";
-    timeoutMs?: number;
-    repo?: Repo;
-    signal?: AbortSignal;
-}>;
-export declare function executeWaitAkuma(input: WaitExecutionInput): Promise<AkumaWaitResult>;
-type TellExecutionInput = Readonly<{
-    path: WorldRoot;
-    id: AkumaStatus["id"];
-    body: string;
-    tellId?: string;
-    recordedAt?: string;
-    repo?: Repo;
-    signal?: AbortSignal;
-}>;
-export declare function executeTellAkuma(input: TellExecutionInput): Promise<AkumaTellResult>;
-type KillExecutionInput = Readonly<{
-    path: WorldRoot;
-    ids: readonly AkumaStatus["id"][];
-    repo?: Repo;
-    signal?: AbortSignal;
-}>;
-export declare function executeKillAkuma(input: KillExecutionInput): Promise<AkumaKillResult>;
-declare const waitRequestSchema: z.ZodPipe<z.ZodObject<{
-    targets: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>>;
-    completion: z.ZodEnum<{
-        any: "any";
-        all: "all";
-    }>;
-    timeoutMs: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>, z.ZodTransform<{
-    timeoutMs?: number;
-    targets: import("../akuma/identity.js").AkuId[];
-    completion: "any" | "all";
-    action: "akuma.wait";
-}, {
-    targets: import("../akuma/identity.js").AkuId[];
-    completion: "any" | "all";
-    timeoutMs?: number | undefined;
-}>>;
-declare const tellRequestSchema: z.ZodPipe<z.ZodObject<{
-    target: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
-    body: z.ZodString;
-}, z.core.$strict>, z.ZodTransform<{
-    target: import("../akuma/identity.js").AkuId;
-    body: string;
-    action: "akuma.tell";
-}, {
-    target: import("../akuma/identity.js").AkuId;
-    body: string;
-}>>;
-declare const killRequestSchema: z.ZodPipe<z.ZodObject<{
-    targets: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>>;
-}, z.core.$strict>, z.ZodTransform<{
-    targets: import("../akuma/identity.js").AkuId[];
-    action: "akuma.kill";
-}, {
-    targets: import("../akuma/identity.js").AkuId[];
-}>>;
-declare const waitServiceSchema: z.ZodObject<{
-    action: z.ZodLiteral<"akuma.wait">;
-}, z.core.$strict>;
-declare const tellServiceSchema: z.ZodObject<{
-    action: z.ZodLiteral<"akuma.tell">;
-    target: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
-    tellId: z.ZodString;
-}, z.core.$strict>;
-declare const killServiceSchema: z.ZodObject<{
-    action: z.ZodLiteral<"akuma.kill">;
-    results: z.ZodArray<z.ZodObject<{
-        id: z.ZodPipe<z.ZodString, z.ZodTransform<import("../akuma/identity.js").AkuId, string>>;
-        evidence: z.ZodEnum<{
-            unavailable: "unavailable";
-            killed: "killed";
-            "already-killed": "already-killed";
-            "already-stopped": "already-stopped";
-            hung: "hung";
-            untidy: "untidy";
-        }>;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-type FleetRequest = (Omit<z.infer<typeof waitRequestSchema>, "targets"> & Readonly<{
-    targets: readonly AkumaStatus["id"][];
-}>) | z.infer<typeof tellRequestSchema> | (Omit<z.infer<typeof killRequestSchema>, "targets"> & Readonly<{
-    targets: readonly AkumaStatus["id"][];
-}>);
-type FleetService = z.infer<typeof waitServiceSchema> | z.infer<typeof tellServiceSchema> | (Omit<z.infer<typeof killServiceSchema>, "results"> & Readonly<{
-    results: readonly Readonly<{
-        id: AkumaStatus["id"];
-        evidence: KillEvidence;
-    }>[];
-}>);
-export type FleetRequestPort = Readonly<{
-    wait(input: Readonly<{
-        targets: readonly AkumaStatus["id"][];
-        completion: "any" | "all";
-        timeoutMs?: number;
-        signal: AbortSignal;
-    }>): Promise<AkumaWaitResult>;
-    tell(input: Readonly<{
-        target: AkumaStatus["id"];
-        body: string;
-        tellId: string;
-        recordedAt: string;
-        signal: AbortSignal;
-    }>): Promise<AkumaTellResult>;
-    kill(input: Readonly<{
-        targets: readonly AkumaStatus["id"][];
-        signal: AbortSignal;
-    }>): Promise<AkumaKillResult | Readonly<{
-        result: unknown;
-        service: readonly Readonly<{
-            id: AkumaStatus["id"];
-            evidence: KillEvidence;
-        }>[];
-    }>>;
-}>;
-type FleetExecutionContext = Readonly<{
-    id: string;
-    admittedAt: string;
-    signal: AbortSignal;
-    upstream: FleetRequestPort;
-}>;
-/** Fleet owns its Body Request payload, live result, and durable service codecs. */
-export declare function fleetRequestCommand(action: FleetRequest["action"]): RequestCommand<FleetRequest, unknown, FleetService, FleetService, FleetExecutionContext>;
-export declare function fleetRequestCommands(): Readonly<Record<"akuma.wait" | "akuma.tell" | "akuma.kill", ErasedRequestCommand>>;
 export declare function statusAkuma(input: AkumaAddressInput): Promise<AkumaObservation>;
 export declare function waitAkuma(input: AkumaWaitInput, execution?: ExecutionContext): Promise<AkumaWaitResult>;
 export declare function killAkuma(input: AkumaSetAddressInput, execution?: ExecutionContext): Promise<AkumaKillResult>;