@astrosheep/keiyaku 4.5.7 → 4.5.9

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

@@ -1,77 +1,222 @@
-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 ErasedRequestCommand, type RequestCommand } from "../akuma/request-wire.js";
+import type { AuditReport } from "../protocol/audit.js";
+import type { IntegrationConflictMaterialized } from "../protocol/deliver.js";
 import type { DeliveryValue } from "./delivery.js";
-export type DeliveryExecutionInput = Readonly<{
-    scope: RepositoryScope;
-    contractId: ContractId;
-    actor?: ReturnType<typeof actorOption>["actor"];
-    message?: string;
-    requireBranchesToBeUpToDate: boolean;
+import type { MutationResult } from "./mutation.js";
+import type { DeliveryExecutionInput, Review } from "./contract-forwarding.js";
+import { z } from "zod";
+type DeliveryResult = MutationResult<DeliveryValue> | IntegrationConflictMaterialized;
+type ReviewResult = MutationResult<Review>;
+type AuditResult = MutationResult<AuditReport>;
+type ContractResult = DeliveryResult | ReviewResult | AuditResult;
+type ContractRequester = NonNullable<DeliveryExecutionInput["actor"]>;
+declare const auditRequestSchema: z.ZodPipe<z.ZodObject<{
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    includeDirty: z.ZodBoolean;
+    showDiff: z.ZodBoolean;
+}, z.core.$strict>, z.ZodTransform<{
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
+    includeDirty: boolean;
+    showDiff: boolean;
+    action: "contract.audit";
+}, {
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
+    includeDirty: boolean;
+    showDiff: boolean;
+}>>;
+declare const deliverRequestSchema: z.ZodPipe<z.ZodObject<{
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    includeDirty: z.ZodBoolean;
+    materializeConflict: z.ZodBoolean;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<{
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
     includeDirty: boolean;
     materializeConflict: boolean;
-    signal?: AbortSignal;
-    hooks: WorktreeHooks;
+    message?: string | undefined;
+    action: "contract.deliver";
+}, {
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
+    includeDirty: boolean;
+    materializeConflict: boolean;
+    message?: string | undefined;
+}>>;
+declare const reviewRequestSchema: z.ZodPipe<z.ZodObject<{
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    verdict: z.ZodEnum<{
+        satisfied: "satisfied";
+        unsatisfied: "unsatisfied";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodTransform<{
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
+    verdict: "satisfied" | "unsatisfied";
+    summary?: string | undefined;
+    action: "contract.review";
+}, {
+    repoRoot: string;
+    contractId: import("../core/facts/types.js").ContractId;
+    verdict: "satisfied" | "unsatisfied";
+    summary?: string | undefined;
+}>>;
+export type ContractRequest = z.infer<typeof auditRequestSchema> | z.infer<typeof deliverRequestSchema> | z.infer<typeof reviewRequestSchema>;
+type DeliverRequest = Extract<ContractRequest, {
+    action: "contract.deliver";
 }>;
-export type ReviewExecutionInput = Readonly<{
-    scope: RepositoryScope;
-    contractId: ContractId;
-    actor?: ReturnType<typeof actorOption>["actor"];
-    verdict: AttestationVerdict;
-    summary?: string;
-    hooks: WorktreeHooks;
+type ReviewRequest = Extract<ContractRequest, {
+    action: "contract.review";
 }>;
-export type AttestationVerdict = "satisfied" | "unsatisfied";
-export type Review = ReviewValue & Readonly<{
-    continuation?: ContinuationReport;
+type AuditRequest = Extract<ContractRequest, {
+    action: "contract.audit";
 }>;
-export type ForwardedMutationReceipt<Value> = Readonly<{
-    kind: "accepted";
-    result: MutationResult<Value>;
-}> | Readonly<{
-    kind: "refused";
-    refusal: KeiyakuRefusal;
-}> | Readonly<{
-    kind: "retry";
-    reason: KeiyakuRetryReason;
+type ContractResultFor<Action extends ContractRequest["action"]> = Action extends "contract.deliver" ? DeliveryResult : Action extends "contract.review" ? ReviewResult : AuditResult;
+type ContractRequestFor<Action extends ContractRequest["action"]> = Extract<ContractRequest, {
+    action: Action;
 }>;
-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;
+declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"audit-report">;
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    report: z.ZodType<Readonly<{
+        candidate: Readonly<{
+            kind: "blocked";
+            refusal: import("./contract.js").DeliveryPreparationRefusal;
+        }> | Readonly<{
+            kind: "ready";
+            workspace: Readonly<{
+                kind: "worktree";
+                path: string;
+            }>;
+            identity: import("../core/facts/types.js").DeliverData;
+            scope: Readonly<{
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+                paths?: readonly string[];
+            }>;
+            diff?: string;
+        }>;
+        verification: Readonly<{
+            kind: "not-run";
+        }> | Readonly<{
+            kind: "satisfied";
+            passed: number;
+            total: number;
+            summary?: string;
+        }> | Readonly<{
+            kind: "unsatisfied";
+            passed: number;
+            total: number;
+            summary?: string;
+        }> | Readonly<{
+            kind: "stopped";
+            stop: import("./contract.js").VerificationStop;
+        }>;
+        target: Readonly<{
+            kind: "not-observed";
+        }> | import("../git/target-placement.js").AuditTargetAnswer;
+        delivery?: Readonly<{
+            changeId: import("../core/facts/types.js").ChangeId;
+            relation: "identical" | "differs";
+        }>;
+    }>, unknown, z.core.$ZodTypeInternals<Readonly<{
+        candidate: Readonly<{
+            kind: "blocked";
+            refusal: import("./contract.js").DeliveryPreparationRefusal;
+        }> | Readonly<{
+            kind: "ready";
+            workspace: Readonly<{
+                kind: "worktree";
+                path: string;
+            }>;
+            identity: import("../core/facts/types.js").DeliverData;
+            scope: Readonly<{
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+                paths?: readonly string[];
+            }>;
+            diff?: string;
+        }>;
+        verification: Readonly<{
+            kind: "not-run";
+        }> | Readonly<{
+            kind: "satisfied";
+            passed: number;
+            total: number;
+            summary?: string;
+        }> | Readonly<{
+            kind: "unsatisfied";
+            passed: number;
+            total: number;
+            summary?: string;
+        }> | Readonly<{
+            kind: "stopped";
+            stop: import("./contract.js").VerificationStop;
+        }>;
+        target: Readonly<{
+            kind: "not-observed";
+        }> | import("../git/target-placement.js").AuditTargetAnswer;
+        delivery?: Readonly<{
+            changeId: import("../core/facts/types.js").ChangeId;
+            relation: "identical" | "differs";
+        }>;
+    }>, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"accepted-reference">;
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    deliveryFactId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"accepted-reference">;
+    repoRoot: z.ZodString;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    reviewFactId: z.ZodString;
+}, z.core.$strict>]>;
+export type ContractService = z.infer<typeof contractServiceSchema>;
+export type ContractRequestPort = Readonly<{
+    audit(input: AuditRequest & Readonly<{
+        requester: ContractRequester;
+        signal: AbortSignal;
+    }>): Promise<Readonly<{
+        result: AuditResult;
+        auditReport?: AuditReport;
+    }>>;
+    deliver(input: DeliverRequest & Readonly<{
+        requester: ContractRequester;
+        signal: AbortSignal;
+    }>): Promise<Readonly<{
+        result: DeliveryResult;
+        deliveryFactId?: string;
+    }>>;
+    review(input: ReviewRequest & Readonly<{
+        requester: ContractRequester;
+        signal: AbortSignal;
+    }>): Promise<Readonly<{
+        result: ReviewResult;
+        reviewFactId?: string;
+    }>>;
+}>;
+type ContractExecutionContext = Readonly<{
+    requester: ContractRequester;
+    signal: AbortSignal;
+    upstream: ContractRequestPort;
+}>;
+export declare function contractRequestCommand(action: ContractRequest["action"]): RequestCommand<ContractRequest, ContractResult, ContractService, ContractService, ContractExecutionContext>;
+export declare function contractRequestCommands(): Readonly<Record<"contract.audit" | "contract.deliver" | "contract.review", ErasedRequestCommand>>;
+export declare function requestForwardedContractLive<Action extends ContractRequest["action"]>(input: Readonly<{
+    directory: string;
+    action: Action;
+    request: ContractRequestFor<Action>;
     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;
-}>>;
+}>): Promise<ContractResultFor<Action>>;
+export { executeLocalDelivery, executeLocalReview, executeForwardedAudit, executeForwardedDeliver, executeForwardedReview, } from "./contract-forwarding.js";
+export type { AttestationVerdict, DeliveryExecutionInput, Review, ReviewExecutionInput, } from "./contract-forwarding.js";

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

@@ -1,130 +1,201 @@
-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);
+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 { isAbsolute, resolve } from "node:path";
+import { z } from "zod";
+const absolutePathSchema = z.string().refine((value) => isAbsolute(value) && resolve(value) === value);
+const nonblankStringSchema = z.string().refine((value) => value.trim() !== "");
+const contractIdSchema = z.string().transform((value, context) => {
+    try {
+        return contractId(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "expected ContractId" });
+        return z.NEVER;
+    }
+});
+const contractRequestBaseSchema = z.object({ repoRoot: absolutePathSchema, contractId: contractIdSchema }).strict();
+const auditRequestSchema = contractRequestBaseSchema
+    .extend({
+    includeDirty: z.boolean(),
+    showDiff: z.boolean(),
+})
+    .transform((request) => ({ action: "contract.audit", ...request }));
+const deliverRequestSchema = contractRequestBaseSchema
+    .extend({ includeDirty: z.boolean(), materializeConflict: z.boolean(), message: nonblankStringSchema.optional() })
+    .transform((request) => ({ action: "contract.deliver", ...request }));
+const reviewRequestSchema = contractRequestBaseSchema
+    .extend({ verdict: z.enum(["satisfied", "unsatisfied"]), summary: nonblankStringSchema.optional() })
+    .transform((request) => ({ action: "contract.review", ...request }));
+const auditServiceSchema = z
+    .object({
+    kind: z.literal("audit-report"),
+    repoRoot: absolutePathSchema,
+    contractId: contractIdSchema,
+    report: auditReportSchema,
+})
+    .strict();
+const deliveryReferenceSchema = z
+    .object({
+    kind: z.literal("accepted-reference"),
+    repoRoot: absolutePathSchema,
+    contractId: contractIdSchema,
+    deliveryFactId: nonblankStringSchema,
+})
+    .strict();
+const reviewReferenceSchema = z
+    .object({
+    kind: z.literal("accepted-reference"),
+    repoRoot: absolutePathSchema,
+    contractId: contractIdSchema,
+    reviewFactId: nonblankStringSchema,
+})
+    .strict();
+const contractServiceSchema = z.union([auditServiceSchema, deliveryReferenceSchema, 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 operationContext(scope, channel, contractId) {
-    return { scope, channel, contractId, deriveDocument: derivedDocument };
+function isAbortSignal(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        typeof value.throwIfAborted === "function");
 }
-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,
-        });
-    });
+function isContractRequestPort(value) {
+    const port = contractPayload(value);
+    return (port !== null &&
+        (typeof port.audit === "function" || typeof port.deliver === "function" || typeof port.review === "function"));
 }
