@cat-factory/contracts 0.240.0 → 0.242.0

package/dist/routes/public-evidence.d.ts

@@ -0,0 +1,291 @@
+/**
+ * The run's verification report: the engine's bundle of captured facts, byte-for-byte what it
+ * maintains on the pull request, composed on read from the run's persisted state.
+ *
+ * A consumer that scraped the fenced JSON block out of a PR body can read it here instead, and
+ * gets it for the runs that never opened a pull request at all.
+ */
+export declare const getPublicRunReportContract: {
+    readonly method: "get";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        runId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ runId }: {
+        runId: string;
+    }) => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly version: import("valibot").NumberSchema<undefined>;
+            readonly generatedAt: import("valibot").NumberSchema<undefined>;
+            readonly run: import("valibot").ObjectSchema<{
+                readonly executionId: import("valibot").StringSchema<undefined>;
+                readonly blockId: import("valibot").StringSchema<undefined>;
+                readonly blockTitle: import("valibot").StringSchema<undefined>;
+                readonly pipelineId: import("valibot").StringSchema<undefined>;
+                readonly pipelineName: import("valibot").StringSchema<undefined>;
+                readonly repo: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly provider: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").PicklistSchema<["github", "gitlab"], undefined>, undefined>, undefined>;
+                readonly startedAt: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                readonly steps: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly index: import("valibot").NumberSchema<undefined>;
+                    readonly agentKind: import("valibot").StringSchema<undefined>;
+                    readonly state: import("valibot").StringSchema<undefined>;
+                    readonly model: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly issues: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly source: import("valibot").StringSchema<undefined>;
+                    readonly externalId: import("valibot").StringSchema<undefined>;
+                    readonly title: import("valibot").StringSchema<undefined>;
+                    readonly url: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+            readonly ci: import("valibot").ObjectSchema<{
+                readonly status: import("valibot").PicklistSchema<["reported", "absent"], undefined>;
+                readonly note: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly verdict: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").PicklistSchema<["pass", "pending", "fail"], undefined>, undefined>, undefined>;
+                readonly headSha: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly failingChecks: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly name: import("valibot").StringSchema<undefined>;
+                    readonly conclusion: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly url: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    readonly repo: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly fixerAttempts: import("valibot").NumberSchema<undefined>;
+                readonly maxFixerAttempts: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+            }, undefined>;
+            readonly validation: import("valibot").ObjectSchema<{
+                readonly status: import("valibot").PicklistSchema<["reported", "absent"], undefined>;
+                readonly note: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly passed: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").BooleanSchema<undefined>, undefined>, undefined>;
+                readonly stepKind: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly attempts: import("valibot").NumberSchema<undefined>;
+                readonly maxAttempts: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                readonly at: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                readonly commands: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly label: import("valibot").StringSchema<undefined>;
+                    readonly command: import("valibot").StringSchema<undefined>;
+                    readonly exitCode: import("valibot").NumberSchema<undefined>;
+                    readonly passed: import("valibot").BooleanSchema<undefined>;
+                    readonly timedOut: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").BooleanSchema<undefined>, undefined>, undefined>;
+                    readonly durationMs: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                    readonly outputTail: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+            readonly reproduction: import("valibot").ObjectSchema<{
+                readonly status: import("valibot").PicklistSchema<["reported", "absent"], undefined>;
+                readonly note: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly verdict: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").PicklistSchema<["reproduced", "inconclusive", "declared_infeasible"], undefined>, undefined>, undefined>;
+                readonly command: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly testPaths: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly omittedTestPaths: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                readonly base: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly exitCode: import("valibot").NumberSchema<undefined>;
+                    readonly passed: import("valibot").BooleanSchema<undefined>;
+                    readonly durationMs: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                    readonly timedOut: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").BooleanSchema<undefined>, undefined>, undefined>;
+                    readonly setupFailed: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").BooleanSchema<undefined>, undefined>, undefined>;
+                    readonly outputTail: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                }, undefined>, undefined>, undefined>;
+                readonly final: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly exitCode: import("valibot").NumberSchema<undefined>;
+                    readonly passed: import("valibot").BooleanSchema<undefined>;
+                    readonly durationMs: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                    readonly timedOut: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").BooleanSchema<undefined>, undefined>, undefined>;
+                    readonly setupFailed: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").BooleanSchema<undefined>, undefined>, undefined>;
+                    readonly outputTail: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                }, undefined>, undefined>, undefined>;
+                readonly attempts: import("valibot").NumberSchema<undefined>;
+                readonly maxAttempts: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+                readonly reason: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly alternativeVerification: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly observation: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly at: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+            }, undefined>;
+            readonly tests: import("valibot").ObjectSchema<{
+                readonly status: import("valibot").PicklistSchema<["reported", "absent"], undefined>;
+                readonly note: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly greenlight: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").BooleanSchema<undefined>, undefined>, undefined>;
+                readonly summary: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly environment: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly tested: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly outcomes: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly name: import("valibot").StringSchema<undefined>;
+                    readonly status: import("valibot").StringSchema<undefined>;
+                    readonly detail: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly concerns: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly title: import("valibot").StringSchema<undefined>;
+                    readonly severity: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>;
+                readonly fixerAttempts: import("valibot").NumberSchema<undefined>;
+                readonly maxFixerAttempts: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>, undefined>;
+            }, undefined>;
+            readonly requirements: import("valibot").ObjectSchema<{
+                readonly status: import("valibot").PicklistSchema<["reported", "absent"], undefined>;
+                readonly note: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly entries: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly id: import("valibot").StringSchema<undefined>;
+                    readonly title: import("valibot").StringSchema<undefined>;
+                    readonly module: import("valibot").StringSchema<undefined>;
+                    readonly group: import("valibot").StringSchema<undefined>;
+                    readonly priority: import("valibot").PicklistSchema<["must", "should", "could"], undefined>;
+                    readonly state: import("valibot").PicklistSchema<["aspirational", "established"], undefined>;
+                    readonly verdict: import("valibot").PicklistSchema<["met", "not_met", "not_covered"], undefined>;
+                    readonly detail: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly criteriaCount: import("valibot").NumberSchema<undefined>;
+                }, undefined>, undefined>;
+                readonly met: import("valibot").NumberSchema<undefined>;
+                readonly notMet: import("valibot").NumberSchema<undefined>;
+                readonly notCovered: import("valibot").NumberSchema<undefined>;
+                readonly regressions: import("valibot").NumberSchema<undefined>;
+                readonly total: import("valibot").NumberSchema<undefined>;
+            }, undefined>;
+            readonly environments: import("valibot").ObjectSchema<{
+                readonly status: import("valibot").PicklistSchema<["reported", "absent"], undefined>;
+                readonly note: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly entries: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly frameId: import("valibot").StringSchema<undefined>;
+                    readonly status: import("valibot").PicklistSchema<["ready", "failed", "skipped"], undefined>;
+                    readonly url: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    readonly error: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                }, undefined>, undefined>;
+                readonly teardown: import("valibot").PicklistSchema<["confirmed", "unconfirmed", "pending", "failed", "not_applicable"], undefined>;
+                readonly timeline: import("valibot").ObjectSchema<{
+                    readonly gap: import("valibot").NullableSchema<import("valibot").PicklistSchema<["unwired", "unreadable", "truncated", "not_provisioned"], undefined>, undefined>;
+                    readonly note: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    readonly provisionedAt: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                    readonly tornDownAt: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                    readonly provisionFailures: import("valibot").NumberSchema<undefined>;
+                    readonly teardownFailures: import("valibot").NumberSchema<undefined>;
+                    readonly teardownsUnconfirmed: import("valibot").NumberSchema<undefined>;
+                }, undefined>;
+                readonly evidence: import("valibot").ObjectSchema<{
+                    readonly status: import("valibot").PicklistSchema<["captured", "local", "undeclared", "absent"], undefined>;
+                    readonly note: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    readonly ranAgainst: import("valibot").NullableSchema<import("valibot").PicklistSchema<["local", "ephemeral"], undefined>, undefined>;
+                    readonly capturedAt: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                    readonly outcomes: import("valibot").NumberSchema<undefined>;
+                    readonly requirementVerdicts: import("valibot").NumberSchema<undefined>;
+                    readonly screenshots: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly view: import("valibot").StringSchema<undefined>;
+                        readonly artifactId: import("valibot").StringSchema<undefined>;
+                        readonly hasReference: import("valibot").BooleanSchema<undefined>;
+                        readonly url: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    }, undefined>, undefined>;
+                    readonly url: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>;
+                readonly proof: import("valibot").PicklistSchema<["complete", "incomplete", "not_applicable"], undefined>;
+                readonly gaps: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>;
+            readonly merge: import("valibot").ObjectSchema<{
+                readonly status: import("valibot").PicklistSchema<["reported", "absent"], undefined>;
+                readonly note: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly assessment: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ObjectSchema<{
+                    readonly complexity: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 1, undefined>]>;
+                    readonly risk: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 1, undefined>]>;
+                    readonly impact: import("valibot").SchemaWithPipe<readonly [import("valibot").NumberSchema<undefined>, import("valibot").MinValueAction<number, 0, undefined>, import("valibot").MaxValueAction<number, 1, undefined>]>;
+                    readonly rationale: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+                readonly outcome: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly reason: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly presetName: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+            }, undefined>;
+            readonly judges: import("valibot").ObjectSchema<{
+                readonly status: import("valibot").PicklistSchema<["reported", "absent"], undefined>;
+                readonly note: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                readonly verdicts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly stepKind: import("valibot").StringSchema<undefined>;
+                    readonly rubricName: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly rubricOverridden: import("valibot").BooleanSchema<undefined>;
+                    readonly score: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                    readonly threshold: import("valibot").NullableSchema<import("valibot").NumberSchema<undefined>, undefined>;
+                    readonly disposition: import("valibot").NullableSchema<import("valibot").PicklistSchema<["pass", "park", "bounce", "fail"], undefined>, undefined>;
+                    readonly summary: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly findings: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                        readonly title: import("valibot").SchemaWithFallback<import("valibot").StringSchema<undefined>, "Untitled finding">;
+                        readonly detail: import("valibot").SchemaWithFallback<import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                        readonly severity: import("valibot").SchemaWithFallback<import("valibot").PicklistSchema<["low", "medium", "high", "critical"], undefined>, "medium">;
+                        readonly where: import("valibot").SchemaWithFallback<import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>, undefined>;
+                    }, undefined>, undefined>;
+                    readonly bounces: import("valibot").NumberSchema<undefined>;
+                    readonly maxBounces: import("valibot").NumberSchema<undefined>;
+                    readonly model: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                }, undefined>, undefined>;
+            }, undefined>;
+            readonly observability: import("valibot").ObjectSchema<{
+                readonly runUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly trajectoryUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly reportUrl: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+            }, undefined>;
+            readonly truncations: import("valibot").ArraySchema<import("valibot").StringSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+};
+/** The binary artifacts the run captured (metadata; the bytes are a second, per-artifact fetch). */
+export declare const listPublicRunArtifactsContract: {
+    readonly method: "get";
+    readonly requestPathParamsSchema: import("valibot").ObjectSchema<{
+        runId: import("valibot").StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ runId }: {
+        runId: string;
+    }) => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': import("valibot").ObjectSchema<{
+            readonly error: import("valibot").ObjectSchema<{
+                readonly code: import("valibot").StringSchema<undefined>;
+                readonly message: import("valibot").StringSchema<undefined>;
+                readonly details: import("valibot").OptionalSchema<import("valibot").UnknownSchema, undefined>;
+                readonly issues: import("valibot").OptionalSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                    readonly path: import("valibot").OptionalSchema<import("valibot").StringSchema<undefined>, undefined>;
+                    readonly message: import("valibot").StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: import("valibot").ObjectSchema<{
+            readonly artifacts: import("valibot").ArraySchema<import("valibot").ObjectSchema<{
+                readonly artifactId: import("valibot").StringSchema<undefined>;
+                readonly kind: import("valibot").PicklistSchema<["screenshot", "reference"], undefined>;
+                readonly view: import("valibot").NullableSchema<import("valibot").StringSchema<undefined>, undefined>;
+                readonly contentType: import("valibot").StringSchema<undefined>;
+                readonly byteSize: import("valibot").NumberSchema<undefined>;
+                readonly hash: import("valibot").StringSchema<undefined>;
+                readonly createdAt: import("valibot").NumberSchema<undefined>;
+            }, undefined>, undefined>;
+        }, undefined>;
+    };
+};
+//# sourceMappingURL=public-evidence.d.ts.map

