anpord 0.1.2 → 0.1.4

package/dist/compiler-CKiewwUc.mjs

@@ -0,0 +1,188 @@
+import { a as parseRepo, i as cloneUrlOf, r as repo } from "./source-Fg1h2VNn.mjs";
+import { Effect, Option } from "effect";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { build } from "esbuild";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/evals/local-repo.ts
+const run = promisify(execFile);
+const git = (args, cwd) => Effect.tryPromise(() => run("git", [...args], { cwd })).pipe(Effect.map(({ stdout }) => stdout.trim()), Effect.orElseSucceed(() => ""));
+const environment = () => globalThis.process?.env ?? {};
+const remoteUrl = (cwd) => Effect.gen(function* () {
+	const { GITHUB_REPOSITORY } = environment();
+	const origin = yield* git([
+		"remote",
+		"get-url",
+		"origin"
+	], cwd);
+	return origin === "" && GITHUB_REPOSITORY !== void 0 ? GITHUB_REPOSITORY : origin;
+});
+const fetchableRef = (cwd) => Effect.gen(function* () {
+	const { GITHUB_HEAD_REF } = environment();
+	if (GITHUB_HEAD_REF !== void 0 && GITHUB_HEAD_REF !== "") return GITHUB_HEAD_REF;
+	const [head, onRemote] = yield* Effect.all([git(["rev-parse", "HEAD"], cwd), git([
+		"branch",
+		"--remotes",
+		"--contains",
+		"HEAD"
+	], cwd)], { concurrency: 2 });
+	return head === "" || onRemote === "" ? null : head;
+});
+const localRepo = (cwd) => Effect.gen(function* () {
+	const [remote, ref] = yield* Effect.all([remoteUrl(cwd), fetchableRef(cwd)], { concurrency: 2 });
+	const parsed = remote === "" ? null : parseRepo(remote);
+	return parsed === null ? Option.none() : Option.some({
+		kind: "repo",
+		ref,
+		url: cloneUrlOf(parsed)
+	});
+}).pipe(Effect.withSpan("Eval.localRepo"));
+//#endregion
+//#region src/evals/runner-source.ts
+const runtime = `
+import { access, readFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+
+const exec = (command) => new Promise((resolve, reject) => {
+  const child = spawn("/bin/sh", ["-lc", command], { cwd: process.cwd() });
+  let stderr = "";
+  let stdout = "";
+  child.stderr.on("data", chunk => { stderr += chunk; });
+  child.stdout.on("data", chunk => { stdout += chunk; });
+  child.on("error", reject);
+  child.on("close", code => resolve({ exitCode: code ?? 1, stderr, stdout }));
+});
+
+const context = {
+  exec,
+  exists: path => access(path).then(() => true, () => false),
+  readText: path => readFile(path, "utf8"),
+};
+
+try {
+  const raw = await validate(context);
+  const result = typeof raw === "boolean" ? { passed: raw } : raw;
+  if (typeof result?.passed !== "boolean") throw new Error("A validator must return a boolean or { passed, message? }");
+  console.log("ANPORD_VALIDATOR_RESULT=" + JSON.stringify(result));
+} catch (error) {
+  console.error(error instanceof Error ? error.stack : String(error));
+  process.exitCode = 1;
+}
+`;
+const validatorEntry = (module, name) => `import { ${name} as validate } from ${JSON.stringify(module)};\n${runtime}`;
+const definitionEntry = (entry) => `import definition from ${JSON.stringify(entry)}; export default definition;`;
+//#endregion
+//#region src/evals/compiler.ts
+const authoringExports = ["export const defineEval = value => value;", `export { empty, files, repo } from "./source";`].join("\n");
+const authoringDir = dirname(fileURLToPath(import.meta.url));
+const ANPORD_MODULE = /^anpord$/;
+const ANY_MODULE = /.*/;
+const authoringModule = {
+	name: "anpord-authoring",
+	setup: (compiler) => {
+		compiler.onResolve({ filter: ANPORD_MODULE }, () => ({
+			namespace: "anpord-authoring",
+			path: "anpord"
+		}));
+		compiler.onLoad({
+			filter: ANY_MODULE,
+			namespace: "anpord-authoring"
+		}, () => ({
+			contents: authoringExports,
+			loader: "js",
+			resolveDir: authoringDir
+		}));
+	}
+};
+const bundle = (contents, entry) => Effect.tryPromise({
+	try: () => build({
+		absWorkingDir: process.cwd(),
+		bundle: true,
+		format: "esm",
+		metafile: true,
+		platform: "node",
+		resolveExtensions: [
+			".ts",
+			".mjs",
+			".js",
+			".cjs",
+			".json"
+		],
+		plugins: [authoringModule],
+		stdin: {
+			contents,
+			resolveDir: process.cwd(),
+			sourcefile: "anpord-eval-entry.ts"
+		},
+		target: "node18",
+		treeShaking: true,
+		write: false
+	}).then((result) => ({
+		inputs: Object.keys(result.metafile?.inputs ?? {}).map((path) => resolve(path)),
+		source: result.outputFiles[0]?.text ?? ""
+	})),
+	catch: (cause) => new Error(`Could not compile ${entry}`, { cause })
+});
+const loadDefinition = (entry) => bundle(definitionEntry(entry), entry).pipe(Effect.flatMap(({ inputs, source }) => Effect.acquireUseRelease(Effect.tryPromise(() => mkdtemp(join(tmpdir(), "anpord-eval-"))), (directory) => Effect.tryPromise({
+	try: async () => {
+		const output = join(directory, "definition.mjs");
+		await writeFile(output, source);
+		return {
+			definition: (await import(pathToFileURL(output).href)).default,
+			inputs
+		};
+	},
+	catch: (cause) => new Error(`Could not load ${entry}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause })
+}), (directory) => Effect.promise(() => rm(directory, {
+	force: true,
+	recursive: true
+})).pipe(Effect.ignore))));
+const validatorModule = (entry, inputs, name) => Effect.gen(function* () {
+	const pattern = new RegExp(`\\bexport\\s+(?:async\\s+)?(?:const|function)\\s+${name}\\b`);
+	const matches = yield* Effect.filter(inputs.filter((path) => path !== entry && !path.includes(`${sep}node_modules${sep}`)), (path) => Effect.tryPromise(() => readFile(path, "utf8")).pipe(Effect.map((source) => pattern.test(source)), Effect.orElseSucceed(() => false)), { concurrency: 8 });
+	if (matches.length !== 1) return yield* Effect.fail(/* @__PURE__ */ new Error(`${name} must be one named function or const export from a separate TypeScript file`));
+	return matches[0];
+});
+const isDefinition = (value) => typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.prompt === "string" && Array.isArray(value.cases) && Array.isArray(value.tasks) && Number.isInteger(value.trials);
+const sourceFor = (definition, subject, fallback) => {
+	const source = subject.source ?? definition.source;
+	if (source !== void 0) return { source: typeof source === "string" ? repo(source) : source };
+	return Option.match(fallback, {
+		onNone: () => ({}),
+		onSome: (source) => ({ source })
+	});
+};
+const compileEvalEffect = (path) => Effect.gen(function* () {
+	const entry = resolve(path);
+	const loaded = yield* loadDefinition(entry);
+	const definition = loaded.definition;
+	if (!isDefinition(definition)) return yield* Effect.fail(/* @__PURE__ */ new Error(`${entry} must default export defineEval({ ... })`));
+	const fallback = definition.source === void 0 && definition.cases.some((subject) => subject.source === void 0) ? yield* localRepo(dirname(entry)) : Option.none();
+	return {
+		cases: yield* Effect.forEach(definition.cases, (subject) => Effect.gen(function* () {
+			const hasValidator = typeof subject.validate === "function";
+			if (hasValidator === (typeof subject.verify === "string")) return yield* Effect.fail(/* @__PURE__ */ new Error(`${subject.name} must have exactly one of validate or verify`));
+			const validator = hasValidator ? {
+				name: subject.validate?.name || subject.name,
+				source: (yield* bundle(validatorEntry(yield* validatorModule(entry, loaded.inputs, subject.validate?.name || subject.name), subject.validate?.name || subject.name), entry)).source
+			} : null;
+			return {
+				name: subject.name,
+				setup: subject.setup ?? null,
+				...sourceFor(definition, subject, fallback),
+				validator,
+				variables: subject.variables ?? {},
+				verify: subject.verify ?? null
+			};
+		}), { concurrency: 4 }),
+		prompt: definition.prompt,
+		tasks: [...definition.tasks],
+		trials: definition.trials
+	};
+}).pipe(Effect.withSpan("Eval.compile"));
+const compileEval = (path) => Effect.runPromise(compileEvalEffect(path));
+//#endregion
+export { compileEvalEffect as n, compileEval as t };

package/dist/compiler-CZoX4jkx.cjs

@@ -0,0 +1,198 @@
+const require_source = require("./source-DvlGawEw.cjs");
+let effect = require("effect");
+let node_fs_promises = require("node:fs/promises");
+let node_os = require("node:os");
+let node_path = require("node:path");
+let node_url = require("node:url");
+let esbuild = require("esbuild");
+let node_child_process = require("node:child_process");
+//#region src/evals/local-repo.ts
+const run = (0, require("node:util").promisify)(node_child_process.execFile);
+const git = (args, cwd) => effect.Effect.tryPromise(() => run("git", [...args], { cwd })).pipe(effect.Effect.map(({ stdout }) => stdout.trim()), effect.Effect.orElseSucceed(() => ""));
+const environment = () => globalThis.process?.env ?? {};
+const remoteUrl = (cwd) => effect.Effect.gen(function* () {
+	const { GITHUB_REPOSITORY } = environment();
+	const origin = yield* git([
+		"remote",
+		"get-url",
+		"origin"
+	], cwd);
+	return origin === "" && GITHUB_REPOSITORY !== void 0 ? GITHUB_REPOSITORY : origin;
+});
+const fetchableRef = (cwd) => effect.Effect.gen(function* () {
+	const { GITHUB_HEAD_REF } = environment();
+	if (GITHUB_HEAD_REF !== void 0 && GITHUB_HEAD_REF !== "") return GITHUB_HEAD_REF;
+	const [head, onRemote] = yield* effect.Effect.all([git(["rev-parse", "HEAD"], cwd), git([
+		"branch",
+		"--remotes",
+		"--contains",
+		"HEAD"
+	], cwd)], { concurrency: 2 });
+	return head === "" || onRemote === "" ? null : head;
+});
+const localRepo = (cwd) => effect.Effect.gen(function* () {
+	const [remote, ref] = yield* effect.Effect.all([remoteUrl(cwd), fetchableRef(cwd)], { concurrency: 2 });
+	const parsed = remote === "" ? null : require_source.parseRepo(remote);
+	return parsed === null ? effect.Option.none() : effect.Option.some({
+		kind: "repo",
+		ref,
+		url: require_source.cloneUrlOf(parsed)
+	});
+}).pipe(effect.Effect.withSpan("Eval.localRepo"));
+//#endregion
+//#region src/evals/runner-source.ts
+const runtime = `
+import { access, readFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+
+const exec = (command) => new Promise((resolve, reject) => {
+  const child = spawn("/bin/sh", ["-lc", command], { cwd: process.cwd() });
+  let stderr = "";
+  let stdout = "";
+  child.stderr.on("data", chunk => { stderr += chunk; });
+  child.stdout.on("data", chunk => { stdout += chunk; });
+  child.on("error", reject);
+  child.on("close", code => resolve({ exitCode: code ?? 1, stderr, stdout }));
+});
+
+const context = {
+  exec,
+  exists: path => access(path).then(() => true, () => false),
+  readText: path => readFile(path, "utf8"),
+};
+
+try {
+  const raw = await validate(context);
+  const result = typeof raw === "boolean" ? { passed: raw } : raw;
+  if (typeof result?.passed !== "boolean") throw new Error("A validator must return a boolean or { passed, message? }");
+  console.log("ANPORD_VALIDATOR_RESULT=" + JSON.stringify(result));
+} catch (error) {
+  console.error(error instanceof Error ? error.stack : String(error));
+  process.exitCode = 1;
+}
+`;
+const validatorEntry = (module, name) => `import { ${name} as validate } from ${JSON.stringify(module)};\n${runtime}`;
+const definitionEntry = (entry) => `import definition from ${JSON.stringify(entry)}; export default definition;`;
+//#endregion
+//#region src/evals/compiler.ts
+const authoringExports = ["export const defineEval = value => value;", `export { empty, files, repo } from "./source";`].join("\n");
+const authoringDir = (0, node_path.dirname)((0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href));
+const ANPORD_MODULE = /^anpord$/;
+const ANY_MODULE = /.*/;
+const authoringModule = {
+	name: "anpord-authoring",
+	setup: (compiler) => {
+		compiler.onResolve({ filter: ANPORD_MODULE }, () => ({
+			namespace: "anpord-authoring",
+			path: "anpord"
+		}));
+		compiler.onLoad({
+			filter: ANY_MODULE,
+			namespace: "anpord-authoring"
+		}, () => ({
+			contents: authoringExports,
+			loader: "js",
+			resolveDir: authoringDir
+		}));
+	}
+};
+const bundle = (contents, entry) => effect.Effect.tryPromise({
+	try: () => (0, esbuild.build)({
+		absWorkingDir: process.cwd(),
+		bundle: true,
+		format: "esm",
+		metafile: true,
+		platform: "node",
+		resolveExtensions: [
+			".ts",
+			".mjs",
+			".js",
+			".cjs",
+			".json"
+		],
+		plugins: [authoringModule],
+		stdin: {
+			contents,
+			resolveDir: process.cwd(),
+			sourcefile: "anpord-eval-entry.ts"
+		},
+		target: "node18",
+		treeShaking: true,
+		write: false
+	}).then((result) => ({
+		inputs: Object.keys(result.metafile?.inputs ?? {}).map((path) => (0, node_path.resolve)(path)),
+		source: result.outputFiles[0]?.text ?? ""
+	})),
+	catch: (cause) => new Error(`Could not compile ${entry}`, { cause })
+});
+const loadDefinition = (entry) => bundle(definitionEntry(entry), entry).pipe(effect.Effect.flatMap(({ inputs, source }) => effect.Effect.acquireUseRelease(effect.Effect.tryPromise(() => (0, node_fs_promises.mkdtemp)((0, node_path.join)((0, node_os.tmpdir)(), "anpord-eval-"))), (directory) => effect.Effect.tryPromise({
+	try: async () => {
+		const output = (0, node_path.join)(directory, "definition.mjs");
+		await (0, node_fs_promises.writeFile)(output, source);
+		return {
+			definition: (await import((0, node_url.pathToFileURL)(output).href)).default,
+			inputs
+		};
+	},
+	catch: (cause) => new Error(`Could not load ${entry}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause })
+}), (directory) => effect.Effect.promise(() => (0, node_fs_promises.rm)(directory, {
+	force: true,
+	recursive: true
+})).pipe(effect.Effect.ignore))));
+const validatorModule = (entry, inputs, name) => effect.Effect.gen(function* () {
+	const pattern = new RegExp(`\\bexport\\s+(?:async\\s+)?(?:const|function)\\s+${name}\\b`);
+	const matches = yield* effect.Effect.filter(inputs.filter((path) => path !== entry && !path.includes(`${node_path.sep}node_modules${node_path.sep}`)), (path) => effect.Effect.tryPromise(() => (0, node_fs_promises.readFile)(path, "utf8")).pipe(effect.Effect.map((source) => pattern.test(source)), effect.Effect.orElseSucceed(() => false)), { concurrency: 8 });
+	if (matches.length !== 1) return yield* effect.Effect.fail(/* @__PURE__ */ new Error(`${name} must be one named function or const export from a separate TypeScript file`));
+	return matches[0];
+});
+const isDefinition = (value) => typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.prompt === "string" && Array.isArray(value.cases) && Array.isArray(value.tasks) && Number.isInteger(value.trials);
+const sourceFor = (definition, subject, fallback) => {
+	const source = subject.source ?? definition.source;
+	if (source !== void 0) return { source: typeof source === "string" ? require_source.repo(source) : source };
+	return effect.Option.match(fallback, {
+		onNone: () => ({}),
+		onSome: (source) => ({ source })
+	});
+};
+const compileEvalEffect = (path) => effect.Effect.gen(function* () {
+	const entry = (0, node_path.resolve)(path);
+	const loaded = yield* loadDefinition(entry);
+	const definition = loaded.definition;
+	if (!isDefinition(definition)) return yield* effect.Effect.fail(/* @__PURE__ */ new Error(`${entry} must default export defineEval({ ... })`));
+	const fallback = definition.source === void 0 && definition.cases.some((subject) => subject.source === void 0) ? yield* localRepo((0, node_path.dirname)(entry)) : effect.Option.none();
+	return {
+		cases: yield* effect.Effect.forEach(definition.cases, (subject) => effect.Effect.gen(function* () {
+			const hasValidator = typeof subject.validate === "function";
+			if (hasValidator === (typeof subject.verify === "string")) return yield* effect.Effect.fail(/* @__PURE__ */ new Error(`${subject.name} must have exactly one of validate or verify`));
+			const validator = hasValidator ? {
+				name: subject.validate?.name || subject.name,
+				source: (yield* bundle(validatorEntry(yield* validatorModule(entry, loaded.inputs, subject.validate?.name || subject.name), subject.validate?.name || subject.name), entry)).source
+			} : null;
+			return {
+				name: subject.name,
+				setup: subject.setup ?? null,
+				...sourceFor(definition, subject, fallback),
+				validator,
+				variables: subject.variables ?? {},
+				verify: subject.verify ?? null
+			};
+		}), { concurrency: 4 }),
+		prompt: definition.prompt,
+		tasks: [...definition.tasks],
+		trials: definition.trials
+	};
+}).pipe(effect.Effect.withSpan("Eval.compile"));
+const compileEval = (path) => effect.Effect.runPromise(compileEvalEffect(path));
+//#endregion
+Object.defineProperty(exports, "compileEval", {
+	enumerable: true,
+	get: function() {
+		return compileEval;
+	}
+});
+Object.defineProperty(exports, "compileEvalEffect", {
+	enumerable: true,
+	get: function() {
+		return compileEvalEffect;
+	}
+});

