@astrosheep/keiyaku 4.1.1 → 4.1.2

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

@@ -0,0 +1,95 @@
+import type { ContractId, JournalEntry, SnapshotId } from "../core/facts/types.js";
+import type { ContractFileEffect, ContractFileLag } from "../contract-worktree.js";
+import type { ReconcileReport as ProtocolReconcileReport } from "../protocol/reconcile.js";
+import type { Dispatch } from "../dispatch/index.js";
+import type { Gate, WorktreeHooks } from "./configuration.js";
+import type { AmendRegionObservation, RegionObservation } from "./region.js";
+import type { Repo } from "./repo.js";
+import type { MutationResult } from "./mutation.js";
+import type { SettlementReport } from "../settlement/settle.js";
+import type { Keiyaku, AttestationVerdict } from "./contract.js";
+import type { TaskId } from "../task/identity.js";
+export type BindResult = Readonly<Omit<MutationResult<Keiyaku>, "value"> & {
+    keiyaku: Keiyaku;
+} & RegionObservation>;
+export type Fact = JournalEntry;
+export type ContractHistoryEvent = Readonly<{
+    source: "journal";
+    fact: Fact;
+}> | Readonly<{
+    source: "dispatch";
+    dispatch: Dispatch;
+}>;
+export type ContractHistory = Readonly<{
+    id: ContractId;
+    state: SnapshotId;
+    events: readonly ContractHistoryEvent[];
+}>;
+export type TopologyEffect = ProtocolReconcileReport["effects"][number] | ContractFileEffect;
+export type Lag = ProtocolReconcileReport["lag"][number] | ContractFileLag;
+export type AmendResult = Readonly<MutationResult<void> & {
+    documentDiff: string;
+}> & AmendRegionObservation;
+export type ReconcileReport = Readonly<{
+    effects: readonly (ProtocolReconcileReport["effects"][number] | ContractFileEffect)[];
+    lag: readonly (ProtocolReconcileReport["lag"][number] | ContractFileLag)[];
+    settlement: SettlementReport;
+}>;
+export type MarkdownBindInput = Readonly<{
+    repo: Repo;
+    markdown: string;
+    task?: TaskId;
+    target?: string;
+    workspace?: "worktree";
+    actor?: string;
+    after?: readonly ContractId[];
+    gates?: readonly Gate[];
+    hooks?: WorktreeHooks;
+}>;
+export type ForkBindInput = Readonly<{
+    repo: Repo;
+    forkOf: ContractId;
+    target?: string;
+    workspace?: "worktree";
+    actor?: string;
+    hooks?: WorktreeHooks;
+}>;
+export type BindInput = MarkdownBindInput | ForkBindInput;
+type ActorOptions = Readonly<{
+    actor?: string;
+    hooks?: WorktreeHooks;
+}>;
+export type AmendInput = ActorOptions & Readonly<{
+    markdown?: string;
+    after?: readonly ContractId[];
+    gates?: readonly Gate[];
+}>;
+export type ArcInput = ActorOptions & Readonly<{
+    markdown: string;
+}>;
+export type ContractListInput = Readonly<{
+    repo: Repo;
+}>;
+export type ContractObservationInput = Readonly<{
+    repo: Repo;
+    id: ContractId;
+}>;
+export type KeiyakuOfInput = Readonly<{
+    repo: Repo;
+    id: ContractId;
+}>;
+export type ReviewInput = ActorOptions & Readonly<{
+    verdict: AttestationVerdict;
+    summary?: string;
+}>;
+export type AbandonInput = ActorOptions & Readonly<{
+    note?: string;
+}>;
+export type DeliverInput = ActorOptions & Readonly<{
+    message?: string;
+    requireBranchesToBeUpToDate?: boolean;
+    includeDirty?: boolean;
+    materializeConflict?: boolean;
+    signal?: AbortSignal;
+}>;
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,156 +1,31 @@
-import { type ContractFileEffect, type ContractFileLag } from "../contract-worktree.js";
-import { type AmendRegionObservation, type RegionObservation, type RegionOverlap } from "./region.js";
-import { type Gate, type WorktreeHooks } from "./configuration.js";
-import { type ChangeId, type FactKind, type ContractId, type ContractState, type JournalEntry, type SnapshotId } from "../core/facts/types.js";
+import { type RegionOverlap } from "./region.js";
+import { type ChangeId, type FactKind, type ContractId, type ContractState, type SnapshotId } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { type PlacementStop, type RepositoryScope, type VerificationStop, type DeliveryPreparationRefusal } from "../protocol/operations.js";
 import type { ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractObservation, ContractPhase, ContractRow, AfterEndpointObservation, ContractAfterEdge, ContractDependent, ContractWorkspaceObservation } from "../protocol/read/status.js";
 import type { AuditReport } from "../protocol/audit.js";
