@runtypelabs/cli 2.59.0 → 2.59.2

package/dist/chunk-D6C8rned.js

@@ -0,0 +1,578 @@
+#!/usr/bin/env node
+import { t as isTTY } from "./index.js";
+import { DataList, EntityCard, MutationResult, React, Text, render, useEffect, useState } from "./chunk-CoAWdSiE.js";
+import { r as createCliClient } from "./chunk-BW2fg46T.js";
+import { n as ensureAuth } from "./chunk-CJraEBVd.js";
+import { a as printJson, r as getTotalCount } from "./chunk-CcFCyqbB.js";
+import { c as buildEntityPullCommand, s as buildEntityEnsureCommand, t as EVAL_ENSURE_SPEC } from "./chunk-BirUxTtH.js";
+import { n as buildNestedAgentSelector } from "./chunk-BxNJgYbE.js";
+import { Command } from "commander";
+import chalk from "chalk";
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { dirname, join, relative, resolve, sep } from "path";
+import { createJiti } from "jiti";
+// src/lib/eval-discovery.ts
+/** Suffixes that mark a file as an eval suite. */
+const EVAL_FILE_SUFFIXES = [".eval.ts", ".eval.mts"];
+/** Directories never worth walking into during discovery. */
+const IGNORED_DIRS = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	".next",
+	".turbo",
+	"coverage",
+	".cache"
+]);
+function isEvalFile(name) {
+	return EVAL_FILE_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
+/**
+* Recursively find every `*.eval.ts` under `rootDir`, skipping vendored/build
+* directories. Returns absolute paths, sorted for deterministic run order.
+*/
+function discoverEvalFiles(rootDir) {
+	const found = [];
+	const walk = (dir) => {
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const name = entry.name.toString();
+			if (entry.isDirectory()) {
+				if (!IGNORED_DIRS.has(name) && !name.startsWith(".")) walk(join(dir, name));
+			} else if (entry.isFile() && isEvalFile(name)) found.push(join(dir, name));
+		}
+	};
+	walk(rootDir);
+	return found.sort();
+}
+/**
+* Narrow a discovered file list by an id-or-directory-prefix argument.
+* Matches when the relative path starts with the prefix, or the basename contains it.
+* Suite-name matching happens after loading, so this stays permissive: an unmatched prefix still loads everything.
+*/
+function filterEvalFilesByPrefix(files, rootDir, prefix) {
+	const normalized = prefix.replace(/\//g, sep);
+	return files.filter((file) => {
+		const rel = relative(rootDir, file);
+		const base = rel.split(sep).pop() ?? rel;
+		return rel.startsWith(normalized) || base.includes(prefix);
+	});
+}
+let jitiLoader;
+/**
+* Load a `*.eval.ts` module via jiti and return its default export, which must
+* be the `defineEval(...)` result (an `EvalDefinition`). Validates the default
+* export is present and structurally an eval definition; throws an actionable
+* error otherwise (the CLI maps a load failure to exit code 2 — a config error).
+*/
+async function loadEvalDefinition(filePath) {
+	jitiLoader ??= createJiti(import.meta.url, { interopDefault: false });
+	let mod;
+	try {
+		mod = await jitiLoader.import(filePath);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to load eval file ${filePath}: ${message}`, { cause: error });
+	}
+	const exported = mod.default;
+	if (exported === void 0 || exported === null) throw new Error(`Eval file ${filePath} must have a default export: the result of defineEval({...}) from @runtypelabs/sdk.`);
+	if (typeof exported !== "object" || !("target" in exported) || !("cases" in exported) || !Array.isArray(exported.cases)) throw new Error(`Eval file ${filePath} default export is not an eval definition. Export defineEval({ target, cases, ... }).`);
+	return exported;
+}
+// src/lib/eval-junit.ts
+/** XML-escape text/attribute content (the five predefined XML entities). */
+function escapeXml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+/** Build a JUnit XML document string from per-suite case results. */
+function buildJUnitXml(suites) {
+	const totalTests = suites.reduce((sum, s) => sum + s.cases.length, 0);
+	const totalFailures = suites.reduce((sum, s) => sum + s.cases.filter((c) => !c.passed).length, 0);
+	const lines = [];
+	lines.push("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
+	lines.push(`<testsuites name="runtype-eval" tests="${totalTests}" failures="${totalFailures}">`);
+	for (const suite of suites) {
+		const suiteFailures = suite.cases.filter((c) => !c.passed).length;
+		lines.push(`  <testsuite name="${escapeXml(suite.name)}" tests="${suite.cases.length}" failures="${suiteFailures}">`);
+		for (const testCase of suite.cases) {
+			const classname = escapeXml(suite.name);
+			const caseName = escapeXml(testCase.name);
+			if (testCase.passed) lines.push(`    <testcase name="${caseName}" classname="${classname}" />`);
+			else {
+				const reason = testCase.errored ? "Case errored while producing output" : "One or more graders failed";
+				const detailLines = [...testCase.errored && testCase.error ? [`error: ${testCase.error}`] : [], ...testCase.failedGraders];
+				const detail = detailLines.length ? detailLines.join("\n") : reason;
+				lines.push(`    <testcase name="${caseName}" classname="${classname}">`);
+				lines.push(`      <failure message="${escapeXml(reason)}">${escapeXml(detail)}</failure>`);
+				lines.push("    </testcase>");
+			}
+		}
+		lines.push("  </testsuite>");
+	}
+	lines.push("</testsuites>");
+	return lines.join("\n") + "\n";
+}
+// src/commands/eval.ts
+const evalCommand = new Command("eval").description("Manage evaluations");
+evalCommand.command("submit").description("Submit an eval batch").requiredOption("-f, --flow <id>", "Flow ID to evaluate").requiredOption("-r, --records <file>", "JSON file with record IDs").option("-n, --name <name>", "Eval batch name").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	let recordIds;
+	try {
+		const content = readFileSync(options.records, "utf-8");
+		const parsed = JSON.parse(content);
+		recordIds = Array.isArray(parsed) ? parsed : parsed.recordIds || parsed.records || [];
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		console.error(chalk.red(`Failed to read records file: ${message}`));
+		process.exit(1);
+		return;
+	}
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.post("/eval/submit", {
+				flowId: options.flow,
+				recordIds,
+				name: options.name
+			});
+			if (options.json) printJson(data);
+			else {
+				console.log(chalk.green("Eval submitted"));
+				console.log(`  Batch ID: ${chalk.green(data.id)}`);
+				if (data.name) console.log(`  Name: ${data.name}`);
+				console.log(`  Status: ${data.status}`);
+				console.log(`  Records: ${data.totalRecords}`);
+				if (data.groupId) console.log(`  Group: ${data.groupId}`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to submit eval"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		const [resultNode, setResultNode] = useState(void 0);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const data = await client.post("/eval/submit", {
+						flowId: options.flow,
+						recordIds,
+						name: options.name
+					});
+					const fields = [{
+						label: "Batch ID",
+						value: data.id,
+						color: "green"
+					}];
+					if (data.name) fields.push({
+						label: "Name",
+						value: data.name
+					});
+					fields.push({
+						label: "Status",
+						value: data.status
+					});
+					fields.push({
+						label: "Records",
+						value: data.totalRecords
+					});
+					if (data.groupId) fields.push({
+						label: "Group",
+						value: data.groupId
+					});
+					setResultNode(React.createElement(EntityCard, { fields }));
+					setSuccess(true);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setSuccess(false);
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(MutationResult, {
+			loading,
+			loadingLabel: `Submitting eval with ${recordIds.length} records...`,
+			success,
+			successMessage: "Eval submitted",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+evalCommand.command("list").description("List eval batches").option("--flow <id>", "Filter by flow ID").option("--limit <n>", "Limit results", "20").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	const params = { limit: options.limit };
+	if (options.flow) params.flowId = options.flow;
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get("/eval/batches", params);
+			if (options.json) printJson(data);
+			else {
+				const batches = data.data ?? [];
+				if (batches.length === 0) {
+					console.log(chalk.gray("No eval batches found"));
+					return;
+				}
+				console.log(chalk.cyan("Eval Batches:"));
+				for (const batch of batches) {
+					const name = batch.name || batch.id;
+					const progress = batch.totalRecords ? `${batch.completedRecords ?? 0}/${batch.totalRecords}` : "";
+					const statusColor = batch.status === "completed" ? "green" : "yellow";
+					console.log(`  ${chalk.green(batch.id)} ${name} ${chalk[statusColor](`[${batch.status}]`)} ${chalk.gray(progress)}`);
+				}
+				const total = getTotalCount(data.pagination);
+				if (total !== void 0) console.log(chalk.dim(`\n  Total: ${total} batches`));
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch eval batches"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [items, setItems] = useState(null);
+		const [total, setTotal] = useState(void 0);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const data = await client.get("/eval/batches", params);
+					setItems(data.data ?? []);
+					setTotal(getTotalCount(data.pagination));
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(DataList, {
+			title: "Eval Batches",
+			items,
+			error,
+			loading,
+			total,
+			emptyMessage: "No eval batches found",
+			renderCard: (item) => {
+				const b = item;
+				const name = b.name || b.id;
+				const progress = b.totalRecords ? `${b.completedRecords ?? 0}/${b.totalRecords}` : "";
+				const statusColor = b.status === "completed" ? "green" : "yellow";
+				return React.createElement(Text, { color: statusColor }, `  ${b.id} ${name} [${b.status}] ${progress}`);
+			}
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+evalCommand.command("results <id>").description("Get eval batch results").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (id, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.get(`/eval/${id}/results`);
+			if (options.json) printJson(data);
+			else {
+				if (data.batch) {
+					console.log(chalk.cyan(`Eval: ${data.batch.name || data.batch.id}`));
+					console.log(`  Status: ${data.batch.status}`);
+					console.log(`  Progress: ${data.batch.completedRecords ?? 0}/${data.batch.totalRecords ?? 0}`);
+					console.log();
+				}
+				const results = data.data ?? [];
+				if (results.length === 0) {
+					console.log(chalk.gray("No results yet"));
+					return;
+				}
+				console.log(chalk.cyan("Results:"));
+				for (const result of results) {
+					const scoreStr = result.score !== void 0 ? chalk.blue(` score=${result.score}`) : "";
+					const statusColor = result.status === "completed" ? "green" : "red";
+					console.log(`  ${chalk.gray(result.recordId)} ${chalk[statusColor](`[${result.status}]`)}${scoreStr}`);
+				}
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to fetch eval results"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		const [resultNode, setResultNode] = useState(void 0);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const data = await client.get(`/eval/${id}/results`);
+					const results = data.data ?? [];
+					const fields = [];
+					if (data.batch) {
+						fields.push({
+							label: "Eval",
+							value: data.batch.name || data.batch.id
+						});
+						fields.push({
+							label: "Status",
+							value: data.batch.status
+						});
+						fields.push({
+							label: "Progress",
+							value: `${data.batch.completedRecords ?? 0}/${data.batch.totalRecords ?? 0}`
+						});
+					}
+					fields.push({
+						label: "Results",
+						value: results.length
+					});
+					if (results.length > 0) {
+						const completed = results.filter((r) => r.status === "completed").length;
+						const avgScore = results.filter((r) => r.score !== void 0).reduce((sum, r) => sum + (r.score ?? 0), 0) / (results.filter((r) => r.score !== void 0).length || 1);
+						fields.push({
+							label: "Completed",
+							value: `${completed}/${results.length}`,
+							color: "green"
+						});
+						if (results.some((r) => r.score !== void 0)) fields.push({
+							label: "Avg Score",
+							value: avgScore.toFixed(2)
+						});
+					}
+					setResultNode(React.createElement(EntityCard, { fields }));
+					setSuccess(true);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setSuccess(false);
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(MutationResult, {
+			loading,
+			loadingLabel: "Fetching eval results...",
+			success,
+			successMessage: "Eval Results",
+			error,
+			result: resultNode
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+evalCommand.command("compare <groupId>").description("Compare evals in a group").option("--json", "Output as JSON").option("--tty", "Force TTY mode").option("--no-tty", "Force non-TTY mode").action(async (groupId, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) return;
+	const client = createCliClient(apiKey);
+	if (!isTTY(options) || options.json) {
+		try {
+			const data = await client.post("/eval/compare", { groupId });
+			printJson(data);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red("Failed to compare evals"));
+			console.error(chalk.red(message));
+			process.exit(1);
+		}
+		return;
+	}
+	const App = () => {
+		const [loading, setLoading] = useState(true);
+		const [success, setSuccess] = useState(null);
+		const [error, setError] = useState(null);
+		useEffect(() => {
+			const run = async () => {
+				try {
+					const data = await client.post("/eval/compare", { groupId });
+					printJson(data);
+					setSuccess(true);
+					setLoading(false);
+				} catch (err) {
+					setError(err instanceof Error ? err : new Error(String(err)));
+					setSuccess(false);
+					setLoading(false);
+				}
+			};
+			run();
+		}, []);
+		return React.createElement(MutationResult, {
+			loading,
+			loadingLabel: "Comparing evals...",
+			success,
+			successMessage: "Comparison complete",
+			error
+		});
+	};
+	const { waitUntilExit } = render(React.createElement(App));
+	await waitUntilExit();
+});
+/** Exit codes mirror eve: 0 = all pass, 1 = a gate failed, 2 = config error. */
+const EVAL_RUN_EXIT = {
+	pass: 0,
+	fail: 1,
+	config: 2
+};
+/** Print a config error and exit 2 (no `.eval.ts`, load/ensure/run failure, auth). */
+function failConfig(message) {
+	console.error(chalk.red(`Error: ${message}`));
+	process.exit(EVAL_RUN_EXIT.config);
+}
+function printSuiteResult(rootDir, outcome) {
+	const { definition, result } = outcome;
+	const rel = relative(rootDir, outcome.file) || outcome.file;
+	const badge = result.passed ? chalk.green("PASS") : chalk.red("FAIL");
+	const score = `${result.passedCases}/${result.totalCases}`;
+	const runRef = result.runId ? ` · run ${result.runId}` : "";
+	console.log(`${badge} ${chalk.bold(definition.name)} ${chalk.gray(`(${score} cases · ${rel}${runRef})`)}`);
+	for (const testCase of result.cases) {
+		const caseBadge = testCase.passed ? chalk.green("  ✓") : chalk.red("  ✗");
+		console.log(`${caseBadge} ${testCase.name}`);
+		if (!testCase.passed) {
+			for (const outcomeItem of testCase.outcomes.filter((o) => !o.passed)) {
+				const reason = outcomeItem.reasoning ? `: ${outcomeItem.reasoning}` : "";
+				console.log(chalk.red(`      ✗ ${outcomeItem.kind}${reason}`));
+			}
+			if (testCase.errored) {
+				const cause = testCase.error ?? testCase.outputExcerpt;
+				console.log(chalk.red(`      ✗ errored: ${cause.slice(0, 200)}`));
+			}
+		} else for (const outcomeItem of testCase.outcomes.filter((o) => !o.passed && o.severity === "soft")) {
+			const reason = outcomeItem.reasoning ? `: ${outcomeItem.reasoning}` : "";
+			console.log(chalk.yellow(`      ⚠ soft ${outcomeItem.kind}${reason}`));
+		}
+	}
+}
+function toJUnitSuite(outcome) {
+	return {
+		name: outcome.definition.name,
+		cases: outcome.result.cases.map((c) => ({
+			name: c.name,
+			passed: c.passed,
+			errored: c.errored,
+			...c.error ? { error: c.error } : {},
+			failedGraders: c.outcomes.filter((o) => !o.passed).map((o) => `${o.kind}${o.reasoning ? `: ${o.reasoning}` : ""}`)
+		}))
+	};
+}
+evalCommand.command("run [idOrDirPrefix]").description("Run code-colocated eval suites (**/*.eval.ts) as a CI gate (exit 0 pass / 1 fail / 2 config)").option("--strict", "Fail the exit code on soft grader misses too (default: soft misses are reported but do not fail)").option("--virtual", "Run inline without persisting a suite/batch to the dashboard").option("--junit <path>", "Write JUnit XML results to <path>").option("--url <api>", "Override the API base URL (e.g. staging)").option("--cwd <dir>", "Directory to discover *.eval.ts under (default: current directory)").option("--alias <name>", "Run an Agent-target suite against whichever version this release alias points at").option("--version-id <id>", "Run an Agent-target suite against this exact version snapshot").option("--overwrite-managed", "Converge each suite even when its last write came from the dashboard or API (replaces edited ensure-owned cases)").action(async (idOrDirPrefix, options) => {
+	const apiKey = await ensureAuth();
+	if (!apiKey) failConfig("Not authenticated. Set RUNTYPE_API_KEY or run `runtype login`.");
+	let agentSelector = {};
+	try {
+		agentSelector = buildNestedAgentSelector(options);
+	} catch (error) {
+		failConfig(error instanceof Error ? error.message : String(error));
+	}
+	const rootDir = resolve(options.cwd ?? process.cwd());
+	const allFiles = discoverEvalFiles(rootDir);
+	if (allFiles.length === 0) failConfig(`No *.eval.ts files found under ${rootDir}.`);
+	const loadAll = async (files) => {
+		const loaded = [];
+		for (const file of files) try {
+			loaded.push({
+				file,
+				def: await loadEvalDefinition(file)
+			});
+		} catch (error) {
+			failConfig(error instanceof Error ? error.message : String(error));
+		}
+		return loaded;
+	};
+	let loaded;
+	if (idOrDirPrefix) {
+		const byPath = filterEvalFilesByPrefix(allFiles, rootDir, idOrDirPrefix);
+		loaded = byPath.length > 0 ? await loadAll(byPath) : [];
+		if (loaded.length === 0) loaded = (await loadAll(allFiles)).filter(({ def }) => def.name === idOrDirPrefix || def.name.includes(idOrDirPrefix));
+		if (loaded.length === 0) failConfig(`No eval suites matched "${idOrDirPrefix}".`);
+	} else loaded = await loadAll(allFiles);
+	const client = createCliClient(apiKey, options.url);
+	const outcomes = [];
+	for (const { file, def } of loaded) {
+		const runVirtual = options.virtual || def.virtual;
+		try {
+			let result;
+			if (runVirtual) result = await client.post("/eval/run", {
+				definition: def,
+				strict: options.strict ?? false,
+				...agentSelector
+			});
+			else {
+				const ensured = await client.post("/eval/ensure", {
+					name: def.name,
+					definition: def,
+					...options.overwriteManaged ? { onConflict: "overwrite" } : {}
+				});
+				if (!ensured.suiteId) throw new Error(`ensure did not return a suiteId (result: ${ensured.result})`);
+				result = await client.post("/eval/run", {
+					suiteId: ensured.suiteId,
+					strict: options.strict ?? false,
+					...agentSelector
+				});
+			}
+			outcomes.push({
+				file,
+				definition: def,
+				result
+			});
+			printSuiteResult(rootDir, {
+				file,
+				definition: def,
+				result
+			});
+		} catch (error) {
+			failConfig(`Suite "${def.name}" (${relative(rootDir, file) || file}): ` + (error instanceof Error ? error.message : String(error)));
+		}
+	}
+	if (options.junit) try {
+		const xml = buildJUnitXml(outcomes.map(toJUnitSuite));
+		const outPath = resolve(options.junit);
+		mkdirSync(dirname(outPath), { recursive: true });
+		writeFileSync(outPath, xml, "utf-8");
+		console.log(chalk.gray(`JUnit results written to ${options.junit}`));
+	} catch (error) {
+		failConfig(`Failed to write JUnit report: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	const failedSuites = outcomes.filter((o) => !o.result.passed);
+	const totalCases = outcomes.reduce((sum, o) => sum + o.result.totalCases, 0);
+	const passedCases = outcomes.reduce((sum, o) => sum + o.result.passedCases, 0);
+	console.log();
+	if (failedSuites.length === 0) {
+		console.log(chalk.green(`All ${outcomes.length} suite(s) passed (${passedCases}/${totalCases} cases).`));
+		process.exit(EVAL_RUN_EXIT.pass);
+	} else {
+		console.log(chalk.red(`${failedSuites.length} of ${outcomes.length} suite(s) failed (${passedCases}/${totalCases} cases passed).`));
+		process.exit(EVAL_RUN_EXIT.fail);
+	}
+});
+evalCommand.addCommand(buildEntityEnsureCommand(EVAL_ENSURE_SPEC));
+evalCommand.addCommand(buildEntityPullCommand(EVAL_ENSURE_SPEC));
+export { evalCommand };
+

package/dist/chunk-D9ZbUnks.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { D as _isoDate, O as _isoDateTime, n as ZodISODateTime, t as ZodISODate } from "./chunk-BOpO6xE-.js";
+// ../../node_modules/.pnpm/zod@4.6.7/node_modules/zod/v4/classic/iso.js
+function datetime(params) {
+	return _isoDateTime(ZodISODateTime, params);
+}
+function date(params) {
+	return _isoDate(ZodISODate, params);
+}
+export { datetime as n, date as t };
+