package/dist/routes/public-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-evidence.d.ts","sourceRoot":"","sources":["../../src/routes/public-evidence.ts"],"names":[],"mappings":"AAwBA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKrC,CAAA;AAEF,oGAAoG;AACpG,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKzC,CAAA"}

package/dist/routes/public-evidence.js

@@ -0,0 +1,42 @@
+import { defineApiContract } from '@toad-contracts/valibot';
+import { prVerificationReportSchema } from '../pr-report.js';
+import { publicRunArtifactListSchema } from '../public-evidence.js';
+import { errorResponses, singleStringParam } from './_shared.js';
+// ---------------------------------------------------------------------------
+// Route contracts for the public run-EVIDENCE surface: absolute `/api/v1` paths,
+// authenticated in-controller by a public-API key at `read` scope. The wire shapes and the
+// reasoning behind them live in `../public-evidence.ts`.
+//
+// The two reads here are addressed under `/api/v1/runs/:runId/*`, beside the parked-decision
+// routes rather than under `/api/v1/debug/*`, and that is a statement about what they are: a
+// run's evidence is the thing a consumer ACTS on (accept the change, score the run), where the
+// debug surface is what someone reads when a run went wrong. They are workspace-scoped like the
+// debug reads, though. See `PublicEvidenceController` for why the narrower decision scope
+// would be the wrong reach for a consumer whose job is auditing a board.
+//
+// The BYTES (`GET /api/v1/artifacts/:artifactId/blob`) are deliberately not a contract: the
+// response is an image, not JSON, so it is a hand-mounted Hono route documented by hand in
+// `scripts/generate-openapi.mjs`, the same treatment the two SSE endpoints get.
+// ---------------------------------------------------------------------------
+const runIdParams = singleStringParam('runId');
+/**
+ * The run's verification report: the engine's bundle of captured facts, byte-for-byte what it
+ * maintains on the pull request, composed on read from the run's persisted state.
+ *
+ * A consumer that scraped the fenced JSON block out of a PR body can read it here instead, and
+ * gets it for the runs that never opened a pull request at all.
+ */
+export const getPublicRunReportContract = defineApiContract({
+    method: 'get',
+    requestPathParamsSchema: runIdParams,
+    pathResolver: ({ runId }) => `/api/v1/runs/${runId}/report`,
+    responsesByStatusCode: { 200: prVerificationReportSchema, ...errorResponses },
+});
+/** The binary artifacts the run captured (metadata; the bytes are a second, per-artifact fetch). */
+export const listPublicRunArtifactsContract = defineApiContract({
+    method: 'get',
+    requestPathParamsSchema: runIdParams,
+    pathResolver: ({ runId }) => `/api/v1/runs/${runId}/artifacts`,
+    responsesByStatusCode: { 200: publicRunArtifactListSchema, ...errorResponses },
+});
+//# sourceMappingURL=public-evidence.js.map

