@astrosheep/keiyaku 4.1.1 → 4.1.2

package/build/src/git/terminal-reconcile.js

@@ -0,0 +1,278 @@
+import { access } from "node:fs/promises";
+import { isKeiyakuOwnedRef, readRef, writeCommit, worktreeGitDirectory } from "./repository.js";
+import { gitObjectIdForSnapshot, mintSnapshotId } from "./identity.js";
+import { runDestroyHooks } from "./hooks.js";
+import { terminalSealExpectations as decodeTerminalSealExpectations, terminalSealSnapshots, observeTerminalWorkspace, } from "./terminal-seal.js";
+import { GitPlumbingError, runGit } from "./process.js";
+import { worktreePath } from "./workspace.js";
+const pathExists = (path) => access(path).then(() => true, () => false);
+async function removeTerminalWorktree(repository, topology, path) {
+    const registered = topology.paths.has(path);
+    if (!registered) {
+        return {
+            effect: { kind: "worktree", path, action: "unchanged" },
+            retained: await pathExists(path),
+        };
+    }
+    if (!(await pathExists(path))) {
+        await runGit(repository, ["worktree", "remove", path]);
+        topology.paths.delete(path);
+        return { effect: { kind: "worktree", path, action: "removed" }, retained: false };
+    }
+    try {
+        await runGit(repository, ["worktree", "remove", "--force", path]);
+    }
+    catch {
+        return { effect: { kind: "worktree", path, action: "unchanged" }, retained: true };
+    }
+    topology.paths.delete(path);
+    return { effect: { kind: "worktree", path, action: "removed" }, retained: false };
+}
+export async function updateRef(repository, ref, desired) {
+    const before = await readRef(repository, ref);
+    if (before === desired)
+        return { kind: "ref", name: ref, action: "unchanged", before, after: desired };
+    await runGit(repository, [
+        "update-ref",
+        "--no-deref",
+        ref,
+        gitObjectIdForSnapshot(desired),
+        before ?? "0".repeat(desired.length),
+    ]);
+    return { kind: "ref", name: ref, action: before === null ? "created" : "updated", before, after: desired };
+}
+export async function removeRef(repository, ref) {
+    const before = await readRef(repository, ref);
+    if (before === null)
+        return { kind: "ref", name: ref, action: "unchanged", before: null, after: null };
+    await runGit(repository, ["update-ref", "--no-deref", "-d", ref, before]);
+    return { kind: "ref", name: ref, action: "removed", before, after: null };
+}
+async function removeRefWithCustody(repository, ref, custodian, expectedCustodian) {
+    const before = await readRef(repository, ref);
+    if (before === null)
+        return { kind: "ref", name: ref, action: "unchanged", before: null, after: null };
+    if ((await readRef(repository, custodian)) !== expectedCustodian) {
+        return { kind: "ref", name: ref, action: "unchanged", before, after: before };
+    }
+    await runGit(repository, ["update-ref", "--stdin", "--no-deref"], [
+        "start",
+        `verify ${custodian} ${gitObjectIdForSnapshot(expectedCustodian)}`,
+        `delete ${ref} ${before}`,
+        "prepare",
+        "commit",
+        "",
+    ].join("\n"));
+    return { kind: "ref", name: ref, action: "removed", before, after: null };
+}
+function retainedRefEffect(ref, snapshot) {
+    return { kind: "ref", name: ref, action: "unchanged", before: snapshot, after: snapshot };
+}
+async function refRows(repository) {
+    const output = (await runGit(repository, ["for-each-ref", "--format=%(refname)%00%(objectname)"])).toString("utf8");
+    if (output.length === 0)
+        return [];
+    return output
+        .trimEnd()
+        .split("\n")
+        .map((row) => {
+        const [ref, oid, extra] = row.split("\0");
+        if (ref === undefined || oid === undefined || extra !== undefined)
+            throw new Error("Git ref row is malformed");
+        return { ref, oid };
+    });
+}
+async function commitIsAncestor(repository, ancestor, descendant) {
+    try {
+        await runGit(repository, ["merge-base", "--is-ancestor", gitObjectIdForSnapshot(ancestor), descendant]);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof GitPlumbingError && error.status === 1)
+            return false;
+        throw error;
+    }
+}
+async function snapshotCustodian(repository, snapshot) {
+    for (const row of await refRows(repository)) {
+        if (isKeiyakuOwnedRef(row.ref))
+            continue;
+        if (await commitIsAncestor(repository, snapshot, row.oid))
+            return { ref: row.ref, oid: mintSnapshotId(row.oid) };
+    }
+    return null;
+}
+function fromPrimaryWorktree(repository) {
+    return { ...repository, effectiveCwd: repository.primaryWorktree };
+}
+function complete(effects = [], lag = []) {
+    return { effects, lag };
+}
+function retainTerminalWorktree(path, retainedLag, { effects, lag }) {
+    effects.push({ kind: "worktree", path, action: "unchanged" });
+    lag.push(retainedLag);
+    return complete(effects, lag);
+}
+async function terminalSealExpectations(channel, state) {
+    const snapshots = terminalSealSnapshots(state);
+    const objects = await channel.readObjects(snapshots.map(gitObjectIdForSnapshot));
+    return decodeTerminalSealExpectations(state, objects);
+}
+async function removeSealedTerminalWorktree({ repository, topology, path, state, expected, hooks, retryHooks, acc, }) {
+    if (topology.paths.has(path) && (await pathExists(path))) {
+        const terminal = state.terminal;
+        if (terminal === null)
+            throw new Error(`terminal worktree cleanup received active Contract ${state.id}`);
+        const canRecover = terminal.kind === "abandoned";
+        let recovery = null;
+        const recordRecovery = async (workspace) => {
+            const snapshot = mintSnapshotId(await writeCommit({
+                repository,
+                tree: workspace.tree,
+                parent: gitObjectIdForSnapshot(recovery?.snapshot ?? workspace.head),
+                message: `${state.id}: ephemeral abandoned-workspace recovery\n\nKeiyaku-Contract: ${state.id}`,
+                actor: "Keiyaku Recovery",
+                at: terminal.at,
+            }));
+            const effect = {
+                kind: "recovery-snapshot",
+                action: "created",
+                snapshot,
+                retention: "ephemeral",
+            };
+            const existing = acc.effects.findIndex((item) => item.kind === "recovery-snapshot");
+            if (existing < 0)
+                acc.effects.push(effect);
+            else
+                acc.effects[existing] = effect;
+            return { snapshot, workspace };
+        };
+        const before = await observeTerminalWorkspace(repository, path, expected);
+        const beforeWorkspace = before.workspace;
+        const beforeHooks = before.unsealed;
+        if (beforeHooks !== null) {
+            if (!canRecover || beforeWorkspace.submodules.length > 0) {
+                return retainTerminalWorktree(path, beforeHooks, acc);
+            }
+            recovery = await recordRecovery(beforeWorkspace);
+        }
+        const hookLag = await runDestroyHooks(path, await worktreeGitDirectory(repository, path), hooks, retryHooks);
+        if (hookLag !== null)
+            return retainTerminalWorktree(path, hookLag, acc);
+        const after = await observeTerminalWorkspace(repository, path, expected);
+        const afterWorkspace = after.workspace;
+        const afterHooks = after.unsealed;
+        if (afterHooks !== null) {
+            if (!canRecover || afterWorkspace.submodules.length > 0) {
+                return retainTerminalWorktree(path, afterHooks, acc);
+            }
+        }
+        if (canRecover &&
+            (recovery === null ||
+                recovery.workspace.head !== afterWorkspace.head ||
+                recovery.workspace.tree !== afterWorkspace.tree) &&
+            (recovery !== null ||
+                beforeWorkspace.head !== afterWorkspace.head ||
+                beforeWorkspace.tree !== afterWorkspace.tree)) {
+            recovery = await recordRecovery(afterWorkspace);
+        }
+    }
+    const removal = await removeTerminalWorktree(repository, topology, path);
+    if (removal.retained)
+        return retainTerminalWorktree(path, { kind: "worktree-retained", path }, acc);
+    acc.effects.push(removal.effect);
+    return null;
+}
+async function targetCustodyForClaimedIntegration(repository, state, integration) {
+    if (state.terminal?.kind !== "claimed" || state.coordinates.target === undefined)
+        return null;
+    const target = await readRef(repository, state.coordinates.target);
+    if (target === null)
+        return null;
+    const oid = mintSnapshotId(target);
+    return (await commitIsAncestor(repository, integration, oid)) ? { ref: state.coordinates.target, oid } : null;
+}
+function sealedTree(expected, snapshot) {
+    const tree = expected.treeBySnapshot.get(snapshot);
+    if (tree === undefined)
+        throw new Error(`terminal seal tree was not resolved: ${snapshot}`);
+    return tree;
+}
+async function releaseTerminalCustody({ repository, state, resolveSeal, ref, pin, acc: { effects }, }) {
+    const [deliveryRef, candidatePin] = await Promise.all([readRef(repository, ref), readRef(repository, pin)]);
+    if (deliveryRef === null && candidatePin === null)
+        return;
+    if (state.delivery === null) {
+        const custodian = await snapshotCustodian(repository, state.coordinates.start);
+        if (deliveryRef !== null) {
+            effects.push(custodian === null
+                ? retainedRefEffect(ref, deliveryRef)
+                : await removeRefWithCustody(repository, ref, custodian.ref, custodian.oid));
+        }
+        if (candidatePin !== null)
+            effects.push(await removeRef(repository, pin));
+        return;
+    }
+    const tender = state.delivery.data.tenderSnapshot;
+    const integration = state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot;
+    const target = await targetCustodyForClaimedIntegration(repository, state, integration);
+    if (deliveryRef !== null && target !== null) {
+        if (tender === integration) {
+            effects.push(await removeRefWithCustody(repository, ref, target.ref, target.oid));
+        }
+        else {
+            const expected = await resolveSeal();
+            if (sealedTree(expected, tender) === sealedTree(expected, integration)) {
+                effects.push(await removeRefWithCustody(repository, ref, target.ref, target.oid));
+            }
+            else {
+                effects.push(retainedRefEffect(ref, deliveryRef));
+            }
+        }
+    }
+    else if (deliveryRef !== null) {
+        effects.push(retainedRefEffect(ref, deliveryRef));
+    }
+    if (candidatePin !== null) {
+        if (target !== null || (tender === integration && deliveryRef !== null)) {
+            effects.push(target !== null
+                ? await removeRefWithCustody(repository, pin, target.ref, target.oid)
+                : await removeRefWithCustody(repository, pin, ref, tender));
+        }
+        else {
+            effects.push(retainedRefEffect(pin, candidatePin));
+        }
+    }
+}
+export async function reconcileTerminalManagedWorktree({ repository, channel, hooks, retryHooks, retainTerminalWorktree, place }, state, topology, acc, { ref, pin }) {
+    const primary = fromPrimaryWorktree(repository);
+    const path = place === undefined ? undefined : worktreePath(repository, place);
+    const resolveSeal = async () => await terminalSealExpectations(channel, state);
+    if (path === undefined) {
+        if (retainTerminalWorktree === true)
+            return complete(acc.effects, acc.lag);
+        await releaseTerminalCustody({ repository: primary, state, resolveSeal, ref, pin, acc });
+        return complete(acc.effects, acc.lag);
+    }
+    const expected = await resolveSeal();
+    acc.effects.push(await updateRef(primary, ref, state.delivery?.data.tenderSnapshot ?? state.coordinates.start));
+    if (state.delivery !== null) {
+        acc.effects.push(await updateRef(primary, pin, state.currentIntegration?.snapshot ?? state.delivery.data.integration.snapshot));
+    }
+    if (retainTerminalWorktree === true)
+        return complete(acc.effects, acc.lag);
+    const retained = await removeSealedTerminalWorktree({
+        repository: primary,
+        topology,
+        path,
+        state,
+        expected,
+        hooks,
+        retryHooks,
+        acc,
+    });
+    if (retained !== null)
+        return retained;
+    await releaseTerminalCustody({ repository: primary, state, resolveSeal: async () => expected, ref, pin, acc });
+    return complete(acc.effects, acc.lag);
+}

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

