@astrosheep/keiyaku 4.5.7 → 4.5.9

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

@@ -6,7 +6,9 @@ export declare function actorOption(actor: unknown): Readonly<{
     actor?: ActorId;
 }>;
 export declare function requireMarkdown(value: unknown, label?: string): string;
-export declare function requireInput(value: unknown, label: string): Record<string, unknown>;
+export declare function requireInput(value: unknown, label: string, allowed?: readonly string[]): Record<string, unknown>;
+/** Shared public-input failure path for operation owners. */
+export declare function invalidInput(message: string): never;
 export declare function taskOption(value: unknown): TaskId | undefined;
 export declare function optionalNonblank(value: unknown, label: string): string | undefined;
 export declare function optionalBoolean(value: unknown, label: string): boolean | undefined;

package/build/src/library/input.js

@@ -18,11 +18,21 @@ export function requireMarkdown(value, label = "markdown") {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-export function requireInput(value, label) {
+export function requireInput(value, label, allowed) {
     if (!isRecord(value))
         throw new TypeError(`${label} must be an object`);
+    if (allowed !== undefined) {
+        for (const key of Object.keys(value)) {
+            if (!allowed.includes(key))
+                throw new TypeError(`${label} has unknown field: ${key}`);
+        }
+    }
     return value;
 }
+/** Shared public-input failure path for operation owners. */
+export function invalidInput(message) {
+    throw new TypeError(message);
+}
 export function taskOption(value) {
     if (value === undefined)
         return undefined;

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

@@ -1,13 +1,14 @@
-import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku, type Keiyaku as KeiyakuType } from "./contract.js";
-import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
-import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma } from "./fleet.js";
-import { listCatalog } from "./catalog.js";
-import { nukeKeiyaku } from "./nuke.js";
+import { type Keiyaku as KeiyakuType, type LocalContractComposition } from "./contract.js";
+import { composeLibrary } from "./composition.js";
+import { type LibraryExecution } from "../akuma/requests.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { Delivery, KeiyakuRefused, KeiyakuRetry } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./configuration.js";
 export { AkumaWorldScopeError } from "./address.js";
+export { bodyRequestExecution } from "../akuma/requests.js";
+export type { LibraryExecution } from "../akuma/requests.js";
+export type { LocalContractComposition } from "./contract.js";
 export type { AbandonInput, ActorId, AmendInput, AmendResult, ArcInput, AttestationVerdict, AuditInput, AuditReport, DeliveryPreparationRefusal, BindInput, BindResult, AfterEndpointObservation, ContractAfterEdge, ContractBoard, ContractDependent, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractHistory, ContractHistoryEvent, ContractListInput, ContractObservation, ContractObservationInput, ContractPhase, ContractRow, ContractWorkspaceObservation, ContinuationReport, DeliverInput, Fact, IntegrationConflictMaterialized, FactKind, KeiyakuOfInput, KeiyakuRefusal, KeiyakuRetryReason, Lag, MutationResult, PlacementStop, ReconcileReport, Review, ReviewInput, TaskId, TopologyEffect, VerificationReuse, VerificationStop, } from "./contract.js";
 export type { ContractId, ContractState, ChangeId, SnapshotId } from "../core/facts/types.js";
 export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
@@ -28,21 +29,388 @@ export type { NukeConfirmationRefusal, NukeConfirmationRequiredRefusal } from ".
 export type { AkumaAddressInput, AkumaSetAddressInput, AkumaWorldScopeRefusal, DirectAkumaSelector, SetAkumaSelector, } from "./address.js";
 export type { AkumaHistoryInput, AkumaHistoryResult, AkumaInterruptInput, AkumaInterruptResult, AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellInput, AkumaUnobserved, CreatedTaskObservation, DispatchAssociation, AkumaTellResult, AkumaWaitInput, AkumaWaitResult, } from "./fleet.js";
 export type Keiyaku = KeiyakuType;
+export type KeiyakuLibrary = ReturnType<typeof composeLibrary>;
+declare function routedLibrary(input: Readonly<{
+    execution: LibraryExecution;
+}>): KeiyakuLibrary;
+declare function localLibrary(input?: LocalContractComposition): KeiyakuLibrary;
 export declare const Keiyaku: Readonly<{
-    prototype: KeiyakuHandle;
+    withExecution: typeof routedLibrary;
+    withLocal: typeof localLibrary;
+    prototype: import("./contract-handle.js").KeiyakuHandle;
     [Symbol.hasInstance]: (value: unknown) => boolean;
-    bind: typeof bindKeiyaku;
-    call: typeof callKeiyaku;
-    fork: typeof forkKeiyaku;
-    history: typeof historyAkuma;
-    interrupt: typeof interruptAkuma;
-    kill: typeof killAkuma;
-    ls: typeof listCatalog;
-    nuke: typeof nukeKeiyaku;
-    list: typeof listKeiyaku;
-    observe: typeof observeKeiyaku;
-    of: typeof keiyakuOf;
-    status: typeof statusAkuma;
-    tell: typeof tellAkuma;
-    wait: typeof waitAkuma;
+    bind: (input: Parameters<typeof import("./contract.js").bindKeiyaku>[0]) => Promise<import("./contract-types.js").BindResult>;
+    call: (input: Parameters<typeof import("./akuma-creation.js").callKeiyaku>[0]) => Promise<Readonly<{
+        kind: "called";
+        akuma: import("../akuma/identity.js").AkuId;
+        readonly?: import("../akuma/provider-recipe.js").ReadonlyRestraint;
+        execution: Readonly<{
+            cwd: string;
+            source: "input" | "contract-worktree" | "caller" | "process" | "world";
+        }>;
+        dispatch: import("./akuma-creation.js").DispatchStage;
+        alias: import("./akuma-creation.js").AliasStage;
+        observation: import("./akuma-creation.js").CallObservation;
+    }>>;
+    fork: typeof import("./akuma-creation.js").forkKeiyaku;
+    history: typeof import("./fleet.js").historyAkuma;
+    interrupt: typeof import("./fleet.js").interruptAkuma;
+    kill: (input: Parameters<typeof import("./fleet.js").killAkuma>[0]) => Promise<{
+        results: {
+            id: import("../akuma/identity.js").AkuId;
+            evidence: "unavailable" | "killed" | "already-killed" | "already-stopped" | "hung" | "untidy";
+        }[];
+    }>;
+    ls: typeof import("./catalog.js").listCatalog;
+    nuke: typeof import("./nuke.js").nukeKeiyaku;
+    list: typeof import("./contract.js").listKeiyaku;
+    observe: typeof import("./contract.js").observeKeiyaku;
+    of: (input: Parameters<typeof import("./contract.js").keiyakuOf>[0]) => import("./contract-handle.js").KeiyakuHandle;
+    status: typeof import("./fleet.js").statusAkuma;
+    tell: (input: Parameters<typeof import("./fleet.js").tellAkuma>[0]) => Promise<{
+        akuma: import("../akuma/identity.js").AkuId;
+        tell: {
+            admission: {
+                fact: "recorded";
+                tellId: string;
+            };
+            row: {
+                kind: "tell";
+                sequence: number;
+                at: string;
+                tellId: string;
+                text: string;
+                state: "pending" | "told";
+                deliveries: readonly Readonly<{
+                    turnSequence: number;
+                    route: "launch" | "live";
+                    receipt?: "unavailable" | "required";
+                    deliveredAt: string;
+                }>[];
+            };
+            wake: {
+                kind: "failed";
+                diagnostic: string;
+            } | {
+                child: {
+                    code: number | null;
+                    signal: string | null;
+                    log: {
+                        path: string;
+                        from: number;
+                        to: number;
+                    };
+                };
+                kind: "failed";
+                diagnostic: string;
+            } | {
+                kind: "told";
+            } | {
+                kind: "held";
+            } | {
+                kind: "pursuing";
+                bodySequence: number;
+            };
+        };
+    }>;
+    wait: (input: Parameters<typeof import("./fleet.js").waitAkuma>[0]) => Promise<{
+        completion: "any" | "all";
+        observations: {
+            status: {
+                id: import("../akuma/identity.js").AkuId;
+                life: "killed" | "hung" | "untidy" | "running" | "asleep" | "stranded";
+                timeline: {
+                    reportedChanges: readonly {
+                        sequence: number;
+                        at: string;
+                        op: "add" | "update" | "delete" | "unspecified";
+                        path: string;
+                        diffstat?: {
+                            added: number;
+                            removed: number;
+                        } | undefined;
+                    }[];
+                    reportedChangesOmitted: number;
+                    kind: "unborn";
+                    entries: readonly never[];
+                    omitted: 0;
+                } | {
+                    reportedChanges: readonly {
+                        sequence: number;
+                        at: string;
+                        op: "add" | "update" | "delete" | "unspecified";
+                        path: string;
+                        diffstat?: {
+                            added: number;
+                            removed: number;
+                        } | undefined;
+                    }[];
+                    reportedChangesOmitted: number;
+                    kind: "open";
+                    turn: {
+                        kind: "turn";
+                        sequence: number;
+                        turnSequence: number;
+                        bodySequence: number;
+                        at: string;
+                    };
+                    entries: readonly ({
+                        kind: "gap";
+                        count: number;
+                    } | {
+                        kind: "row";
+                        row: {
+                            kind: "tell";
+                            sequence: number;
+                            at: string;
+                            tellId: string;
+                            text: string;
+                            state: "pending" | "told";
+                            deliveries: readonly Readonly<{
+                                turnSequence: number;
+                                route: "launch" | "live";
+                                receipt?: "unavailable" | "required";
+                                deliveredAt: string;
+                            }>[];
+                        } | {
+                            kind: "call";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                        } | {
+                            kind: "note" | "thought" | "said";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                            truncated?: true | undefined;
+                        } | {
+                            kind: "tool";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            name: string;
+                            call: {
+                                kind: "run";
+                                command: string;
+                            } | {
+                                kind: "read";
+                                path: string;
+                                offset?: number | undefined;
+                                limit?: number | undefined;
+                            } | {
+                                kind: "search";
+                                query: string;
+                                scope?: "content" | "files" | "web" | undefined;
+                                path?: string | undefined;
+                                glob?: string | undefined;
+                            } | {
+                                kind: "fileChange";
+                                changes: readonly {
+                                    op: "add" | "update" | "delete" | "unspecified";
+                                    path: string;
+                                    diffstat?: {
+                                        added: number;
+                                        removed: number;
+                                    } | undefined;
+                                }[];
+                            } | {
+                                kind: "other";
+                                display: string;
+                            };
+                            state: "active";
+                            truncated?: true | undefined;
+                        } | {
+                            kind: "tool";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            name: string;
+                            call: {
+                                kind: "run";
+                                command: string;
+                            } | {
+                                kind: "read";
+                                path: string;
+                                offset?: number | undefined;
+                                limit?: number | undefined;
+                            } | {
+                                kind: "search";
+                                query: string;
+                                scope?: "content" | "files" | "web" | undefined;
+                                path?: string | undefined;
+                                glob?: string | undefined;
+                            } | {
+                                kind: "fileChange";
+                                changes: readonly {
+                                    op: "add" | "update" | "delete" | "unspecified";
+                                    path: string;
+                                    diffstat?: {
+                                        added: number;
+                                        removed: number;
+                                    } | undefined;
+                                }[];
+                            } | {
+                                kind: "other";
+                                display: string;
+                            };
+                            state: {
+                                status: "error" | "ok";
+                                message?: string | undefined;
+                                exitCode?: number | undefined;
+                            };
+                            completedAt?: string | undefined;
+                            durationMs?: number | undefined;
+                            truncated?: true | undefined;
+                        };
+                    })[];
+                    omitted: number;
+                } | {
+                    reportedChanges: readonly {
+                        sequence: number;
+                        at: string;
+                        op: "add" | "update" | "delete" | "unspecified";
+                        path: string;
+                        diffstat?: {
+                            added: number;
+                            removed: number;
+                        } | undefined;
+                    }[];
+                    reportedChangesOmitted: number;
+                    kind: "idle";
+                    entries: readonly ({
+                        kind: "gap";
+                        count: number;
+                    } | {
+                        kind: "row";
+                        row: {
+                            kind: "tell";
+                            sequence: number;
+                            at: string;
+                            tellId: string;
+                            text: string;
+                            state: "pending" | "told";
+                            deliveries: readonly Readonly<{
+                                turnSequence: number;
+                                route: "launch" | "live";
+                                receipt?: "unavailable" | "required";
+                                deliveredAt: string;
+                            }>[];
+                        } | {
+                            kind: "call";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                        } | {
+                            kind: "note" | "thought" | "said";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            text: string;
+                            truncated?: true | undefined;
+                        } | {
+                            kind: "tool";
+                            sequence: number;
+                            turnSequence: number;
+                            at: string;
+                            name: string;
+                            call: {
+                                kind: "run";
+                                command: string;
+                            } | {
+                                kind: "read";
+                                path: string;
+                                offset?: number | undefined;
+                                limit?: number | undefined;
+                            } | {
+                                kind: "search";
+                                query: string;
+                                scope?: "content" | "files" | "web" | undefined;
+                                path?: string | undefined;
+                                glob?: string | undefined;
+                            } | {
+                                kind: "fileChange";
+                                changes: readonly {
+                                    op: "add" | "update" | "delete" | "unspecified";
+                                    path: string;
+                                    diffstat?: {
+                                        added: number;
+                                        removed: number;
+                                    } | undefined;
+                                }[];
+                            } | {
+                                kind: "other";
+                                display: string;
+                            };
+                            state: {
+                                status: "error" | "ok";
+                                message?: string | undefined;
+                                exitCode?: number | undefined;
+                            };
+                            completedAt?: string | undefined;
+                            durationMs?: number | undefined;
+                            truncated?: true | undefined;
+                        };
+                    })[];
+                    omitted: number;
+                    outcome?: {
+                        kind: "outcome";
+                        sequence: number;
+                        turnSequence: number;
+                        at: string;
+                        outcome: {
+                            kind: "answered";
+                            historyId: string;
+                            answer: string;
+                        } | {
+                            kind: "failed";
+                            historyId: string;
+                            diagnostic: string;
+                        };
+                    } | undefined;
+                };
+                readonly?: {
+                    enforcement: "native";
+                } | {
+                    enforcement: "none";
+                    diagnostic: string;
+                } | undefined;
+                strandedReason?: "resume-unsupported" | undefined;
+            };
+            contract: {
+                kind: "none";
+            } | {
+                kind: "associated";
+                contractId: import("./contract.js").ContractId;
+            } | {
+                kind: "failed";
+                diagnostic: string;
+            };
+            createdTasks: {
+                kind: "present";
+                rows: readonly {
+                    id: `task/${string}`;
+                    title: string;
+                    state: "open" | "in_progress" | "on_hold" | "done" | "drop";
+                    priority: 0 | 1 | 2 | 3;
+                    disposition: "in_progress" | "on_hold" | "done" | "drop" | "ready" | "blocked";
+                    updatedAt: string;
+                    bodyPresent: boolean;
+                    children?: {
+                        live: number;
+                        total: number;
+                    } | undefined;
+                }[];
+            } | {
+                kind: "failed";
+                diagnostic: string;
+            };
+        }[];
+        unobserved: {
+            id: import("../akuma/identity.js").AkuId;
+            diagnostic: string;
+        }[];
+    }>;
 }>;

package/build/src/library/keiyaku.js

@@ -1,28 +1,20 @@
-import { KeiyakuHandle, bindKeiyaku, keiyakuOf, listKeiyaku, observeKeiyaku, } from "./contract.js";
-import { callKeiyaku, forkKeiyaku } from "./akuma-creation.js";
-import { historyAkuma, interruptAkuma, killAkuma, statusAkuma, tellAkuma, waitAkuma } from "./fleet.js";
-import { listCatalog } from "./catalog.js";
-import { nukeKeiyaku } from "./nuke.js";
+import { captureLocalContractComposition, } from "./contract.js";
+import { composeLibrary } from "./composition.js";
+import { libraryExecutionInput, localExecutionContext } from "../akuma/requests.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 export { Delivery, KeiyakuRefused, KeiyakuRetry } from "./contract.js";
 export { NoGitWorldError, Repo } from "./repo.js";
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError, worktreeHooksFrom } from "./configuration.js";
 export { AkumaWorldScopeError } from "./address.js";
