@astrosheep/keiyaku 4.6.3 → 4.6.6

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

@@ -11,108 +11,99 @@ export declare const deliveryValueSchema: z.ZodObject<{
             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";
+    verification: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+        verdict: z.ZodEnum<{
+            satisfied: "satisfied";
+            unsatisfied: "unsatisfied";
         }>;
+        summary: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"ran">;
+        entry: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>>;
     }, 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";
+        snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+        verdict: z.ZodEnum<{
+            satisfied: "satisfied";
+            unsatisfied: "unsatisfied";
         }>;
-        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;
+        entry: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
+        summary: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"reused">;
     }, 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;
+        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.ZodBoolean>;
-            kind: z.ZodLiteral<"timeout">;
+            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.ZodBoolean>;
-            kind: z.ZodLiteral<"unknown-exit">;
+            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<{
-            kind: z.ZodLiteral<"spawn-error">;
+            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.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>;
+        }, 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>], "kind">>;
     placement: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         refusal: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodEnum<{
@@ -235,7 +226,14 @@ export declare const deliveryValueSchema: z.ZodObject<{
             "already-admitted": "already-admitted";
         }>;
         fact: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
+        reusedIntegration: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
     }, z.core.$strict>;
+    contentChange: 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>>;
     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<{
@@ -511,6 +509,7 @@ export declare const deliveryValueSchema: z.ZodObject<{
             }, z.core.$strict>]>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
+    note: z.ZodOptional<z.ZodString>;
     tenderSnapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
     integration: z.ZodObject<{
         predecessor: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
@@ -526,18 +525,17 @@ export type DeliveryValue = z.infer<typeof deliveryValueSchema>;
 declare class DeliveryHandle {
     private readonly readDiff;
     readonly leading?: DeliveryValue["leading"];
+    readonly contentChange?: DeliveryValue["contentChange"];
     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"];
     readonly tenderSnapshot: SnapshotId;
+    readonly note?: string;
     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" | "verificationSubject" | "verificationSummary" | "placement" | "continuation">>);
+    constructor(identity: Pick<DeliveryValue, "tenderSnapshot" | "integration" | "method" | "policy">, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliveryValue, "leading" | "contentChange" | "completion" | "verification" | "placement" | "continuation">>);
     diff(): Promise<string | null>;
 }
 export type Delivery = DeliveryHandle;

package/build/src/library/delivery.js

@@ -1,11 +1,12 @@
 import { completionEvidenceSchema } from "../protocol/completion.js";
 import { deliverLeadingSchema } from "../protocol/deliver.js";
-import { deliverDataSchema, deliveryDiffOperation } from "../protocol/operations.js";
+import { candidateContentChangeSchema, deliverDataSchema, deliveryDiffOperation, } from "../protocol/operations.js";
 import { continuationReportSchema } from "./continuation.js";
 export const deliveryValueSchema = completionEvidenceSchema
     .extend({
     ...deliverDataSchema.shape,
     leading: deliverLeadingSchema,
+    contentChange: candidateContentChangeSchema.optional(),
     continuation: continuationReportSchema.optional(),
 })
     .strict();

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

@@ -7,8 +7,6 @@ export declare function actorOption(actor: unknown): Readonly<{
 }>;
 export declare function requireMarkdown(value: unknown, label?: string): string;
 export declare function requireInput(value: unknown, label: string, allowed?: readonly string[]): Record<string, unknown>;
-/** Shared public-input failure path for operation owners. */
-export declare function invalidInput(message: string): never;
 export declare function taskOption(value: unknown): TaskId | undefined;
 export declare function optionalNonblank(value: unknown, label: string): string | undefined;
 export declare function optionalBoolean(value: unknown, label: string): boolean | undefined;

package/build/src/library/input.js

@@ -32,10 +32,6 @@ export function requireInput(value, label, allowed) {
     }
     return value;
 }
-/** Shared public-input failure path for operation owners. */
-export function invalidInput(message) {
-    throw new TypeError(message);
-}
 export function taskOption(value) {
     if (value === undefined)
         return undefined;

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

@@ -83,5 +83,4 @@ export declare class InvocationAccumulator implements ProtocolProgress {
     private recordSeatClose;
     private recordLag;
 }
-export declare function physicalOf(snapshot: InvocationSnapshot): ReconcileResult;
 export {};

package/build/src/library/invocation.js

@@ -3,21 +3,10 @@ import { encodeEntry } from "../core/facts/codec.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { observeExecution, } from "../protocol/execution-observation.js";
 import { reconcileLagScope } from "./reconcile.js";
-const CANDIDATE_CONCLUSION_KEYS = [
-    "completion",
-    "verification",
-    "verificationReuse",
-    "verificationSubject",
-    "verificationSummary",
-    "placement",
-];
+const CANDIDATE_CONCLUSION_KEYS = ["completion", "verification", "placement"];
 function entryKey(fact) {
     return `${fact.contract}\u0000${fact.entry}`;
 }
-/** The owner codec's canonical bytes: identity is (contract, entry), the payload is retained whole. */
-function entryBytes(fact) {
-    return encodeEntry(fact);
-}
 /**
  * The one invocation accumulator. It exists before any admission-capable await, satisfies the lower
  * Protocol progress sink, and holds every confirmed publication, candidate conclusion and physical
@@ -54,7 +43,7 @@ export class InvocationAccumulator {
         const incoming = new Map();
         for (const fact of facts) {
             const key = entryKey(fact);
-            const bytes = entryBytes(fact);
+            const bytes = encodeEntry(fact);
             const previous = incoming.get(key)?.bytes ?? this.entries.get(key);
             if (previous !== undefined && previous !== bytes)
                 throw new AuthorityCorruptionError("conflicting invocation receipt");
@@ -88,7 +77,7 @@ export class InvocationAccumulator {
         this.recordResidue(step.state.id, step);
     }
     hasFact(fact) {
-        return this.entries.get(entryKey(fact)) === entryBytes(fact);
+        return this.entries.get(entryKey(fact)) === encodeEntry(fact);
     }
     head(contract) {
         return this.admittedHeads.get(contract);
@@ -277,14 +266,3 @@ export class InvocationAccumulator {
             this.affectedContracts.add(contract);
     }
 }
-export function physicalOf(snapshot) {
-    const effects = [];
-    const lag = [];
-    for (const record of snapshot.effects) {
-        if (record.kind === "reconciliation-effect" && record.effect.kind !== "contract-file")
-            effects.push(record.effect);
-        else if (record.kind === "reconciliation-lag" && record.lag.kind !== "contract-file-failed")
-            lag.push(record.lag);
-    }
-    return { effects, lag };
-}