@@ -0,0 +1,26 @@
+import { type ContractId } from "../core/facts/types.js";
+import { type MutationResult } from "./mutation.js";
+import { type RegionObservation } from "./region.js";
+import { Repo } from "./repo.js";
+import type { WorktreeHooks } from "./configuration.js";
+import type { RepositoryScope } from "../protocol/operations.js";
+type BindInput = Readonly<{
+    repo: Repo;
+    markdown?: unknown;
+    forkOf?: unknown;
+    task?: unknown;
+    target?: unknown;
+    workspace?: unknown;
+    actor?: unknown;
+    after?: unknown;
+    gates?: unknown;
+    hooks?: WorktreeHooks;
+}>;
+type BindResult<Handle> = Readonly<Omit<MutationResult<Handle>, "value"> & {
+    keiyaku: Handle;
+} & RegionObservation>;
+type HandleFactory<Handle> = (contractId: ContractId, scope: RepositoryScope) => Handle;
+export declare function bindKeiyaku<Handle>(input: BindInput, createHandle: HandleFactory<Handle>): Promise<BindResult<Handle>>;
+/** Internal CLI composition; not exported from the package root. */
+export declare function bindFromCli<Handle>(input: BindInput, createHandle: HandleFactory<Handle>): Promise<BindResult<Handle>>;
+export {};

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