+export { bodyRequestExecution } from "../akuma/requests.js";
+function routedLibrary(input) {
+    return composeLibrary(libraryExecutionInput(input));
+}
+function localLibrary(input) {
+    return composeLibrary(localExecutionContext(), captureLocalContractComposition(input));
+}
 export const Keiyaku = Object.freeze({
-    prototype: KeiyakuHandle.prototype,
-    [Symbol.hasInstance]: (value) => value instanceof KeiyakuHandle,
-    bind: bindKeiyaku,
-    call: callKeiyaku,
-    fork: forkKeiyaku,
-    history: historyAkuma,
-    interrupt: interruptAkuma,
-    kill: killAkuma,
-    ls: listCatalog,
-    nuke: nukeKeiyaku,
-    list: listKeiyaku,
-    observe: observeKeiyaku,
-    of: keiyakuOf,
-    status: statusAkuma,
-    tell: tellAkuma,
-    wait: waitAkuma,
+    ...composeLibrary(),
+    withExecution: routedLibrary,
+    withLocal: localLibrary,
 });

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

@@ -1,4 +1,4 @@
-import type { ContractHead, ContractId, JournalEntry } from "../core/facts/types.js";
+import type { ContractHead, ContractId, JournalEntry, SnapshotId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import type { ReconcileReport } from "../protocol/reconcile.js";
 import type { RepositoryScope } from "../protocol/operations.js";
@@ -19,9 +19,9 @@ export type MutationResult<Value> = Readonly<{
     facts: readonly JournalEntry[];
     head: ContractHead;
     value: Value;
-    effects: ReconcileCompletion["effects"];
     lags: ReconcileCompletion["lag"];
-    settlement: SettlementReport;
+    settlementLags: SettlementReport["lags"];
+    recoverySnapshot?: SnapshotId;
 } & AcceptedObligations>;
 type Completion<Value, PublicValue> = Readonly<{
     scope: RepositoryScope;

package/build/src/library/mutation.js

@@ -14,16 +14,15 @@ export async function completeMutation(input) {
         ...(accepted.cleanup === undefined ? {} : { cleanup: accepted.cleanup }),
         ...(accepted.leak === undefined ? {} : { leak: accepted.leak }),
     };
+    const effects = [...(accepted.physical?.effects ?? []), ...reports.flatMap((report) => report.effects)];
+    const recoverySnapshot = effects.findLast((effect) => effect.kind === "recovery-snapshot")?.snapshot;
     return {
         facts: accepted.facts,
         head: accepted.head,
         value: value(accepted.value),
-        effects: [...(accepted.physical?.effects ?? []), ...reports.flatMap((report) => report.effects)],
         lags: [...(accepted.physical?.lag ?? []), ...reports.flatMap((report) => report.lag)],
-        settlement: {
-            actions: reports.flatMap((report) => report.settlement.actions),
-            lags: reports.flatMap((report) => report.settlement.lags),
-        },
+        settlementLags: reports.flatMap((report) => report.settlement.lags),
+        ...(recoverySnapshot === undefined ? {} : { recoverySnapshot }),
         ...obligations,
     };
 }
@@ -39,9 +38,6 @@ export async function completeHolderMutation(input) {
     });
     return {
         ...completed,
-        settlement: {
-            actions: completed.settlement.actions,
-            lags: [...completed.settlement.lags, ...deferred.lags],
-        },
+        settlementLags: [...completed.settlementLags, ...deferred.lags],
     };
 }

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

