@tangle-network/agent-bench 0.7.1 → 0.8.1

package/dist/benchmarks/mcad-cq-bench.d.ts

@@ -0,0 +1,82 @@
+import { BenchmarkAdapter } from "./types.js";
+import { McadTask } from "./mcad-tasks.js";
+import { McadGeometry, McadScoring, Tri } from "./mcad-bench.js";
+//#region src/benchmarks/mcad-cq-bench.d.ts
+/** Package-relative venv, resolved through `_harness`'s bench-root lookup. */
+declare const CADQUERY_VENV = ".venv-cadquery";
+/** Files the worker's script must leave in its working directory. */
+declare const STL_NAME = "part.stl";
+declare const STEP_NAME = "part.step";
+/** Every ISO 10303-21 exchange file (a "STEP file") starts with this token. */
+declare const STEP_MAGIC = "ISO-10303-21";
+/** Hard deadline for one worker script. A hang is a miss, not a stall. */
+declare const MCAD_CQ_TIMEOUT_MS = 120000;
+/**
+ * The exact, VERIFIED install command. Two pins here are load-bearing and neither
+ * is optional on a current host:
+ *   - `--python 3.12`: cadquery 2.4.0 resolves to `cadquery-ocp` 7.7.2, which ships
+ *     wheels for cp38–cp312 only. On a default CPython 3.13 the resolve fails.
+ *   - `'numpy<2'`: cadquery 2.4.0 pins `nptyping==2.0.1`, whose module body reads
+ *     `np.bool8` — removed in numpy 2. Without the pin `import cadquery` raises
+ *     `AttributeError: module 'numpy' has no attribute 'bool8'` at import time.
+ */
+declare const CADQUERY_INSTALL_FIX: string;
+/**
+ * Resolve the CadQuery interpreter. Never falls back to a system `python`: a
+ * silent fallback would either fail deep inside a worker script or — worse — run
+ * against a different CadQuery than the golds were calibrated on.
+ */
+declare function resolveCadqueryPython(env?: Readonly<{
+  MCAD_CQ_PYTHON?: string;
+}>): string;
+/** The one message shape for "there is no usable interpreter" — HARNESS.md style. */
+declare function cadqueryMissingError(python: string, cause?: string): Error;
+/** v2 replacement for `MCAD_DELIVERABLE`. */
+declare const MCAD_CQ_DELIVERABLE: string;
+/** v2 replacement for `MCAD_DELIVERABLE_MULTIBODY` — task 10 only, same reason as v1. */
+declare const MCAD_CQ_DELIVERABLE_MULTIBODY: string;
+/**
+ * Swap the deliverable preamble for the CadQuery one, leaving the upstream
+ * dimensional text byte-identical. Fails loud rather than guessing: a task whose
+ * prompt does not open with one of v1's two known preambles means v1 changed
+ * shape, and silently shipping a prompt with two contradictory deliverables is
+ * exactly the failure this function exists to prevent.
+ */
+declare function toCadQueryPrompt(task: McadTask): string;
+/**
+ * Reject anything that is not an ASCII STL. A binary STL also opens with the
+ * bytes `solid` often enough that the header alone is not a test, so the NUL scan
+ * carries the decision: ASCII STL is printable text end to end.
+ */
+declare function asciiStlProblem(buf: Buffer): string | undefined;
+/** `part.step` exists AND opens with the ISO 10303-21 magic. Reads 12 bytes, not the file. */
+declare function stepFileEmitted(path: string): Promise<boolean>;
+type McadCqBuild = {
+  ok: true;
+  geo: McadGeometry;
+  tris: Tri[];
+  dir: string;
+  stlPath: string;
+  stepEmitted: boolean;
+} | {
+  ok: false;
+  detail: string;
+  dir: string;
+  stepEmitted: boolean;
+};
+/**
+ * Run one CadQuery script and measure what it delivered. Judge-time only.
+ * Throws (never scores) when there is no usable interpreter — an absent toolchain
+ * is an operator defect, and scoring it 0 would silently poison a whole corpus.
+ */
+declare function runAndMeasureCadQuery(src: string, timeoutMs?: number): Promise<McadCqBuild>;
+/**
+ * Append the STEP-delivery check to a v1 scoring and recompute. It is one check
+ * among the spec's, deliberately: the upstream benchmark's deliverable IS a STEP
+ * file, so failing to produce one costs exactly what failing a dimension costs.
+ */
+declare function withStepCheck(scored: McadScoring, stepEmitted: boolean): McadScoring;
+declare function createMcadCqAdapter(): BenchmarkAdapter;
+//#endregion
+export { CADQUERY_INSTALL_FIX, CADQUERY_VENV, MCAD_CQ_DELIVERABLE, MCAD_CQ_DELIVERABLE_MULTIBODY, MCAD_CQ_TIMEOUT_MS, McadCqBuild, STEP_MAGIC, STEP_NAME, STL_NAME, asciiStlProblem, cadqueryMissingError, createMcadCqAdapter, resolveCadqueryPython, runAndMeasureCadQuery, stepFileEmitted, toCadQueryPrompt, withStepCheck };
+//# sourceMappingURL=mcad-cq-bench.d.ts.map

package/dist/benchmarks/mcad-cq-bench.js