package/dist/routes/public-evidence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-evidence.js","sourceRoot":"","sources":["../../src/routes/public-evidence.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAA;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAEhE,8EAA8E;AAC9E,iFAAiF;AACjF,2FAA2F;AAC3F,yDAAyD;AACzD,EAAE;AACF,6FAA6F;AAC7F,6FAA6F;AAC7F,+FAA+F;AAC/F,gGAAgG;AAChG,0FAA0F;AAC1F,yEAAyE;AACzE,EAAE;AACF,4FAA4F;AAC5F,2FAA2F;AAC3F,gFAAgF;AAChF,8EAA8E;AAE9E,MAAM,WAAW,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAA;AAE9C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,iBAAiB,CAAC;IAC1D,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,WAAW;IACpC,YAAY,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,gBAAgB,KAAK,SAAS;IAC3D,qBAAqB,EAAE,EAAE,GAAG,EAAE,0BAA0B,EAAE,GAAG,cAAc,EAAE;CAC9E,CAAC,CAAA;AAEF,oGAAoG;AACpG,MAAM,CAAC,MAAM,8BAA8B,GAAG,iBAAiB,CAAC;IAC9D,MAAM,EAAE,KAAK;IACb,uBAAuB,EAAE,WAAW;IACpC,YAAY,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,gBAAgB,KAAK,YAAY;IAC9D,qBAAqB,EAAE,EAAE,GAAG,EAAE,2BAA2B,EAAE,GAAG,cAAc,EAAE;CAC/E,CAAC,CAAA"}

