@astrosheep/keiyaku 4.5.7 → 4.5.9

package/build/src/library/contract-forwarding-reconciliation-result.d.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+export declare const reconciliationLagSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"worktree-retained">;
+    path: z.ZodString;
+}, z.core.$strict>, z.ZodPipe<z.ZodObject<{
+    kind: z.ZodLiteral<"worktree-follow-retained">;
+    path: z.ZodString;
+    tender: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>;
+    head: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").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.ZodArray<z.ZodString>>;
+}, z.core.$strict>, z.ZodTransform<{
+    kind: "worktree-follow-retained";
+    path: string;
+    tender: import("./contract.js").SnapshotId;
+    head: import("./contract.js").SnapshotId;
+    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
+} | {
+    paths: string[];
+    kind: "worktree-follow-retained";
+    path: string;
+    tender: import("./contract.js").SnapshotId;
+    head: import("./contract.js").SnapshotId;
+    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
+}, {
+    kind: "worktree-follow-retained";
+    path: string;
+    tender: import("./contract.js").SnapshotId;
+    head: import("./contract.js").SnapshotId;
+    reason: "head-moved" | "head-attached" | "operation-in-progress" | "unsupported-parent-shape";
+    paths?: string[] | undefined;
+}>>, z.ZodPipe<z.ZodObject<{
+    kind: z.ZodLiteral<"unsealed-bytes">;
+    path: z.ZodString;
+    paths: z.ZodArray<z.ZodString>;
+    head: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>>;
+}, z.core.$strict>, z.ZodTransform<{
+    kind: "unsealed-bytes";
+    path: string;
+    paths: string[];
+} | {
+    head: import("./contract.js").SnapshotId;
+    kind: "unsealed-bytes";
+    path: string;
+    paths: string[];
+}, {
+    kind: "unsealed-bytes";
+    path: string;
+    paths: string[];
+    head?: import("./contract.js").SnapshotId | undefined;
+}>>, 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<"reconcile-failed">;
+    stage: z.ZodEnum<{
+        observation: "observation";
+        effect: "effect";
+    }>;
+    diagnostic: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"ref-migration-conflict">;
+    legacyRef: z.ZodString;
+    legacyOid: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>;
+    currentRef: z.ZodString;
+    currentOid: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contract.js").SnapshotId, string>>;
+}, 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<{
+        kind: z.ZodLiteral<"timeout">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"spawn-error">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown-exit">;
+    }, z.core.$strict>]>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"contract-file-failed">;
+    worktree: z.ZodString;
+    path: z.ZodString;
+    diagnostic: z.ZodString;
+}, z.core.$strict>]>;

package/build/src/library/contract-forwarding-reconciliation-result.js

@@ -0,0 +1,92 @@
+import { mintSnapshotId } from "../git/identity.js";
+import { z } from "zod";
+function canonicalSnapshot(value, context) {
+    try {
+        return mintSnapshotId(value);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "expected SnapshotId" });
+        return z.NEVER;
+    }
+}
+const nonblankStringSchema = z.string().refine((value) => value.trim() !== "");
+const snapshotIdSchema = z.string().transform(canonicalSnapshot);
+const hookFailureSchema = z.union([
+    z
+        .object({
+        kind: z.literal("exit"),
+        code: z.number().int(),
+        stdout: z.string(),
+        stderr: z.string(),
+        truncated: z.boolean(),
+    })
+        .strict(),
+    z.object({ kind: z.literal("timeout") }).strict(),
+    z.object({ kind: z.literal("spawn-error"), diagnostic: z.string() }).strict(),
+    z.object({ kind: z.literal("unknown-exit") }).strict(),
+]);
+export const reconciliationLagSchema = z.union([
+    z.object({ kind: z.literal("worktree-retained"), path: nonblankStringSchema }).strict(),
+    z
+        .object({
+        kind: z.literal("worktree-follow-retained"),
+        path: nonblankStringSchema,
+        tender: snapshotIdSchema,
+        head: snapshotIdSchema,
+        reason: z.enum(["head-moved", "head-attached", "operation-in-progress", "unsupported-parent-shape"]),
+        paths: z.array(nonblankStringSchema).optional(),
+    })
+        .strict()
+        .transform(({ paths, ...lag }) => (paths === undefined ? lag : { ...lag, paths })),
+    z
+        .object({
+        kind: z.literal("unsealed-bytes"),
+        path: nonblankStringSchema,
+        paths: z.array(nonblankStringSchema),
+        head: snapshotIdSchema.optional(),
+    })
+        .strict()
+        .transform(({ head, ...lag }) => (head === undefined ? lag : { ...lag, head })),
+    z
+        .object({
+        kind: z.literal("target-checkout-retained"),
+        path: nonblankStringSchema,
+        target: nonblankStringSchema,
+        diagnostic: nonblankStringSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("reconcile-failed"),
+        stage: z.enum(["observation", "effect"]),
+        diagnostic: nonblankStringSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("ref-migration-conflict"),
+        legacyRef: nonblankStringSchema,
+        legacyOid: snapshotIdSchema,
+        currentRef: nonblankStringSchema,
+        currentOid: snapshotIdSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("worktree-hook-failed"),
+        phase: z.enum(["create", "destroy"]),
+        path: nonblankStringSchema,
+        command: z.number().int().nonnegative(),
+        name: nonblankStringSchema,
+        failure: hookFailureSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("contract-file-failed"),
+        worktree: nonblankStringSchema,
+        path: nonblankStringSchema,
+        diagnostic: nonblankStringSchema,
+    })
+        .strict(),
+]);