@@ -0,0 +1,339 @@
+import { venvPythonAt } from "./_harness.js";
+import { MCAD_DELIVERABLE, MCAD_DELIVERABLE_MULTIBODY, MCAD_TASKS } from "./mcad-tasks.js";
+import { measureMesh, parseAsciiStl, scoreAgainstSpec, stripCodeFence } from "./mcad-bench.js";
+import { MCAD_CQ_GOLDS, MCAD_CQ_UNCALIBRATED } from "./mcad-cq-golds.js";
+import { mkdtemp, open, readFile, writeFile } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { promisify } from "node:util";
+//#region src/benchmarks/mcad-cq-bench.ts
+/**
+* MCAD-CQ adapter — the v2 runner that closes v1's format deviation.
+*
+* `mcad-tasks.ts` states the deviation in its header: the upstream text-to-cad
+* benchmark asks for STEP, and OpenSCAD cannot emit it, so v1 grades an STL that
+* OpenSCAD compiled. This adapter runs the SAME ten dimensioned parts against the
+* SAME spec assertions, but the worker's artifact is a Python CadQuery script that
+* must export BOTH `part.step` (the format upstream actually asks for) and
+* `part.stl` (ASCII — what the geometry engine measures).
+*
+* Everything downstream of the mesh is v1's engine, IMPORTED not copied:
+* `parseAsciiStl` / `measureMesh` / `pointInSolid` / `scoreAgainstSpec` /
+* `stripCodeFence` all come from `./mcad-bench`, and the specs come from
+* `./mcad-tasks`. Only two things differ:
+*   1. the deliverable preamble (Python + CadQuery, not OpenSCAD) — applied by
+*      mapping at load time, so v1's prompt strings are never mutated;
+*   2. one EXTRA scored check, `stepEmitted`: `part.step` exists and begins with
+*      `ISO-10303-21` (the ISO 10303-21 exchange-file magic every STEP file
+*      opens with). It is scored like any other assertion, so a script that
+*      emits only the mesh cannot reach 1.0 no matter how correct its geometry.
+*
+* Pipeline, in order:
+*   1. run       : `<python> model.py` in a fresh temp dir, 120 s hard deadline
+*   2. deliver   : `part.stl` exists and is ASCII (a binary STL is a miss, not a
+*                  parse problem — the prompt pins the format)
+*   3. watertight: every undirected edge shared by exactly two faces
+*   4. measure   : bbox / volume / connected components / triangle count
+*   5. probe     : ray-parity point-in-solid at the spec's pinned coordinates
+*   6. step      : the `stepEmitted` check above
+* A non-watertight mesh scores 0 for the same reason as v1: an unclosed surface
+* has no well-defined interior, so every downstream number would be fiction.
+*
+* SAFETY, stated once and deliberately. The judge EXECUTES the worker's Python on
+* the host with no sandbox. That is the same trust level as v1 handing arbitrary
+* source to the OpenSCAD kernel, and it carries the same rule: run this judge only
+* on artifacts you would be willing to run by hand. The child process is given a
+* scrubbed environment — no inherited variables beyond `PATH`, `HOME`/`TMPDIR`
+* pointed at the scratch directory, and proxy variables pointed at a closed port —
+* which DISCOURAGES network access and keeps host secrets out of the script's
+* reach. It is not a network jail and does not claim to be one; put the judge in a
+* container if you need that guarantee.
+*
+* Requires an interpreter that can `import cadquery` at JUDGE time only.
+* Resolution order: `MCAD_CQ_PYTHON` (absolute path) → `bench/.venv-cadquery/bin/python`
+* → throw with the exact install command (see `CADQUERY_INSTALL_FIX`).
+*/
+const execFileAsync = promisify(execFile);
+/** Package-relative venv, resolved through `_harness`'s bench-root lookup. */
+const CADQUERY_VENV = ".venv-cadquery";
+/** Files the worker's script must leave in its working directory. */
+const STL_NAME = "part.stl";
+const STEP_NAME = "part.step";
+/** Every ISO 10303-21 exchange file (a "STEP file") starts with this token. */
+const STEP_MAGIC = "ISO-10303-21";
+/** Hard deadline for one worker script. A hang is a miss, not a stall. */
+const MCAD_CQ_TIMEOUT_MS = 12e4;
+/**
+* The exact, VERIFIED install command. Two pins here are load-bearing and neither
+* is optional on a current host:
+*   - `--python 3.12`: cadquery 2.4.0 resolves to `cadquery-ocp` 7.7.2, which ships
+*     wheels for cp38–cp312 only. On a default CPython 3.13 the resolve fails.
+*   - `'numpy<2'`: cadquery 2.4.0 pins `nptyping==2.0.1`, whose module body reads
+*     `np.bool8` — removed in numpy 2. Without the pin `import cadquery` raises
+*     `AttributeError: module 'numpy' has no attribute 'bool8'` at import time.
+*/
+const CADQUERY_INSTALL_FIX = "Fix: create the isolated CadQuery venv (needs `uv`):\n  cd bench && uv venv --python 3.12 .venv-cadquery \\\n    && uv pip install --python .venv-cadquery/bin/python 'cadquery==2.4.0' 'numpy<2'\nBoth pins are required: cadquery-ocp 7.7.2 has no cp313 wheel, and cadquery 2.4.0 pins nptyping 2.0.1, which reads the numpy-1.x-only `np.bool8` at import.\nOr set MCAD_CQ_PYTHON to the ABSOLUTE path of any interpreter that can `import cadquery`.";
+/**
+* Resolve the CadQuery interpreter. Never falls back to a system `python`: a
+* silent fallback would either fail deep inside a worker script or — worse — run
+* against a different CadQuery than the golds were calibrated on.
+*/
+function resolveCadqueryPython(env = process.env) {
+	const configured = env.MCAD_CQ_PYTHON;
+	if (configured === void 0) return venvPythonAt(CADQUERY_VENV);
+	if (!isAbsolute(configured)) throw new Error(`MCAD_CQ_PYTHON must be an absolute path (got ${JSON.stringify(configured)})`);
+	return configured;
+}
+/** The one message shape for "there is no usable interpreter" — HARNESS.md style. */
+function cadqueryMissingError(python, cause) {
+	return /* @__PURE__ */ new Error(`mcad-cq: no CadQuery interpreter at ${python}${cause ? `\n${cause}` : ""}\n${CADQUERY_INSTALL_FIX}`);
+}
+/** Shared tail: what the script must WRITE, which is the whole deliverable contract. */
+const CQ_DELIVERABLE_TAIL = `The script must run standalone under \`python model.py\` and write BOTH of these files into its current working directory: \`${STEP_NAME}\` (STEP) and \`${STL_NAME}\` (ASCII STL, not binary). Export with exactly these two lines:
+  ${`cq.exporters.export(result, "${STEP_NAME}")`}\n  ${`cq.exporters.export(result, "${STL_NAME}", exportType="STL", opt={"ascii": True}, tolerance=0.01, angularTolerance=0.05)`}\nThose tessellation tolerances are what make round features accurate — do not coarsen them. Reply with ONLY the Python code.`;
+/** v2 replacement for `MCAD_DELIVERABLE`. */
+const MCAD_CQ_DELIVERABLE = "Author a Python script using CadQuery (units: mm) that builds exactly this part as one fused solid and binds it to a variable named `result`. " + CQ_DELIVERABLE_TAIL;
+/** v2 replacement for `MCAD_DELIVERABLE_MULTIBODY` — task 10 only, same reason as v1. */
+const MCAD_CQ_DELIVERABLE_MULTIBODY = "Author a Python script using CadQuery (units: mm) that builds exactly this assembly as the separate solid bodies listed below and binds them to a variable named `result` (a `cq.Compound` of those bodies, or a Workplane holding all of them). The bodies must stay disjoint — no two of them may touch or intersect. " + CQ_DELIVERABLE_TAIL;
+/**
+* Swap the deliverable preamble for the CadQuery one, leaving the upstream
+* dimensional text byte-identical. Fails loud rather than guessing: a task whose
+* prompt does not open with one of v1's two known preambles means v1 changed
+* shape, and silently shipping a prompt with two contradictory deliverables is
+* exactly the failure this function exists to prevent.
+*/
+function toCadQueryPrompt(task) {
+	for (const [v1, v2] of [[MCAD_DELIVERABLE_MULTIBODY, MCAD_CQ_DELIVERABLE_MULTIBODY], [MCAD_DELIVERABLE, MCAD_CQ_DELIVERABLE]]) if (task.prompt.startsWith(v1)) return v2 + task.prompt.slice(v1.length);
+	throw new Error(`mcad-cq: task ${task.id} does not open with a known mcad deliverable preamble; mcad-tasks.ts changed shape and the CadQuery prompt mapping must be updated with it`);
+}
+/**
+* The child's whole environment. Nothing is inherited except `PATH` (the
+* interpreter needs its own toolchain on it) and `LANG`. `HOME`/`TMPDIR` point at
+* the scratch dir so the script cannot write to the operator's home, and the proxy
+* variables point at port 9 (discard), which every mainstream HTTP client honours.
+* DISCOURAGEMENT, not a jail — see the file header.
+*/
+function scriptEnv(dir) {
+	const blackhole = "http://127.0.0.1:9";
+	return {
+		PATH: process.env.PATH ?? "/usr/bin:/bin",
+		LANG: process.env.LANG ?? "C.UTF-8",
+		HOME: dir,
+		TMPDIR: dir,
+		PYTHONDONTWRITEBYTECODE: "1",
+		PYTHONHASHSEED: "0",
+		http_proxy: blackhole,
+		https_proxy: blackhole,
+		HTTP_PROXY: blackhole,
+		HTTPS_PROXY: blackhole,
+		no_proxy: "",
+		NO_PROXY: ""
+	};
+}
+/**
+* Reject anything that is not an ASCII STL. A binary STL also opens with the
+* bytes `solid` often enough that the header alone is not a test, so the NUL scan
+* carries the decision: ASCII STL is printable text end to end.
+*/
+function asciiStlProblem(buf) {
+	if (buf.length === 0) return `${STL_NAME} is empty`;
+	if (buf.includes(0)) return `${STL_NAME} is not ASCII (contains NUL bytes — it looks like a binary STL)`;
+	const head = buf.subarray(0, 64).toString("latin1");
+	if (!/^\s*solid\b/.test(head)) return `${STL_NAME} does not start with "solid" (got ${JSON.stringify(head.slice(0, 32))})`;
+	if (!/\bfacet\s+normal\b/.test(buf.toString("utf8"))) return `${STL_NAME} contains no "facet normal" records`;
+}
+/** `part.step` exists AND opens with the ISO 10303-21 magic. Reads 12 bytes, not the file. */
+async function stepFileEmitted(path) {
+	let handle;
+	try {
+		handle = await open(path, "r");
+	} catch {
+		return false;
+	}
+	try {
+		const buf = Buffer.alloc(12);
+		const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
+		return bytesRead === buf.length && buf.toString("latin1") === "ISO-10303-21";
+	} finally {
+		await handle.close();
+	}
+}
+/**
+* Run one CadQuery script and measure what it delivered. Judge-time only.
+* Throws (never scores) when there is no usable interpreter — an absent toolchain
+* is an operator defect, and scoring it 0 would silently poison a whole corpus.
+*/
+async function runAndMeasureCadQuery(src, timeoutMs = MCAD_CQ_TIMEOUT_MS) {
+	const python = resolveCadqueryPython();
+	if (!existsSync(python)) throw cadqueryMissingError(python);
+	const dir = await mkdtemp(join(tmpdir(), "mcad-cq-"));
+	const stlPath = join(dir, STL_NAME);
+	const stepPath = join(dir, STEP_NAME);
+	await writeFile(join(dir, "model.py"), `${src}\n`);
+	const fail = async (detail) => ({
+		ok: false,
+		detail,
+		dir,
+		stepEmitted: await stepFileEmitted(stepPath)
+	});
+	try {
+		await execFileAsync(python, ["model.py"], {
+			cwd: dir,
+			env: scriptEnv(dir),
+			timeout: timeoutMs,
+			killSignal: "SIGKILL",
+			maxBuffer: 1024 * 1024 * 64
+		});
+	} catch (err) {
+		const e = err;
+		if (e.killed) return fail(`script timed out after ${timeoutMs} ms and was killed`);
+		return fail(`script failed: ${(e.stderr ?? e.message ?? "").trim().slice(-800)}`);
+	}
+	let stl;
+	try {
+		stl = await readFile(stlPath);
+	} catch {
+		return fail(`script wrote no ${STL_NAME} in its working directory`);
+	}
+	const bad = asciiStlProblem(stl);
+	if (bad) return fail(bad);
+	const tris = parseAsciiStl(stl.toString("utf8"));
+	if (tris.length === 0) return fail(`${STL_NAME} parsed to zero triangles (empty geometry)`);
+	return {
+		ok: true,
+		geo: measureMesh(tris),
+		tris,
+		dir,
+		stlPath,
+		stepEmitted: await stepFileEmitted(stepPath)
+	};
+}
+/**
+* Append the STEP-delivery check to a v1 scoring and recompute. It is one check
+* among the spec's, deliberately: the upstream benchmark's deliverable IS a STEP
+* file, so failing to produce one costs exactly what failing a dimension costs.
+*/
+function withStepCheck(scored, stepEmitted) {
+	const check = {
+		name: "stepEmitted",
+		ok: stepEmitted,
+		measured: stepEmitted ? `${STEP_NAME} starts with ${STEP_MAGIC}` : `no ${STEP_NAME} starting with ${STEP_MAGIC}`,
+		expected: `${STEP_NAME} exists and starts with ${STEP_MAGIC}`
+	};
+	const checks = [...scored.checks, check];
+	const failed = checks.filter((c) => !c.ok);
+	return {
+		checks,
+		failed,
+		score: (checks.length - failed.length) / checks.length,
+		resolved: failed.length === 0
+	};
+}
+function createMcadCqAdapter() {
+	return {
+		name: "mcad-cq",
+		async preflight() {
+			const python = resolveCadqueryPython();
+			if (!existsSync(python)) throw cadqueryMissingError(python);
+			try {
+				await execFileAsync(python, ["-c", "import cadquery; print(cadquery.__version__)"], {
+					timeout: 3e5,
+					env: scriptEnv(tmpdir())
+				});
+			} catch (err) {
+				const e = err;
+				throw cadqueryMissingError(python, `\`import cadquery\` failed: ${(e.stderr ?? e.message ?? "").trim().slice(-800)}`);
+			}
+		},
+		async loadTasks(opts = {}) {
+			let tasks = MCAD_TASKS;
+			if (opts.ids) tasks = tasks.filter((t) => opts.ids?.includes(t.id));
+			if (opts.limit != null) tasks = tasks.slice(0, opts.limit);
+			return tasks.map((t) => ({
+				id: t.id,
+				prompt: toCadQueryPrompt(t),
+				metadata: {
+					spec: t.spec,
+					source: t.source,
+					calibrated: t.calibrated && !MCAD_CQ_UNCALIBRATED.has(t.id)
+				}
+			}));
+		},
+		async goldArtifact(task) {
+			return MCAD_CQ_GOLDS[task.id];
+		},
+		async judge(task, artifact) {
+			const spec = task.metadata?.spec;
+			if (!spec) return {
+				resolved: false,
+				score: 0,
+				detail: `task ${task.id} carries no mcad spec`
+			};
+			const src = stripCodeFence(artifact);
+			if (!src) return {
+				resolved: false,
+				score: 0,
+				detail: "empty artifact"
+			};
+			const built = await runAndMeasureCadQuery(src);
+			if (!built.ok) return {
+				resolved: false,
+				score: 0,
+				detail: `${built.detail} [dir ${built.dir}, stepEmitted ${built.stepEmitted}]`
+			};
+			const { geo, tris, stlPath, stepEmitted, dir } = built;
+			if (!geo.watertight) return {
+				resolved: false,
+				score: 0,
+				detail: JSON.stringify({
+					gate: "watertight",
+					failed: [{
+						name: "watertight",
+						measured: `${geo.openEdges} edge(s) not shared by exactly two faces`,
+						expected: "0 open edges (closed 2-manifold solid)"
+					}],
+					geo: {
+						triangles: geo.triangles,
+						degenerateFaces: geo.degenerateFaces
+					},
+					stepEmitted,
+					stlPath,
+					dir
+				})
+			};
+			const scored = withStepCheck(scoreAgainstSpec(geo, tris, spec), stepEmitted);
+			return {
+				resolved: scored.resolved,
+				score: scored.score,
+				detail: JSON.stringify({
+					failed: scored.failed.map((c) => ({
+						name: c.name,
+						measured: c.measured,
+						expected: c.expected
+					})),
+					checks: Object.fromEntries(scored.checks.map((c) => [c.name, c.ok])),
+					geo: {
+						triangles: geo.triangles,
+						solids: geo.solids,
+						volume: +geo.volume.toFixed(2),
+						degenerateFaces: geo.degenerateFaces,
+						bbox: {
+							x: +geo.bbox.size.x.toFixed(3),
+							y: +geo.bbox.size.y.toFixed(3),
+							z: +geo.bbox.size.z.toFixed(3)
+						}
+					},
+					stepEmitted,
+					stlPath,
+					dir
+				})
+			};
+		}
+	};
+}
+//#endregion
+export { CADQUERY_INSTALL_FIX, CADQUERY_VENV, MCAD_CQ_DELIVERABLE, MCAD_CQ_DELIVERABLE_MULTIBODY, MCAD_CQ_TIMEOUT_MS, STEP_MAGIC, STEP_NAME, STL_NAME, asciiStlProblem, cadqueryMissingError, createMcadCqAdapter, resolveCadqueryPython, runAndMeasureCadQuery, stepFileEmitted, toCadQueryPrompt, withStepCheck };
+
+//# sourceMappingURL=mcad-cq-bench.js.map