@@ -1,4 +1,4 @@
-import type { WorldRoot } from "../world.js";
+import { type WorldRoot } from "../world.js";
 export type NukeInput = Readonly<{
     world: WorldRoot;
     confirm?: string;

package/build/src/library/nuke.js

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import { stopAkuma } from "../akuma/nuke.js";
 import { nukeGit } from "../git/nuke.js";
 import { nukeTask } from "../task/operations.js";
+import { World } from "../world.js";
 import { KeiyakuRefused } from "./refusal.js";
 import { requireInput, requireMarkdown } from "./input.js";
 function diagnostic(error) {
@@ -18,14 +19,14 @@ async function removeEmptyWorldMarker(world) {
             throw error;
     }
 }
-function nukeInput(input) {
+async function nukeInput(input) {
     const value = requireInput(input, "nuke input");
-    const world = requireMarkdown(value.world, "world");
+    const world = await World.prove(requireMarkdown(value.world, "world"));
     const confirm = value.confirm === undefined ? undefined : requireMarkdown(value.confirm, "confirm");
     return { world, ...(confirm === undefined ? {} : { confirm }) };
 }
 export async function nukeKeiyaku(input) {
-    const value = nukeInput(input);
+    const value = await nukeInput(input);
     if (value.confirm === undefined) {
         throw new KeiyakuRefused({ kind: "nuke-confirmation-required", world: value.world });
     }

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

@@ -9,6 +9,10 @@ export type ReconcileCompletion = Readonly<{
     effects: readonly (ReconcileReport["effects"][number] | ContractFileEffect)[];
     lag: readonly (ReconcileReport["lag"][number] | ContractFileLag)[];
     settlement: SettlementReport;
+    hookRuns?: readonly {
+        phase: "create" | "destroy";
+        name: string;
+    }[];
 }>;
 export type RepoContractReconcileReport = ReconcileCompletion;
 type RepoReconcileContracts = readonly Readonly<{

package/build/src/library/reconcile.js

@@ -97,6 +97,7 @@ export async function completeReconcile(input) {
     const release = releaseEligible(retained.state, cleanup?.report, appointment.place !== undefined)
         ? await releaseAppointments(input.scope, [input.contractId])
         : undefined;
+    const hookRuns = [...(retained.report.hookRuns ?? []), ...(cleanup?.report.hookRuns ?? [])];
     return {
         effects: [...retained.report.effects, ...projection.effects, ...(cleanup?.report.effects ?? [])],
         lag: [
@@ -106,6 +107,7 @@ export async function completeReconcile(input) {
             ...(release === undefined ? [] : [release]),
         ],
         settlement,
+        ...(hookRuns.length === 0 ? {} : { hookRuns }),
     };
 }
 function attachReleaseLag(contracts, released, lag) {

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

@@ -27,12 +27,3 @@ export declare class KeiyakuRetry extends Error {
     get code(): KeiyakuRetryReason["kind"];
 }
 export declare function requireAccepted<Value, Refusal extends KeiyakuRefusal>(result: IntentOutcome<Value, Refusal>): AcceptedIntent<Value>;
-export declare function forwardedMutationFailure(error: unknown): Readonly<{
-    result: Readonly<{
-        kind: "refused";
-        refusal: KeiyakuRefusal;
-    } | {
-        kind: "retry";
-        reason: KeiyakuRetryReason;
-    }>;
-}>;

package/build/src/library/refusal.js

@@ -27,10 +27,3 @@ export function requireAccepted(result) {
         throw new KeiyakuRetry(result.reason);
     return result;
 }
-export function forwardedMutationFailure(error) {
-    if (error instanceof KeiyakuRefused)
-        return { result: { kind: "refused", refusal: error.refusal } };
-    if (error instanceof KeiyakuRetry)
-        return { result: { kind: "retry", reason: error.reason } };
-    throw error;
-}