-import { type IntegrationConflictMaterialized, type VerificationReuse } from "../protocol/deliver.js";
-import type { ReconcileReport as ProtocolReconcileReport } from "../protocol/reconcile.js";
-import { type ReviewValue } from "../protocol/review.js";
-import { type Dispatch } from "../dispatch/index.js";
-import { type SettlementReport } from "../settlement/settle.js";
+import type { IntegrationConflictMaterialized, VerificationReuse } from "../protocol/deliver.js";
 import type { TaskId } from "../task/identity.js";
-import { Repo, type ReconcileInput } from "./repo.js";
+import { type ReconcileInput } from "./repo.js";
 import { type AuditInput } from "./audit.js";
-import { Delivery, type DeliveryValue } from "./delivery.js";
+import { Delivery } from "./delivery.js";
 import { type ContinuationReport } from "./continuation.js";
 import { type MutationResult } from "./mutation.js";
+import type { AbandonInput, AmendInput, AmendResult, ArcInput, BindInput, BindResult, ContractListInput, ContractObservationInput, DeliverInput, ForkBindInput, KeiyakuOfInput, MarkdownBindInput, ReconcileReport, ReviewInput, ContractHistory, ContractHistoryEvent, Fact, Lag, TopologyEffect } from "./contract-types.js";
+import { type AttestationVerdict as OperationAttestationVerdict, type Review as OperationReview } from "./contract-operations.js";
 import { KeiyakuRetry, type KeiyakuRefusal, type KeiyakuRetryReason } from "./refusal.js";
 export { KeiyakuRefused } from "./refusal.js";
 export { KeiyakuRetry, type KeiyakuRefusal, type KeiyakuRetryReason };
+export { executeForwardedDeliver, executeForwardedReview } from "./contract-operations.js";
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
 export type { Gate, GatesFromInput, HookCommand, RequireBranchesToBeUpToDateFromInput, WorktreeHooks, } from "./configuration.js";
-export type { AuditInput, AuditReport, ChangeId, ContinuationReport, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractAfterEdge, ContractId, ContractDependent, ContractObservation, ContractPhase, ContractRow, ContractState, ContractWorkspaceObservation, DeliveryPreparationRefusal, FactKind, IntegrationConflictMaterialized, MutationResult, PlacementStop, RegionOverlap, SnapshotId, TaskId, VerificationReuse, VerificationStop, };
+export type { AbandonInput, AmendInput, AmendResult, ArcInput, AuditInput, AuditReport, ChangeId, ContinuationReport, ContractBoard, ContractDisposition, ContractGateCurrent, ContractGateReport, ContractAfterEdge, ContractId, ContractHistory, ContractHistoryEvent, ContractDependent, ContractObservation, ContractPhase, ContractRow, ContractState, ContractWorkspaceObservation, BindInput, BindResult, ContractListInput, ContractObservationInput, DeliverInput, ForkBindInput, KeiyakuOfInput, MarkdownBindInput, ReconcileReport, ReviewInput, DeliveryPreparationRefusal, Fact, FactKind, IntegrationConflictMaterialized, Lag, MutationResult, PlacementStop, RegionOverlap, SnapshotId, TaskId, TopologyEffect, VerificationReuse, VerificationStop, };
 export type { AfterEndpointObservation };