package/dist/benchmarks/mcad-cq-bench.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcad-cq-bench.js","names":[],"sources":["../../src/benchmarks/mcad-cq-bench.ts"],"sourcesContent":["/**\n * MCAD-CQ adapter — the v2 runner that closes v1's format deviation.\n *\n * `mcad-tasks.ts` states the deviation in its header: the upstream text-to-cad\n * benchmark asks for STEP, and OpenSCAD cannot emit it, so v1 grades an STL that\n * OpenSCAD compiled. This adapter runs the SAME ten dimensioned parts against the\n * SAME spec assertions, but the worker's artifact is a Python CadQuery script that\n * must export BOTH `part.step` (the format upstream actually asks for) and\n * `part.stl` (ASCII — what the geometry engine measures).\n *\n * Everything downstream of the mesh is v1's engine, IMPORTED not copied:\n * `parseAsciiStl` / `measureMesh` / `pointInSolid` / `scoreAgainstSpec` /\n * `stripCodeFence` all come from `./mcad-bench`, and the specs come from\n * `./mcad-tasks`. Only two things differ:\n *   1. the deliverable preamble (Python + CadQuery, not OpenSCAD) — applied by\n *      mapping at load time, so v1's prompt strings are never mutated;\n *   2. one EXTRA scored check, `stepEmitted`: `part.step` exists and begins with\n *      `ISO-10303-21` (the ISO 10303-21 exchange-file magic every STEP file\n *      opens with). It is scored like any other assertion, so a script that\n *      emits only the mesh cannot reach 1.0 no matter how correct its geometry.\n *\n * Pipeline, in order:\n *   1. run       : `<python> model.py` in a fresh temp dir, 120 s hard deadline\n *   2. deliver   : `part.stl` exists and is ASCII (a binary STL is a miss, not a\n *                  parse problem — the prompt pins the format)\n *   3. watertight: every undirected edge shared by exactly two faces\n *   4. measure   : bbox / volume / connected components / triangle count\n *   5. probe     : ray-parity point-in-solid at the spec's pinned coordinates\n *   6. step      : the `stepEmitted` check above\n * A non-watertight mesh scores 0 for the same reason as v1: an unclosed surface\n * has no well-defined interior, so every downstream number would be fiction.\n *\n * SAFETY, stated once and deliberately. The judge EXECUTES the worker's Python on\n * the host with no sandbox. That is the same trust level as v1 handing arbitrary\n * source to the OpenSCAD kernel, and it carries the same rule: run this judge only\n * on artifacts you would be willing to run by hand. The child process is given a\n * scrubbed environment — no inherited variables beyond `PATH`, `HOME`/`TMPDIR`\n * pointed at the scratch directory, and proxy variables pointed at a closed port —\n * which DISCOURAGES network access and keeps host secrets out of the script's\n * reach. It is not a network jail and does not claim to be one; put the judge in a\n * container if you need that guarantee.\n *\n * Requires an interpreter that can `import cadquery` at JUDGE time only.\n * Resolution order: `MCAD_CQ_PYTHON` (absolute path) → `bench/.venv-cadquery/bin/python`\n * → throw with the exact install command (see `CADQUERY_INSTALL_FIX`).\n */\n\nimport { execFile } from 'node:child_process'\nimport { existsSync } from 'node:fs'\nimport { mkdtemp, open, readFile, writeFile } from 'node:fs/promises'\nimport { tmpdir } from 'node:os'\nimport { isAbsolute, join } from 'node:path'\nimport { promisify } from 'node:util'\nimport { venvPythonAt } from './_harness'\nimport {\n  type McadCheck,\n  type McadGeometry,\n  type McadScoring,\n  type McadTaskMeta,\n  type Tri,\n  measureMesh,\n  parseAsciiStl,\n  scoreAgainstSpec,\n  stripCodeFence,\n} from './mcad-bench'\nimport { MCAD_CQ_GOLDS, MCAD_CQ_UNCALIBRATED } from './mcad-cq-golds'\nimport { MCAD_DELIVERABLE, MCAD_DELIVERABLE_MULTIBODY, MCAD_TASKS, type McadTask } from './mcad-tasks'\nimport type { BenchmarkAdapter, BenchScore, BenchTask, LoadOptions } from './types'\n\nconst execFileAsync = promisify(execFile)\n\n/** Package-relative venv, resolved through `_harness`'s bench-root lookup. */\nexport const CADQUERY_VENV = '.venv-cadquery'\n\n/** Files the worker's script must leave in its working directory. */\nexport const STL_NAME = 'part.stl'\nexport const STEP_NAME = 'part.step'\n\n/** Every ISO 10303-21 exchange file (a \"STEP file\") starts with this token. */\nexport const STEP_MAGIC = 'ISO-10303-21'\n\n/** Hard deadline for one worker script. A hang is a miss, not a stall. */\nexport const MCAD_CQ_TIMEOUT_MS = 120_000\n\n/**\n * The exact, VERIFIED install command. Two pins here are load-bearing and neither\n * is optional on a current host:\n *   - `--python 3.12`: cadquery 2.4.0 resolves to `cadquery-ocp` 7.7.2, which ships\n *     wheels for cp38–cp312 only. On a default CPython 3.13 the resolve fails.\n *   - `'numpy<2'`: cadquery 2.4.0 pins `nptyping==2.0.1`, whose module body reads\n *     `np.bool8` — removed in numpy 2. Without the pin `import cadquery` raises\n *     `AttributeError: module 'numpy' has no attribute 'bool8'` at import time.\n */\nexport const CADQUERY_INSTALL_FIX =\n  'Fix: create the isolated CadQuery venv (needs `uv`):\\n' +\n  '  cd bench && uv venv --python 3.12 .venv-cadquery \\\\\\n' +\n  \"    && uv pip install --python .venv-cadquery/bin/python 'cadquery==2.4.0' 'numpy<2'\\n\" +\n  'Both pins are required: cadquery-ocp 7.7.2 has no cp313 wheel, and cadquery 2.4.0 pins ' +\n  \"nptyping 2.0.1, which reads the numpy-1.x-only `np.bool8` at import.\\n\" +\n  'Or set MCAD_CQ_PYTHON to the ABSOLUTE path of any interpreter that can `import cadquery`.'\n\n/**\n * Resolve the CadQuery interpreter. Never falls back to a system `python`: a\n * silent fallback would either fail deep inside a worker script or — worse — run\n * against a different CadQuery than the golds were calibrated on.\n */\nexport function resolveCadqueryPython(\n  env: Readonly<{ MCAD_CQ_PYTHON?: string }> = process.env,\n): string {\n  const configured = env.MCAD_CQ_PYTHON\n  if (configured === undefined) return venvPythonAt(CADQUERY_VENV)\n  if (!isAbsolute(configured)) throw new Error(`MCAD_CQ_PYTHON must be an absolute path (got ${JSON.stringify(configured)})`)\n  return configured\n}\n\n/** The one message shape for \"there is no usable interpreter\" — HARNESS.md style. */\nexport function cadqueryMissingError(python: string, cause?: string): Error {\n  return new Error(\n    `mcad-cq: no CadQuery interpreter at ${python}${cause ? `\\n${cause}` : ''}\\n${CADQUERY_INSTALL_FIX}`,\n  )\n}\n\n// ---------------------------------------------------------------------------\n// Prompt mapping (v1's prompt strings are read, never written)\n// ---------------------------------------------------------------------------\n\nconst CQ_EXPORT_STEP = `cq.exporters.export(result, \"${STEP_NAME}\")`\nconst CQ_EXPORT_STL =\n  `cq.exporters.export(result, \"${STL_NAME}\", exportType=\"STL\", opt={\"ascii\": True}, ` +\n  'tolerance=0.01, angularTolerance=0.05)'\n\n/** Shared tail: what the script must WRITE, which is the whole deliverable contract. */\nconst CQ_DELIVERABLE_TAIL =\n  'The script must run standalone under `python model.py` and write BOTH of these files into its ' +\n  `current working directory: \\`${STEP_NAME}\\` (STEP) and \\`${STL_NAME}\\` (ASCII STL, not binary). ` +\n  'Export with exactly these two lines:\\n' +\n  `  ${CQ_EXPORT_STEP}\\n` +\n  `  ${CQ_EXPORT_STL}\\n` +\n  'Those tessellation tolerances are what make round features accurate — do not coarsen them. ' +\n  'Reply with ONLY the Python code.'\n\n/** v2 replacement for `MCAD_DELIVERABLE`. */\nexport const MCAD_CQ_DELIVERABLE =\n  'Author a Python script using CadQuery (units: mm) that builds exactly this part as one fused solid ' +\n  'and binds it to a variable named `result`. ' +\n  CQ_DELIVERABLE_TAIL\n\n/** v2 replacement for `MCAD_DELIVERABLE_MULTIBODY` — task 10 only, same reason as v1. */\nexport const MCAD_CQ_DELIVERABLE_MULTIBODY =\n  'Author a Python script using CadQuery (units: mm) that builds exactly this assembly as the separate ' +\n  'solid bodies listed below and binds them to a variable named `result` (a `cq.Compound` of those bodies, ' +\n  'or a Workplane holding all of them). The bodies must stay disjoint — no two of them may touch or ' +\n  'intersect. ' +\n  CQ_DELIVERABLE_TAIL\n\n/**\n * Swap the deliverable preamble for the CadQuery one, leaving the upstream\n * dimensional text byte-identical. Fails loud rather than guessing: a task whose\n * prompt does not open with one of v1's two known preambles means v1 changed\n * shape, and silently shipping a prompt with two contradictory deliverables is\n * exactly the failure this function exists to prevent.\n */\nexport function toCadQueryPrompt(task: McadTask): string {\n  for (const [v1, v2] of [\n    [MCAD_DELIVERABLE_MULTIBODY, MCAD_CQ_DELIVERABLE_MULTIBODY],\n    [MCAD_DELIVERABLE, MCAD_CQ_DELIVERABLE],\n  ] as const) {\n    if (task.prompt.startsWith(v1)) return v2 + task.prompt.slice(v1.length)\n  }\n  throw new Error(\n    `mcad-cq: task ${task.id} does not open with a known mcad deliverable preamble; ` +\n      'mcad-tasks.ts changed shape and the CadQuery prompt mapping must be updated with it',\n  )\n}\n\n// ---------------------------------------------------------------------------\n// Running the worker's script\n// ---------------------------------------------------------------------------\n\n/**\n * The child's whole environment. Nothing is inherited except `PATH` (the\n * interpreter needs its own toolchain on it) and `LANG`. `HOME`/`TMPDIR` point at\n * the scratch dir so the script cannot write to the operator's home, and the proxy\n * variables point at port 9 (discard), which every mainstream HTTP client honours.\n * DISCOURAGEMENT, not a jail — see the file header.\n */\nfunction scriptEnv(dir: string): NodeJS.ProcessEnv {\n  const blackhole = 'http://127.0.0.1:9'\n  return {\n    PATH: process.env.PATH ?? '/usr/bin:/bin',\n    LANG: process.env.LANG ?? 'C.UTF-8',\n    HOME: dir,\n    TMPDIR: dir,\n    PYTHONDONTWRITEBYTECODE: '1',\n    PYTHONHASHSEED: '0',\n    http_proxy: blackhole,\n    https_proxy: blackhole,\n    HTTP_PROXY: blackhole,\n    HTTPS_PROXY: blackhole,\n    no_proxy: '',\n    NO_PROXY: '',\n  }\n}\n\n/**\n * Reject anything that is not an ASCII STL. A binary STL also opens with the\n * bytes `solid` often enough that the header alone is not a test, so the NUL scan\n * carries the decision: ASCII STL is printable text end to end.\n */\nexport function asciiStlProblem(buf: Buffer): string | undefined {\n  if (buf.length === 0) return `${STL_NAME} is empty`\n  if (buf.includes(0)) return `${STL_NAME} is not ASCII (contains NUL bytes — it looks like a binary STL)`\n  const head = buf.subarray(0, 64).toString('latin1')\n  if (!/^\\s*solid\\b/.test(head)) return `${STL_NAME} does not start with \"solid\" (got ${JSON.stringify(head.slice(0, 32))})`\n  if (!/\\bfacet\\s+normal\\b/.test(buf.toString('utf8'))) return `${STL_NAME} contains no \"facet normal\" records`\n  return undefined\n}\n\n/** `part.step` exists AND opens with the ISO 10303-21 magic. Reads 12 bytes, not the file. */\nexport async function stepFileEmitted(path: string): Promise<boolean> {\n  let handle: Awaited<ReturnType<typeof open>>\n  try {\n    handle = await open(path, 'r')\n  } catch {\n    return false\n  }\n  try {\n    const buf = Buffer.alloc(STEP_MAGIC.length)\n    const { bytesRead } = await handle.read(buf, 0, buf.length, 0)\n    return bytesRead === buf.length && buf.toString('latin1') === STEP_MAGIC\n  } finally {\n    await handle.close()\n  }\n}\n\nexport type McadCqBuild =\n  | { ok: true; geo: McadGeometry; tris: Tri[]; dir: string; stlPath: string; stepEmitted: boolean }\n  | { ok: false; detail: string; dir: string; stepEmitted: boolean }\n\n/**\n * Run one CadQuery script and measure what it delivered. Judge-time only.\n * Throws (never scores) when there is no usable interpreter — an absent toolchain\n * is an operator defect, and scoring it 0 would silently poison a whole corpus.\n */\nexport async function runAndMeasureCadQuery(src: string, timeoutMs = MCAD_CQ_TIMEOUT_MS): Promise<McadCqBuild> {\n  const python = resolveCadqueryPython()\n  if (!existsSync(python)) throw cadqueryMissingError(python)\n\n  const dir = await mkdtemp(join(tmpdir(), 'mcad-cq-'))\n  const stlPath = join(dir, STL_NAME)\n  const stepPath = join(dir, STEP_NAME)\n  await writeFile(join(dir, 'model.py'), `${src}\\n`)\n\n  const fail = async (detail: string): Promise<McadCqBuild> => ({\n    ok: false,\n    detail,\n    dir,\n    stepEmitted: await stepFileEmitted(stepPath),\n  })\n\n  try {\n    await execFileAsync(python, ['model.py'], {\n      cwd: dir,\n      env: scriptEnv(dir),\n      timeout: timeoutMs,\n      killSignal: 'SIGKILL',\n      maxBuffer: 1024 * 1024 * 64,\n    })\n  } catch (err) {\n    const e = err as NodeJS.ErrnoException & { killed?: boolean; stderr?: string }\n    if (e.killed) return fail(`script timed out after ${timeoutMs} ms and was killed`)\n    const stderr = (e.stderr ?? e.message ?? '').trim()\n    return fail(`script failed: ${stderr.slice(-800)}`)\n  }\n\n  let stl: Buffer\n  try {\n    stl = await readFile(stlPath)\n  } catch {\n    return fail(`script wrote no ${STL_NAME} in its working directory`)\n  }\n  const bad = asciiStlProblem(stl)\n  if (bad) return fail(bad)\n\n  const tris = parseAsciiStl(stl.toString('utf8'))\n  if (tris.length === 0) return fail(`${STL_NAME} parsed to zero triangles (empty geometry)`)\n\n  return {\n    ok: true,\n    geo: measureMesh(tris),\n    tris,\n    dir,\n    stlPath,\n    stepEmitted: await stepFileEmitted(stepPath),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Scoring\n// ---------------------------------------------------------------------------\n\n/**\n * Append the STEP-delivery check to a v1 scoring and recompute. It is one check\n * among the spec's, deliberately: the upstream benchmark's deliverable IS a STEP\n * file, so failing to produce one costs exactly what failing a dimension costs.\n */\nexport function withStepCheck(scored: McadScoring, stepEmitted: boolean): McadScoring {\n  const check: McadCheck = {\n    name: 'stepEmitted',\n    ok: stepEmitted,\n    measured: stepEmitted ? `${STEP_NAME} starts with ${STEP_MAGIC}` : `no ${STEP_NAME} starting with ${STEP_MAGIC}`,\n    expected: `${STEP_NAME} exists and starts with ${STEP_MAGIC}`,\n  }\n  const checks = [...scored.checks, check]\n  const failed = checks.filter((c) => !c.ok)\n  return { checks, failed, score: (checks.length - failed.length) / checks.length, resolved: failed.length === 0 }\n}\n\n// ---------------------------------------------------------------------------\n// Adapter\n// ---------------------------------------------------------------------------\n\nexport function createMcadCqAdapter(): BenchmarkAdapter {\n  return {\n    name: 'mcad-cq',\n\n    async preflight() {\n      const python = resolveCadqueryPython()\n      if (!existsSync(python)) throw cadqueryMissingError(python)\n      try {\n        await execFileAsync(python, ['-c', 'import cadquery; print(cadquery.__version__)'], {\n          timeout: 300_000,\n          env: scriptEnv(tmpdir()),\n        })\n      } catch (err) {\n        const e = err as NodeJS.ErrnoException & { stderr?: string }\n        throw cadqueryMissingError(python, `\\`import cadquery\\` failed: ${(e.stderr ?? e.message ?? '').trim().slice(-800)}`)\n      }\n    },\n\n    async loadTasks(opts: LoadOptions = {}) {\n      let tasks: McadTask[] = MCAD_TASKS\n      if (opts.ids) tasks = tasks.filter((t) => opts.ids?.includes(t.id))\n      if (opts.limit != null) tasks = tasks.slice(0, opts.limit)\n      return tasks.map(\n        (t): BenchTask => ({\n          id: t.id,\n          prompt: toCadQueryPrompt(t),\n          metadata: {\n            spec: t.spec,\n            source: t.source,\n            // Calibration is per-ADAPTER: a task calibrated against the OpenSCAD\n            // gold says nothing about whether a CadQuery gold reaches 1.0 here.\n            calibrated: t.calibrated && !MCAD_CQ_UNCALIBRATED.has(t.id),\n          } satisfies McadTaskMeta,\n        }),\n      )\n    },\n\n    async goldArtifact(task: BenchTask) {\n      return MCAD_CQ_GOLDS[task.id]\n    },\n\n    async judge(task: BenchTask, artifact: string): Promise<BenchScore> {\n      const spec = (task.metadata as McadTaskMeta | undefined)?.spec\n      if (!spec) return { resolved: false, score: 0, detail: `task ${task.id} carries no mcad spec` }\n\n      const src = stripCodeFence(artifact)\n      if (!src) return { resolved: false, score: 0, detail: 'empty artifact' }\n\n      const built = await runAndMeasureCadQuery(src)\n      if (!built.ok) {\n        return { resolved: false, score: 0, detail: `${built.detail} [dir ${built.dir}, stepEmitted ${built.stepEmitted}]` }\n      }\n\n      const { geo, tris, stlPath, stepEmitted, dir } = built\n      if (!geo.watertight) {\n        return {\n          resolved: false,\n          score: 0,\n          detail: JSON.stringify({\n            gate: 'watertight',\n            failed: [\n              {\n                name: 'watertight',\n                measured: `${geo.openEdges} edge(s) not shared by exactly two faces`,\n                expected: '0 open edges (closed 2-manifold solid)',\n              },\n            ],\n            geo: { triangles: geo.triangles, degenerateFaces: geo.degenerateFaces },\n            stepEmitted,\n            stlPath,\n            dir,\n          }),\n        }\n      }\n\n      const scored = withStepCheck(scoreAgainstSpec(geo, tris, spec), stepEmitted)\n      return {\n        resolved: scored.resolved,\n        score: scored.score,\n        detail: JSON.stringify({\n          failed: scored.failed.map((c) => ({ name: c.name, measured: c.measured, expected: c.expected })),\n          checks: Object.fromEntries(scored.checks.map((c) => [c.name, c.ok])),\n          geo: {\n            triangles: geo.triangles,\n            solids: geo.solids,\n            volume: +geo.volume.toFixed(2),\n            degenerateFaces: geo.degenerateFaces,\n            bbox: {\n              x: +geo.bbox.size.x.toFixed(3),\n              y: +geo.bbox.size.y.toFixed(3),\n              z: +geo.bbox.size.z.toFixed(3),\n            },\n          },\n          stepEmitted,\n          stlPath,\n          dir,\n        }),\n      }\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/benchmarks/mcad-cq-golds.d.ts