-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,
-        });
-    });
+function contractPayload(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
 }
-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;
+function decodeContractRequest(action, value) {
+    const schema = action === "contract.audit"
+        ? auditRequestSchema
+        : action === "contract.deliver"
+            ? deliverRequestSchema
+            : reviewRequestSchema;
+    const parsed = schema.safeParse(value);
+    return parsed.success ? parsed.data : null;
 }
-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;
+function decodeContractService(action, value) {
+    const schema = action === "contract.audit"
+        ? auditServiceSchema
+        : action === "contract.deliver"
+            ? deliveryReferenceSchema
+            : reviewReferenceSchema;
+    const parsed = schema.safeParse(value);
+    if (!parsed.success)
+        throw new Error(`malformed stored Contract service evidence for ${action}`);
+    return parsed.data;
 }
-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 };
+async function executeContractRequest(request, context) {
+    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 });
+        if (served.auditReport === undefined)
+            throw new Error(`Contract ${request.action} completed without durable service evidence`);
+        return {
+            result: served.result,
+            service: {
+                kind: "audit-report",
+                repoRoot: request.repoRoot,
+                contractId: request.contractId,
+                report: served.auditReport,
+            },
+        };
     }
-    catch (error) {
-        return forwardedMutationFailure(error);
+    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 });
+        if (served.deliveryFactId === undefined)
+            throw new Error(`Contract ${request.action} completed without durable service evidence`);
+        return {
+            result: served.result,
+            service: {
+                kind: "accepted-reference",
+                repoRoot: request.repoRoot,
+                contractId: request.contractId,
+                deliveryFactId: served.deliveryFactId,
+            },
+        };
     }