-export type Fact = JournalEntry;
-export type ContractHistoryEvent = Readonly<{
-    source: "journal";
-    fact: Fact;
-}> | Readonly<{
-    source: "dispatch";
-    dispatch: Dispatch;
-}>;
-export type ContractHistory = Readonly<{
-    id: ContractId;
-    state: SnapshotId;
-    events: readonly ContractHistoryEvent[];
-}>;
 export type ActorId = string;
-export type AttestationVerdict = "satisfied" | "unsatisfied";
-export type Review = ReviewValue & Readonly<{
-    continuation?: ContinuationReport;
-}>;
-export type TopologyEffect = ProtocolReconcileReport["effects"][number] | ContractFileEffect;
-export type Lag = ProtocolReconcileReport["lag"][number] | ContractFileLag;
+export type AttestationVerdict = OperationAttestationVerdict;
+export type Review = OperationReview;
 export { Delivery };
-export type BindResult = Readonly<Omit<MutationResult<Keiyaku>, "value"> & {
-    keiyaku: Keiyaku;
-} & RegionObservation>;
-export type AmendResult = Readonly<MutationResult<void> & {
-    documentDiff: string;
-}> & AmendRegionObservation;
-export type ReconcileReport = Readonly<{
-    effects: readonly TopologyEffect[];
-    lag: readonly Lag[];
-    settlement: SettlementReport;
-}>;
 export type { SettlementAction, SettlementLag, SettlementReport } from "../settlement/settle.js";