@@ -0,0 +1,106 @@
+import { decodeContractDocument } from "../body/decode.js";
+import { contractId } from "../core/facts/types.js";
+import { withGitDecodeChannel } from "../git/read-observation.js";
+import { admitForkBindWithAppointment, prepareMarkdownBind } from "./bind.js";
+import { actorOption, normalizedGates, normalizedList, requireInput, requireMarkdown, taskOption } from "./input.js";
+import { completionInput, completeHolderMutation, completeMutation } from "./mutation.js";
+import { requireAccepted } from "./refusal.js";
+import { observeRegion } from "./region.js";
+import { scopeForRepo } from "./repo.js";
+import { worktreeHooksOption } from "./configuration.js";
+function acceptedBindResult(result, region) {
+    const { facts, head, effects, lags, settlement } = result;
+    return { facts, head, keiyaku: result.value, effects, lags, settlement, ...region };
+}
+export async function bindKeiyaku(input, createHandle) {
+    const values = requireInput(input, "Keiyaku.bind input");
+    const hooks = worktreeHooksOption(values.hooks);
+    const forkOf = values.forkOf;
+    if (forkOf !== undefined) {
+        for (const key of Object.keys(values)) {
+            if (!["repo", "forkOf", "target", "workspace", "actor", "hooks"].includes(key)) {
+                throw new TypeError(`fork bind input has unknown field: ${key}`);
+            }
+        }
+        if (typeof forkOf !== "string")
+            throw new TypeError("forkOf must be a ContractId");
+        let sourceId;
+        try {
+            sourceId = contractId(forkOf);
+        }
+        catch (error) {
+            throw new TypeError(error instanceof Error ? error.message : "forkOf must be a ContractId");
+        }
+        const sourceScope = scopeForRepo(values.repo);
+        if ((values.workspace ?? "worktree") !== "worktree")
+            throw new TypeError("workspace must be worktree");
+        const target = values.target;
+        if (target !== undefined && typeof target !== "string")
+            throw new TypeError("target must be a string");
+        const actor = actorOption(values.actor);
+        return withGitDecodeChannel(sourceScope, async (channel) => {
+            const fork = await admitForkBindWithAppointment({
+                scope: sourceScope,
+                channel,
+                sourceId,
+                ...(target === undefined ? {} : { target }),
+                ...actor,
+            });
+            const admission = requireAccepted(fork.admission);
+            const id = admission.value.contractId;
+            const toHandle = ({ contractId: contract }) => createHandle(contract, sourceScope);
+            const result = await completeMutation({
+                ...completionInput(sourceScope, channel, id, toHandle, hooks),
+                accepted: admission,
+            });
+            return acceptedBindResult(result, await observeRegion(sourceScope, channel, id, fork.document.region));
+        });
+    }
+    return bindMarkdownFromValues(values, "targetless", createHandle);
+}
+/** Internal CLI composition; not exported from the package root. */
+export async function bindFromCli(input, createHandle) {
+    const values = requireInput(input, "Keiyaku.bind input");
+    return values.forkOf !== undefined
+        ? bindKeiyaku(input, createHandle)
+        : bindMarkdownFromValues(values, "current-branch", createHandle);
+}
+async function bindMarkdownFromValues(values, omittedTarget, createHandle) {
+    const hooks = worktreeHooksOption(values.hooks);
+    const scope = scopeForRepo(values.repo);
+    const task = taskOption(values.task);
+    const document = decodeContractDocument(requireMarkdown(values.markdown));
+    if ((values.workspace ?? "worktree") !== "worktree")
+        throw new TypeError("workspace must be worktree");
+    const target = values.target;
+    if (target !== undefined && typeof target !== "string")
+        throw new TypeError("target must be a string");
+    const actor = actorOption(values.actor);
+    const gates = normalizedGates(values.gates);
+    const after = normalizedList(values.after, "after", contractId);
+    const targetSelection = target !== undefined ? { kind: "explicit", target } : { kind: omittedTarget };
+    return withGitDecodeChannel(scope, async (channel) => {
+        const admission = await prepareMarkdownBind({
+            scope,
+            channel,
+            document,
+            gates,
+            after,
+            workspace: "worktree",
+            targetSelection,
+            ...(task === undefined ? {} : { task }),
+            ...actor,
+        });
+        const accepted = requireAccepted(admission.admission === null ? admission.result : admission.admission.result);
+        const id = accepted.value.contractId;
+        const toHandle = ({ contractId: contract }) => createHandle(contract, scope);
+        const result = admission.admission === null
+            ? await completeMutation({ ...completionInput(scope, channel, id, toHandle, hooks), accepted })
+            : await completeHolderMutation({
+                completion: completionInput(scope, channel, id, toHandle, hooks),
+                admission: admission.admission,
+                requireAccepted,
+            });
+        return acceptedBindResult(result, await observeRegion(scope, channel, id, document.region));
+    });
+}

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