package/dist/routes/visual-confirm.d.ts

@@ -82,6 +82,7 @@ export declare const approveVisualConfirmContract: {
                         readonly branch: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                     }, undefined>, undefined>, undefined>;
                     readonly lastVerdict: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["pass", "pending", "fail"], undefined>, undefined>, undefined>;
+                    readonly config: v.OptionalSchema<v.NullableSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 80, undefined>]>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>, v.MaxLengthAction<string[], 50, undefined>]>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
                     readonly lastFailureSummary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
                     readonly failingChecks: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
                         readonly name: v.StringSchema<undefined>;
@@ -355,6 +356,16 @@ export declare const approveVisualConfirmContract: {
                         readonly anchorId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                         readonly body: v.StringSchema<undefined>;
                     }, undefined>, undefined>, undefined>;
+                    readonly requiredApprovals: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+                    readonly approverPolicy: v.OptionalSchema<v.ObjectSchema<{
+                        readonly roles: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["admin", "member", "viewer"], undefined>, undefined>, undefined>;
+                        readonly userIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    }, undefined>, undefined>;
+                    readonly approvals: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                        readonly actorId: v.StringSchema<undefined>;
+                        readonly actorLabel: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                        readonly at: v.NumberSchema<undefined>;
+                    }, undefined>, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
                 readonly companion: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
                     readonly threshold: v.NumberSchema<undefined>;
