@astrosheep/keiyaku 4.1.0 → 4.1.2

package/build/src/library/bind.js

@@ -1,9 +1,13 @@
 import { randomBytes } from "node:crypto";
-import { releaseContractWorktree, reserveContractWorktree, withContractWorktreeAppointment, } from "../contract-worktree.js";
+import { decodeContractDocument } from "../body/decode.js";
 import { contractIdFromSegment } from "../core/facts/types.js";
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { fitIdentityStem, normalizeIdentityStem } from "../identity/normalize.js";
 import { bindOperation } from "../protocol/bind.js";
-import { claimTaskHolder } from "../settlement/holder.js";
+import { stateOperation } from "../protocol/operations.js";
+import { claimTaskHolder, claimTaskHolderWithFence } from "../settlement/holder.js";
+import { KeiyakuRefused } from "./refusal.js";
+import { contractTerms, documentDerivation } from "./input.js";
 function candidateId(title, collision) {
     const stem = fitIdentityStem({ stem: normalizeIdentityStem({ source: title }) || "contract", maxBytes: 48 });
     const suffix = collision === 0 ? "" : `-${randomBytes(8).toString("hex")}`;
@@ -16,11 +20,15 @@ async function attempt(input, id) {
         terms: input.terms,
         verification: input.verification,
         workspace: input.workspace,
+        ...(input.coordinates === undefined ? {} : { coordinates: input.coordinates }),
+        ...(input.source === undefined ? {} : { source: input.source }),
         contractId: id,
-        ...(input.target === undefined ? {} : { target: input.target }),
-        ...(input.task === undefined ? {} : {
-            decorateOffer: ({ contractId: owner }) => [claimTaskHolder(input.task, owner)],
-        }),
+        ...(input.targetSelection === undefined ? {} : { targetSelection: input.targetSelection }),
+        ...(input.task === undefined
+            ? {}
+            : {
+                decorateOffer: ({ contractId: owner }) => [claimTaskHolder(input.task, owner)],
+            }),
         ...(input.actor === undefined ? {} : { actor: input.actor }),
     });
 }
@@ -28,29 +36,97 @@ async function attemptCandidates(input) {
     let result;
     for (let collision = 0; collision <= 3; collision += 1) {
         const id = candidateId(input.title, collision);
-        let reserved = false;
-        if (input.workspace === "here") {
-            const reservation = await reserveContractWorktree(input.scope, id);
-            if (reservation.kind !== "reserved") {
-                return { kind: "refused", refusal: {
-                        kind: "here-worktree-appointed",
-                        path: reservation.path,
-                        ...(reservation.kind === "appointed" ? { contract: reservation.contract } : {}),
-                    } };
-            }
-            reserved = true;
-        }
         result = await attempt(input, id);
         if (result.kind === "accepted")
             return result;
-        if (reserved)
-            await releaseContractWorktree(input.scope, id);
         if (result.kind !== "refused" || result.refusal.kind !== "contract-exists")
             return result;
     }
     return result;
 }
 export async function admitBindWithAppointment(input) {
-    const action = () => attemptCandidates(input);
-    return input.workspace === "here" ? await withContractWorktreeAppointment(input.scope, action) : action();
+    return await attemptCandidates(input);
+}
+export async function admitForkBindWithAppointment(input) {
+    let source;
+    try {
+        source = await stateOperation({ scope: input.scope, channel: input.channel, contractId: input.sourceId });
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === `contract does not exist: ${input.sourceId}`) {
+            throw new KeiyakuRefused({ kind: "fork-source-missing", contractId: input.sourceId });
+        }
+        if (error instanceof AuthorityCorruptionError) {
+            throw new KeiyakuRefused({ kind: "fork-source-invalid", contractId: input.sourceId });
+        }
+        throw error;
+    }
+    const sourceObject = (await input.channel.readObjects([source.coordinates.start])).get(source.coordinates.start);
+    if (sourceObject?.kind !== "present" || sourceObject.type !== "commit") {
+        throw new KeiyakuRefused({ kind: "fork-source-unavailable", contractId: input.sourceId });
+    }
+    const currentSource = await stateOperation({
+        scope: input.scope,
+        channel: input.channel,
+        contractId: input.sourceId,
+    });
+    if (currentSource.head !== source.head ||
+        currentSource.coordinates.start !== source.coordinates.start ||
+        currentSource.terms.document.key !== source.terms.document.key) {
+        throw new KeiyakuRefused({ kind: "fork-source-moved", contractId: input.sourceId });
+    }
+    let sourceDocument;
+    try {
+        sourceDocument = decodeContractDocument(source.terms.document.bytes);
+    }
+    catch (error) {
+        if (error instanceof TypeError) {
+            throw new KeiyakuRefused({ kind: "fork-source-invalid", contractId: input.sourceId });
+        }
+        throw error;
+    }
+    const markdown = sourceDocument.document.bytes.replace(/^\s*#\s*[^\r\n]*(?:\r?\n|$)/u, `# Fork · ${sourceDocument.title}${sourceDocument.document.bytes.includes("\r\n") ? "\r\n" : "\n"}`);
+    const document = decodeContractDocument(markdown);
+    const terms = contractTerms(document, source.terms.gates, source.terms.after);
+    const admission = await attemptCandidates({
+        scope: input.scope,
+        channel: input.channel,
+        title: document.title,
+        terms,
+        verification: documentDerivation(document, terms.gates).verification,
+        workspace: "worktree",
+        targetSelection: input.target === undefined
+            ? source.coordinates.target === undefined
+                ? { kind: "targetless" }
+                : { kind: "explicit", target: source.coordinates.target }
+            : { kind: "explicit", target: input.target },
+        coordinates: { start: source.coordinates.start },
+        source: {
+            contractId: input.sourceId,
+            head: source.head,
+            start: source.coordinates.start,
+            document: source.terms.document.key,
+        },
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+    });
+    return { admission, document };
+}
+export async function admitMarkdownBind(input) {
+    return await admitBindWithAppointment(input);
+}
+export async function prepareMarkdownBind(input) {
+    const terms = contractTerms(input.document, input.gates, input.after);
+    const admitCandidate = () => admitMarkdownBind({
+        scope: input.scope,
+        channel: input.channel,
+        title: input.document.title,
+        terms,
+        verification: documentDerivation(input.document, terms.gates).verification,
+        workspace: input.workspace,
+        ...(input.targetSelection === undefined ? {} : { targetSelection: input.targetSelection }),
+        ...(input.task === undefined ? {} : { task: input.task }),
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+    });
+    const admission = input.task === undefined ? null : await claimTaskHolderWithFence(input.scope, input.task, admitCandidate);
+    return { admission, result: admission === null ? await admitCandidate() : admission.result };
 }

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