@@ -0,0 +1,77 @@
+import { type RepositoryScope } from "../protocol/operations.js";
+import { type IntegrationConflictMaterialized } from "../protocol/deliver.js";
+import { type ReviewValue } from "../protocol/review.js";
+import { type ContinuationReport } from "./continuation.js";
+import { type MutationResult } from "./mutation.js";
+import { type KeiyakuRefusal, type KeiyakuRetryReason } from "./refusal.js";
+import { actorOption } from "./input.js";
+import { type WorktreeHooks } from "./configuration.js";
+import { Repo } from "./repo.js";
+import { type ContractId } from "../core/facts/types.js";
+import type { UpstreamRequestOutcome } from "../akuma/requests.js";
+import type { DeliveryValue } from "./delivery.js";
+export type DeliveryExecutionInput = Readonly<{
+    scope: RepositoryScope;
+    contractId: ContractId;
+    actor?: ReturnType<typeof actorOption>["actor"];
+    message?: string;
+    requireBranchesToBeUpToDate: boolean;
+    includeDirty: boolean;
+    materializeConflict: boolean;
+    signal?: AbortSignal;
+    hooks: WorktreeHooks;
+}>;
+export type ReviewExecutionInput = Readonly<{
+    scope: RepositoryScope;
+    contractId: ContractId;
+    actor?: ReturnType<typeof actorOption>["actor"];
+    verdict: AttestationVerdict;
+    summary?: string;
+    hooks: WorktreeHooks;
+}>;
+export type AttestationVerdict = "satisfied" | "unsatisfied";
+export type Review = ReviewValue & Readonly<{
+    continuation?: ContinuationReport;
+}>;
+export type ForwardedMutationReceipt<Value> = Readonly<{
+    kind: "accepted";
+    result: MutationResult<Value>;
+}> | Readonly<{
+    kind: "refused";
+    refusal: KeiyakuRefusal;
+}> | Readonly<{
+    kind: "retry";
+    reason: KeiyakuRetryReason;
+}>;
+export type ForwardedDeliveryReceipt = ForwardedMutationReceipt<DeliveryValue> | IntegrationConflictMaterialized;
+export type ForwardedReviewReceipt = ForwardedMutationReceipt<Review>;
+export declare function executeLocalDelivery(input: DeliveryExecutionInput): Promise<MutationResult<DeliveryValue> | IntegrationConflictMaterialized>;
+export declare function executeLocalReview(input: ReviewExecutionInput): Promise<MutationResult<Review>>;
+export declare function forwardedReceipt<Receipt>(outcome: UpstreamRequestOutcome, action: string): Receipt;
+export declare function requireForwarded(receipt: ForwardedDeliveryReceipt): MutationResult<DeliveryValue> | IntegrationConflictMaterialized;
+export declare function requireForwarded(receipt: ForwardedReviewReceipt): MutationResult<Review>;
+export declare function executeForwardedDeliver(input: Readonly<{
+    repo: Repo;
+    contractId: string;
+    requester: string;
+    message?: string;
+    includeDirty: boolean;
+    materializeConflict: boolean;
+    requireBranchesToBeUpToDate: boolean;
+    hooks: WorktreeHooks;
+    signal?: AbortSignal;
+}>): Promise<Readonly<{
+    result: ForwardedDeliveryReceipt;
+    deliveryFactId?: string;
+}>>;
+export declare function executeForwardedReview(input: Readonly<{
+    repo: Repo;
+    contractId: string;
+    requester: string;
+    verdict: AttestationVerdict;
+    summary?: string;
+    hooks: WorktreeHooks;
+}>): Promise<Readonly<{
+    result: ForwardedReviewReceipt;
+    reviewFactId?: string;
+}>>;

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