@@ -652,6 +663,14 @@ export declare const approveVisualConfirmContract: {
                         readonly modalities: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<["image", "audio", "video", "3d-model", "3d-scene", "document"], undefined>, undefined>, undefined>;
                         readonly mediaTypes: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.ToLowerCaseAction, v.MinLengthAction<string, 3, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "must be a media type of the form type/subtype">]>, undefined>, undefined>;
                     }, undefined>, undefined>;
+                    readonly gateConfig: v.OptionalSchema<v.ObjectSchema<{
+                        readonly approvers: v.OptionalSchema<v.ObjectSchema<{
+                            readonly roles: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["admin", "member", "viewer"], undefined>, undefined>, undefined>;
+                            readonly userIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+                        }, undefined>, undefined>;
+                        readonly minApprovals: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 10, undefined>]>, undefined>;
+                        readonly fields: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 80, undefined>]>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>, v.MaxLengthAction<string[], 50, undefined>]>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>;
+                    }, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
                 readonly skipped: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
                 readonly noBusinessSpecs: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
@@ -1145,6 +1164,7 @@ export declare const requestVisualConfirmFixContract: {
                         readonly branch: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                     }, undefined>, undefined>, undefined>;
                     readonly lastVerdict: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["pass", "pending", "fail"], undefined>, undefined>, undefined>;
+                    readonly config: v.OptionalSchema<v.NullableSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 80, undefined>]>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>, v.MaxLengthAction<string[], 50, undefined>]>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
                     readonly lastFailureSummary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
                     readonly failingChecks: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
                         readonly name: v.StringSchema<undefined>;
@@ -1418,6 +1438,16 @@ export declare const requestVisualConfirmFixContract: {
                         readonly anchorId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                         readonly body: v.StringSchema<undefined>;
                     }, undefined>, undefined>, undefined>;
+                    readonly requiredApprovals: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+                    readonly approverPolicy: v.OptionalSchema<v.ObjectSchema<{
+                        readonly roles: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["admin", "member", "viewer"], undefined>, undefined>, undefined>;
+                        readonly userIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    }, undefined>, undefined>;
+                    readonly approvals: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                        readonly actorId: v.StringSchema<undefined>;
+                        readonly actorLabel: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                        readonly at: v.NumberSchema<undefined>;
+                    }, undefined>, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
                 readonly companion: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
                     readonly threshold: v.NumberSchema<undefined>;
@@ -1715,6 +1745,14 @@ export declare const requestVisualConfirmFixContract: {
                         readonly modalities: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<["image", "audio", "video", "3d-model", "3d-scene", "document"], undefined>, undefined>, undefined>;
                         readonly mediaTypes: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.ToLowerCaseAction, v.MinLengthAction<string, 3, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "must be a media type of the form type/subtype">]>, undefined>, undefined>;
                     }, undefined>, undefined>;
