@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -3,9 +3,10 @@ import { type ActorId, type ContractId } from "../core/facts/types.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import { bindOperation, type BindTargetSelection } from "../protocol/bind.js";
 import { type IntentOutcome, type RepositoryScope } from "../protocol/operations.js";
+import type { ProtocolProgress } from "../protocol/progress.js";
 import type { TaskId } from "../task/identity.js";
 import type { VerificationDeclarationPreparation } from "../verification/declaration.js";
-import { type KeiyakuRefusal } from "./refusal.js";
+import type { ForkSourceRefusal, OperationRefusals } from "./refusal.js";
 type BindAttemptInput = Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;
@@ -19,23 +20,48 @@ type BindAttemptInput = Readonly<{
     }>;
     source?: Parameters<typeof bindOperation>[0]["source"];
     task?: TaskId;
+    progress?: ProtocolProgress;
     actor?: ActorId;
 }>;
 export declare function admitBindWithAppointment(input: BindAttemptInput): Promise<IntentOutcome<Readonly<{
     contractId: ContractId;
-}>, KeiyakuRefusal>>;
+}>, {
+    kind: "verification-declaration-invalid";
+    contractId?: ContractId | undefined;
+} | {
+    kind: "target-missing" | "unborn-head" | "invalid-target";
+} | {
+    kind: "fork-source-moved";
+    contractId: ContractId;
+} | {
+    kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
+    contractId: ContractId;
+} | {
+    kind: "fork-source-missing" | "fork-source-unavailable";
+    contractId: ContractId;
+}>>;
+type ForkBindAdmission = Readonly<{
+    kind: "document";
+    document: ReturnType<typeof decodeContractDocument>;
+    admission: IntentOutcome<Readonly<{
+        contractId: ContractId;
+    }>, OperationRefusals["bind"]>;
+}>;
+/**
+ * A legally non-forkable source is an expected refusal; corrupt persisted authority for a source that
+ * does exist is exceptional and names that source Contract.
+ */
 export declare function admitForkBindWithAppointment(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;
     sourceId: ContractId;
     target?: string;
+    progress?: ProtocolProgress;
     actor?: ActorId;
-}>): Promise<{
-    admission: IntentOutcome<Readonly<{
-        contractId: ContractId;
-    }>, KeiyakuRefusal>;
-    document: import("../body/types.js").DecodedContractDocument;
-}>;
+}>): Promise<Readonly<{
+    kind: "refused";
+    refusal: ForkSourceRefusal;
+}> | ForkBindAdmission>;
 export declare function admitMarkdownBind(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;
@@ -45,10 +71,25 @@ export declare function admitMarkdownBind(input: Readonly<{
     workspace: "worktree";
     targetSelection?: BindTargetSelection;
     task?: TaskId;
+    progress?: ProtocolProgress;
     actor?: ActorId;
 }>): Promise<IntentOutcome<Readonly<{
     contractId: ContractId;
-}>, KeiyakuRefusal>>;
+}>, {
+    kind: "verification-declaration-invalid";
+    contractId?: ContractId | undefined;
+} | {
+    kind: "target-missing" | "unborn-head" | "invalid-target";
+} | {
+    kind: "fork-source-moved";
+    contractId: ContractId;
+} | {
+    kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
+    contractId: ContractId;
+} | {
+    kind: "fork-source-missing" | "fork-source-unavailable";
+    contractId: ContractId;
+}>>;
 export declare function prepareMarkdownBind(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;
@@ -58,13 +99,66 @@ export declare function prepareMarkdownBind(input: Readonly<{
     workspace: "worktree";
     targetSelection?: BindTargetSelection;
     task?: TaskId;
+    progress?: ProtocolProgress;
     actor?: ActorId;
 }>): Promise<{
-    admission: import("../settlement/holder.js").TaskHolderAdmission<IntentOutcome<Readonly<{
-        contractId: ContractId;
-    }>, KeiyakuRefusal>> | null;
+    admission: (Readonly<{
+        kind: "completed";
+        result: IntentOutcome<Readonly<{
+            contractId: ContractId;
+        }>, {
+            kind: "verification-declaration-invalid";
+            contractId?: ContractId | undefined;
+        } | {
+            kind: "target-missing" | "unborn-head" | "invalid-target";
+        } | {
+            kind: "fork-source-moved";
+            contractId: ContractId;
+        } | {
+            kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
+            contractId: ContractId;
+        } | {
+            kind: "fork-source-missing" | "fork-source-unavailable";
+            contractId: ContractId;
+        }>;
+    }> | Readonly<{
+        kind: "accepted-release-failed";
+        result: IntentOutcome<Readonly<{
+            contractId: ContractId;
+        }>, {
+            kind: "verification-declaration-invalid";
+            contractId?: ContractId | undefined;
+        } | {
+            kind: "target-missing" | "unborn-head" | "invalid-target";
+        } | {
+            kind: "fork-source-moved";
+            contractId: ContractId;
+        } | {
+            kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
+            contractId: ContractId;
+        } | {
+            kind: "fork-source-missing" | "fork-source-unavailable";
+            contractId: ContractId;
+        }>;
+        taskId: TaskId;
+        diagnostic: string;
+    }>) | null;
     result: IntentOutcome<Readonly<{
         contractId: ContractId;
-    }>, KeiyakuRefusal>;
+    }>, {
+        kind: "verification-declaration-invalid";
+        contractId?: ContractId | undefined;
+    } | {
+        kind: "target-missing" | "unborn-head" | "invalid-target";
+    } | {
+        kind: "fork-source-moved";
+        contractId: ContractId;
+    } | {
+        kind: "contract-exists" | "invalid-after" | "unknown-prerequisite";
+        contractId: ContractId;
+    } | {
+        kind: "fork-source-missing" | "fork-source-unavailable";
+        contractId: ContractId;
+    }>;
 }>;
 export {};

