anpord 0.1.24 → 0.1.26

package/README.md

@@ -1,6 +1,6 @@
 # anpord
 
-TypeScript SDK for [Anpord](https://anpord.com). Define coding-agent evals, run them across agents and sandboxes, and manage versioned prompts.
+TypeScript SDK and CLI for [Anpord](https://anpord.com). Define coding-agent evals, run them on different harnesses, models and sandboxes, and manage versioned prompts.
 
 ## Install
 
@@ -8,32 +8,44 @@ TypeScript SDK for [Anpord](https://anpord.com). Define coding-agent evals, run
 npm install anpord
 ```
 
-## Define an eval
+## Define a suite
+
+A suite groups cases that share a prompt and setup. Suites and cases need an `id`, a lowercase handle such as `writes-hello`; a `name` is optional and defaults to the id. Each variant is a harness, model and sandbox to run every case on, with an optional profile.
 
 ```ts
-import { suite, empty } from "anpord";
+import { command, suite, empty } from "anpord";
 
 export default suite({
-  name: "greeting",
+  id: "greeting",
   source: empty,
   prompt: "{{task}}",
   cases: [
     {
-      name: "writes hello",
+      id: "writes-hello",
       variables: { task: "Create hello.txt containing exactly hello" },
-      verify: 'test "$(cat hello.txt)" = hello',
+      validate: command('test "$(cat hello.txt)" = hello'),
+    },
+  ],
+  variants: [
+    { harness: "codex", model: "gpt-5.6-sol" },
+    { harness: "claude", model: "sonnet", sandbox: "daytona" },
+    {
+      harness: "opencode",
+      model: "anthropic/claude-sonnet-4.6",
+      profile: { dir: "./profiles/strict", name: "strict" },
     },
   ],
-  tasks: [{ harness: "codex", model: "model-id", provider: "daytona" }],
   trials: 3,
 });
 ```
 
+A case has one `validate`: a shell `command(...)` whose exit code decides the trial, a validator function, a model judge, or an array of validators and judges that must all pass. A command decides a case on its own and cannot go in an array.
+
 ```sh
 npx anpord eval ./greeting.eval.ts
 ```
 
-With no file, the CLI discovers every `**/*.eval.ts` suite.
+Each file starts a batch: one run per case per variant. Each run makes `trials` attempts, each in its own sandbox. With no file, the CLI finds every `*.eval.ts` file under the current directory.
 
 ## Mock MCP and CLI
 
@@ -82,7 +94,7 @@ export const usersCli = cli({
 });
 ```
 
-Attach definitions with `mcp: [usersMcp]` or `cli: [usersCli]`. Handlers use plain TypeScript. Schemas infer handler types and validate calls at runtime.
+Attach them to a suite with `mcp: [usersMcp]` or `cli: [usersCli]`. Schemas type the handlers and validate calls at runtime. The `command` from `anpord/cli` declares a mock CLI command, unlike the `command` validator from `anpord`, so alias one of them in a file that imports both.
 
 ## Model judges
 
@@ -99,28 +111,45 @@ const correctness = judge({
 });
 ```
 
-Set `validate: correctness`, or combine it with code: `validate: [checkToolCalls, correctness]`. Every check must pass. Judges use the organization's harness connection, including Codex subscriptions. For direct OpenAI calls, use `provider: "openai"` and configure an OpenAI key in the environment connection.
+Set `validate: correctness` on a case, or combine it with code: `validate: [checkToolCalls, correctness]`. Every check must pass. A judge with `harness` uses that harness connection, including a ChatGPT sign-in for Codex. To call OpenAI directly, use `provider: "openai"` and add an OpenAI model connection.
 
-See [model judges](https://docs.anpord.com/evals/judges) for isolation, authentication, and unscored failures.
+See [model judges](https://docs.anpord.com/evals/judges) for isolation, authentication and unscored failures.
 
-## Use the API
+## Start a batch from code
 
 ```ts
 import { Anpord } from "anpord";
-import { compileEval } from "anpord/eval";
+import greeting from "./greeting.eval";
 
 const anpord = new Anpord();
-const run = await anpord.evals.startAndWait(
-  await compileEval("./greeting.eval.ts")
-);
+const batch = await anpord.evals.batches.startAndWait(greeting);
 
-console.log(run.status, run.cells);
+console.log(batch.status, batch.runs);
 await anpord.dispose();
 ```
 
-The client reads `ANPORD_API_KEY`.
+The client reads `ANPORD_API_KEY`. `batch.runs` holds one run per case and variant, each with its trials and pass rate. `evals.batches.start` returns as soon as the batch is started, and `evals.batches.wait({ id })` waits on one started earlier.
+
+## Read and rerun from code
+
+```ts
+const { cases } = await anpord.evals.cases.list({ suite: "greeting" });
+const detail = await anpord.evals.cases.get({ id: "writes-hello" });
+
+const rerun = await anpord.evals.cases.run({
+  id: "writes-hello",
+  trials: 3,
+  variants: detail.variants.map(({ variant }) => variant.id),
+});
+
+const { runs } = await anpord.evals.runs.list({ caseId: "writes-hello" });
+const run = await anpord.evals.runs.get({ id: rerun.runs[0].id });
+const models = await anpord.evals.models.list({ harness: "codex" });
+```
+
+`evals.batches`, `evals.cases`, `evals.runs` and `evals.models` follow the data model: a suite holds cases, a case runs on variants, and each run of a case on a variant holds its trials. A batch is the runs started together.
 
-See the [documentation](https://docs.anpord.com) for cases, validators, profiles, mock interfaces, prompt releases, and the API reference.
+See the [documentation](https://docs.anpord.com) for cases, validators, profiles, mocks, prompt releases and the API reference.
 
 ## License
 

package/dist/api-context.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_api_mocks = require("./api-mocks-CgiC7T9U.cjs");
+const require_api_mocks = require("./api-mocks-CMB0IJFX.cjs");
 let effect = require("effect");
 let node_fs_promises = require("node:fs/promises");
 //#region src/mock-api/context.ts

package/dist/api-context.d.cts

@@ -1,4 +1,4 @@
-import { t as ApiCall } from "./api-mocks-ofqP55P_.cjs";
+import { t as ApiCall } from "./api-mocks-CmytjGmi.cjs";
 //#region src/mock-api/context.d.ts
 declare const apiContext: {
   url: (name: string) => Promise<string>;

package/dist/api-context.d.mts

@@ -1,4 +1,4 @@
-import { t as ApiCall } from "./api-mocks-ofqP55P_.mjs";
+import { t as ApiCall } from "./api-mocks-CmytjGmi.mjs";
 //#region src/mock-api/context.d.ts
 declare const apiContext: {
   url: (name: string) => Promise<string>;

package/dist/api-context.mjs

@@ -1,4 +1,4 @@
-import { a as ApiCall, n as API_MANIFEST, o as ApiManifest, t as API_JOURNAL } from "./api-mocks-BYWvJp9v.mjs";
+import { n as API_MANIFEST, o as ApiCall, s as ApiManifest, t as API_JOURNAL } from "./api-mocks-C0uY0UBb.mjs";
 import { Schema } from "effect";
 import { readFile } from "node:fs/promises";
 //#region src/mock-api/context.ts

package/dist/api-mocks-C0uY0UBb.mjs

@@ -0,0 +1,183 @@
+import { n as EvalJudgment } from "./eval-judges-DVxvZQl5.mjs";
+import { Schema } from "effect";
+//#region ../schema/src/domain/secret-text.ts
+const REDACTED = "[redacted]";
+const KNOWN_MINIMUM = 8;
+const EDGE = "(?<![A-Za-z0-9_-])";
+const HAS_DIGIT = "(?=[A-Za-z0-9._~+/-]*[0-9])";
+const CREDENTIAL = new RegExp([
+	`${EDGE}sk-${HAS_DIGIT}[A-Za-z0-9_-]{20,}`,
+	`${EDGE}[rs]k_(?:live|test)_[A-Za-z0-9]{10,}`,
+	`${EDGE}am_sk_[A-Za-z0-9_-]+`,
+	`${EDGE}anp_[A-Za-z0-9_-]{16,}`,
+	`${EDGE}gh[pousr]_[A-Za-z0-9]{20,}`,
+	`${EDGE}github_pat_[A-Za-z0-9_]{20,}`,
+	`${EDGE}xox[abeoprs]-[A-Za-z0-9-]{10,}`,
+	`${EDGE}(?:AKIA|ASIA)[A-Z0-9]{16}`,
+	`${EDGE}AIza[A-Za-z0-9_-]{35}`,
+	`${EDGE}eyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}`,
+	`(?<=\\b[Bb]earer\\s+)${HAS_DIGIT}[A-Za-z0-9._~+/-]{16,}=*`,
+	"(?<=[a-z][a-z0-9+.-]*://[^/\\s:@]+:)[^/\\s@]+(?=@)",
+	"-----BEGIN [A-Z ]*PRIVATE KEY-----[\\s\\S]*?-----END [A-Z ]*PRIVATE KEY-----"
+].join("|"), "g");
+const escapedForms = (value) => [value, JSON.stringify(value).slice(1, -1)];
+const redactSecrets = (text, known = []) => known.filter((value) => value.length >= KNOWN_MINIMUM).flatMap(escapedForms).toSorted((left, right) => right.length - left.length).reduce((redacted, value) => redacted.replaceAll(value, REDACTED), text).replace(CREDENTIAL, REDACTED);
+//#endregion
+//#region ../schema/src/domain/eval-validations.ts
+const VALIDATION_TEXT_LIMIT = 16e3;
+const VALIDATION_BUDGET = 64e3;
+const VALIDATION_FRAME = "ANPORD_VALIDATION=";
+const EVIDENCE_LIMITS = {
+	budget: VALIDATION_BUDGET,
+	text: VALIDATION_TEXT_LIMIT
+};
+const REPORTED_LIMITS = {
+	budget: 192e3,
+	text: 64e3
+};
+const valueWithin = (limit) => Schema.Struct({
+	text: Schema.String.pipe(Schema.maxLength(limit)),
+	format: Schema.Literal("text", "json"),
+	state: Schema.Literal("captured", "disabled", "unavailable"),
+	truncated: Schema.Boolean
+});
+const callOf = (value) => Schema.Struct({
+	index: Schema.NonNegativeInt,
+	method: Schema.Literal("answer", "transcript", "turns", "readText", "exists", "exec", "cli.calls", "api.calls", "api.url", "mcp.calls"),
+	startedAt: Schema.Number,
+	durationMs: Schema.NullOr(Schema.NonNegativeInt),
+	input: value,
+	output: value,
+	error: Schema.NullOr(value)
+});
+const validationOf = (value, call) => Schema.Struct({
+	id: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(200)),
+	index: Schema.NonNegativeInt,
+	name: Schema.String.pipe(Schema.maxLength(200)),
+	kind: Schema.Literal("code", "judge", "command"),
+	status: Schema.Literal("queued", "running", "passed", "failed", "error", "skipped"),
+	startedAt: Schema.NullOr(Schema.Number),
+	durationMs: Schema.NullOr(Schema.NonNegativeInt),
+	message: Schema.String.pipe(Schema.maxLength(2e3)),
+	exitCode: Schema.NullOr(Schema.Int),
+	truncated: Schema.Boolean,
+	judgment: Schema.optional(EvalJudgment),
+	input: value,
+	output: value,
+	error: Schema.NullOr(value),
+	metadata: Schema.optional(value),
+	calls: Schema.Array(call).pipe(Schema.maxItems(64)),
+	logs: Schema.Array(Schema.Struct({
+		index: Schema.NonNegativeInt,
+		at: Schema.Number,
+		level: Schema.Literal("stdout", "stderr"),
+		value
+	})).pipe(Schema.maxItems(64))
+});
+const ValidationValue = valueWithin(VALIDATION_TEXT_LIMIT).annotations({ identifier: "ValidationValue" });
+const EvalValidation = validationOf(ValidationValue, callOf(ValidationValue).annotations({ identifier: "ValidationCall" })).annotations({ identifier: "EvalValidation" });
+const ReportedValue = valueWithin(REPORTED_LIMITS.text);
+const ReportedValidation = validationOf(ReportedValue, callOf(ReportedValue));
+const EvalValidations = Schema.Array(EvalValidation).pipe(Schema.maxItems(40)).annotations({ identifier: "EvalValidations" });
+const validationSnapshot = (value) => ({
+	...value,
+	truncated: value.truncated || [
+		value.input,
+		value.output,
+		value.error,
+		value.metadata,
+		...value.calls.flatMap((call) => [
+			call.input,
+			call.output,
+			call.error
+		]),
+		...value.logs.map((log) => log.value)
+	].some((field) => field?.truncated)
+});
+const unavailableValue = {
+	text: "",
+	format: "text",
+	state: "unavailable",
+	truncated: false
+};
+const validationCapture = (enabled = true, secrets = [], limits = EVIDENCE_LIMITS) => {
+	let remaining = limits.budget;
+	return (value, format = "json") => {
+		if (!enabled) return {
+			...unavailableValue,
+			state: "disabled",
+			format
+		};
+		try {
+			const encoded = format === "text" ? String(value) : JSON.stringify(value);
+			if (encoded === void 0) return {
+				...unavailableValue,
+				format
+			};
+			const raw = redactSecrets(encoded, secrets);
+			const text = raw.slice(0, Math.min(remaining, limits.text));
+			remaining -= text.length;
+			return {
+				text,
+				format,
+				state: "captured",
+				truncated: text.length < raw.length
+			};
+		} catch {
+			return {
+				...unavailableValue,
+				format
+			};
+		}
+	};
+};
+const validationExecution = (identity, startedAt) => ({
+	...identity,
+	startedAt,
+	status: startedAt === null ? "skipped" : "running",
+	durationMs: null,
+	exitCode: null,
+	message: "",
+	truncated: false,
+	input: unavailableValue,
+	output: unavailableValue,
+	error: null,
+	calls: [],
+	logs: []
+});
+//#endregion
+//#region ../schema/src/domain/api-mocks.ts
+const API_PROGRAM = "workspace/.anpord/api/program.json";
+const API_MANIFEST = ".anpord/api/manifest.json";
+const API_JOURNAL = ".anpord/api/calls.jsonl";
+const API_READY = "ANPORD_API_READY=";
+const API_REPORTED_LIMITS = {
+	budget: 96e3,
+	text: 64e3
+};
+const ApiProgram = Schema.Struct({ entry: Schema.Literal(".anpord/api/server.mjs") });
+const ApiManifest = Schema.Array(Schema.Struct({
+	name: Schema.String,
+	url: Schema.String,
+	endpoints: Schema.Array(Schema.Struct({
+		method: Schema.String,
+		path: Schema.String,
+		description: Schema.optional(Schema.String)
+	}))
+}));
+var ApiCall = class extends Schema.Class("ApiCall")({
+	api: Schema.String,
+	index: Schema.NonNegativeInt,
+	method: Schema.String,
+	path: Schema.String,
+	matched: Schema.Boolean,
+	startedAt: Schema.Number,
+	durationMs: Schema.NonNegativeInt,
+	input: ReportedValue,
+	output: ReportedValue,
+	status: Schema.Int,
+	error: Schema.NullOr(Schema.String.pipe(Schema.maxLength(2e3))),
+	logs: Schema.Array(ReportedValue).pipe(Schema.maxItems(64))
+}) {};
+//#endregion
+export { validationExecution as _, API_REPORTED_LIMITS as a, ApiProgram as c, REPORTED_LIMITS as d, ReportedValidation as f, validationCapture as g, unavailableValue as h, API_READY as i, EVIDENCE_LIMITS as l, VALIDATION_TEXT_LIMIT as m, API_MANIFEST as n, ApiCall as o, VALIDATION_FRAME as p, API_PROGRAM as r, ApiManifest as s, API_JOURNAL as t, EvalValidations as u, validationSnapshot as v, redactSecrets as y };

package/dist/api-mocks-CMB0IJFX.cjs

@@ -0,0 +1,296 @@
+const require_eval_judges = require("./eval-judges-CO0ds-HQ.cjs");
+let effect = require("effect");
+//#region ../schema/src/domain/secret-text.ts
+const REDACTED = "[redacted]";
+const KNOWN_MINIMUM = 8;
+const EDGE = "(?<![A-Za-z0-9_-])";
+const HAS_DIGIT = "(?=[A-Za-z0-9._~+/-]*[0-9])";
+const CREDENTIAL = new RegExp([
+	`${EDGE}sk-${HAS_DIGIT}[A-Za-z0-9_-]{20,}`,
+	`${EDGE}[rs]k_(?:live|test)_[A-Za-z0-9]{10,}`,
+	`${EDGE}am_sk_[A-Za-z0-9_-]+`,
+	`${EDGE}anp_[A-Za-z0-9_-]{16,}`,
+	`${EDGE}gh[pousr]_[A-Za-z0-9]{20,}`,
+	`${EDGE}github_pat_[A-Za-z0-9_]{20,}`,
+	`${EDGE}xox[abeoprs]-[A-Za-z0-9-]{10,}`,
+	`${EDGE}(?:AKIA|ASIA)[A-Z0-9]{16}`,
+	`${EDGE}AIza[A-Za-z0-9_-]{35}`,
+	`${EDGE}eyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}`,
+	`(?<=\\b[Bb]earer\\s+)${HAS_DIGIT}[A-Za-z0-9._~+/-]{16,}=*`,
+	"(?<=[a-z][a-z0-9+.-]*://[^/\\s:@]+:)[^/\\s@]+(?=@)",
+	"-----BEGIN [A-Z ]*PRIVATE KEY-----[\\s\\S]*?-----END [A-Z ]*PRIVATE KEY-----"
+].join("|"), "g");
+const escapedForms = (value) => [value, JSON.stringify(value).slice(1, -1)];
+const redactSecrets = (text, known = []) => known.filter((value) => value.length >= KNOWN_MINIMUM).flatMap(escapedForms).toSorted((left, right) => right.length - left.length).reduce((redacted, value) => redacted.replaceAll(value, REDACTED), text).replace(CREDENTIAL, REDACTED);
+//#endregion
+//#region ../schema/src/domain/eval-validations.ts
+const VALIDATION_TEXT_LIMIT = 16e3;
+const VALIDATION_BUDGET = 64e3;
+const VALIDATION_FRAME = "ANPORD_VALIDATION=";
+const EVIDENCE_LIMITS = {
+	budget: VALIDATION_BUDGET,
+	text: VALIDATION_TEXT_LIMIT
+};
+const REPORTED_LIMITS = {
+	budget: 192e3,
+	text: 64e3
+};
+const valueWithin = (limit) => effect.Schema.Struct({
+	text: effect.Schema.String.pipe(effect.Schema.maxLength(limit)),
+	format: effect.Schema.Literal("text", "json"),
+	state: effect.Schema.Literal("captured", "disabled", "unavailable"),
+	truncated: effect.Schema.Boolean
+});
+const callOf = (value) => effect.Schema.Struct({
+	index: effect.Schema.NonNegativeInt,
+	method: effect.Schema.Literal("answer", "transcript", "turns", "readText", "exists", "exec", "cli.calls", "api.calls", "api.url", "mcp.calls"),
+	startedAt: effect.Schema.Number,
+	durationMs: effect.Schema.NullOr(effect.Schema.NonNegativeInt),
+	input: value,
+	output: value,
+	error: effect.Schema.NullOr(value)
+});
+const validationOf = (value, call) => effect.Schema.Struct({
+	id: effect.Schema.String.pipe(effect.Schema.minLength(1), effect.Schema.maxLength(200)),
+	index: effect.Schema.NonNegativeInt,
+	name: effect.Schema.String.pipe(effect.Schema.maxLength(200)),
+	kind: effect.Schema.Literal("code", "judge", "command"),
+	status: effect.Schema.Literal("queued", "running", "passed", "failed", "error", "skipped"),
+	startedAt: effect.Schema.NullOr(effect.Schema.Number),
+	durationMs: effect.Schema.NullOr(effect.Schema.NonNegativeInt),
+	message: effect.Schema.String.pipe(effect.Schema.maxLength(2e3)),
+	exitCode: effect.Schema.NullOr(effect.Schema.Int),
+	truncated: effect.Schema.Boolean,
+	judgment: effect.Schema.optional(require_eval_judges.EvalJudgment),
+	input: value,
+	output: value,
+	error: effect.Schema.NullOr(value),
+	metadata: effect.Schema.optional(value),
+	calls: effect.Schema.Array(call).pipe(effect.Schema.maxItems(64)),
+	logs: effect.Schema.Array(effect.Schema.Struct({
+		index: effect.Schema.NonNegativeInt,
+		at: effect.Schema.Number,
+		level: effect.Schema.Literal("stdout", "stderr"),
+		value
+	})).pipe(effect.Schema.maxItems(64))
+});
+const ValidationValue = valueWithin(VALIDATION_TEXT_LIMIT).annotations({ identifier: "ValidationValue" });
+const EvalValidation = validationOf(ValidationValue, callOf(ValidationValue).annotations({ identifier: "ValidationCall" })).annotations({ identifier: "EvalValidation" });
+const ReportedValue = valueWithin(REPORTED_LIMITS.text);
+const ReportedValidation = validationOf(ReportedValue, callOf(ReportedValue));
+const EvalValidations = effect.Schema.Array(EvalValidation).pipe(effect.Schema.maxItems(40)).annotations({ identifier: "EvalValidations" });
+const validationSnapshot = (value) => ({
+	...value,
+	truncated: value.truncated || [
+		value.input,
+		value.output,
+		value.error,
+		value.metadata,
+		...value.calls.flatMap((call) => [
+			call.input,
+			call.output,
+			call.error
+		]),
+		...value.logs.map((log) => log.value)
+	].some((field) => field?.truncated)
+});
+const unavailableValue = {
+	text: "",
+	format: "text",
+	state: "unavailable",
+	truncated: false
+};
+const validationCapture = (enabled = true, secrets = [], limits = EVIDENCE_LIMITS) => {
+	let remaining = limits.budget;
+	return (value, format = "json") => {
+		if (!enabled) return {
+			...unavailableValue,
+			state: "disabled",
+			format
+		};
+		try {
+			const encoded = format === "text" ? String(value) : JSON.stringify(value);
+			if (encoded === void 0) return {
+				...unavailableValue,
+				format
+			};
+			const raw = redactSecrets(encoded, secrets);
+			const text = raw.slice(0, Math.min(remaining, limits.text));
+			remaining -= text.length;
+			return {
+				text,
+				format,
+				state: "captured",
+				truncated: text.length < raw.length
+			};
+		} catch {
+			return {
+				...unavailableValue,
+				format
+			};
+		}
+	};
+};
+const validationExecution = (identity, startedAt) => ({
+	...identity,
+	startedAt,
+	status: startedAt === null ? "skipped" : "running",
+	durationMs: null,
+	exitCode: null,
+	message: "",
+	truncated: false,
+	input: unavailableValue,
+	output: unavailableValue,
+	error: null,
+	calls: [],
+	logs: []
+});
+//#endregion
+//#region ../schema/src/domain/api-mocks.ts
+const API_PROGRAM = "workspace/.anpord/api/program.json";
+const API_MANIFEST = ".anpord/api/manifest.json";
+const API_JOURNAL = ".anpord/api/calls.jsonl";
+const API_READY = "ANPORD_API_READY=";
+const API_REPORTED_LIMITS = {
+	budget: 96e3,
+	text: 64e3
+};
+const ApiProgram = effect.Schema.Struct({ entry: effect.Schema.Literal(".anpord/api/server.mjs") });
+const ApiManifest = effect.Schema.Array(effect.Schema.Struct({
+	name: effect.Schema.String,
+	url: effect.Schema.String,
+	endpoints: effect.Schema.Array(effect.Schema.Struct({
+		method: effect.Schema.String,
+		path: effect.Schema.String,
+		description: effect.Schema.optional(effect.Schema.String)
+	}))
+}));
+var ApiCall = class extends effect.Schema.Class("ApiCall")({
+	api: effect.Schema.String,
+	index: effect.Schema.NonNegativeInt,
+	method: effect.Schema.String,
+	path: effect.Schema.String,
+	matched: effect.Schema.Boolean,
+	startedAt: effect.Schema.Number,
+	durationMs: effect.Schema.NonNegativeInt,
+	input: ReportedValue,
+	output: ReportedValue,
+	status: effect.Schema.Int,
+	error: effect.Schema.NullOr(effect.Schema.String.pipe(effect.Schema.maxLength(2e3))),
+	logs: effect.Schema.Array(ReportedValue).pipe(effect.Schema.maxItems(64))
+}) {};
+//#endregion
+Object.defineProperty(exports, "API_JOURNAL", {
+	enumerable: true,
+	get: function() {
+		return API_JOURNAL;
+	}
+});
+Object.defineProperty(exports, "API_MANIFEST", {
+	enumerable: true,
+	get: function() {
+		return API_MANIFEST;
+	}
+});
+Object.defineProperty(exports, "API_PROGRAM", {
+	enumerable: true,
+	get: function() {
+		return API_PROGRAM;
+	}
+});
+Object.defineProperty(exports, "API_READY", {
+	enumerable: true,
+	get: function() {
+		return API_READY;
+	}
+});
+Object.defineProperty(exports, "API_REPORTED_LIMITS", {
+	enumerable: true,
+	get: function() {
+		return API_REPORTED_LIMITS;
+	}
+});
+Object.defineProperty(exports, "ApiCall", {
+	enumerable: true,
+	get: function() {
+		return ApiCall;
+	}
+});
+Object.defineProperty(exports, "ApiManifest", {
+	enumerable: true,
+	get: function() {
+		return ApiManifest;
+	}
+});
+Object.defineProperty(exports, "ApiProgram", {
+	enumerable: true,
+	get: function() {
+		return ApiProgram;
+	}
+});
+Object.defineProperty(exports, "EVIDENCE_LIMITS", {
+	enumerable: true,
+	get: function() {
+		return EVIDENCE_LIMITS;
+	}
+});
+Object.defineProperty(exports, "EvalValidations", {
+	enumerable: true,
+	get: function() {
+		return EvalValidations;
+	}
+});
+Object.defineProperty(exports, "REPORTED_LIMITS", {
+	enumerable: true,
+	get: function() {
+		return REPORTED_LIMITS;
+	}
+});
+Object.defineProperty(exports, "ReportedValidation", {
+	enumerable: true,
+	get: function() {
+		return ReportedValidation;
+	}
+});
+Object.defineProperty(exports, "VALIDATION_FRAME", {
+	enumerable: true,
+	get: function() {
+		return VALIDATION_FRAME;
+	}
+});
+Object.defineProperty(exports, "VALIDATION_TEXT_LIMIT", {
+	enumerable: true,
+	get: function() {
+		return VALIDATION_TEXT_LIMIT;
+	}
+});
+Object.defineProperty(exports, "redactSecrets", {
+	enumerable: true,
+	get: function() {
+		return redactSecrets;
+	}
+});
+Object.defineProperty(exports, "unavailableValue", {
+	enumerable: true,
+	get: function() {
+		return unavailableValue;
+	}
+});
+Object.defineProperty(exports, "validationCapture", {
+	enumerable: true,
+	get: function() {
+		return validationCapture;
+	}
+});
+Object.defineProperty(exports, "validationExecution", {
+	enumerable: true,
+	get: function() {
+		return validationExecution;
+	}
+});
+Object.defineProperty(exports, "validationSnapshot", {
+	enumerable: true,
+	get: function() {
+		return validationSnapshot;
+	}
+});