@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/protocol/audit.d.ts

@@ -1,55 +1,256 @@
-import { type DeliveryDiffScope } from "../git/integration.js";
-import type { ChangeId, ContractState, DeliverData, EntryUlid } from "../core/facts/types.js";
-import { type AuditTargetAnswer } from "../git/target-placement.js";
-import type { DeliveryPreparationRefusal, DocumentDerivation, IntentOutcome, MutationOperationInput, VerificationStop } from "./operations.js";
-export { decodeAuditReport } from "./result-codec.js";
-type AuditWorkspace = Readonly<{
-    kind: "worktree";
-    path: string;
-}>;
-type DiffScope = DeliveryDiffScope;
-export type AuditReport = Readonly<{
-    candidate: Readonly<{
-        kind: "blocked";
-        refusal: DeliveryPreparationRefusal;
-    }> | Readonly<{
-        kind: "ready";
-        workspace: AuditWorkspace;
-        identity: DeliverData;
-        scope: DiffScope;
-        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: VerificationStop;
-    }>;
-    target: Readonly<{
-        kind: "not-observed";
-    }> | AuditTargetAnswer;
-    delivery?: Readonly<{
-        changeId: ChangeId;
-        relation: "identical" | "differs";
-        verification: Readonly<{
-            kind: "undeclared" | "unrecorded";
-        }> | Readonly<{
-            kind: "recorded";
-            verdict: "satisfied" | "unsatisfied";
-            fact: EntryUlid;
+import { z } from "zod";
+import type { ContractState, SnapshotId } from "../core/facts/types.js";
+import type { DocumentDerivation, IntentOutcome, MutationOperationInput } from "./operations.js";
+export declare const auditReportSchema: z.ZodObject<{
+    candidate: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"blocked">;
+        refusal: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"target-missing">;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"worktree-missing">;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"dirty-workspace">;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            staged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            unstaged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            untracked: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            submodules: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            shortStat: z.ZodObject<{
+                filesChanged: z.ZodNumber;
+                insertions: z.ZodNumber;
+                deletions: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unmerged-paths">;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            paths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>, z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+            kind: z.ZodLiteral<"integration-failed">;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            reason: z.ZodEnum<{
+                "not-based-on-target": "not-based-on-target";
+                "unrelated-histories": "unrelated-histories";
+                conflict: "conflict";
+            }>;
+            targetHead: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+            conflictPaths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strict>, z.ZodTransform<{
+            kind: "integration-failed";
+            contractId: import("../core/facts/types.js").ContractId;
+            reason: "not-based-on-target" | "unrelated-histories" | "conflict";
+            targetHead: SnapshotId;
+        } & {
+            conflictPaths?: readonly string[];
+        }, {
+            kind: "integration-failed";
+            contractId: import("../core/facts/types.js").ContractId;
+            reason: "not-based-on-target" | "unrelated-histories" | "conflict";
+            targetHead: SnapshotId;
+            conflictPaths?: readonly string[] | undefined;
+        }>>, z.ZodObject<{
+            kind: z.ZodLiteral<"integration-unsupported">;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            requiredGit: z.ZodLiteral<"2.38">;
+        }, z.core.$strict>]>, z.ZodObject<{
+            kind: z.ZodLiteral<"merge-state-present">;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            workspace: z.ZodObject<{
+                kind: z.ZodLiteral<"worktree">;
+                path: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"checkout-not-followable">;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            target: z.ZodString;
+            path: z.ZodString;
+            reason: z.ZodLiteral<"untracked">;
+            paths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"ready">;
+        workspace: z.ZodObject<{
+            kind: z.ZodLiteral<"worktree">;
+            path: z.ZodString;
+        }, z.core.$strict>;
+        identity: z.ZodObject<{
+            tenderSnapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+            integration: z.ZodObject<{
+                predecessor: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+                snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+                changeId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+            }, z.core.$strict>;
+            method: z.ZodLiteral<"squash">;
+            policy: z.ZodObject<{
+                requireBranchesToBeUpToDate: z.ZodBoolean;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        scope: z.ZodObject<{
+            filesChanged: z.ZodNumber;
+            insertions: z.ZodNumber;
+            deletions: z.ZodNumber;
+            paths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strict>;
+        diff: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>;
+    verification: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"not-run">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"undeclared">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"stopped">;
+        stop: z.ZodUnion<readonly [z.ZodObject<{
+            refusal: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodEnum<{
+                    terminal: "terminal";
+                    "contract-missing": "contract-missing";
+                }>;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"verification-declaration-invalid">;
+                contractId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>, z.ZodObject<{
+            retry: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodEnum<{
+                    exhausted: "exhausted";
+                    collision: "collision";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"publication-failed">;
+                diagnostic: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
+            stdout: z.ZodOptional<z.ZodString>;
+            stderr: z.ZodOptional<z.ZodString>;
+            truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            failure: z.ZodEnum<{
+                cancelled: "cancelled";
+                "unknown-exit": "unknown-exit";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            stdout: z.ZodOptional<z.ZodString>;
+            stderr: z.ZodOptional<z.ZodString>;
+            truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            failure: z.ZodEnum<{
+                "spawn-error": "spawn-error";
+                "candidate-unavailable": "candidate-unavailable";
+            }>;
+            diagnostic: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            stdout: z.ZodOptional<z.ZodString>;
+            stderr: z.ZodOptional<z.ZodString>;
+            truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            failure: z.ZodLiteral<"environment-failure">;
+            diagnostic: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            stdout: z.ZodOptional<z.ZodString>;
+            stderr: z.ZodOptional<z.ZodString>;
+            truncated: z.ZodOptional<z.ZodLiteral<true>>;
+            failure: z.ZodLiteral<"environment-failure">;
+            name: z.ZodString;
+            detail: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"exit">;
+                code: z.ZodNumber;
+                stdout: z.ZodString;
+                stderr: z.ZodString;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>, z.ZodObject<{
+                stdout: z.ZodOptional<z.ZodString>;
+                stderr: z.ZodOptional<z.ZodString>;
+                truncated: z.ZodOptional<z.ZodBoolean>;
+                kind: z.ZodLiteral<"timeout">;
+            }, z.core.$strict>, z.ZodObject<{
+                stdout: z.ZodOptional<z.ZodString>;
+                stderr: z.ZodOptional<z.ZodString>;
+                truncated: z.ZodOptional<z.ZodBoolean>;
+                kind: z.ZodLiteral<"unknown-exit">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"spawn-error">;
+                diagnostic: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>]>]>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodEnum<{
+            satisfied: "satisfied";
+            unsatisfied: "unsatisfied";
         }>;
-    }>;
-}>;
+        passed: z.ZodNumber;
+        total: z.ZodNumber;
+        summary: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        entry: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
+        verdict: z.ZodEnum<{
+            satisfied: "satisfied";
+            unsatisfied: "unsatisfied";
+        }>;
+        summary: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"reused">;
+    }, z.core.$strict>]>;
+    target: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"not-observed">;
+    }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"placeable">;
+        ref: z.ZodString;
+        head: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"moved">;
+        ref: z.ZodString;
+        expected: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+        observed: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"refused">;
+        refusal: z.ZodObject<{
+            kind: z.ZodLiteral<"checkout-not-followable">;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            target: z.ZodString;
+            path: z.ZodString;
+            reason: z.ZodLiteral<"untracked">;
+            paths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>]>;
+    targetLag: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"none">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+        subject: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"worktree">;
+            path: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"counted">;
+        behind: z.ZodNumber;
+        subject: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodLiteral<"worktree">;
+            path: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>]>>;
+    delivery: z.ZodOptional<z.ZodObject<{
+        changeId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+        relation: z.ZodEnum<{
+            identical: "identical";
+            differs: "differs";
+        }>;
+        verification: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodEnum<{
+                undeclared: "undeclared";
+                unrecorded: "unrecorded";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"recorded">;
+            verdict: z.ZodEnum<{
+                satisfied: "satisfied";
+                unsatisfied: "unsatisfied";
+            }>;
+            fact: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
+        }, z.core.$strict>]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AuditReport = z.infer<typeof auditReportSchema>;
 type AuditOperationInput = MutationOperationInput & Readonly<{
     deriveDocument?: (state: ContractState) => DocumentDerivation;
     requireBranchesToBeUpToDate?: boolean;
@@ -57,4 +258,6 @@ type AuditOperationInput = MutationOperationInput & Readonly<{
     showDiff?: boolean;
     signal?: AbortSignal;
 }>;
-export declare function auditOperation(input: AuditOperationInput): Promise<IntentOutcome<AuditReport>>;
+type AuditRefusal = import("../core/verbs/deliver.js").DeliverRefusal | import("../verification/declaration.js").VerificationDeclarationRefusal;
+export declare function auditOperation(input: AuditOperationInput): Promise<IntentOutcome<AuditReport, AuditRefusal>>;
+export {};

package/build/src/protocol/audit.js

@@ -1,13 +1,60 @@
-import { readDeliveryDiff, readDeliveryScope } from "../git/integration.js";
+import { z } from "zod";
+import { deliverDataSchema, deliveryPreparationRefusalSchema, verificationStopSchema, changeIdSchema, verdictSchema, entryUlidSchema, } from "./operations.js";
+import { auditTargetAnswerSchema } from "../git/target-placement.js";
+import { verificationReuseSchema } from "./intent.js";
+import { deliveryDiffScopeSchema, readDeliveryDiff, readDeliveryScope } from "../git/integration.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { activeContract, documentIsCurrent } from "../core/facts/observation.js";
 import { adjudicateAuditTarget } from "../git/target-placement.js";
+import { observeTargetLag, contractTargetLagSchema, worktreeWorkspaceSchema } from "../git/workspace.js";
 import { readManagedWorktreeAppointment } from "../workspace-place.js";
 import { currentVerifiedAttestation, verifyDelivery } from "./intent.js";
 import { accepted, admitted } from "./outcome.js";
 import { prepareDelivery } from "./deliver.js";
 import { timestamp, unpackVerificationOutcome } from "./operations.js";
-export { decodeAuditReport } from "./result-codec.js";
+export const auditReportSchema = z
+    .object({
+    candidate: z.union([
+        z.object({ kind: z.literal("blocked"), refusal: deliveryPreparationRefusalSchema }).strict(),
+        z
+            .object({
+            kind: z.literal("ready"),
+            workspace: worktreeWorkspaceSchema,
+            identity: deliverDataSchema,
+            scope: deliveryDiffScopeSchema,
+            diff: z.string().optional(),
+        })
+            .strict(),
+    ]),
+    verification: z.union([
+        z.object({ kind: z.literal("not-run") }).strict(),
+        z.object({ kind: z.literal("undeclared") }).strict(),
+        z.object({ kind: z.literal("stopped"), stop: verificationStopSchema }).strict(),
+        z
+            .object({
+            kind: z.enum(["satisfied", "unsatisfied"]),
+            passed: z.number(),
+            total: z.number(),
+            summary: z.string().optional(),
+        })
+            .strict(),
+        verificationReuseSchema.extend({ kind: z.literal("reused") }).strict(),
+    ]),
+    target: z.union([z.object({ kind: z.literal("not-observed") }).strict(), auditTargetAnswerSchema]),
+    targetLag: contractTargetLagSchema.optional(),
+    delivery: z
+        .object({
+        changeId: changeIdSchema,
+        relation: z.enum(["identical", "differs"]),
+        verification: z.union([
+            z.object({ kind: z.enum(["undeclared", "unrecorded"]) }).strict(),
+            z.object({ kind: z.literal("recorded"), verdict: verdictSchema, fact: entryUlidSchema }).strict(),
+        ]),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
 async function auditWorkspace(repository, state) {
     const appointed = await readManagedWorktreeAppointment(repository, state.id);
     if (appointed.kind === "failed")
@@ -48,11 +95,15 @@ async function auditCandidateVerification(input, state, snapshot, definition) {
         throw new Error("audit verification preparation unexpectedly produced no attempt");
     return unpackVerificationOutcome(verification);
 }
-function auditVerificationAnswer(verified) {
+function auditVerificationAnswer(verified, declared) {
+    if (!declared)
+        return { kind: "undeclared" };
     if (verified === undefined)
         return { kind: "not-run" };
     if (verified.stop !== undefined)
         return { kind: "stopped", stop: verified.stop };
+    if (verified.reuse !== undefined)
+        return { kind: "reused", ...verified.reuse };
     if (verified.counts === undefined)
         throw new Error("terminal Verification is missing producer counts");
     return {
@@ -102,6 +153,7 @@ function completedAudit(state, verified, value) {
         ? accepted(state, [], value, undefined, obligations)
         : { ...admitted(verified.admission, value), ...obligations };
 }
+// eslint-disable-next-line complexity -- one adjudicated audit retains partial observations before each later owner boundary.
 export async function auditOperation(input) {
     const observed = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
     const state = activeContract(observed.decision, input.contractId);
@@ -131,15 +183,21 @@ export async function auditOperation(input) {
     if (prepared.kind === "refused")
         return accepted(state, [], blockedAudit(prepared.refusal));
     const candidate = await readyAuditCandidate(input.scope, prepared.data, workspace.answer, input.showDiff === true);
+    input.progress?.recordAudit(state.id, { candidate });
     const verified = derivation.verification.data === null
         ? undefined
         : await auditCandidateVerification(input, state, prepared.data.integration.snapshot, derivation.verification.data);
-    const verification = auditVerificationAnswer(verified);
+    const verification = auditVerificationAnswer(verified, derivation.verification.data !== null);
     const delivery = auditDeliveryRelation(verified?.admission?.state ?? state, prepared.data, derivation.verification.data !== null);
+    input.progress?.recordAudit(state.id, { verification, ...(delivery === undefined ? {} : { delivery }) });
+    const target = await auditTargetAnswer(input.scope, state, prepared.data);
+    input.progress?.recordAudit(state.id, { target });
+    const targetLag = target.kind === "placeable" ? await observeTargetLag(input.scope, workspace.answer.path, target.head) : undefined;
     const value = {
         candidate,
         verification,
-        target: await auditTargetAnswer(input.scope, state, prepared.data),
+        target,
+        ...(targetLag === undefined ? {} : { targetLag }),
         ...(delivery === undefined ? {} : { delivery }),
     };
     return completedAudit(state, verified, value);

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

@@ -1,26 +1,27 @@
+import { z } from "zod";
+import type { ActorId, BindData, ContractId } from "../core/facts/types.js";
+import { type BindRefusal } from "../core/verbs/bind.js";
 import { type BindTargetSelection } from "../git/observe.js";
-export type { BindTargetSelection };
 import type { GitRepository } from "../git/process.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
-import { type BindData, type ActorId, type ContractId } from "../core/facts/types.js";
-import { type BindRefusal } from "../core/verbs/bind.js";
-export type { BindRefusal } from "../core/verbs/bind.js";
 import type { VerificationDeclarationPreparation, VerificationDeclarationRefusal } from "../verification/declaration.js";
 import { type IntentOutcome } from "./outcome.js";
 import type { CompanionDecorator } from "./run.js";
-export type TargetInputRefusal = Readonly<{
-    kind: "invalid-target";
-}> | Readonly<{
-    kind: "target-missing";
-}> | Readonly<{
-    kind: "unborn-head";
-}>;
-export type ForkSourceMovedRefusal = Readonly<{
-    kind: "fork-source-moved";
-    contractId: ContractId;
-}>;
-export declare function decodeTargetInputRefusal(value: unknown): TargetInputRefusal;
-export declare function decodeForkSourceMovedRefusal(value: unknown): ForkSourceMovedRefusal;
+export type { BindRefusal } from "../core/verbs/bind.js";
+export type { BindTargetSelection };
+export declare const targetInputRefusalSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "target-missing": "target-missing";
+        "unborn-head": "unborn-head";
+        "invalid-target": "invalid-target";
+    }>;
+}, z.core.$strict>;
+type TargetInputRefusal = z.infer<typeof targetInputRefusalSchema>;
+export declare const forkSourceMovedRefusalSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"fork-source-moved">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<ContractId, string>>;
+}, z.core.$strict>;
+type ForkSourceMovedRefusal = z.infer<typeof forkSourceMovedRefusalSchema>;
 type BindOperationInput = Readonly<{
     scope: GitRepository;
     channel: GitDecodeChannel;

package/build/src/protocol/bind.js

@@ -1,34 +1,15 @@
-import { normalizeTargetBranch, observeBindCoordinates, } from "../git/observe.js";
-import { gitObjectIdForSnapshot } from "../git/identity.js";
-import { contractId } from "../core/facts/types.js";
+import { z } from "zod";
 import { decideBind } from "../core/verbs/bind.js";
+import { contractIdSchema, gitObjectIdForSnapshot } from "../git/identity.js";
+import { normalizeTargetBranch, observeBindCoordinates, } from "../git/observe.js";
 import { admitPreparedIntent } from "./intent.js";
 import { complete } from "./outcome.js";
-export function decodeTargetInputRefusal(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        throw new Error("malformed target input refusal");
-    const object = value;
-    if (object.kind !== "invalid-target" && object.kind !== "target-missing" && object.kind !== "unborn-head")
-        throw new Error("malformed target input refusal");
-    if (Object.keys(object).length !== 1)
-        throw new Error("malformed target input refusal");
-    return { kind: object.kind };
-}
-export function decodeForkSourceMovedRefusal(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        throw new Error("malformed fork-source refusal");
-    const object = value;
-    if (object.kind !== "fork-source-moved")
-        throw new Error("malformed fork-source refusal");
-    if (Object.keys(object).some((key) => key !== "kind" && key !== "contractId"))
-        throw new Error("malformed fork-source refusal");
-    try {
-        return { kind: "fork-source-moved", contractId: contractId(String(object.contractId)) };
-    }
-    catch {
-        throw new Error("malformed fork-source refusal");
-    }
-}
+export const targetInputRefusalSchema = z
+    .object({ kind: z.enum(["invalid-target", "target-missing", "unborn-head"]) })
+    .strict();
+export const forkSourceMovedRefusalSchema = z
+    .object({ kind: z.literal("fork-source-moved"), contractId: contractIdSchema })
+    .strict();
 /**
  * Acquire the repeatable Git coordinates outside the publication seat. The artifact carries the
  * observed start/target plus the expected ref assertions that publication must still confirm.