package/dist/config.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_client = require("./client-Cno4LwRq.cjs");
+const require_client = require("./client-BCZEcfVE.cjs");
 let effect = require("effect");
 //#region src/client/config.ts
 const apiKeyConfig = effect.Config.redacted("ANPORD_API_KEY");

package/dist/config.mjs

@@ -1,4 +1,4 @@
-import { n as DEFAULT_BASE_URL } from "./client-bJBNwTKq.mjs";
+import { n as DEFAULT_BASE_URL } from "./client-BfhmGRQl.mjs";
 import { Config } from "effect";
 //#region src/client/config.ts
 const apiKeyConfig = Config.redacted("ANPORD_API_KEY");

package/dist/{errors-C0E5A8fN.cjs → errors-Boum34f5.cjs}

@@ -1,4 +1,27 @@
 let effect_ParseResult = require("effect/ParseResult");
+//#region ../template/src/syntax.ts
+/**
+* What a variable looks like, defined once.
+*
+* The editor's atom node, the extractor and the renderer have to agree
+* exactly: a name the editor draws as a chip but the renderer does not fill
+* reaches the model as literal braces, and nobody notices until the output is
+* wrong.
+*/
+const VARIABLE_PATTERN = String.raw`\{\{\s*([\w.-]+)\s*\}\}`;
+/**
+* Escapes and variables together, escapes first.
+*
+* They cannot be two passes: `{{{{name}}}}` contains `{{name}}` starting at
+* its third brace, so a substitution pass run on its own would fill the very
+* text the escape exists to protect. Reading both in one sweep is what keeps
+* the extractor and the renderer agreeing on what counts as a variable.
+*
+* A fresh instance each call, because a global regular expression carries its
+* own `lastIndex` and a shared one silently skips matches on a second pass.
+*/
+const tokenMatcher = () => new RegExp(String.raw`(\{\{\{\{)|(\}\}\}\})|${VARIABLE_PATTERN}`, "g");
+//#endregion
 //#region src/client/errors.ts
 var MissingApiKey = class extends Error {
 	name = "MissingApiKey";
@@ -21,6 +44,7 @@ const statusOf = (error) => {
 	switch (error._tag) {
 		case "BadRequest": return 400;
 		case "Unauthorized": return 401;
+		case "Forbidden": return 403;
 		case "NotFound": return 404;
 		case "Conflict": return 409;
 		case "InternalError": return 500;
@@ -65,3 +89,9 @@ Object.defineProperty(exports, "asAnpordError", {
 		return asAnpordError;
 	}
 });
+Object.defineProperty(exports, "tokenMatcher", {
+	enumerable: true,
+	get: function() {
+		return tokenMatcher;
+	}
+});

package/dist/{errors-DEfS6oaQ.mjs → errors-C9bQUcA3.mjs}

@@ -1,4 +1,27 @@
 import { ArrayFormatter } from "effect/ParseResult";
+//#region ../template/src/syntax.ts
+/**
+* What a variable looks like, defined once.
+*
+* The editor's atom node, the extractor and the renderer have to agree
+* exactly: a name the editor draws as a chip but the renderer does not fill
+* reaches the model as literal braces, and nobody notices until the output is
+* wrong.
+*/
+const VARIABLE_PATTERN = String.raw`\{\{\s*([\w.-]+)\s*\}\}`;
+/**
+* Escapes and variables together, escapes first.
+*
+* They cannot be two passes: `{{{{name}}}}` contains `{{name}}` starting at
+* its third brace, so a substitution pass run on its own would fill the very
+* text the escape exists to protect. Reading both in one sweep is what keeps
+* the extractor and the renderer agreeing on what counts as a variable.
+*
+* A fresh instance each call, because a global regular expression carries its
+* own `lastIndex` and a shared one silently skips matches on a second pass.
+*/
+const tokenMatcher = () => new RegExp(String.raw`(\{\{\{\{)|(\}\}\}\})|${VARIABLE_PATTERN}`, "g");
+//#endregion
 //#region src/client/errors.ts
 var MissingApiKey = class extends Error {
 	name = "MissingApiKey";
@@ -21,6 +44,7 @@ const statusOf = (error) => {
 	switch (error._tag) {
 		case "BadRequest": return 400;
 		case "Unauthorized": return 401;
+		case "Forbidden": return 403;
 		case "NotFound": return 404;
 		case "Conflict": return 409;
 		case "InternalError": return 500;
@@ -47,4 +71,4 @@ const asAnpordError = (error) => error instanceof AnpordError ? error : new Anpo
 	status: statusOf(error)
 });
 //#endregion
-export { MissingApiKey as n, asAnpordError as r, AnpordError as t };
+export { tokenMatcher as i, MissingApiKey as n, asAnpordError as r, AnpordError as t };

package/dist/eval.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_compiler = require("./compiler-CZoX4jkx.cjs");
+exports.compileEval = require_compiler.compileEval;
+exports.compileEvalEffect = require_compiler.compileEvalEffect;

package/dist/eval.d.cts

@@ -0,0 +1,25 @@
+import { t as PublicStartEvalRequest } from "./evals-api-sqVNeWet.cjs";
+import { Effect } from "effect";
+//#region src/evals/compiler.d.ts
+declare const compileEvalEffect: (path: string) => Effect.Effect<{
+  cases: {
+    validator: {
+      name: string;
+      source: string;
+    } | null;
+    variables: Readonly<Record<string, string>>;
+    verify: string | null;
+    name: string;
+    setup: string | null;
+  }[];
+  prompt: string;
+  tasks: {
+    readonly harness: "codex" | "opencode" | "pi" | "fx" | "claude" | "gemini" | "qwen" | "cursor";
+    readonly model: string;
+    readonly provider: "daytona" | "e2b" | "upstash" | "modal" | "cloudflare" | "vercel";
+  }[];
+  trials: number;
+}, Error, never>;
+declare const compileEval: (path: string) => Promise<PublicStartEvalRequest>;
+//#endregion
+export { compileEval, compileEvalEffect };

package/dist/eval.d.mts

@@ -0,0 +1,25 @@
+import { t as PublicStartEvalRequest } from "./evals-api-DUNVUGUy.mjs";
+import { Effect } from "effect";
+//#region src/evals/compiler.d.ts
+declare const compileEvalEffect: (path: string) => Effect.Effect<{
+  cases: {
+    validator: {
+      name: string;
+      source: string;
+    } | null;
+    variables: Readonly<Record<string, string>>;
+    verify: string | null;
+    name: string;
+    setup: string | null;
+  }[];
+  prompt: string;
+  tasks: {
+    readonly harness: "codex" | "opencode" | "pi" | "fx" | "claude" | "gemini" | "qwen" | "cursor";
+    readonly model: string;
+    readonly provider: "daytona" | "e2b" | "upstash" | "modal" | "cloudflare" | "vercel";
+  }[];
+  trials: number;
+}, Error, never>;
+declare const compileEval: (path: string) => Promise<PublicStartEvalRequest>;
+//#endregion
+export { compileEval, compileEvalEffect };

package/dist/eval.mjs

@@ -0,0 +1,2 @@
+import { n as compileEvalEffect, t as compileEval } from "./compiler-CKiewwUc.mjs";
+export { compileEval, compileEvalEffect };

package/dist/evals-api-DUNVUGUy.d.mts

@@ -0,0 +1,93 @@
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSecurity } from "@effect/platform";
+import { Context, Schema } from "effect";
+//#region ../schema/src/domain/errors.d.ts
+declare const NotFound_base: Schema.TaggedErrorClass<NotFound, "NotFound", {
+  readonly _tag: Schema.tag<"NotFound">;
+} & {
+  message: typeof Schema.String;
+}>;
+declare class NotFound extends NotFound_base {}
+declare const Conflict_base: Schema.TaggedErrorClass<Conflict, "Conflict", {
+  readonly _tag: Schema.tag<"Conflict">;
+} & {
+  message: typeof Schema.String;
+}>;
+declare class Conflict extends Conflict_base {}
+declare const BadRequest_base: Schema.TaggedErrorClass<BadRequest, "BadRequest", {
+  readonly _tag: Schema.tag<"BadRequest">;
+} & {
+  message: typeof Schema.String;
+}>;
+declare class BadRequest extends BadRequest_base {}
+declare const Unauthorized_base: Schema.TaggedErrorClass<Unauthorized, "Unauthorized", {
+  readonly _tag: Schema.tag<"Unauthorized">;
+} & {
+  message: typeof Schema.String;
+}>;
+declare class Unauthorized extends Unauthorized_base {}
+declare const Forbidden_base: Schema.TaggedErrorClass<Forbidden, "Forbidden", {
+  readonly _tag: Schema.tag<"Forbidden">;
+} & {
+  message: typeof Schema.String;
+}>;
+/** Distinct from Unauthorized: the caller is who they say they are, and the
+ * answer is still no. Signing in again cannot help, so the client must not
+ * treat this as an expired session. */
+declare class Forbidden extends Forbidden_base {}
+//#endregion
+//#region ../schema/src/public/evals-api.d.ts
+declare const PublicStartEvalRequest: Schema.Struct<{
+  cases: Schema.filter<Schema.Array$<Schema.refine<{
+    readonly name: string;
+    readonly setup?: string | null | undefined;
+    readonly source?: {
+      readonly kind: "empty";
+    } | {
+      readonly kind: "repo";
+      readonly ref: string | null;
+      readonly url: string;
+    } | {
+      readonly kind: "files";
+      readonly files: {
+        readonly [x: string]: string;
+      };
+    } | undefined;
+    readonly validator?: {
+      readonly name: string;
+      readonly source: string;
+    } | null | undefined;
+    readonly variables?: {
+      readonly [x: string]: string;
+    } | undefined;
+    readonly verify: string | null;
+  }, Schema.Struct<{
+    name: typeof Schema.String;
+    setup: Schema.optional<Schema.NullOr<typeof Schema.String>>;
+    source: Schema.optional<Schema.Union<[Schema.Struct<{
+      kind: Schema.Literal<["empty"]>;
+    }>, Schema.Struct<{
+      kind: Schema.Literal<["repo"]>;
+      ref: Schema.NullOr<typeof Schema.String>;
+      url: Schema.refine<string, typeof Schema.String>;
+    }>, Schema.Struct<{
+      files: Schema.Record$<typeof Schema.String, typeof Schema.String>;
+      kind: Schema.Literal<["files"]>;
+    }>]>>;
+    validator: Schema.optional<Schema.NullOr<Schema.Struct<{
+      name: Schema.filter<Schema.filter<typeof Schema.String>>;
+      source: Schema.filter<Schema.filter<typeof Schema.String>>;
+    }>>>;
+    variables: Schema.optional<Schema.Record$<typeof Schema.String, typeof Schema.String>>;
+    verify: Schema.NullOr<typeof Schema.String>;
+  }>>>>;
+  prompt: typeof Schema.String;
+  tasks: Schema.filter<Schema.Array$<Schema.Struct<{
+    harness: Schema.Literal<["codex", "opencode", "pi", "fx", "claude", "gemini", "qwen", "cursor"]>;
+    model: Schema.filter<typeof Schema.String>;
+    provider: Schema.Literal<["daytona", "e2b", "upstash", "modal", "cloudflare", "vercel"]>;
+  }>>>;
+  trials: Schema.filter<typeof Schema.Int>;
+}>;
+type PublicStartEvalRequest = typeof PublicStartEvalRequest.Type;
+//#endregion
+export { NotFound as a, Forbidden as i, BadRequest as n, Unauthorized as o, Conflict as r, PublicStartEvalRequest as t };