+    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 });
+    if (served.reviewFactId === undefined)
+        throw new Error(`Contract ${request.action} completed without durable service evidence`);
+    return {
+        result: served.result,
+        service: {
+            kind: "accepted-reference",
+            repoRoot: request.repoRoot,
+            contractId: request.contractId,
+            reviewFactId: served.reviewFactId,
+        },
+    };
 }
-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);
+function decodedContractResult(action, value) {
+    const schema = action === "contract.audit"
+        ? auditResultSchema
+        : action === "contract.deliver"
+            ? deliveryResultSchema
+            : reviewResultSchema;
+    const parsed = schema.safeParse(value);
+    if (!parsed.success)
+        throw new Error(`transport integrity: Contract ${action} returned an invalid live result`);
+    return parsed.data;
+}
+export function contractRequestCommand(action) {
+    return {
+        action,
+        encodeRequest: (request) => {
+            const { action: _action, ...payload } = request;
+            return payload;
+        },
+        decodeRequest: (value) => decodeContractRequest(action, value),
+        encodeResult: (value) => value,
+        decodeResult: (value) => decodedContractResult(action, value),
+        encodeFailure: encodeContractLiveFailure,
+        decodeFailure: decodeContractLiveFailure,
+        encodeService: (service) => service,
+        decodeService: (service) => decodeContractService(action, service),
+        projectService: (service) => decodeContractService(action, service),
+        decodeReference: (reference) => decodeContractService(action, reference),
+        isPermitted: (allowed) => allowed.includes(action),
+        decodeExecutionContext: decodeContractExecutionContext,
+        execute: executeContractRequest,
+    };
+}
+export function contractRequestCommands() {
+    return {
+        "contract.audit": eraseRequestCommand(contractRequestCommand("contract.audit")),
+        "contract.deliver": eraseRequestCommand(contractRequestCommand("contract.deliver")),
+        "contract.review": eraseRequestCommand(contractRequestCommand("contract.review")),
+    };
+}
+export async function requestForwardedContractLive(input) {
+    const command = contractRequestCommand(input.action);
+    const response = await requestBodyCommand({
+        directory: input.directory,
+        command,
+        value: input.request,
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    if (response.kind === "reference") {
+        throw new Error(`transport integrity: request ${response.requestId} action ${response.action} returned a durable reference without a live result`);
     }
+    return response.result;
 }
+export { executeLocalDelivery, executeLocalReview, executeForwardedAudit, executeForwardedDeliver, executeForwardedReview, } from "./contract-forwarding.js";

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

@@ -59,6 +59,11 @@ type ActorOptions = Readonly<{
     actor?: string;
     hooks?: WorktreeHooks;
 }>;
+export type LocalContractComposition = Readonly<{
+    actor?: string;
+    hooks?: WorktreeHooks;
+    requireBranchesToBeUpToDate?: boolean;
+}>;
 export type AmendInput = ActorOptions & Readonly<{
     markdown?: string;
     after?: readonly ContractId[];
@@ -78,16 +83,15 @@ export type KeiyakuOfInput = Readonly<{
     repo: Repo;
     id: ContractId;
 }>;
-export type ReviewInput = ActorOptions & Readonly<{
+export type ReviewInput = Readonly<{
     verdict: AttestationVerdict;
     summary?: string;
 }>;
 export type AbandonInput = ActorOptions & Readonly<{
     note?: string;
 }>;
-export type DeliverInput = ActorOptions & Readonly<{
+export type DeliverInput = Readonly<{
     message?: string;
-    requireBranchesToBeUpToDate?: boolean;
     includeDirty?: boolean;
     materializeConflict?: boolean;
     signal?: AbortSignal;