@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,18 +1,535 @@
-import type { SnapshotId } from "../core/facts/types.js";
-import type { DeliverValue as ProtocolDeliverValue } from "../protocol/deliver.js";
-import { type ContinuationReport } from "./continuation.js";
 import { z } from "zod";
-export type DeliveryValue = ProtocolDeliverValue & Readonly<{
-    continuation?: ContinuationReport;
-}>;
-export declare function decodeDeliveryValue(value: unknown): DeliveryValue;
-export declare const deliveryValueSchema: z.ZodType<DeliveryValue, unknown, z.core.$ZodTypeInternals<DeliveryValue, unknown>>;
+import type { SnapshotId } from "../core/facts/types.js";
+import { type RepositoryScope } from "../protocol/operations.js";
+export declare const deliveryValueSchema: z.ZodObject<{
+    completion: z.ZodOptional<z.ZodObject<{
+        integration: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+        predecessor: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
+        target: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodObject<{
+            deletions: z.ZodNumber;
+            filesChanged: z.ZodNumber;
+            insertions: z.ZodNumber;
+        }, z.core.$strict>>;
+        verification: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                reused: "reused";
+                ran: "ran";
+            }>;
+            verdict: z.ZodEnum<{
+                satisfied: "satisfied";
+                unsatisfied: "unsatisfied";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    verification: z.ZodOptional<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>]>]>>;
+    verificationReuse: z.ZodOptional<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>;
+    }, z.core.$strict>>;
+    verificationSubject: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            reused: "reused";
+            ran: "ran";
+        }>;
+        verdict: z.ZodEnum<{
+            satisfied: "satisfied";
+            unsatisfied: "unsatisfied";
+        }>;
+        snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+    }, z.core.$strict>>;
+    verificationSummary: z.ZodOptional<z.ZodString>;
+    placement: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        refusal: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodEnum<{
+                terminal: "terminal";
+                "contract-missing": "contract-missing";
+                "delivery-missing": "delivery-missing";
+            }>;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"gates-unsatisfied">;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            unmet: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                gate: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").Gate, string>>;
+                current: z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"missing">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"attested">;
+                    verdict: z.ZodEnum<{
+                        satisfied: "satisfied";
+                        unsatisfied: "unsatisfied";
+                    }>;
+                    at: z.ZodString;
+                    summary: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"stale">;
+                    priorVerdict: z.ZodEnum<{
+                        satisfied: "satisfied";
+                        unsatisfied: "unsatisfied";
+                    }>;
+                    reason: z.ZodOptional<z.ZodObject<{
+                        kind: z.ZodLiteral<"candidate-content-changed">;
+                        target: z.ZodOptional<z.ZodString>;
+                        previousChange: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+                        currentChange: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>]>;
+            }, z.core.$strict>>>;
+            target: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"prerequisites-unsatisfied">;
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            unmet: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                state: z.ZodEnum<{
+                    abandoned: "abandoned";
+                    missing: "missing";
+                    active: "active";
+                }>;
+            }, 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.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<"target-missing">;
+            contractId: 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.ZodObject<{
+        failure: z.ZodLiteral<"target-placement-failed">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        failure: z.ZodLiteral<"target-moved">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+        target: z.ZodString;
+        integratedAt: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+        observed: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
+        attempts: z.ZodNumber;
+        observedTreeEqualsCandidate: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        failure: z.ZodLiteral<"target-moved">;
+        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+        target: z.ZodString;
+        expected: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+        observed: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
+        observedTreeEqualsCandidate: z.ZodBoolean;
+    }, z.core.$strict>]>>;
+    leading: z.ZodObject<{
+        kind: z.ZodEnum<{
+            "admitted-now": "admitted-now";
+            "already-admitted": "already-admitted";
+        }>;
+        fact: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
+    }, z.core.$strict>;
+    continuation: z.ZodOptional<z.ZodObject<{
+        claimed: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>>>;
+        stopped: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            stop: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                refusal: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        terminal: "terminal";
+                        "contract-missing": "contract-missing";
+                        "delivery-missing": "delivery-missing";
+                    }>;
+                    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"gates-unsatisfied">;
+                    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                    unmet: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                        gate: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").Gate, string>>;
+                        current: z.ZodUnion<readonly [z.ZodObject<{
+                            kind: z.ZodLiteral<"missing">;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"attested">;
+                            verdict: z.ZodEnum<{
+                                satisfied: "satisfied";
+                                unsatisfied: "unsatisfied";
+                            }>;
+                            at: z.ZodString;
+                            summary: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strict>, z.ZodObject<{
+                            kind: z.ZodLiteral<"stale">;
+                            priorVerdict: z.ZodEnum<{
+                                satisfied: "satisfied";
+                                unsatisfied: "unsatisfied";
+                            }>;
+                            reason: z.ZodOptional<z.ZodObject<{
+                                kind: z.ZodLiteral<"candidate-content-changed">;
+                                target: z.ZodOptional<z.ZodString>;
+                                previousChange: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+                                currentChange: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+                            }, z.core.$strict>>;
+                        }, z.core.$strict>]>;
+                    }, z.core.$strict>>>;
+                    target: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"prerequisites-unsatisfied">;
+                    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                    unmet: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                        contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                        state: z.ZodEnum<{
+                            abandoned: "abandoned";
+                            missing: "missing";
+                            active: "active";
+                        }>;
+                    }, 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.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<"target-missing">;
+                    contractId: 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.ZodObject<{
+                failure: z.ZodLiteral<"target-placement-failed">;
+                diagnostic: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                failure: z.ZodLiteral<"target-moved">;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                target: z.ZodString;
+                integratedAt: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+                observed: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
+                attempts: z.ZodNumber;
+                observedTreeEqualsCandidate: z.ZodBoolean;
+            }, z.core.$strict>, z.ZodObject<{
+                failure: z.ZodLiteral<"target-moved">;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                target: z.ZodString;
+                expected: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+                observed: z.ZodNullable<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
+                observedTreeEqualsCandidate: z.ZodBoolean;
+            }, z.core.$strict>]>, 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.ZodObject<{
+                kind: z.ZodLiteral<"execution-stopped">;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                stage: z.ZodEnum<{
+                    admission: "admission";
+                    placement: "placement";
+                    verification: "verification";
+                    continuation: "continuation";
+                    reconciliation: "reconciliation";
+                    reintegration: "reintegration";
+                }>;
+                reason: z.ZodEnum<{
+                    failed: "failed";
+                    cancelled: "cancelled";
+                }>;
+                diagnostic: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"already-terminal">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"physical-lag">;
+                lags: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"worktree-retained">;
+                    path: z.ZodString;
+                    diagnostic: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"worktree-follow-retained">;
+                    path: z.ZodString;
+                    tender: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+                    head: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+                    reason: z.ZodEnum<{
+                        "head-moved": "head-moved";
+                        "head-attached": "head-attached";
+                        "operation-in-progress": "operation-in-progress";
+                        "unsupported-parent-shape": "unsupported-parent-shape";
+                    }>;
+                    paths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"unsealed-bytes">;
+                    path: z.ZodString;
+                    paths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                    head: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"target-checkout-retained">;
+                    path: z.ZodString;
+                    target: z.ZodString;
+                    diagnostic: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"worktree-hook-failed">;
+                    phase: z.ZodEnum<{
+                        destroy: "destroy";
+                        create: "create";
+                    }>;
+                    path: z.ZodString;
+                    command: z.ZodNumber;
+                    name: z.ZodString;
+                    failure: 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.ZodObject<{
+                    kind: z.ZodLiteral<"reconcile-failed">;
+                    stage: z.ZodEnum<{
+                        observation: "observation";
+                        effect: "effect";
+                    }>;
+                    diagnostic: z.ZodString;
+                }, z.core.$strict>]>>>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    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>;
+export type DeliveryValue = z.infer<typeof deliveryValueSchema>;
 declare class DeliveryHandle {
     private readonly readDiff;
     readonly leading?: DeliveryValue["leading"];
     readonly completion?: DeliveryValue["completion"];
     readonly verification?: DeliveryValue["verification"];
     readonly verificationReuse?: DeliveryValue["verificationReuse"];
+    readonly verificationSubject?: DeliveryValue["verificationSubject"];
     readonly verificationSummary?: DeliveryValue["verificationSummary"];
     readonly placement?: DeliveryValue["placement"];
     readonly continuation?: DeliveryValue["continuation"];
@@ -20,7 +537,7 @@ declare class DeliveryHandle {
     readonly integration: DeliveryValue["integration"];
     readonly method: DeliveryValue["method"];
     readonly policy: DeliveryValue["policy"];
-    constructor(identity: Pick<DeliveryValue, "tenderSnapshot" | "integration" | "method" | "policy">, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliveryValue, "leading" | "completion" | "verification" | "verificationReuse" | "verificationSummary" | "placement" | "continuation">>);
+    constructor(identity: Pick<DeliveryValue, "tenderSnapshot" | "integration" | "method" | "policy">, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliveryValue, "leading" | "completion" | "verification" | "verificationReuse" | "verificationSubject" | "verificationSummary" | "placement" | "continuation">>);
     diff(): Promise<string | null>;
 }
 export type Delivery = DeliveryHandle;
@@ -29,5 +546,8 @@ type HandleType<T extends object> = Readonly<{
     [Symbol.hasInstance](value: unknown): boolean;
 }>;
 export declare const Delivery: HandleType<DeliveryHandle>;
-export declare function deliveryHandle(delivery: DeliveryValue, readDiff: () => Promise<string | null>): Delivery;
+export declare function deliveryHandle(delivery: DeliveryValue, readDiff: () => Promise<string | null>): Delivery & DeliveryValue;
+export declare function deliveryHandle(delivery: Pick<DeliveryValue, "tenderSnapshot" | "integration" | "method" | "policy"> & Partial<DeliveryValue>, readDiff: () => Promise<string | null>): Delivery;
+export declare function deliveryForContract(scope: RepositoryScope, delivery: DeliveryValue): Delivery & DeliveryValue;
+export declare function deliveryForContract(scope: RepositoryScope, delivery: Pick<DeliveryValue, "tenderSnapshot" | "integration" | "method" | "policy">): Delivery;
 export {};

package/build/src/library/delivery.js

@@ -1,48 +1,14 @@
-import { decodeDeliverData } from "../core/facts/codec.js";
-import { decodeCompletionEvidence, decodeDeliverLeading } from "../protocol/result-codec.js";
-import { decodeContinuationReport } from "./continuation.js";
-import { ownerSchema } from "./result-codec.js";
-export function decodeDeliveryValue(value) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        throw new Error("malformed delivery value");
-    const object = value;
-    const allowed = new Set([
-        "tenderSnapshot",
-        "integration",
-        "method",
-        "policy",
-        "leading",
-        "completion",
-        "verification",
-        "verificationReuse",
-        "verificationSummary",
-        "placement",
-        "continuation",
-    ]);
-    for (const key of Object.keys(object))
-        if (!allowed.has(key))
-            throw new Error("malformed delivery value");
-    const identity = decodeDeliverData({
-        tenderSnapshot: object.tenderSnapshot,
-        integration: object.integration,
-        method: object.method,
-        policy: object.policy,
-    });
-    const evidence = decodeCompletionEvidence({
-        ...(object.completion === undefined ? {} : { completion: object.completion }),
-        ...(object.verification === undefined ? {} : { verification: object.verification }),
-        ...(object.verificationReuse === undefined ? {} : { verificationReuse: object.verificationReuse }),
-        ...(object.verificationSummary === undefined ? {} : { verificationSummary: object.verificationSummary }),
-        ...(object.placement === undefined ? {} : { placement: object.placement }),
-    });
-    return {
-        ...identity,
-        ...(object.leading === undefined ? {} : { leading: decodeDeliverLeading(object.leading) }),
-        ...evidence,
-        ...(object.continuation === undefined ? {} : { continuation: decodeContinuationReport(object.continuation) }),
-    };
-}
-export const deliveryValueSchema = ownerSchema(decodeDeliveryValue, "expected delivery value");
+import { completionEvidenceSchema } from "../protocol/completion.js";
+import { deliverLeadingSchema } from "../protocol/deliver.js";
+import { deliverDataSchema, deliveryDiffOperation } from "../protocol/operations.js";
+import { continuationReportSchema } from "./continuation.js";
+export const deliveryValueSchema = completionEvidenceSchema
+    .extend({
+    ...deliverDataSchema.shape,
+    leading: deliverLeadingSchema,
+    continuation: continuationReportSchema.optional(),
+})
+    .strict();
 class DeliveryHandle {
     readDiff;
     constructor(identity, readDiff, outcomes = {}) {
@@ -52,6 +18,8 @@ class DeliveryHandle {
         this.method = identity.method;
         this.policy = identity.policy;
         Object.assign(this, outcomes);
+        Object.defineProperty(this, "readDiff", { value: readDiff, enumerable: false });
+        Object.freeze(this);
     }
     diff() {
         return this.readDiff();
@@ -64,3 +32,10 @@ export const Delivery = Object.freeze({
 export function deliveryHandle(delivery, readDiff) {
     return new DeliveryHandle(delivery, readDiff, delivery);
 }
+export function deliveryForContract(scope, delivery) {
+    return deliveryHandle(delivery, () => deliveryDiffOperation({
+        scope,
+        integrationPredecessor: delivery.integration.predecessor,
+        integrationSnapshot: delivery.integration.snapshot,
+    }));
+}

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

@@ -14,6 +14,8 @@ export declare function optionalNonblank(value: unknown, label: string): string
 export declare function optionalBoolean(value: unknown, label: string): boolean | undefined;
 export declare function optionalSignal(value: unknown): AbortSignal | undefined;
 export declare function normalizedList<T>(values: unknown, label: string, brand: (value: string) => T): readonly T[];
-export declare function normalizedGates(values: unknown): readonly Gate[];
 export declare function contractTerms(document: DecodedContractDocument, gates: readonly Gate[], after: readonly ContractId[]): ContractTerms;
 export declare function documentDerivation(document: DecodedContractDocument, gates: readonly Gate[], contractId?: ContractId): DocumentDerivation;
+/** Early CLI acquisition uses the same Library caller boundary, never document-owner capabilities. */
+export declare function validateContractMarkdown(markdown: string): void;
+export declare function validateArcMarkdown(markdown: string): void;