@@ -0,0 +1,36 @@
+//#region src/benchmarks/mcad-cq-golds.d.ts
+/**
+ * MCAD-CQ gold oracles — one Python CadQuery script per task in `mcad-tasks.ts`.
+ *
+ * These are CALIBRATION artifacts, not exemplar answers: their whole job is to
+ * prove this adapter's accept direction fires. Every one has been run through
+ * `createMcadCqAdapter().judge()` on this host, and a task is reported calibrated
+ * only when its gold below scores 1.0 — including the `stepEmitted` check, so
+ * every gold really does write a STEP file, which is the deviation v1 could not
+ * close.
+ *
+ * They are written plain and share one preamble of four helpers. Two of those
+ * helpers are not stylistic:
+ *   - `fuse_all` runs ONE multi-argument boolean instead of N sequential unions
+ *     on a growing solid. OCC's cost is superlinear in the accumulated face
+ *     count, and the fin stack (task 07), the staircase (task 09) and the blade
+ *     ring (task 08) all miss the judge's 120 s deadline the sequential way.
+ *   - `group` builds a compound of DISJOINT cutters, so a four-bore cut is one
+ *     boolean rather than four.
+ *
+ * Where a gold deviates from the prompt's literal dimensions the deviation is
+ * named in a comment at the point of the deviation, with the reason. There is one,
+ * inherited verbatim from v1: task 10's ring tooth-tip diameter.
+ */
+/** Gold CadQuery script per task id — preamble, body, then the two export lines. */
+declare const MCAD_CQ_GOLDS: Record<string, string>;
+/**
+ * Task ids whose CadQuery gold does NOT reach 1.0 through this adapter. Empty
+ * means every gold calibrates; an entry here is a promise that the spec was left
+ * alone and the gold is the thing that fell short, with the failing check named in
+ * a comment on the body above.
+ */
+declare const MCAD_CQ_UNCALIBRATED: ReadonlySet<string>;
+//#endregion
+export { MCAD_CQ_GOLDS, MCAD_CQ_UNCALIBRATED };
+//# sourceMappingURL=mcad-cq-golds.d.ts.map