package/build/src/library/bind.js

@@ -7,7 +7,7 @@ import { fitIdentityStemWords, normalizeIdentityStem } from "../identity/normali
 import { bindOperation } from "../protocol/bind.js";
 import { stateOperation } from "../protocol/operations.js";
 import { claimTaskHolder, claimTaskHolderWithFence } from "../settlement/holder.js";
-import { KeiyakuRefused } from "./refusal.js";
+import { KeiyakuError } from "./outcome.js";
 import { contractTerms, documentDerivation } from "./input.js";
 const CONTRACT_ID_CODE_POINTS = 32;
 const CONTRACT_ID_ATTEMPTS = 4;
@@ -31,6 +31,7 @@ async function attempt(input, id) {
                 decorateOffer: ({ contractId: owner }) => [claimTaskHolder(input.task, owner)],
             }),
         ...(input.actor === undefined ? {} : { actor: input.actor }),
+        ...(input.progress === undefined ? {} : { progress: input.progress }),
     });
 }
 async function attemptCandidates(input) {
@@ -49,43 +50,46 @@ async function attemptCandidates(input) {
 export async function admitBindWithAppointment(input) {
     return await attemptCandidates(input);
 }
+/**
+ * A legally non-forkable source is an expected refusal; corrupt persisted authority for a source that
+ * does exist is exceptional and names that source Contract.
+ */
 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 missing = () => ({
+        kind: "refused",
+        refusal: { kind: "fork-source-missing", contractId: input.sourceId },
+    });
+    let source = await stateOperation({ scope: input.scope, channel: input.channel, contractId: input.sourceId });
+    if (source === null)
+        return missing();
     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 });
+    if (sourceObject === undefined)
+        throw new Error(`missing fork source object observation: ${input.sourceId}`);
+    if (sourceObject.kind !== "present" || sourceObject.type !== "commit") {
+        return { kind: "refused", refusal: { 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 ||
+    if (currentSource === null ||
+        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 });
+        return { kind: "refused", refusal: { kind: "fork-source-moved", contractId: input.sourceId } };
     }
+    source = currentSource;
     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;
+        if (error instanceof AuthorityCorruptionError)
+            throw error;
+        throw new KeiyakuError("authority-corruption", `fork source ${input.sourceId} has an undecodable document`, {
+            cause: 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, { requireTimeout: true });
@@ -110,8 +114,9 @@ export async function admitForkBindWithAppointment(input) {
             document: source.terms.document.key,
         },
         ...(input.actor === undefined ? {} : { actor: input.actor }),
+        ...(input.progress === undefined ? {} : { progress: input.progress }),
     });
-    return { admission, document };
+    return { kind: "document", admission, document };
 }
 export async function admitMarkdownBind(input) {
     return await admitBindWithAppointment(input);
@@ -128,6 +133,7 @@ export async function prepareMarkdownBind(input) {
         ...(input.targetSelection === undefined ? {} : { targetSelection: input.targetSelection }),
         ...(input.task === undefined ? {} : { task: input.task }),
         ...(input.actor === undefined ? {} : { actor: input.actor }),
+        ...(input.progress === undefined ? {} : { progress: input.progress }),
     });
     const admission = input.task === undefined ? null : await claimTaskHolderWithFence(input.scope, input.task, admitCandidate);
     return { admission, result: admission === null ? await admitCandidate() : admission.result };