-export type MarkdownBindInput = Readonly<{
-    repo: Repo;
-    markdown: string;
-    task?: TaskId;
-    target?: string;
-    workspace?: "worktree";
-    actor?: ActorId;
-    after?: readonly ContractId[];
-    gates?: readonly Gate[];
-    hooks?: WorktreeHooks;
-}>;
-export type ForkBindInput = Readonly<{
-    repo: Repo;
-    forkOf: ContractId;
-    target?: string;
-    workspace?: "worktree";
-    actor?: ActorId;
-    hooks?: WorktreeHooks;
-}>;
-export type BindInput = MarkdownBindInput | ForkBindInput;
-type ActorOptions = Readonly<{
-    actor?: ActorId;
-    hooks?: WorktreeHooks;
-}>;
-export type AmendInput = ActorOptions & Readonly<{
-    markdown?: string;
-    after?: readonly ContractId[];
-    gates?: readonly Gate[];
-}>;
-export type ArcInput = ActorOptions & Readonly<{
-    markdown: string;
-}>;
-export type ContractListInput = Readonly<{
-    repo: Repo;
-}>;
-export type ContractObservationInput = Readonly<{
-    repo: Repo;
-    id: ContractId;
-}>;
-export type KeiyakuOfInput = Readonly<{
-    repo: Repo;
-    id: ContractId;
-}>;
-export type ReviewInput = ActorOptions & Readonly<{
-    verdict: AttestationVerdict;
-    summary?: string;
-}>;
-export type AbandonInput = ActorOptions & Readonly<{
-    note?: string;
-}>;
-export type DeliverInput = ActorOptions & Readonly<{
-    message?: string;
-    requireBranchesToBeUpToDate?: boolean;
-    includeDirty?: boolean;
-    materializeConflict?: boolean;
-    signal?: AbortSignal;
-}>;
-type ForwardedMutationReceipt<Value> = Readonly<{
-    kind: "accepted";
-    result: MutationResult<Value>;
-}> | Readonly<{
-    kind: "refused";
-    refusal: KeiyakuRefusal;
-}> | Readonly<{
-    kind: "retry";
-    reason: KeiyakuRetryReason;
-}>;
-type ForwardedDeliveryReceipt = ForwardedMutationReceipt<DeliveryValue> | IntegrationConflictMaterialized;
-type ForwardedReviewReceipt = ForwardedMutationReceipt<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;
-}>>;
 export declare class KeiyakuHandle {
     private readonly id;
     private readonly scope;

package/build/src/library/contract.js

@@ -3,8 +3,8 @@ import { applyAmendDocument } from "../body/amend.js";
 import { decodeArcDocument } from "../body/arc.js";
 import { decodeContractDocument } from "../body/decode.js";
 import { renderContractGuidance } from "../contract-worktree.js";
-import { actorOption, contractTerms, documentDerivation, normalizedGates, normalizedList, optionalBoolean, optionalNonblank, optionalSignal, requireInput, requireMarkdown, taskOption, } from "./input.js";
-import { observeChangedRegion, observeRegion, } from "./region.js";
+import { actorOption, contractTerms, documentDerivation, normalizedGates, normalizedList, optionalBoolean, optionalNonblank, optionalSignal, requireInput, requireMarkdown, } from "./input.js";
+import { observeChangedRegion } from "./region.js";
 import { worktreeHooksOption } from "./configuration.js";
 import { contractId, } from "../core/facts/types.js";
 export { AuthorityCorruptionError } from "../core/facts/errors.js";
@@ -12,151 +12,25 @@ import { contractObservationOperation, contractsOperation, deliveryDiffOperation
 import { abandonOperation } from "../protocol/abandon.js";
 import { amendOperation } from "../protocol/amend.js";
 import { arcOperation } from "../protocol/arc.js";
-import { deliverOperation } from "../protocol/deliver.js";
-import { reviewOperation } from "../protocol/review.js";
 import { readDispatchesAt } from "../dispatch/index.js";
 import { mintSnapshotId } from "../git/identity.js";
 import { observeContractsForAdmissionInObservationAt } from "../git/observe.js";
 import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
 import { releaseTaskHolder, releaseTaskHolderWithFence, taskHolderObservationSelection } from "../settlement/holder.js";
 import { reconcileInput, scopeForRepo } from "./repo.js";
-import { injectedBodyRequests, requestBodyDeliver, requestBodyReview, } from "../akuma/requests.js";
+import { injectedBodyRequests, requestBodyDeliver, requestBodyReview } from "../akuma/requests.js";
 import { auditContract } from "./audit.js";
 import { Delivery, deliveryHandle } from "./delivery.js";
-import { continueAcceptedCompletion } from "./continuation.js";
 import { completionInput, completeHolderMutation, completeMutation } from "./mutation.js";
 import { completeReconcile } from "./reconcile.js";
-import { admitForkBindWithAppointment, prepareMarkdownBind } from "./bind.js";
-import { forwardedMutationFailure, KeiyakuRefused, KeiyakuRetry, requireAccepted, } from "./refusal.js";
+import { bindFromCli as bindFromCliImplementation, bindKeiyaku as bindKeiyakuImplementation } from "./contract-bind.js";
+import { executeLocalDelivery, executeLocalReview, forwardedReceipt, requireForwarded, } from "./contract-operations.js";
+import { KeiyakuRefused, KeiyakuRetry, requireAccepted, } from "./refusal.js";
 export { KeiyakuRefused } from "./refusal.js";
 export { KeiyakuRetry };
+export { executeForwardedDeliver, executeForwardedReview } from "./contract-operations.js";
 export { gatesFrom, requireBranchesToBeUpToDateFrom, SettingsError } from "./configuration.js";
 export { Delivery };
-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,
-    };
-}
-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,
-        });
-    });
-}
-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 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 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);
-    }
-}
 export class KeiyakuHandle {
     id;
     scope;
@@ -446,97 +320,10 @@ export async function observeKeiyaku(input) {
     }
     return withGitDecodeChannel(scope, (channel) => contractObservationOperation({ scope, channel, contractId: id }));
 }
-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) {
-    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 }) => new KeiyakuHandle(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");
+    return bindKeiyakuImplementation(input, (id, scope) => new KeiyakuHandle(id, scope));
 }
 /** Internal CLI composition; not exported from the package root. */
 export async function bindFromCli(input) {
-    const values = requireInput(input, "Keiyaku.bind input");
-    return values.forkOf !== undefined ? bindKeiyaku(input) : bindMarkdownFromValues(values, "current-branch");
-}
-async function bindMarkdownFromValues(values, omittedTarget) {
-    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 }) => new KeiyakuHandle(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));
-    });
+    return bindFromCliImplementation(input, (id, scope) => new KeiyakuHandle(id, scope));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.1.1",
+  "version": "4.1.2",
   "files": [
     "build"
   ],