@@ -43,6 +43,7 @@ export type Catalog = Readonly<{
     kind: "contracts";
     root: string;
     state: string | null;
+    observedAt: string;
     rows: ContractBoard["rows"];
 }> | Readonly<{
     kind: "archetypes";

package/build/src/library/catalog.js

@@ -40,8 +40,11 @@ function queryValue(value) {
 export async function listCatalog(input) {
     const values = requireInput(input, "Keiyaku.ls input");
     const query = queryValue(values.query);
-    const allowed = query.kind === "contracts" ? ["query", "repo"]
-        : query.kind === "archetypes" ? ["query", "home"] : ["query", "path"];
+    const allowed = query.kind === "contracts"
+        ? ["query", "repo"]
+        : query.kind === "archetypes"
+            ? ["query", "home"]
+            : ["query", "path"];
     for (const key of Object.keys(values)) {
         if (!allowed.includes(key))
             throw new TypeError(`Keiyaku.ls input has unknown field: ${key}`);
@@ -50,7 +53,7 @@ export async function listCatalog(input) {
         if (!(values.repo instanceof Repo))
             throw new TypeError("repo must be a Repo");
         const board = await listKeiyaku({ repo: values.repo });
-        return { kind: "contracts", root: board.root, state: board.state, rows: board.rows };
+        return { kind: "contracts", root: board.root, state: board.state, observedAt: board.observedAt, rows: board.rows };
     }
     if (query.kind === "archetypes") {
         const home = optionalHome(values.home);

package/build/src/library/configuration.js

@@ -81,7 +81,9 @@ function command(value, coordinate, ErrorType) {
     }
     if (value.argv[0].trim().length === 0)
         throw new ErrorType(`${coordinate}.argv[0] must be nonblank`);
-    if (!Number.isSafeInteger(value.timeoutMs) || value.timeoutMs < 1 || value.timeoutMs > 2_147_483_647) {
+    if (!Number.isSafeInteger(value.timeoutMs) ||
+        value.timeoutMs < 1 ||
+        value.timeoutMs > 2_147_483_647) {
         throw new ErrorType(`${coordinate}.timeoutMs must be an integer from 1 through 2147483647`);
     }
     return Object.freeze({ argv: Object.freeze([...value.argv]), timeoutMs: value.timeoutMs });

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

@@ -1,14 +1,13 @@
 import type { ContractId, ContractState } from "../core/facts/types.js";
 import { type GitDecodeChannel } from "../git/read-observation.js";
-import type { DocumentDerivation, HereWorkspaceResolver, PlacementStop, RepositoryScope } from "../protocol/operations.js";
+import type { DocumentDerivation, PlacementStop, RepositoryScope } from "../protocol/operations.js";
 import type { AcceptedIntent } from "./mutation.js";
 export type ContinuationReport = Readonly<{
-    attempted: number;
     claimed: readonly ContractId[];
     stopped: readonly Readonly<{
         contractId: ContractId;
         stop: PlacementStop | Readonly<{
-            kind: "already-terminal" | "delivery-missing";
+            kind: "already-terminal";
         }>;
     }>[];
 }>;
@@ -18,7 +17,19 @@ export declare function continueDeliveredDependents<Value extends object>(input:
     contractId: ContractId;
     accepted: AcceptedIntent<Value>;
     deriveDocument: (state: ContractState) => DocumentDerivation;
-    resolveHereWorkspace?: HereWorkspaceResolver;
+    actor?: import("../core/facts/types.js").ActorId;
+    signal?: AbortSignal;
+}>): Promise<AcceptedIntent<Value & Readonly<{
+    continuation?: ContinuationReport;
+}>>>;
+export declare function continueAcceptedCompletion<Value extends Readonly<{
+    completion?: unknown;
+}>>(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+    contractId: ContractId;
+    accepted: AcceptedIntent<Value>;
+    deriveDocument: (state: ContractState) => DocumentDerivation;
     actor?: import("../core/facts/types.js").ActorId;
     signal?: AbortSignal;
 }>): Promise<AcceptedIntent<Value & Readonly<{

package/build/src/library/continuation.js

@@ -1,19 +1,22 @@
 import { observeActiveContractWorld } from "../git/observe.js";
 import { withGitReadObservation } from "../git/read-observation.js";
 import { continueDeliveryOperation } from "../protocol/deliver.js";
-function directDependents(world, claimed, attempted, newlyClaimed) {
-    const dependents = [];
-    for (const [contractId, record] of world.contracts) {
+function reverseDependents(world) {
+    const index = new Map();
+    for (const record of world.contracts.values()) {
         const state = record.state;
-        if (state === null
-            || attempted.has(contractId)
-            || !state.terms.after.includes(claimed)
-            || state.delivery === null
-            || !state.terms.after.every((dependency) => newlyClaimed.has(dependency) || world.eligibility.get(dependency)?.terminal?.kind === "claimed"))
+        if (state === null || state.delivery === null)
             continue;
-        dependents.push({ state, journal: record.entries });
+        const dependent = { state, journal: record.entries };
+        for (const prerequisite of state.terms.after) {
+            const dependents = index.get(prerequisite) ?? [];
+            dependents.push(dependent);
+            index.set(prerequisite, dependents);
+        }
     }
-    return dependents.sort((left, right) => left.state.id.localeCompare(right.state.id));
+    for (const dependents of index.values())
+        dependents.sort((left, right) => left.state.id.localeCompare(right.state.id));
+    return index;
 }
 function appendAccepted(primary, child) {
     const effects = [...(primary.physical?.effects ?? []), ...(child.physical?.effects ?? [])];
@@ -26,6 +29,7 @@ function appendAccepted(primary, child) {
 }
 export async function continueDeliveredDependents(input) {
     const world = await withGitReadObservation(input.scope, input.channel, async (observation) => await observeActiveContractWorld(observation));
+    const dependents = reverseDependents(world);
     const pending = [input.contractId];
     const attempted = new Set();
     const newlyClaimed = new Set(pending);
@@ -34,8 +38,11 @@ export async function continueDeliveredDependents(input) {
     let accepted = input.accepted;
     while (pending.length > 0) {
         const parent = pending.shift();
-        for (const candidate of directDependents(world, parent, attempted, newlyClaimed)) {
+        for (const candidate of dependents.get(parent) ?? []) {
             const contractId = candidate.state.id;
+            if (attempted.has(contractId) ||
+                !candidate.state.terms.after.every((dependency) => newlyClaimed.has(dependency) || world.eligibility.get(dependency)?.terminal?.kind === "claimed"))
+                continue;
             attempted.add(contractId);
             const child = await continueDeliveryOperation({
                 scope: input.scope,
@@ -43,7 +50,6 @@ export async function continueDeliveredDependents(input) {
                 state: candidate.state,
                 journal: candidate.journal,
                 deriveDocument: input.deriveDocument,
-                ...(input.resolveHereWorkspace === undefined ? {} : { resolveHereWorkspace: input.resolveHereWorkspace }),
                 ...(input.actor === undefined ? {} : { actor: input.actor }),
                 ...(input.signal === undefined ? {} : { signal: input.signal }),
             });
@@ -60,9 +66,6 @@ export async function continueDeliveredDependents(input) {
             if ("refusal" in stop && stop.refusal.kind === "terminal") {
                 stopped.push({ contractId, stop: { kind: "already-terminal" } });
             }
-            else if ("refusal" in stop && stop.refusal.kind === "delivery-missing") {
-                stopped.push({ contractId, stop: { kind: "delivery-missing" } });
-            }
             else {
                 stopped.push({ contractId, stop });
             }
@@ -72,7 +75,12 @@ export async function continueDeliveredDependents(input) {
         ...accepted,
         value: {
             ...accepted.value,
-            ...(attempted.size === 0 ? {} : { continuation: { attempted: attempted.size, claimed, stopped } }),
+            ...(attempted.size === 0 ? {} : { continuation: { claimed, stopped } }),
         },
     };
 }
+export async function continueAcceptedCompletion(input) {
+    if (input.accepted.value.completion === undefined)
+        return input.accepted;
+    return await continueDeliveredDependents(input);
+}

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);
+    }
+}