@cleocode/contracts 2026.4.68 → 2026.4.70

package/dist/acceptance-gate-schema.d.ts

@@ -0,0 +1,624 @@
+/**
+ * Zod validation schemas for {@link AcceptanceGate} and related types.
+ *
+ * Kept in a separate file from the plain TypeScript types so that consumers
+ * that do not need runtime validation (e.g. type-only imports) pay zero cost.
+ *
+ * All schemas are named `*Schema` and derive their inferred types from the
+ * canonical TypeScript interfaces in `./acceptance-gate.ts`.
+ *
+ * @epic T760
+ * @task T763
+ * @task T779
+ */
+import { z } from 'zod';
+/**
+ * Zod schema for {@link GateBase} — fields every gate variant carries.
+ *
+ * Not exported as a standalone validator because it is always composed into a
+ * full gate schema via `z.discriminatedUnion`. Exported so downstream packages
+ * can extend it (e.g. for migration or testing).
+ */
+export declare const gateBaseSchema: z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Zod schema for {@link FileAssertion}.
+ *
+ * Each variant carries a `type` literal that drives the discriminated union.
+ */
+export declare const fileAssertionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"exists">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"absent">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"nonEmpty">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"maxBytes">;
+    value: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"minBytes">;
+    value: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"contains">;
+    value: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"matches">;
+    regex: z.ZodString;
+    flags: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"sha256">;
+    value: z.ZodString;
+}, z.core.$strip>], "type">;
+/** Inferred TypeScript type from {@link fileAssertionSchema}. */
+export type FileAssertionInput = z.input<typeof fileAssertionSchema>;
+/**
+ * Zod schema for {@link TestGate}.
+ *
+ * Validates that `command` is present and `expect` is one of the two allowed
+ * literal values.
+ */
+export declare const testGateSchema: z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"test">;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    expect: z.ZodEnum<{
+        pass: "pass";
+        exit0: "exit0";
+    }>;
+    minCount: z.ZodOptional<z.ZodNumber>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+/** Zod schema for {@link FileGate}. */
+export declare const fileGateSchema: z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"file">;
+    path: z.ZodString;
+    assertions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"exists">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"absent">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"nonEmpty">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"maxBytes">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"minBytes">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"contains">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"matches">;
+        regex: z.ZodString;
+        flags: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"sha256">;
+        value: z.ZodString;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+/** Zod schema for {@link CommandGate}. */
+export declare const commandGateSchema: z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"command">;
+    cmd: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    stdoutMatches: z.ZodOptional<z.ZodString>;
+    stderrMatches: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+/** Zod schema for {@link LintGate}. */
+export declare const lintGateSchema: z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"lint">;
+    tool: z.ZodEnum<{
+        biome: "biome";
+        eslint: "eslint";
+        tsc: "tsc";
+        prettier: "prettier";
+        rustc: "rustc";
+        clippy: "clippy";
+    }>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    expect: z.ZodEnum<{
+        clean: "clean";
+        noErrors: "noErrors";
+    }>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** Zod schema for {@link HttpGate}. */
+export declare const httpGateSchema: z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"http">;
+    url: z.ZodString;
+    method: z.ZodOptional<z.ZodEnum<{
+        GET: "GET";
+        HEAD: "HEAD";
+        POST: "POST";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>>;
+    status: z.ZodNumber;
+    bodyMatches: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    startCommand: z.ZodOptional<z.ZodString>;
+    startupDelayMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Zod schema for {@link ManualGate}. */
+export declare const manualGateSchema: z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"manual">;
+    prompt: z.ZodString;
+    verdicts: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        warn: "warn";
+    }>>>;
+}, z.core.$strip>;
+/**
+ * Zod discriminated-union schema for {@link AcceptanceGate}.
+ *
+ * Uses `z.discriminatedUnion('kind', [...])` for O(1) variant lookup.
+ * Parse with `acceptanceGateSchema.parse(input)` or
+ * `acceptanceGateSchema.safeParse(input)`.
+ *
+ * @example
+ * ```ts
+ * const gate = acceptanceGateSchema.parse({
+ *   kind: 'test',
+ *   command: 'pnpm test',
+ *   expect: 'pass',
+ *   description: 'Test suite must pass',
+ * });
+ * ```
+ */
+export declare const acceptanceGateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"test">;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    expect: z.ZodEnum<{
+        pass: "pass";
+        exit0: "exit0";
+    }>;
+    minCount: z.ZodOptional<z.ZodNumber>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"file">;
+    path: z.ZodString;
+    assertions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"exists">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"absent">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"nonEmpty">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"maxBytes">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"minBytes">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"contains">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"matches">;
+        regex: z.ZodString;
+        flags: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"sha256">;
+        value: z.ZodString;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"command">;
+    cmd: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    stdoutMatches: z.ZodOptional<z.ZodString>;
+    stderrMatches: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"lint">;
+    tool: z.ZodEnum<{
+        biome: "biome";
+        eslint: "eslint";
+        tsc: "tsc";
+        prettier: "prettier";
+        rustc: "rustc";
+        clippy: "clippy";
+    }>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    expect: z.ZodEnum<{
+        clean: "clean";
+        noErrors: "noErrors";
+    }>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"http">;
+    url: z.ZodString;
+    method: z.ZodOptional<z.ZodEnum<{
+        GET: "GET";
+        HEAD: "HEAD";
+        POST: "POST";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>>;
+    status: z.ZodNumber;
+    bodyMatches: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    startCommand: z.ZodOptional<z.ZodString>;
+    startupDelayMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"manual">;
+    prompt: z.ZodString;
+    verdicts: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        warn: "warn";
+    }>>>;
+}, z.core.$strip>], "kind">;
+/** Inferred TypeScript type from {@link acceptanceGateSchema}. */
+export type AcceptanceGateSchemaInput = z.input<typeof acceptanceGateSchema>;
+/**
+ * Zod schema for {@link AcceptanceGateResult}.
+ *
+ * Validates the shape produced by the gate runner and stored in
+ * `lifecycle_gate_results`.
+ */
+export declare const acceptanceGateResultSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    req: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        file: "file";
+        test: "test";
+        command: "command";
+        lint: "lint";
+        http: "http";
+        manual: "manual";
+    }>;
+    result: z.ZodEnum<{
+        error: "error";
+        pass: "pass";
+        fail: "fail";
+        warn: "warn";
+        skipped: "skipped";
+    }>;
+    durationMs: z.ZodNumber;
+    evidence: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+    checkedAt: z.ZodString;
+    checkedBy: z.ZodString;
+}, z.core.$strip>;
+/** Inferred TypeScript type from {@link acceptanceGateResultSchema}. */
+export type AcceptanceGateResultInput = z.input<typeof acceptanceGateResultSchema>;
+/**
+ * Zod schema for a single acceptance criterion — either a non-empty string
+ * (legacy) or a structured {@link AcceptanceGate} (machine-verifiable).
+ *
+ * **Tightened (T800)**: Rejects empty strings, whitespace-only strings, and
+ * any non-gate objects. Clear error messages guide callers toward valid input.
+ *
+ * Strings are validated with `z.string().trim().min(1)` to eliminate empty
+ * and whitespace-only criteria. The gate branch uses the existing discriminated-union
+ * schema so all six gate kinds (`test`, `file`, `command`, `lint`, `http`, `manual`)
+ * are accepted.
+ *
+ * @example
+ * ```ts
+ * acceptanceItemSchema.parse('must render in <100ms');      // => 'must render in <100ms'
+ * acceptanceItemSchema.parse({ kind: 'test', command: 'pnpm test', expect: 'pass', description: '...' }); // => TestGate
+ * acceptanceItemSchema.parse('');                            // ERROR: string must be non-empty
+ * acceptanceItemSchema.parse({ foo: 'bar' });               // ERROR: invalid gate object
+ * ```
+ *
+ * @epic T760
+ * @task T780
+ * @task T800
+ */
+export declare const acceptanceItemSchema: z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"test">;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    expect: z.ZodEnum<{
+        pass: "pass";
+        exit0: "exit0";
+    }>;
+    minCount: z.ZodOptional<z.ZodNumber>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"file">;
+    path: z.ZodString;
+    assertions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"exists">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"absent">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"nonEmpty">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"maxBytes">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"minBytes">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"contains">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"matches">;
+        regex: z.ZodString;
+        flags: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"sha256">;
+        value: z.ZodString;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"command">;
+    cmd: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    stdoutMatches: z.ZodOptional<z.ZodString>;
+    stderrMatches: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"lint">;
+    tool: z.ZodEnum<{
+        biome: "biome";
+        eslint: "eslint";
+        tsc: "tsc";
+        prettier: "prettier";
+        rustc: "rustc";
+        clippy: "clippy";
+    }>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    expect: z.ZodEnum<{
+        clean: "clean";
+        noErrors: "noErrors";
+    }>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"http">;
+    url: z.ZodString;
+    method: z.ZodOptional<z.ZodEnum<{
+        GET: "GET";
+        HEAD: "HEAD";
+        POST: "POST";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>>;
+    status: z.ZodNumber;
+    bodyMatches: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    startCommand: z.ZodOptional<z.ZodString>;
+    startupDelayMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"manual">;
+    prompt: z.ZodString;
+    verdicts: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        warn: "warn";
+    }>>>;
+}, z.core.$strip>], "kind">]>;
+/** Inferred TypeScript type from {@link acceptanceItemSchema}. */
+export type AcceptanceItemInput = z.input<typeof acceptanceItemSchema>;
+/**
+ * Zod schema for a mixed acceptance array — `(string | AcceptanceGate)[]`.
+ *
+ * **Tightened (T800)**:
+ * - Requires at least 1 item (matching CLEO's anti-hallucination policy).
+ * - Rejects duplicate `req:` GSD-style REQ-IDs within the same array.
+ *
+ * Use this to validate the full `Task.acceptance` field after widening (T780).
+ *
+ * @example
+ * ```ts
+ * // Valid: mixed types with unique req IDs
+ * acceptanceArraySchema.parse([
+ *   'must render in <100ms',
+ *   { kind: 'test', command: 'pnpm test', expect: 'pass', description: 'Tests pass', req: 'TEST-01' }
+ * ]);
+ *
+ * // ERROR: empty array
+ * acceptanceArraySchema.parse([]);
+ *
+ * // ERROR: duplicate req:'TEST-01' across two gates
+ * acceptanceArraySchema.parse([
+ *   { kind: 'test', command: 'pnpm test', expect: 'pass', description: 'Tests pass', req: 'TEST-01' },
+ *   { kind: 'file', path: 'README.md', assertions: [{ type: 'exists' }], description: 'README exists', req: 'TEST-01' }
+ * ]);
+ * ```
+ *
+ * @epic T760
+ * @task T780
+ * @task T800
+ */
+export declare const acceptanceArraySchema: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"test">;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    expect: z.ZodEnum<{
+        pass: "pass";
+        exit0: "exit0";
+    }>;
+    minCount: z.ZodOptional<z.ZodNumber>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"file">;
+    path: z.ZodString;
+    assertions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"exists">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"absent">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"nonEmpty">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"maxBytes">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"minBytes">;
+        value: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"contains">;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"matches">;
+        regex: z.ZodString;
+        flags: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"sha256">;
+        value: z.ZodString;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"command">;
+    cmd: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    stdoutMatches: z.ZodOptional<z.ZodString>;
+    stderrMatches: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"lint">;
+    tool: z.ZodEnum<{
+        biome: "biome";
+        eslint: "eslint";
+        tsc: "tsc";
+        prettier: "prettier";
+        rustc: "rustc";
+        clippy: "clippy";
+    }>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    expect: z.ZodEnum<{
+        clean: "clean";
+        noErrors: "noErrors";
+    }>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"http">;
+    url: z.ZodString;
+    method: z.ZodOptional<z.ZodEnum<{
+        GET: "GET";
+        HEAD: "HEAD";
+        POST: "POST";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>>;
+    status: z.ZodNumber;
+    bodyMatches: z.ZodOptional<z.ZodString>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    startCommand: z.ZodOptional<z.ZodString>;
+    startupDelayMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    req: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    advisory: z.ZodOptional<z.ZodBoolean>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"manual">;
+    prompt: z.ZodString;
+    verdicts: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        pass: "pass";
+        fail: "fail";
+        warn: "warn";
+    }>>>;
+}, z.core.$strip>], "kind">]>>;
+/** Inferred TypeScript type from {@link acceptanceArraySchema}. */
+export type AcceptanceArrayInput = z.input<typeof acceptanceArraySchema>;
+//# sourceMappingURL=acceptance-gate-schema.d.ts.map

package/dist/acceptance-gate-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptance-gate-schema.d.ts","sourceRoot":"","sources":["../src/acceptance-gate-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;;iBASzB,CAAC;AAIH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;2BAe9B,CAAC;AAEH,iEAAiE;AACjE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAIrE;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;iBAQzB,CAAC;AAEH,uCAAuC;AACvC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIzB,CAAC;AAEH,0CAA0C;AAC1C,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;iBAS5B,CAAC;AAEH,uCAAuC;AACvC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;iBAMzB,CAAC;AAEH,uCAAuC;AACvC,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;iBASzB,CAAC;AAEH,yCAAyC;AACzC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;iBAI3B,CAAC;AAIH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAO/B,CAAC;AAEH,kEAAkE;AAClE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAI7E;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;iBAWrC,CAAC;AAEH,wEAAwE;AACxE,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAInF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAU/B,CAAC;AAEH,kEAAkE;AAClE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAwB/B,CAAC;AAEJ,mEAAmE;AACnE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}