+                    readonly gateConfig: v.OptionalSchema<v.ObjectSchema<{
+                        readonly approvers: v.OptionalSchema<v.ObjectSchema<{
+                            readonly roles: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["admin", "member", "viewer"], undefined>, undefined>, undefined>;
+                            readonly userIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+                        }, undefined>, undefined>;
+                        readonly minApprovals: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 10, undefined>]>, undefined>;
+                        readonly fields: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 80, undefined>]>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>, v.MaxLengthAction<string[], 50, undefined>]>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>;
+                    }, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
                 readonly skipped: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
                 readonly noBusinessSpecs: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
@@ -2206,6 +2244,7 @@ export declare const recaptureVisualConfirmContract: {
                         readonly branch: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                     }, undefined>, undefined>, undefined>;
                     readonly lastVerdict: v.OptionalSchema<v.NullableSchema<v.PicklistSchema<["pass", "pending", "fail"], undefined>, undefined>, undefined>;
+                    readonly config: v.OptionalSchema<v.NullableSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 80, undefined>]>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>, v.MaxLengthAction<string[], 50, undefined>]>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>, undefined>;
                     readonly lastFailureSummary: v.OptionalSchema<v.NullableSchema<v.StringSchema<undefined>, undefined>, undefined>;
                     readonly failingChecks: v.OptionalSchema<v.NullableSchema<v.ArraySchema<v.ObjectSchema<{
                         readonly name: v.StringSchema<undefined>;
@@ -2479,6 +2518,16 @@ export declare const recaptureVisualConfirmContract: {
                         readonly anchorId: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
                         readonly body: v.StringSchema<undefined>;
                     }, undefined>, undefined>, undefined>;
+                    readonly requiredApprovals: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+                    readonly approverPolicy: v.OptionalSchema<v.ObjectSchema<{
+                        readonly roles: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["admin", "member", "viewer"], undefined>, undefined>, undefined>;
+                        readonly userIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+                    }, undefined>, undefined>;
+                    readonly approvals: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                        readonly actorId: v.StringSchema<undefined>;
+                        readonly actorLabel: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                        readonly at: v.NumberSchema<undefined>;
+                    }, undefined>, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
                 readonly companion: v.OptionalSchema<v.NullableSchema<v.ObjectSchema<{
                     readonly threshold: v.NumberSchema<undefined>;
@@ -2776,6 +2825,14 @@ export declare const recaptureVisualConfirmContract: {
                         readonly modalities: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<["image", "audio", "video", "3d-model", "3d-scene", "document"], undefined>, undefined>, undefined>;
                         readonly mediaTypes: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.ToLowerCaseAction, v.MinLengthAction<string, 3, undefined>, v.MaxLengthAction<string, 128, undefined>, v.RegexAction<string, "must be a media type of the form type/subtype">]>, undefined>, undefined>;
                     }, undefined>, undefined>;
+                    readonly gateConfig: v.OptionalSchema<v.ObjectSchema<{
+                        readonly approvers: v.OptionalSchema<v.ObjectSchema<{
+                            readonly roles: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<readonly ["admin", "member", "viewer"], undefined>, undefined>, undefined>;
+                            readonly userIds: v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>;
+                        }, undefined>, undefined>;
+                        readonly minApprovals: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 10, undefined>]>, undefined>;
+                        readonly fields: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, 80, undefined>]>, v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, v.SchemaWithPipe<readonly [v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MaxLengthAction<string, 2000, undefined>]>, undefined>, v.MaxLengthAction<string[], 50, undefined>]>, v.BooleanSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, undefined>;
+                    }, undefined>, undefined>;
                 }, undefined>, undefined>, undefined>;
                 readonly skipped: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
                 readonly noBusinessSpecs: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;

package/dist/routes/visual-confirm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"visual-confirm.d.ts","sourceRoot":"","sources":["../../src/routes/visual-confirm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqC,MAAM,yBAAyB,CAAA;AAC3F,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAc5B,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMvC,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM1C,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMzC,CAAA"}
+{"version":3,"file":"visual-confirm.d.ts","sourceRoot":"","sources":["../../src/routes/visual-confirm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqC,MAAM,yBAAyB,CAAA;AAC3F,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAc5B,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMvC,CAAA;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAM1C,CAAA;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMzC,CAAA"}