@@ -0,0 +1,130 @@
+import { decodeContractDocument } from "../body/decode.js";
+import { deliverOperation } from "../protocol/deliver.js";
+import { reviewOperation } from "../protocol/review.js";
+import { continueAcceptedCompletion } from "./continuation.js";
+import { completionInput, completeMutation } from "./mutation.js";
+import { forwardedMutationFailure, KeiyakuRefused, KeiyakuRetry, requireAccepted, } from "./refusal.js";
+import { actorOption, documentDerivation, optionalNonblank } from "./input.js";
+import { scopeForRepo } from "./repo.js";
+import { contractId } from "../core/facts/types.js";
+import { withGitDecodeChannel } from "../git/read-observation.js";
+function derivedDocument(state) {
+    return documentDerivation(decodeContractDocument(state.terms.document.bytes), state.terms.gates, state.id);
+}
+function operationContext(scope, channel, contractId) {
+    return { scope, channel, contractId, deriveDocument: derivedDocument };
+}
+export async function executeLocalDelivery(input) {
+    return withGitDecodeChannel(input.scope, async (channel) => {
+        const operation = operationContext(input.scope, channel, input.contractId);
+        const outcome = await deliverOperation({
+            ...operation,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            ...(input.message === undefined ? {} : { message: input.message }),
+            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
+            includeDirty: input.includeDirty,
+            materializeConflict: input.materializeConflict,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+        });
+        if (outcome.kind === "integration-conflict-materialized")
+            return outcome;
+        const accepted = requireAccepted(outcome);
+        const continued = await continueAcceptedCompletion({
+            ...operation,
+            accepted,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+        });
+        return completeMutation({
+            ...completionInput(input.scope, channel, input.contractId, (delivery) => delivery, input.hooks),
+            accepted: continued,
+        });
+    });
+}
+export async function executeLocalReview(input) {
+    return withGitDecodeChannel(input.scope, async (channel) => {
+        const operation = operationContext(input.scope, channel, input.contractId);
+        const accepted = requireAccepted(await reviewOperation({
+            ...operation,
+            verdict: input.verdict,
+            ...(input.summary === undefined ? {} : { summary: input.summary }),
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+        }));
+        const continued = await continueAcceptedCompletion({
+            ...operation,
+            accepted,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+        });
+        return completeMutation({
+            ...completionInput(input.scope, channel, input.contractId, (review) => review, input.hooks),
+            accepted: continued,
+        });
+    });
+}
+export function forwardedReceipt(outcome, action) {
+    if (outcome.kind === "failed") {
+        throw new Error(outcome.failure.kind === "failed"
+            ? outcome.failure.diagnostic
+            : `Unexpected Akuma target failure for ${action}: ${outcome.failure.id}`);
+    }
+    return outcome.result;
+}
+export function requireForwarded(receipt) {
+    if (receipt.kind === "refused")
+        throw new KeiyakuRefused(receipt.refusal);
+    if (receipt.kind === "retry")
+        throw new KeiyakuRetry(receipt.reason);
+    return receipt.kind === "accepted" ? receipt.result : receipt;
+}
+export async function executeForwardedDeliver(input) {
+    const id = contractId(input.contractId);
+    const actor = actorOption(input.requester).actor;
+    const message = optionalNonblank(input.message, "deliver message");
+    try {
+        const result = await executeLocalDelivery({
+            scope: scopeForRepo(input.repo),
+            contractId: id,
+            ...(actor === undefined ? {} : { actor }),
+            ...(message === undefined ? {} : { message }),
+            requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
+            includeDirty: input.includeDirty,
+            materializeConflict: input.materializeConflict,
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            hooks: input.hooks,
+        });
+        if (!("facts" in result))
+            return { result };
+        const delivery = result.facts.find((fact) => fact.kind === "deliver");
+        if (delivery === undefined)
+            throw new Error("accepted delivery is missing its journal fact");
+        return { result: { kind: "accepted", result }, deliveryFactId: delivery.entry };
+    }
+    catch (error) {
+        return forwardedMutationFailure(error);
+    }
+}
+export async function executeForwardedReview(input) {
+    const id = contractId(input.contractId);
+    const actor = actorOption(input.requester).actor;
+    if (input.verdict !== "satisfied" && input.verdict !== "unsatisfied") {
+        throw new TypeError("verdict must be satisfied or unsatisfied");
+    }
+    const summary = optionalNonblank(input.summary, "review summary");
+    try {
+        const result = await executeLocalReview({
+            scope: scopeForRepo(input.repo),
+            contractId: id,
+            ...(actor === undefined ? {} : { actor }),
+            verdict: input.verdict,
+            ...(summary === undefined ? {} : { summary }),
+            hooks: input.hooks,
+        });
+        const review = result.facts.find((fact) => fact.kind === "attestation");
+        if (review === undefined)
+            throw new Error("accepted review is missing its journal fact");
+        return { result: { kind: "accepted", result }, reviewFactId: review.entry };
+    }
+    catch (error) {
+        return forwardedMutationFailure(error);
+    }
+}