rivet-design 0.26.0 → 0.26.2

package/dist/types/guidance-verifier.d.ts

@@ -1,130 +1,102 @@
 import { z } from 'zod';
 import type { GuidanceDocument } from './guidance';
-export declare const GuidanceVerifierPackageSchema: z.ZodEffects<z.ZodObject<{
+export declare const GuidanceVerifierPackageSchema: z.ZodObject<{
     runtime: z.ZodLiteral<"node">;
-    entrypoint: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    files: z.ZodEffects<z.ZodArray<z.ZodObject<{
-        name: z.ZodEffects<z.ZodString, string, string>;
-        content: z.ZodEffects<z.ZodString, string, string>;
-    }, "strict", z.ZodTypeAny, {
-        name: string;
-        content: string;
-    }, {
-        name: string;
-        content: string;
-    }>, "many">, {
-        name: string;
-        content: string;
-    }[], {
-        name: string;
-        content: string;
-    }[]>;
-}, "strict", z.ZodTypeAny, {
-    files: {
-        name: string;
-        content: string;
-    }[];
-    runtime: "node";
-    entrypoint: string;
-}, {
-    files: {
-        name: string;
-        content: string;
-    }[];
-    runtime: "node";
-    entrypoint: string;
-}>, {
-    files: {
-        name: string;
-        content: string;
-    }[];
-    runtime: "node";
-    entrypoint: string;
-}, {
-    files: {
-        name: string;
-        content: string;
-    }[];
-    runtime: "node";
-    entrypoint: string;
-}>;
-export type GuidanceVerifierPackage = z.infer<typeof GuidanceVerifierPackageSchema>;
-export declare const GuidanceVerifierResultSchema: z.ZodEffects<z.ZodObject<{
-    checks: z.ZodArray<z.ZodObject<{
+    entrypoint: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const GuidanceVerifierResultSchema: z.ZodObject<{
+    checks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         id: z.ZodString;
-        category: z.ZodString;
-        status: z.ZodEnum<["pass", "fail", "blocked"]>;
-        rule: z.ZodString;
-        target: z.ZodString;
-        expected: z.ZodEffects<z.ZodType<unknown, z.ZodTypeDef, unknown>, unknown, unknown>;
-        observed: z.ZodEffects<z.ZodType<unknown, z.ZodTypeDef, unknown>, unknown, unknown>;
-        evidence: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
-    }, "strict", z.ZodTypeAny, {
-        status: "pass" | "fail" | "blocked";
-        id: string;
-        category: string;
-        rule: string;
-        target: string;
-        expected?: unknown;
-        observed?: unknown;
-        evidence?: string[] | undefined;
-    }, {
-        status: "pass" | "fail" | "blocked";
-        id: string;
-        category: string;
-        rule: string;
-        target: string;
-        expected?: unknown;
-        observed?: unknown;
-        evidence?: string[] | undefined;
-    }>, "many">;
-}, "strict", z.ZodTypeAny, {
-    checks: {
-        status: "pass" | "fail" | "blocked";
-        id: string;
-        category: string;
-        rule: string;
-        target: string;
-        expected?: unknown;
-        observed?: unknown;
-        evidence?: string[] | undefined;
-    }[];
-}, {
-    checks: {
-        status: "pass" | "fail" | "blocked";
-        id: string;
-        category: string;
-        rule: string;
-        target: string;
-        expected?: unknown;
-        observed?: unknown;
-        evidence?: string[] | undefined;
-    }[];
-}>, {
-    checks: {
-        status: "pass" | "fail" | "blocked";
-        id: string;
-        category: string;
-        rule: string;
-        target: string;
-        expected?: unknown;
-        observed?: unknown;
-        evidence?: string[] | undefined;
-    }[];
-}, {
-    checks: {
-        status: "pass" | "fail" | "blocked";
-        id: string;
-        category: string;
-        rule: string;
-        target: string;
-        expected?: unknown;
-        observed?: unknown;
-        evidence?: string[] | undefined;
-    }[];
-}>;
+        priority: z.ZodNullable<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+        currentState: z.ZodString;
+        proposedFix: z.ZodNullable<z.ZodString>;
+        evidence: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            mediaType: z.ZodString;
+            label: z.ZodString;
+            role: z.ZodEnum<{
+                reference: "reference";
+                observed: "observed";
+            }>;
+        }, z.core.$strict>>;
+        comparison: z.ZodOptional<z.ZodObject<{
+            expected: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            observed: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            unit: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        location: z.ZodOptional<z.ZodString>;
+        status: z.ZodLiteral<"pass">;
+        problem: z.ZodNull;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        priority: z.ZodNullable<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+        currentState: z.ZodString;
+        proposedFix: z.ZodNullable<z.ZodString>;
+        evidence: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            mediaType: z.ZodString;
+            label: z.ZodString;
+            role: z.ZodEnum<{
+                reference: "reference";
+                observed: "observed";
+            }>;
+        }, z.core.$strict>>;
+        comparison: z.ZodOptional<z.ZodObject<{
+            expected: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            observed: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            unit: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        location: z.ZodOptional<z.ZodString>;
+        status: z.ZodLiteral<"fail">;
+        problem: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        priority: z.ZodNullable<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+        currentState: z.ZodString;
+        proposedFix: z.ZodNullable<z.ZodString>;
+        evidence: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            mediaType: z.ZodString;
+            label: z.ZodString;
+            role: z.ZodEnum<{
+                reference: "reference";
+                observed: "observed";
+            }>;
+        }, z.core.$strict>>;
+        comparison: z.ZodOptional<z.ZodObject<{
+            expected: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            observed: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+            unit: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        location: z.ZodOptional<z.ZodString>;
+        status: z.ZodLiteral<"blocked">;
+        problem: z.ZodString;
+    }, z.core.$strict>], "status">>;
+}, z.core.$strict>;
 export type GuidanceVerifierResult = z.infer<typeof GuidanceVerifierResultSchema>;
 export type GuidanceVerifierRun = {
+    schemaVersion: 1;
+    verifier: {
+        contextId: string;
+        sourceDigest: string;
+    };
+    projectPath: string;
     runDirectory: string;
     durationMs: number;
 } & ({
@@ -145,86 +117,20 @@ export interface GuidanceVerifierInput {
     };
 }
 export declare const GuidanceVerifierSchema: z.ZodObject<{
-    markdown: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-    package: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+    markdown: z.ZodString;
+    package: z.ZodOptional<z.ZodObject<{
         runtime: z.ZodLiteral<"node">;
-        entrypoint: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
-        files: z.ZodEffects<z.ZodArray<z.ZodObject<{
-            name: z.ZodEffects<z.ZodString, string, string>;
-            content: z.ZodEffects<z.ZodString, string, string>;
-        }, "strict", z.ZodTypeAny, {
-            name: string;
-            content: string;
-        }, {
-            name: string;
-            content: string;
-        }>, "many">, {
-            name: string;
-            content: string;
-        }[], {
-            name: string;
-            content: string;
-        }[]>;
-    }, "strict", z.ZodTypeAny, {
-        files: {
-            name: string;
-            content: string;
-        }[];
-        runtime: "node";
-        entrypoint: string;
-    }, {
-        files: {
-            name: string;
-            content: string;
-        }[];
-        runtime: "node";
-        entrypoint: string;
-    }>, {
-        files: {
-            name: string;
-            content: string;
-        }[];
-        runtime: "node";
-        entrypoint: string;
-    }, {
-        files: {
-            name: string;
-            content: string;
-        }[];
-        runtime: "node";
-        entrypoint: string;
-    }>>;
+        entrypoint: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
     sourceDigest: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    markdown: string;
-    sourceDigest: string;
-    package?: {
-        files: {
-            name: string;
-            content: string;
-        }[];
-        runtime: "node";
-        entrypoint: string;
-    } | undefined;
-}, {
-    markdown: string;
-    sourceDigest: string;
-    package?: {
-        files: {
-            name: string;
-            content: string;
-        }[];
-        runtime: "node";
-        entrypoint: string;
-    } | undefined;
-}>;
+}, z.core.$strict>;
 export declare const GuidanceVerifierSummarySchema: z.ZodObject<{
     isStale: z.ZodBoolean;
-}, "strict", z.ZodTypeAny, {
-    isStale: boolean;
-}, {
-    isStale: boolean;
-}>;
+}, z.core.$strict>;
 export type GuidanceVerifier = z.infer<typeof GuidanceVerifierSchema>;
 interface GuidanceVerificationSource {
     source: GuidanceDocument;

package/dist/types/guidance-verifier.js

@@ -20,29 +20,52 @@ const JsonValueSchema = zod_1.z.lazy(() => zod_1.z.union([
     zod_1.z.boolean(),
     zod_1.z.null(),
     zod_1.z.array(JsonValueSchema),
-    zod_1.z.record(JsonValueSchema),
+    zod_1.z.record(zod_1.z.string(), JsonValueSchema),
 ]));
 const CheckValueSchema = JsonValueSchema.refine((value) => value !== undefined &&
     Buffer.byteLength(JSON.stringify(value)) <= VALUE_BYTES, 'Check values must be bounded JSON');
 const CheckTextSchema = zod_1.z.string().trim().min(1).max(CHECK_TEXT_LENGTH);
-exports.GuidanceVerifierResultSchema = zod_1.z
+const CheckSchema = zod_1.z
     .object({
-    checks: zod_1.z
+    id: CheckTextSchema,
+    priority: zod_1.z.enum(['high', 'medium', 'low']).nullable(),
+    currentState: CheckTextSchema,
+    proposedFix: CheckTextSchema.nullable(),
+    evidence: zod_1.z
         .array(zod_1.z
         .object({
-        id: CheckTextSchema,
-        category: CheckTextSchema,
-        status: zod_1.z.enum(['pass', 'fail', 'blocked']),
-        rule: CheckTextSchema,
-        target: CheckTextSchema,
+        path: guidance_references_1.GuidanceReferenceNameSchema,
+        mediaType: CheckTextSchema.regex(/^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i),
+        label: CheckTextSchema,
+        role: zod_1.z.enum(['observed', 'reference']),
+    })
+        .strict())
+        .max(CHECK_LIMIT),
+    comparison: zod_1.z
+        .object({
         expected: CheckValueSchema,
         observed: CheckValueSchema,
-        evidence: zod_1.z
-            .array(guidance_references_1.GuidanceReferenceNameSchema)
-            .max(CHECK_LIMIT)
-            .optional(),
+        unit: CheckTextSchema.nullable(),
     })
-        .strict())
+        .strict()
+        .optional(),
+    location: CheckTextSchema.optional(),
+})
+    .strict();
+exports.GuidanceVerifierResultSchema = zod_1.z
+    .object({
+    checks: zod_1.z
+        .array(zod_1.z.discriminatedUnion('status', [
+        CheckSchema.extend({ status: zod_1.z.literal('pass'), problem: zod_1.z.null() }),
+        CheckSchema.extend({
+            status: zod_1.z.literal('fail'),
+            problem: CheckTextSchema,
+        }),
+        CheckSchema.extend({
+            status: zod_1.z.literal('blocked'),
+            problem: CheckTextSchema,
+        }),
+    ]))
         .min(1)
         .max(CHECK_LIMIT),
 })