@tangle-network/agent-eval 0.200.1 → 0.201.0

package/dist/benchmarks/index.d.ts

@@ -22,7 +22,7 @@ interface BenchmarkMetricCalibrationResult {
   gap: number;
   reasons: string[];
 }
-declare function calibrateBenchmarkMetric<TPayload = unknown, TArtifact = string>(options: BenchmarkMetricCalibrationOptions<TPayload, TArtifact>): Promise<BenchmarkMetricCalibrationResult>;
+export declare function calibrateBenchmarkMetric<TPayload = unknown, TArtifact = string>(options: BenchmarkMetricCalibrationOptions<TPayload, TArtifact>): Promise<BenchmarkMetricCalibrationResult>;
 //#endregion
 //#region src/benchmarks/harbor.d.ts
 /** One Harbor task, as its `task.toml` and `instruction.md` state it. */
@@ -90,9 +90,9 @@ interface HarborBenchmarkAdapter<TArtifact> extends BenchmarkAdapter<HarborTaskI
   loadAll(): Promise<HarborTaskItem[]>;
 }
 /** Read one Harbor task directory. Throws when `task.toml` or `instruction.md` is missing or malformed. */
-declare function readHarborTask(taskDir: string): Promise<HarborTaskPayload>;
+export declare function readHarborTask(taskDir: string): Promise<HarborTaskPayload>;
 /** Import a Harbor dataset checkout as a `BenchmarkAdapter` whose scorer is the dataset's own verifier. */
-declare function createHarborBenchmarkAdapter<TArtifact = string>(options: HarborBenchmarkOptions<TArtifact>): HarborBenchmarkAdapter<TArtifact>;
+export declare function createHarborBenchmarkAdapter<TArtifact = string>(options: HarborBenchmarkOptions<TArtifact>): HarborBenchmarkAdapter<TArtifact>;
 //#endregion
 //#region src/benchmarks/routing/dataset.d.ts
 /**
@@ -217,7 +217,7 @@ interface BenchmarkRunResult<TPayload = unknown, TArtifact = string> {
   reportJsonPath: string;
   reportMarkdownPath: string;
 }
-declare function runBenchmarkAdapter<TPayload = unknown, TArtifact = string>(options: BenchmarkRunOptions<TPayload, TArtifact>): Promise<BenchmarkRunResult<TPayload, TArtifact>>;
+export declare function runBenchmarkAdapter<TPayload = unknown, TArtifact = string>(options: BenchmarkRunOptions<TPayload, TArtifact>): Promise<BenchmarkRunResult<TPayload, TArtifact>>;
 //#endregion
 //#region src/benchmarks/standard-formats.d.ts
 interface StandardRetrievalDocument {
@@ -280,13 +280,13 @@ interface StandardRetrievalEvaluationOptions {
   passMetric?: string;
   passThreshold?: number;
 }
-declare function parseJsonlRows<T = unknown>(text: string): T[];
-declare function parseQrels(text: string): StandardRetrievalQrel[];
-declare function parseBeirCorpusJsonl(text: string): StandardRetrievalDocument[];
-declare function parseBeirQueriesJsonl(text: string): StandardRetrievalQuery[];
-declare function buildStandardRetrievalItems(options: BuildStandardRetrievalItemsOptions): Array<BenchmarkDatasetItem<StandardRetrievalPayload>>;
-declare function createRetrievalIdBenchmarkAdapter(options: RetrievalIdAdapterOptions): BenchmarkAdapter<BenchmarkDatasetItem<StandardRetrievalPayload>, StandardRetrievalPayload, StandardRetrievalArtifact>;
-declare function evaluateStandardRetrieval(payload: StandardRetrievalPayload, artifact: StandardRetrievalArtifact, options?: StandardRetrievalEvaluationOptions): {
+export declare function parseJsonlRows<T = unknown>(text: string): T[];
+export declare function parseQrels(text: string): StandardRetrievalQrel[];
+export declare function parseBeirCorpusJsonl(text: string): StandardRetrievalDocument[];
+export declare function parseBeirQueriesJsonl(text: string): StandardRetrievalQuery[];
+export declare function buildStandardRetrievalItems(options: BuildStandardRetrievalItemsOptions): Array<BenchmarkDatasetItem<StandardRetrievalPayload>>;
+export declare function createRetrievalIdBenchmarkAdapter(options: RetrievalIdAdapterOptions): BenchmarkAdapter<BenchmarkDatasetItem<StandardRetrievalPayload>, StandardRetrievalPayload, StandardRetrievalArtifact>;
+export declare function evaluateStandardRetrieval(payload: StandardRetrievalPayload, artifact: StandardRetrievalArtifact, options?: StandardRetrievalEvaluationOptions): {
   score: number;
   passed: boolean;
   dimensions: Record<string, number>;
@@ -297,5 +297,5 @@ declare function evaluateStandardRetrieval(payload: StandardRetrievalPayload, ar
   };
 };
 //#endregion
-export { BENCHMARK_SPLIT_SEED, type BenchmarkAdapter, type BenchmarkDatasetItem, type BenchmarkDistribution, type BenchmarkEvaluation, type BenchmarkFamily, type BenchmarkMetricCalibrationOptions, type BenchmarkMetricCalibrationResult, type BenchmarkReport, type BenchmarkResponder, type BenchmarkRunOptions, type BenchmarkRunResult, type BenchmarkScenario, type BenchmarkSliceSummary, type BenchmarkSource, type BenchmarkTaskKind, type BuildStandardRetrievalItemsOptions, type HarborBenchmarkAdapter, type HarborBenchmarkOptions, type HarborGradeOutcome, type HarborTaskItem, type HarborTaskPayload, type RetrievalIdAdapterOptions, type StandardRetrievalArtifact, type StandardRetrievalDocument, type StandardRetrievalEvaluationOptions, type StandardRetrievalPayload, type StandardRetrievalQrel, type StandardRetrievalQuery, type StandardRetrievalResult, buildStandardRetrievalItems, calibrateBenchmarkMetric, createHarborBenchmarkAdapter, createRetrievalIdBenchmarkAdapter, deterministicSplit, evaluateStandardRetrieval, parseBeirCorpusJsonl, parseBeirQueriesJsonl, parseJsonlRows, parseQrels, readHarborTask, index_d_exports as routing, runBenchmarkAdapter };
+export { BENCHMARK_SPLIT_SEED, type BenchmarkAdapter, type BenchmarkDatasetItem, type BenchmarkDistribution, type BenchmarkEvaluation, type BenchmarkFamily, type BenchmarkMetricCalibrationOptions, type BenchmarkMetricCalibrationResult, type BenchmarkReport, type BenchmarkResponder, type BenchmarkRunOptions, type BenchmarkRunResult, type BenchmarkScenario, type BenchmarkSliceSummary, type BenchmarkSource, type BenchmarkTaskKind, type BuildStandardRetrievalItemsOptions, type HarborBenchmarkAdapter, type HarborBenchmarkOptions, type HarborGradeOutcome, type HarborTaskItem, type HarborTaskPayload, type RetrievalIdAdapterOptions, type StandardRetrievalArtifact, type StandardRetrievalDocument, type StandardRetrievalEvaluationOptions, type StandardRetrievalPayload, type StandardRetrievalQrel, type StandardRetrievalQuery, type StandardRetrievalResult, deterministicSplit, index_d_exports as routing };
 //# sourceMappingURL=index.d.ts.map

package/dist/benchmarks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/benchmarks/calibration.ts","../../src/benchmarks/harbor.ts","../../src/benchmarks/routing/dataset.ts","../../src/benchmarks/routing/index.ts","../../src/benchmarks/runner.ts","../../src/benchmarks/standard-formats.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/benchmarks/calibration.ts","../../src/benchmarks/harbor.ts","../../src/benchmarks/routing/dataset.ts","../../src/benchmarks/routing/index.ts","../../src/benchmarks/runner.ts","../../src/benchmarks/standard-formats.ts"],"mappings":"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"}

package/dist/benchmarks/index.js

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "../rolldown-runtime-8H4AJuhK.js";
-import { rt as runCampaign } from "../llm-judge-CL6f3utD.js";
-import { S as fsCampaignStorage } from "../external-optimizer-subprocess-laM1-UDV.js";
-import "../campaign-L391bmir.js";
+import { rt as runCampaign } from "../llm-judge-C-0P1WiT.js";
+import { S as fsCampaignStorage } from "../external-optimizer-subprocess-CkyUUV7h.js";
+import "../campaign-PmTWZi72.js";
 import { join, resolve } from "node:path";
 import { readFile, readdir, stat } from "node:fs/promises";
 import { parse } from "smol-toml";

package/dist/{bounded-process-BBZob7vl.js → bounded-process-Cj9YjXbE.js}

@@ -28,9 +28,9 @@ import { StringDecoder } from "node:string_decoder";
 * bytes are discarded and `outputTruncated` is set.
 */
 /** Wall-clock bound applied when the caller names none. */
-const DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS = 10 * 6e4;
+const DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS = 6e5;
 /** Cap on captured stdout+stderr applied when the caller names none. */
-const DEFAULT_MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
+const DEFAULT_MAX_OUTPUT_BYTES = 16777216;
 /**
 * Window `close` is given after the process group is killed. A grandchild
 * that escaped the group can hold the pipes open indefinitely; the caller
@@ -232,4 +232,4 @@ function exitCodeFor(code, killedByTimeout, killedBySignal) {
 //#endregion
 export { runBoundedProcess as n, DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS as t };
 
-//# sourceMappingURL=bounded-process-BBZob7vl.js.map
+//# sourceMappingURL=bounded-process-Cj9YjXbE.js.map

package/dist/{bounded-process-BBZob7vl.js.map → bounded-process-Cj9YjXbE.js.map}

@@ -1 +1 @@
-{"version":3,"file":"bounded-process-BBZob7vl.js","names":[],"sources":["../src/bounded-process.ts"],"sourcesContent":["/**\n * `runBoundedProcess` — run one command under a wall-clock bound and return\n * what it produced, leaving no descendant behind.\n *\n * The child leads its own process group (`detached` on every non-win32\n * platform), so a deadline or an abort kills the group with\n * `process.kill(-pid, 'SIGKILL')` rather than only the shell that was\n * spawned. That distinction is the whole point of this module: `sh -c\n * 'solver & wait'` puts the real work in a grandchild, and a kill aimed at\n * the shell alone leaves that grandchild running, holding the stdout and\n * stderr pipes open. `close` then never fires, so the deadline produces no\n * result the caller can observe and the descendant outlives the run.\n *\n * Two further guarantees the caller depends on:\n *\n *   - A killed run never reports success. A SIGKILLed child can still close\n *     with exit code 0, so a run killed by the deadline or by an abort has\n *     its exit code forced non-zero.\n *   - A run always resolves. If a grandchild escaped the group and still\n *     holds the pipes, the result is delivered {@link KILL_DRAIN_MS} after\n *     the kill instead of waiting on a `close` that will not come.\n *\n * The captured output is bounded. Once the cap is reached the streams are\n * still drained — the child needs its pipes read to reach `close` — but the\n * bytes are discarded and `outputTruncated` is set.\n */\n\nimport { spawn } from 'node:child_process'\nimport { StringDecoder } from 'node:string_decoder'\n\n/** Wall-clock bound applied when the caller names none. */\nexport const DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS = 10 * 60_000\n\n/** Cap on captured stdout+stderr applied when the caller names none. */\nconst DEFAULT_MAX_OUTPUT_BYTES = 16 * 1024 * 1024\n\n/**\n * Window `close` is given after the process group is killed. A grandchild\n * that escaped the group can hold the pipes open indefinitely; the caller\n * receives its result at the end of this window rather than hanging.\n */\nconst KILL_DRAIN_MS = 2000\n\n/** Exit code reported for a run the wall-clock bound killed (GNU `timeout`). */\nconst TIMEOUT_EXIT_CODE = 124\n\n/** Exit code reported for a run an `AbortSignal` killed (128 + SIGKILL). */\nconst ABORT_EXIT_CODE = 137\n\n/** Exit code reported when the process could not be spawned at all. */\nconst SPAWN_FAILURE_EXIT_CODE = 127\n\n/** Exit code reported when a process closed with no code and was not killed. */\nconst UNKNOWN_EXIT_CODE = 1\n\nexport interface BoundedProcessInput {\n  /**\n   * The command line, interpreted by a shell unless `shell` is `false`. When\n   * {@link BoundedProcessInput.args} is present this is a program path\n   * instead, and no shell reads it.\n   */\n  command: string\n  /**\n   * Argument vector for `command`, delivered to the program as separate\n   * argv entries with no shell between them.\n   *\n   * This is the form to use whenever an argument carries text the caller did\n   * not author — a script body, a path, a pattern. Without it, `interpreter\n   * -flag <script>` can only be expressed by quoting the script into a\n   * shell string, and a quoting bug there is a command injection rather than\n   * a wrong answer. Each entry arrives verbatim, so there is nothing to\n   * quote: `{ command: 'bash', args: ['-n', '-c', body] }` parses `body`\n   * whatever shell metacharacters it holds.\n   *\n   * Two limits are the platform's, not this module's. A NUL byte in an entry\n   * cannot be passed to a process at all, and is reported as a `runnerError`\n   * rather than thrown. A lone surrogate is encoded to UTF-8 as U+FFFD, and a\n   * non-string entry from an untypechecked caller is coerced with `String()`,\n   * so an entry is verbatim exactly when it is a string a UTF-8 argv can hold.\n   *\n   * A shell cannot interpret an argument vector, so `args` and a truthy\n   * `shell` are contradictory. Passing both spawns nothing and reports\n   * `runnerError`.\n   */\n  args?: string[]\n  /**\n   * Text written to the child's standard input. The stream is closed after\n   * the write, so a command that reads until end-of-file sees exactly this\n   * payload and then EOF.\n   *\n   * The child's stdin is closed whether or not this field is present. A pipe\n   * nobody closes is a hang: a command that reads stdin waits for bytes that\n   * never arrive until the deadline kills it, which reads downstream as a\n   * slow command rather than as a caller that forgot to send input.\n   *\n   * The payload is written as UTF-8 and is otherwise verbatim: a NUL byte,\n   * a newline, a quote and a backslash all arrive as themselves, because\n   * nothing parses this text. The one platform limit is the one `args`\n   * already states — a lone surrogate is encoded as U+FFFD, since no UTF-8\n   * stream can carry it.\n   *\n   * A child that exits before reading breaks the pipe. That is the child's\n   * behaviour, not a runner failure, so the run still settles on the child's\n   * own exit code, and the undelivered payload is reported in `runnerError`\n   * with the `stdin not delivered:` prefix. Whether a SMALL payload to a\n   * command that ignores stdin reports this is a race — the write may land in\n   * the pipe buffer before the child exits — so the flag is a statement about\n   * delivery, never about the command. It is not a race for the case that\n   * matters: a payload larger than the pipe buffer that the child never\n   * drains cannot be delivered, and reports every time.\n   */\n  stdin?: string\n  /**\n   * Shell that interprets `command`. `true` (the default) uses the platform\n   * default — `/bin/sh` on POSIX, `cmd.exe` on Windows. A string names the\n   * shell binary, e.g. `'bash'`, which is required for a bash-only construct\n   * such as `[[ ]]` or `$BASH_VERSION`. `false` executes `command` directly\n   * as a program path with no arguments. Ignored — and refused when truthy —\n   * once {@link BoundedProcessInput.args} is present.\n   */\n  shell?: boolean | string\n  /** Working directory. The parent's cwd is inherited when omitted. */\n  cwd?: string\n  /**\n   * Environment for the child. How it combines with the parent environment\n   * is decided by {@link BoundedProcessInput.envMode}.\n   */\n  env?: NodeJS.ProcessEnv\n  /**\n   * `'merge'` (the default) layers `env` on top of `process.env`, so the\n   * child sees every variable this process has plus the named ones.\n   * `'replace'` passes exactly `env` and nothing else, which is what a\n   * grader needs when the claim under test is about the variables the\n   * command could read. `PATH` is not re-added under `'replace'`, and a\n   * command that must find a binary on `PATH` names `PATH` itself.\n   *\n   * With no `PATH` in the child environment the two forms do NOT search the\n   * same directories, so a caller under `'replace'` that names no `PATH` gets\n   * a resolution that depends on which form it picked. The shell form execs\n   * the shell, which applies its own compiled-in default; the argv form\n   * reaches `execvp`, which falls back to `confstr(_CS_PATH)`. Measured on\n   * Linux/glibc: `/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin`\n   * against `/bin:/usr/bin`, so a binary in `/usr/local/bin` resolves on the\n   * shell form and reports ENOENT on the argv form. Name `PATH` and both\n   * forms search exactly what was named.\n   */\n  envMode?: 'merge' | 'replace'\n  /** Wall-clock bound in ms. Defaults to 10 minutes. */\n  timeoutMs?: number\n  /**\n   * Cap on captured stdout+stderr. Reaching it truncates the captured text\n   * and sets `outputTruncated`; it never kills the process. Defaults to\n   * 16 MiB.\n   */\n  maxOutputBytes?: number\n  /**\n   * Kills the process group when it aborts, the same way the deadline does.\n   * A signal that is already aborted when `runBoundedProcess` is called\n   * prevents the spawn entirely — nothing runs.\n   */\n  signal?: AbortSignal\n}\n\nexport interface BoundedProcessResult {\n  /**\n   * The process actually started. False when nothing ran at all: an\n   * already-aborted signal, `args` with a truthy `shell`, an argument the\n   * platform refuses, or a program that does not exist.\n   *\n   * This is the field to branch on, never the text of `runnerError`. A caller\n   * deciding whether a run produced an outcome at all is asking exactly this,\n   * and asking it here is type-checked rather than held by a wording\n   * convention.\n   */\n  spawned: boolean\n  /**\n   * The `stdin` payload reached the child in full. True whenever the caller\n   * supplied none, because nothing could fail to arrive.\n   *\n   * False means the command ran on partial input, which is a fact about the\n   * answer it produced: a checksum over a truncated payload is a wrong answer,\n   * not a failed run. `spawned` stays true and `exitCode` stays the child's.\n   */\n  stdinDelivered: boolean\n  /**\n   * Exit code. Forced non-zero whenever `killedByTimeout` or\n   * `killedBySignal` is set, because a SIGKILLed child can close with 0 and\n   * a killed run must never read as a pass.\n   */\n  exitCode: number\n  /** Captured stdout, truncated at `maxOutputBytes`. */\n  stdout: string\n  /**\n   * Captured stderr, truncated at `maxOutputBytes`. A runner-side failure is\n   * reported in `runnerError`, not appended here; the caller decides whether\n   * the command's own stderr and the runner's diagnosis belong together.\n   */\n  stderr: string\n  /** Wall-clock duration in ms, measured across the whole call. */\n  wallMs: number\n  /** The wall-clock bound was reached and the process group was killed. */\n  killedByTimeout: boolean\n  /** `signal` aborted and the process group was killed. */\n  killedBySignal: boolean\n  /** `maxOutputBytes` was reached and later output was discarded. */\n  outputTruncated: boolean\n  /**\n   * Human-readable diagnosis of a runner-side failure, in one of three shapes:\n   *\n   *   - `not spawned:` — the caller's own bug, such as `args` with a truthy\n   *     `shell`, or an already-aborted signal. No retry helps.\n   *   - `stdin not delivered:` — the command ran and exited on its own, and\n   *     the stdin payload did not reach it in full because the child closed\n   *     the pipe first.\n   *   - anything else — the process could not be spawned (a missing binary, a\n   *     NUL byte in an argument).\n   *\n   * Absent when the command ran and read everything it was sent, however it\n   * exited. The prefixes are for a person reading a log; code reads `spawned`\n   * and `stdinDelivered`, which say the same things and are type-checked.\n   */\n  runnerError?: string\n}\n\nexport async function runBoundedProcess(input: BoundedProcessInput): Promise<BoundedProcessResult> {\n  const start = Date.now()\n  const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES\n  const timeoutMs = input.timeoutMs ?? DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS\n  const envMode = input.envMode ?? 'merge'\n  const env =\n    input.env === undefined && envMode === 'merge'\n      ? undefined\n      : envMode === 'replace'\n        ? { ...input.env }\n        : { ...process.env, ...input.env }\n\n  if (input.signal?.aborted) {\n    return {\n      spawned: false,\n      stdinDelivered: true,\n      exitCode: ABORT_EXIT_CODE,\n      stdout: '',\n      stderr: '',\n      wallMs: Date.now() - start,\n      killedByTimeout: false,\n      killedBySignal: true,\n      outputTruncated: false,\n      runnerError: 'aborted before spawn: the AbortSignal was already aborted',\n    }\n  }\n\n  // Reported rather than thrown, because this module's contract is that a\n  // call always resolves. A caller bug still reads as a failure and never as\n  // a pass: the exit code is non-zero and `runnerError` names the cause.\n  if (input.args !== undefined && input.shell) {\n    return {\n      spawned: false,\n      stdinDelivered: true,\n      exitCode: SPAWN_FAILURE_EXIT_CODE,\n      stdout: '',\n      stderr: '',\n      wallMs: Date.now() - start,\n      killedByTimeout: false,\n      killedBySignal: false,\n      outputTruncated: false,\n      // Shares `SPAWN_FAILURE_EXIT_CODE` with a program that does not exist,\n      // because both mean nothing ran. The `not spawned:` prefix is the stable\n      // discriminator: it marks the caller's own bug, which no retry fixes.\n      runnerError:\n        'not spawned: `args` passes an argument vector directly to the program, so a shell ' +\n        'cannot interpret it — pass `args` or a truthy `shell`, never both',\n    }\n  }\n\n  return await new Promise<BoundedProcessResult>((resolve) => {\n    const spawnOptions = {\n      cwd: input.cwd,\n      env,\n      // Own process group so a kill reaches the whole tree, not just the\n      // shell — otherwise a runaway grandchild keeps the pipes open and\n      // `close` never fires.\n      detached: process.platform !== 'win32',\n    }\n    // The argv form takes the same bounds, the same group and the same kill\n    // path. Two things differ, and both are stated where they are decided:\n    // no shell reads the command, and executable lookup falls back to a\n    // different default `PATH` when the caller names none (see `envMode`).\n    //\n    // `spawn` validates its arguments and THROWS synchronously — a NUL byte in\n    // `command` or in an `args` entry, or an `args` that is not an array from\n    // an untypechecked caller. A throw inside this executor would reject, and\n    // this module's contract is that a call always resolves. A caller that\n    // grades untrusted text must be able to score that text as failed rather\n    // than die on it.\n    let child: ReturnType<typeof spawn>\n    try {\n      child =\n        input.args === undefined\n          ? spawn(input.command, { ...spawnOptions, shell: input.shell ?? true })\n          : spawn(input.command, input.args, { ...spawnOptions, shell: false })\n    } catch (err) {\n      resolve({\n        spawned: false,\n        stdinDelivered: true,\n        exitCode: SPAWN_FAILURE_EXIT_CODE,\n        stdout: '',\n        stderr: '',\n        wallMs: Date.now() - start,\n        killedByTimeout: false,\n        killedBySignal: false,\n        outputTruncated: false,\n        runnerError: String(err),\n      })\n      return\n    }\n    // A pipe nobody closes is a hang, so stdin is always ended — after the\n    // payload when there is one, immediately when there is not. A write that\n    // fails is recorded and never thrown: the child already ran, and this\n    // module's contract is that a call always resolves.\n    let stdinError: string | undefined\n    const childStdin = child.stdin\n    if (childStdin) {\n      childStdin.on('error', (err) => {\n        // Closing an unused pipe races a command that exits at once, and that\n        // broken pipe says nothing about a caller who sent nothing. Only a\n        // payload the caller supplied can fail to be delivered.\n        if (input.stdin !== undefined) stdinError ??= `stdin not delivered: ${String(err)}`\n      })\n      if (input.stdin === undefined) childStdin.end()\n      else childStdin.end(input.stdin, 'utf8')\n    } else if (input.stdin !== undefined) {\n      stdinError = 'stdin not delivered: the child was spawned with no stdin pipe'\n    }\n\n    let stdout = ''\n    let stderr = ''\n    let outputBytes = 0\n    let outputTruncated = false\n    let killedByTimeout = false\n    let killedBySignal = false\n    let settled = false\n\n    // Bound the in-memory buffer so a runaway process can't OOM the caller.\n    // Once the cap is hit the streams are still drained (the child needs them\n    // read to reach `close`) but the bytes are discarded.\n    function capture(s: string): string {\n      if (outputBytes >= maxOutputBytes) {\n        outputTruncated = true\n        return ''\n      }\n      const room = maxOutputBytes - outputBytes\n      if (s.length > room) {\n        outputBytes = maxOutputBytes\n        outputTruncated = true\n        return s.slice(0, room)\n      }\n      outputBytes += s.length\n      return s\n    }\n\n    // Decoded across chunk boundaries. A stream arrives as Buffers split at\n    // arbitrary byte offsets, so decoding each chunk on its own replaces any\n    // multi-byte character that straddles a boundary with U+FFFD — the output\n    // is then corrupted at every 64 KiB of non-ASCII text. The decoder holds\n    // the partial sequence until its remaining bytes arrive.\n    const stdoutDecoder = new StringDecoder('utf8')\n    const stderrDecoder = new StringDecoder('utf8')\n    const decode = (decoder: StringDecoder, d: unknown): string =>\n      Buffer.isBuffer(d) ? decoder.write(d) : String(d)\n\n    const onStdout = (d: unknown) => {\n      const chunk = capture(decode(stdoutDecoder, d))\n      if (chunk) stdout += chunk\n    }\n    const onStderr = (d: unknown) => {\n      const chunk = capture(decode(stderrDecoder, d))\n      if (chunk) stderr += chunk\n    }\n\n    child.stdout?.on('data', onStdout)\n    child.stderr?.on('data', onStderr)\n\n    let forceResolve: ReturnType<typeof setTimeout> | undefined\n\n    const cleanup = () => {\n      clearTimeout(timeout)\n      if (forceResolve) clearTimeout(forceResolve)\n      input.signal?.removeEventListener('abort', onAbort)\n      child.stdout?.off('data', onStdout)\n      child.stderr?.off('data', onStderr)\n      // The stdin `error` listener stays attached on purpose: a stream that\n      // emits `error` with no listener throws, and a late EPIPE after the run\n      // has settled must not take the process down.\n      child.removeAllListeners('close')\n      child.removeAllListeners('error')\n    }\n\n    // Resolve exactly once. `code` comes from `close`; on a kill path the\n    // exit code is forced non-zero so a SIGKILLed child that reports 0 can\n    // never read as a clean pass downstream.\n    const finish = (outcome: { code: number | null; spawned?: boolean; runnerError?: string }) => {\n      if (settled) return\n      settled = true\n      cleanup()\n      const spawned = outcome.spawned ?? true\n      resolve({\n        spawned,\n        // A program that never started was sent nothing, whatever the write to\n        // its doomed pipe reported.\n        stdinDelivered: spawned ? stdinError === undefined : true,\n        exitCode: exitCodeFor(outcome.code, killedByTimeout, killedBySignal),\n        stdout,\n        stderr,\n        wallMs: Date.now() - start,\n        killedByTimeout,\n        killedBySignal,\n        outputTruncated,\n        runnerError: outcome.runnerError ?? stdinError,\n      })\n    }\n\n    // SIGKILL the whole process group (we spawned detached). On a clean close\n    // this never runs.\n    const killTree = () => {\n      try {\n        if (process.platform !== 'win32' && typeof child.pid === 'number') {\n          process.kill(-child.pid, 'SIGKILL')\n        } else {\n          child.kill('SIGKILL')\n        }\n      } catch (err) {\n        // ESRCH means the group exited between the decision to kill and the\n        // signal, which `close` reports on its own. Anything else means the\n        // group may still be running, which the caller must hear about.\n        if ((err as NodeJS.ErrnoException)?.code !== 'ESRCH') {\n          console.warn('[bounded-process] SIGKILL of the process group failed:', err)\n        }\n      }\n    }\n\n    // Give `close` a brief window to fire (flushing any final output) after\n    // the group dies; if an orphaned grandchild keeps the pipes open, resolve\n    // anyway so the caller can't hang on a runaway. The deadline and an abort\n    // can both fire, so the kill happens at most once and the drain window is\n    // not restarted by the second one.\n    let killed = false\n    const killAndDrain = () => {\n      if (killed) return\n      killed = true\n      killTree()\n      forceResolve = setTimeout(() => finish({ code: null }), KILL_DRAIN_MS)\n    }\n\n    function onAbort() {\n      if (settled) return\n      killedBySignal = true\n      killAndDrain()\n    }\n\n    const timeout = setTimeout(() => {\n      killedByTimeout = true\n      killAndDrain()\n    }, timeoutMs)\n\n    input.signal?.addEventListener('abort', onAbort, { once: true })\n\n    child.on('close', (code) => {\n      if (forceResolve) clearTimeout(forceResolve)\n      finish({ code })\n    })\n    child.on('error', (err) => {\n      if (forceResolve) clearTimeout(forceResolve)\n      // `error` on a child means the program never started — a missing binary,\n      // a refused argument. Nothing ran, whatever the stdin write did.\n      finish({ code: SPAWN_FAILURE_EXIT_CODE, spawned: false, runnerError: String(err) })\n    })\n  })\n}\n\n/**\n * A killed run reports the code the child closed with only when that code is\n * already non-zero; otherwise it reports the conventional code for the kind\n * of kill. A run that closed on its own with no code at all reports 1.\n */\nfunction exitCodeFor(\n  code: number | null,\n  killedByTimeout: boolean,\n  killedBySignal: boolean,\n): number {\n  if (code !== null && code !== 0) return code\n  if (killedByTimeout) return TIMEOUT_EXIT_CODE\n  if (killedBySignal) return ABORT_EXIT_CODE\n  return code ?? UNKNOWN_EXIT_CODE\n}\n"],"mappings":"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"}
+{"version":3,"file":"bounded-process-Cj9YjXbE.js","names":[],"sources":["../src/bounded-process.ts"],"sourcesContent":["/**\n * `runBoundedProcess` — run one command under a wall-clock bound and return\n * what it produced, leaving no descendant behind.\n *\n * The child leads its own process group (`detached` on every non-win32\n * platform), so a deadline or an abort kills the group with\n * `process.kill(-pid, 'SIGKILL')` rather than only the shell that was\n * spawned. That distinction is the whole point of this module: `sh -c\n * 'solver & wait'` puts the real work in a grandchild, and a kill aimed at\n * the shell alone leaves that grandchild running, holding the stdout and\n * stderr pipes open. `close` then never fires, so the deadline produces no\n * result the caller can observe and the descendant outlives the run.\n *\n * Two further guarantees the caller depends on:\n *\n *   - A killed run never reports success. A SIGKILLed child can still close\n *     with exit code 0, so a run killed by the deadline or by an abort has\n *     its exit code forced non-zero.\n *   - A run always resolves. If a grandchild escaped the group and still\n *     holds the pipes, the result is delivered {@link KILL_DRAIN_MS} after\n *     the kill instead of waiting on a `close` that will not come.\n *\n * The captured output is bounded. Once the cap is reached the streams are\n * still drained — the child needs its pipes read to reach `close` — but the\n * bytes are discarded and `outputTruncated` is set.\n */\n\nimport { spawn } from 'node:child_process'\nimport { StringDecoder } from 'node:string_decoder'\n\n/** Wall-clock bound applied when the caller names none. */\nexport const DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS = 10 * 60_000\n\n/** Cap on captured stdout+stderr applied when the caller names none. */\nconst DEFAULT_MAX_OUTPUT_BYTES = 16 * 1024 * 1024\n\n/**\n * Window `close` is given after the process group is killed. A grandchild\n * that escaped the group can hold the pipes open indefinitely; the caller\n * receives its result at the end of this window rather than hanging.\n */\nconst KILL_DRAIN_MS = 2000\n\n/** Exit code reported for a run the wall-clock bound killed (GNU `timeout`). */\nconst TIMEOUT_EXIT_CODE = 124\n\n/** Exit code reported for a run an `AbortSignal` killed (128 + SIGKILL). */\nconst ABORT_EXIT_CODE = 137\n\n/** Exit code reported when the process could not be spawned at all. */\nconst SPAWN_FAILURE_EXIT_CODE = 127\n\n/** Exit code reported when a process closed with no code and was not killed. */\nconst UNKNOWN_EXIT_CODE = 1\n\nexport interface BoundedProcessInput {\n  /**\n   * The command line, interpreted by a shell unless `shell` is `false`. When\n   * {@link BoundedProcessInput.args} is present this is a program path\n   * instead, and no shell reads it.\n   */\n  command: string\n  /**\n   * Argument vector for `command`, delivered to the program as separate\n   * argv entries with no shell between them.\n   *\n   * This is the form to use whenever an argument carries text the caller did\n   * not author — a script body, a path, a pattern. Without it, `interpreter\n   * -flag <script>` can only be expressed by quoting the script into a\n   * shell string, and a quoting bug there is a command injection rather than\n   * a wrong answer. Each entry arrives verbatim, so there is nothing to\n   * quote: `{ command: 'bash', args: ['-n', '-c', body] }` parses `body`\n   * whatever shell metacharacters it holds.\n   *\n   * Two limits are the platform's, not this module's. A NUL byte in an entry\n   * cannot be passed to a process at all, and is reported as a `runnerError`\n   * rather than thrown. A lone surrogate is encoded to UTF-8 as U+FFFD, and a\n   * non-string entry from an untypechecked caller is coerced with `String()`,\n   * so an entry is verbatim exactly when it is a string a UTF-8 argv can hold.\n   *\n   * A shell cannot interpret an argument vector, so `args` and a truthy\n   * `shell` are contradictory. Passing both spawns nothing and reports\n   * `runnerError`.\n   */\n  args?: string[]\n  /**\n   * Text written to the child's standard input. The stream is closed after\n   * the write, so a command that reads until end-of-file sees exactly this\n   * payload and then EOF.\n   *\n   * The child's stdin is closed whether or not this field is present. A pipe\n   * nobody closes is a hang: a command that reads stdin waits for bytes that\n   * never arrive until the deadline kills it, which reads downstream as a\n   * slow command rather than as a caller that forgot to send input.\n   *\n   * The payload is written as UTF-8 and is otherwise verbatim: a NUL byte,\n   * a newline, a quote and a backslash all arrive as themselves, because\n   * nothing parses this text. The one platform limit is the one `args`\n   * already states — a lone surrogate is encoded as U+FFFD, since no UTF-8\n   * stream can carry it.\n   *\n   * A child that exits before reading breaks the pipe. That is the child's\n   * behaviour, not a runner failure, so the run still settles on the child's\n   * own exit code, and the undelivered payload is reported in `runnerError`\n   * with the `stdin not delivered:` prefix. Whether a SMALL payload to a\n   * command that ignores stdin reports this is a race — the write may land in\n   * the pipe buffer before the child exits — so the flag is a statement about\n   * delivery, never about the command. It is not a race for the case that\n   * matters: a payload larger than the pipe buffer that the child never\n   * drains cannot be delivered, and reports every time.\n   */\n  stdin?: string\n  /**\n   * Shell that interprets `command`. `true` (the default) uses the platform\n   * default — `/bin/sh` on POSIX, `cmd.exe` on Windows. A string names the\n   * shell binary, e.g. `'bash'`, which is required for a bash-only construct\n   * such as `[[ ]]` or `$BASH_VERSION`. `false` executes `command` directly\n   * as a program path with no arguments. Ignored — and refused when truthy —\n   * once {@link BoundedProcessInput.args} is present.\n   */\n  shell?: boolean | string\n  /** Working directory. The parent's cwd is inherited when omitted. */\n  cwd?: string\n  /**\n   * Environment for the child. How it combines with the parent environment\n   * is decided by {@link BoundedProcessInput.envMode}.\n   */\n  env?: NodeJS.ProcessEnv\n  /**\n   * `'merge'` (the default) layers `env` on top of `process.env`, so the\n   * child sees every variable this process has plus the named ones.\n   * `'replace'` passes exactly `env` and nothing else, which is what a\n   * grader needs when the claim under test is about the variables the\n   * command could read. `PATH` is not re-added under `'replace'`, and a\n   * command that must find a binary on `PATH` names `PATH` itself.\n   *\n   * With no `PATH` in the child environment the two forms do NOT search the\n   * same directories, so a caller under `'replace'` that names no `PATH` gets\n   * a resolution that depends on which form it picked. The shell form execs\n   * the shell, which applies its own compiled-in default; the argv form\n   * reaches `execvp`, which falls back to `confstr(_CS_PATH)`. Measured on\n   * Linux/glibc: `/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin`\n   * against `/bin:/usr/bin`, so a binary in `/usr/local/bin` resolves on the\n   * shell form and reports ENOENT on the argv form. Name `PATH` and both\n   * forms search exactly what was named.\n   */\n  envMode?: 'merge' | 'replace'\n  /** Wall-clock bound in ms. Defaults to 10 minutes. */\n  timeoutMs?: number\n  /**\n   * Cap on captured stdout+stderr. Reaching it truncates the captured text\n   * and sets `outputTruncated`; it never kills the process. Defaults to\n   * 16 MiB.\n   */\n  maxOutputBytes?: number\n  /**\n   * Kills the process group when it aborts, the same way the deadline does.\n   * A signal that is already aborted when `runBoundedProcess` is called\n   * prevents the spawn entirely — nothing runs.\n   */\n  signal?: AbortSignal\n}\n\nexport interface BoundedProcessResult {\n  /**\n   * The process actually started. False when nothing ran at all: an\n   * already-aborted signal, `args` with a truthy `shell`, an argument the\n   * platform refuses, or a program that does not exist.\n   *\n   * This is the field to branch on, never the text of `runnerError`. A caller\n   * deciding whether a run produced an outcome at all is asking exactly this,\n   * and asking it here is type-checked rather than held by a wording\n   * convention.\n   */\n  spawned: boolean\n  /**\n   * The `stdin` payload reached the child in full. True whenever the caller\n   * supplied none, because nothing could fail to arrive.\n   *\n   * False means the command ran on partial input, which is a fact about the\n   * answer it produced: a checksum over a truncated payload is a wrong answer,\n   * not a failed run. `spawned` stays true and `exitCode` stays the child's.\n   */\n  stdinDelivered: boolean\n  /**\n   * Exit code. Forced non-zero whenever `killedByTimeout` or\n   * `killedBySignal` is set, because a SIGKILLed child can close with 0 and\n   * a killed run must never read as a pass.\n   */\n  exitCode: number\n  /** Captured stdout, truncated at `maxOutputBytes`. */\n  stdout: string\n  /**\n   * Captured stderr, truncated at `maxOutputBytes`. A runner-side failure is\n   * reported in `runnerError`, not appended here; the caller decides whether\n   * the command's own stderr and the runner's diagnosis belong together.\n   */\n  stderr: string\n  /** Wall-clock duration in ms, measured across the whole call. */\n  wallMs: number\n  /** The wall-clock bound was reached and the process group was killed. */\n  killedByTimeout: boolean\n  /** `signal` aborted and the process group was killed. */\n  killedBySignal: boolean\n  /** `maxOutputBytes` was reached and later output was discarded. */\n  outputTruncated: boolean\n  /**\n   * Human-readable diagnosis of a runner-side failure, in one of three shapes:\n   *\n   *   - `not spawned:` — the caller's own bug, such as `args` with a truthy\n   *     `shell`, or an already-aborted signal. No retry helps.\n   *   - `stdin not delivered:` — the command ran and exited on its own, and\n   *     the stdin payload did not reach it in full because the child closed\n   *     the pipe first.\n   *   - anything else — the process could not be spawned (a missing binary, a\n   *     NUL byte in an argument).\n   *\n   * Absent when the command ran and read everything it was sent, however it\n   * exited. The prefixes are for a person reading a log; code reads `spawned`\n   * and `stdinDelivered`, which say the same things and are type-checked.\n   */\n  runnerError?: string\n}\n\nexport async function runBoundedProcess(input: BoundedProcessInput): Promise<BoundedProcessResult> {\n  const start = Date.now()\n  const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES\n  const timeoutMs = input.timeoutMs ?? DEFAULT_BOUNDED_PROCESS_TIMEOUT_MS\n  const envMode = input.envMode ?? 'merge'\n  const env =\n    input.env === undefined && envMode === 'merge'\n      ? undefined\n      : envMode === 'replace'\n        ? { ...input.env }\n        : { ...process.env, ...input.env }\n\n  if (input.signal?.aborted) {\n    return {\n      spawned: false,\n      stdinDelivered: true,\n      exitCode: ABORT_EXIT_CODE,\n      stdout: '',\n      stderr: '',\n      wallMs: Date.now() - start,\n      killedByTimeout: false,\n      killedBySignal: true,\n      outputTruncated: false,\n      runnerError: 'aborted before spawn: the AbortSignal was already aborted',\n    }\n  }\n\n  // Reported rather than thrown, because this module's contract is that a\n  // call always resolves. A caller bug still reads as a failure and never as\n  // a pass: the exit code is non-zero and `runnerError` names the cause.\n  if (input.args !== undefined && input.shell) {\n    return {\n      spawned: false,\n      stdinDelivered: true,\n      exitCode: SPAWN_FAILURE_EXIT_CODE,\n      stdout: '',\n      stderr: '',\n      wallMs: Date.now() - start,\n      killedByTimeout: false,\n      killedBySignal: false,\n      outputTruncated: false,\n      // Shares `SPAWN_FAILURE_EXIT_CODE` with a program that does not exist,\n      // because both mean nothing ran. The `not spawned:` prefix is the stable\n      // discriminator: it marks the caller's own bug, which no retry fixes.\n      runnerError:\n        'not spawned: `args` passes an argument vector directly to the program, so a shell ' +\n        'cannot interpret it — pass `args` or a truthy `shell`, never both',\n    }\n  }\n\n  return await new Promise<BoundedProcessResult>((resolve) => {\n    const spawnOptions = {\n      cwd: input.cwd,\n      env,\n      // Own process group so a kill reaches the whole tree, not just the\n      // shell — otherwise a runaway grandchild keeps the pipes open and\n      // `close` never fires.\n      detached: process.platform !== 'win32',\n    }\n    // The argv form takes the same bounds, the same group and the same kill\n    // path. Two things differ, and both are stated where they are decided:\n    // no shell reads the command, and executable lookup falls back to a\n    // different default `PATH` when the caller names none (see `envMode`).\n    //\n    // `spawn` validates its arguments and THROWS synchronously — a NUL byte in\n    // `command` or in an `args` entry, or an `args` that is not an array from\n    // an untypechecked caller. A throw inside this executor would reject, and\n    // this module's contract is that a call always resolves. A caller that\n    // grades untrusted text must be able to score that text as failed rather\n    // than die on it.\n    let child: ReturnType<typeof spawn>\n    try {\n      child =\n        input.args === undefined\n          ? spawn(input.command, { ...spawnOptions, shell: input.shell ?? true })\n          : spawn(input.command, input.args, { ...spawnOptions, shell: false })\n    } catch (err) {\n      resolve({\n        spawned: false,\n        stdinDelivered: true,\n        exitCode: SPAWN_FAILURE_EXIT_CODE,\n        stdout: '',\n        stderr: '',\n        wallMs: Date.now() - start,\n        killedByTimeout: false,\n        killedBySignal: false,\n        outputTruncated: false,\n        runnerError: String(err),\n      })\n      return\n    }\n    // A pipe nobody closes is a hang, so stdin is always ended — after the\n    // payload when there is one, immediately when there is not. A write that\n    // fails is recorded and never thrown: the child already ran, and this\n    // module's contract is that a call always resolves.\n    let stdinError: string | undefined\n    const childStdin = child.stdin\n    if (childStdin) {\n      childStdin.on('error', (err) => {\n        // Closing an unused pipe races a command that exits at once, and that\n        // broken pipe says nothing about a caller who sent nothing. Only a\n        // payload the caller supplied can fail to be delivered.\n        if (input.stdin !== undefined) stdinError ??= `stdin not delivered: ${String(err)}`\n      })\n      if (input.stdin === undefined) childStdin.end()\n      else childStdin.end(input.stdin, 'utf8')\n    } else if (input.stdin !== undefined) {\n      stdinError = 'stdin not delivered: the child was spawned with no stdin pipe'\n    }\n\n    let stdout = ''\n    let stderr = ''\n    let outputBytes = 0\n    let outputTruncated = false\n    let killedByTimeout = false\n    let killedBySignal = false\n    let settled = false\n\n    // Bound the in-memory buffer so a runaway process can't OOM the caller.\n    // Once the cap is hit the streams are still drained (the child needs them\n    // read to reach `close`) but the bytes are discarded.\n    function capture(s: string): string {\n      if (outputBytes >= maxOutputBytes) {\n        outputTruncated = true\n        return ''\n      }\n      const room = maxOutputBytes - outputBytes\n      if (s.length > room) {\n        outputBytes = maxOutputBytes\n        outputTruncated = true\n        return s.slice(0, room)\n      }\n      outputBytes += s.length\n      return s\n    }\n\n    // Decoded across chunk boundaries. A stream arrives as Buffers split at\n    // arbitrary byte offsets, so decoding each chunk on its own replaces any\n    // multi-byte character that straddles a boundary with U+FFFD — the output\n    // is then corrupted at every 64 KiB of non-ASCII text. The decoder holds\n    // the partial sequence until its remaining bytes arrive.\n    const stdoutDecoder = new StringDecoder('utf8')\n    const stderrDecoder = new StringDecoder('utf8')\n    const decode = (decoder: StringDecoder, d: unknown): string =>\n      Buffer.isBuffer(d) ? decoder.write(d) : String(d)\n\n    const onStdout = (d: unknown) => {\n      const chunk = capture(decode(stdoutDecoder, d))\n      if (chunk) stdout += chunk\n    }\n    const onStderr = (d: unknown) => {\n      const chunk = capture(decode(stderrDecoder, d))\n      if (chunk) stderr += chunk\n    }\n\n    child.stdout?.on('data', onStdout)\n    child.stderr?.on('data', onStderr)\n\n    let forceResolve: ReturnType<typeof setTimeout> | undefined\n\n    const cleanup = () => {\n      clearTimeout(timeout)\n      if (forceResolve) clearTimeout(forceResolve)\n      input.signal?.removeEventListener('abort', onAbort)\n      child.stdout?.off('data', onStdout)\n      child.stderr?.off('data', onStderr)\n      // The stdin `error` listener stays attached on purpose: a stream that\n      // emits `error` with no listener throws, and a late EPIPE after the run\n      // has settled must not take the process down.\n      child.removeAllListeners('close')\n      child.removeAllListeners('error')\n    }\n\n    // Resolve exactly once. `code` comes from `close`; on a kill path the\n    // exit code is forced non-zero so a SIGKILLed child that reports 0 can\n    // never read as a clean pass downstream.\n    const finish = (outcome: { code: number | null; spawned?: boolean; runnerError?: string }) => {\n      if (settled) return\n      settled = true\n      cleanup()\n      const spawned = outcome.spawned ?? true\n      resolve({\n        spawned,\n        // A program that never started was sent nothing, whatever the write to\n        // its doomed pipe reported.\n        stdinDelivered: spawned ? stdinError === undefined : true,\n        exitCode: exitCodeFor(outcome.code, killedByTimeout, killedBySignal),\n        stdout,\n        stderr,\n        wallMs: Date.now() - start,\n        killedByTimeout,\n        killedBySignal,\n        outputTruncated,\n        runnerError: outcome.runnerError ?? stdinError,\n      })\n    }\n\n    // SIGKILL the whole process group (we spawned detached). On a clean close\n    // this never runs.\n    const killTree = () => {\n      try {\n        if (process.platform !== 'win32' && typeof child.pid === 'number') {\n          process.kill(-child.pid, 'SIGKILL')\n        } else {\n          child.kill('SIGKILL')\n        }\n      } catch (err) {\n        // ESRCH means the group exited between the decision to kill and the\n        // signal, which `close` reports on its own. Anything else means the\n        // group may still be running, which the caller must hear about.\n        if ((err as NodeJS.ErrnoException)?.code !== 'ESRCH') {\n          console.warn('[bounded-process] SIGKILL of the process group failed:', err)\n        }\n      }\n    }\n\n    // Give `close` a brief window to fire (flushing any final output) after\n    // the group dies; if an orphaned grandchild keeps the pipes open, resolve\n    // anyway so the caller can't hang on a runaway. The deadline and an abort\n    // can both fire, so the kill happens at most once and the drain window is\n    // not restarted by the second one.\n    let killed = false\n    const killAndDrain = () => {\n      if (killed) return\n      killed = true\n      killTree()\n      forceResolve = setTimeout(() => finish({ code: null }), KILL_DRAIN_MS)\n    }\n\n    function onAbort() {\n      if (settled) return\n      killedBySignal = true\n      killAndDrain()\n    }\n\n    const timeout = setTimeout(() => {\n      killedByTimeout = true\n      killAndDrain()\n    }, timeoutMs)\n\n    input.signal?.addEventListener('abort', onAbort, { once: true })\n\n    child.on('close', (code) => {\n      if (forceResolve) clearTimeout(forceResolve)\n      finish({ code })\n    })\n    child.on('error', (err) => {\n      if (forceResolve) clearTimeout(forceResolve)\n      // `error` on a child means the program never started — a missing binary,\n      // a refused argument. Nothing ran, whatever the stdin write did.\n      finish({ code: SPAWN_FAILURE_EXIT_CODE, spawned: false, runnerError: String(err) })\n    })\n  })\n}\n\n/**\n * A killed run reports the code the child closed with only when that code is\n * already non-zero; otherwise it reports the conventional code for the kind\n * of kill. A run that closed on its own with no code at all reports 1.\n */\nfunction exitCodeFor(\n  code: number | null,\n  killedByTimeout: boolean,\n  killedBySignal: boolean,\n): number {\n  if (code !== null && code !== 0) return code\n  if (killedByTimeout) return TIMEOUT_EXIT_CODE\n  if (killedBySignal) return ABORT_EXIT_CODE\n  return code ?? UNKNOWN_EXIT_CODE\n}\n"],"mappings":"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"}

package/dist/builder-eval/index.d.ts

@@ -24,24 +24,24 @@ interface TestGradedRunResult {
 }
 //#endregion
 //#region src/builder-eval/builder-session.d.ts
-interface BuilderSessionInit {
+export interface BuilderSessionInit {
   projectId: string;
   chatId?: string;
   /** Free-form: user's task description, project name, etc. Stored on the builder Run. */
   tags?: Record<string, string>;
 }
-interface ShipOptions {
+export interface ShipOptions {
   harness: HarnessConfig;
   driver?: SandboxDriver;
   /** scenarioId of this app-build run. Defaults to `${projectId}/build`. */
   scenarioId?: string;
 }
-interface RunAppScenarioOptions {
+export interface RunAppScenarioOptions {
   scenario: TestGradedScenario;
   /** Harness driver override; defaults to the one the session was created with. */
   driver?: SandboxDriver;
 }
-declare class BuilderSession {
+export declare class BuilderSession {
   private store;
   private builderEmitter;
   readonly projectId: string;
@@ -105,7 +105,7 @@ declare class BuilderSession {
  * returns { builderRunId, lastBuildRunId, chatRuns }. For chat-first UIs
  * this is how a resumed session finds its place in the edit history.
  */
-declare function resumeBuilderSession(store: TraceStore, projectId: string): Promise<{
+export declare function resumeBuilderSession(store: TraceStore, projectId: string): Promise<{
   projectId: string;
   chatRuns: Run[];
   lastBuilderRun?: Run;
@@ -114,8 +114,8 @@ declare function resumeBuilderSession(store: TraceStore, projectId: string): Pro
 }>;
 //#endregion
 //#region src/builder-eval/three-layer-eval.d.ts
-type ProjectKind = 'full' | 'scaffold-only';
-interface ThreeLayerProjectReport {
+export type ProjectKind = 'full' | 'scaffold-only';
+export interface ThreeLayerProjectReport {
   projectId: string;
   /**
    * `'full'` when the project has at least one `app-runtime` run;
@@ -141,17 +141,17 @@ interface ThreeLayerProjectReport {
    */
   complete: boolean;
 }
-declare function scoreProject(store: TraceStore, projectId: string): Promise<ThreeLayerProjectReport>;
+export declare function scoreProject(store: TraceStore, projectId: string): Promise<ThreeLayerProjectReport>;
 /** Aggregate scoring across every project in a corpus. */
-declare function scoreAllProjects(store: TraceStore): Promise<ThreeLayerProjectReport[]>;
+export declare function scoreAllProjects(store: TraceStore): Promise<ThreeLayerProjectReport[]>;
 //#endregion
 //#region src/builder-eval/correlation.d.ts
-interface LayerCorrelation {
+export interface LayerCorrelation {
   n: number;
   pearson: number;
   spearman: number;
 }
-interface CorrelationReport {
+export interface CorrelationReport {
   /** Pairs present in the corpus (layers with ≥ 2 matched data points). */
   metaVsBuild?: LayerCorrelation;
   metaVsRuntime?: LayerCorrelation;
@@ -159,10 +159,10 @@ interface CorrelationReport {
   /** Number of complete projects (all 3 scores present). */
   completeProjects: number;
 }
-declare function correlateLayers(reports: ThreeLayerProjectReport[]): CorrelationReport;
+export declare function correlateLayers(reports: ThreeLayerProjectReport[]): CorrelationReport;
 //#endregion
 //#region src/builder-eval/project-registry.d.ts
-interface ProjectSummary {
+export interface ProjectSummary {
   projectId: string;
   chatCount: number;
   buildCount: number;
@@ -174,7 +174,7 @@ interface ProjectSummary {
     score?: number;
   };
 }
-interface ChatSummary {
+export interface ChatSummary {
   chatId: string;
   projectId: string;
   builderRunId: string;
@@ -188,11 +188,11 @@ interface ChatSummary {
   buildRunId?: string;
   appRuntimeRunIds: string[];
 }
-interface ProjectTimelineEntry {
+export interface ProjectTimelineEntry {
   run: Run;
   layerBucket: 'chat' | 'build' | 'runtime' | 'other';
 }
-declare class ProjectRegistry {
+export declare class ProjectRegistry {
   private store;
   constructor(store: TraceStore);
   listProjects(): Promise<ProjectSummary[]>;
@@ -200,5 +200,4 @@ declare class ProjectRegistry {
   projectChats(projectId: string): Promise<ChatSummary[]>;
 }
 //#endregion
-export { BuilderSession, BuilderSessionInit, ChatSummary, CorrelationReport, LayerCorrelation, ProjectKind, ProjectRegistry, ProjectSummary, ProjectTimelineEntry, RunAppScenarioOptions, ShipOptions, ThreeLayerProjectReport, correlateLayers, resumeBuilderSession, scoreAllProjects, scoreProject };
 //# sourceMappingURL=index.d.ts.map

package/dist/builder-eval/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/test-graded-scenario.ts","../../src/builder-eval/builder-session.ts","../../src/builder-eval/three-layer-eval.ts","../../src/builder-eval/correlation.ts","../../src/builder-eval/project-registry.ts"],"mappings":";;;;;UAmBiB;EACf;EACA;EACA,SAAS;;EAET;;EAEA;;EAEA,OAAO;;UAUQ;EACf;EACA,UAAU;EACV,SAAS;EACT;EACA;EACA,eAAe;;;;UCjBA;EACf;EACA;;EAEA,OAAO;;UAGQ;EACf,SAAS;EACT,SAAS;;EAET;;UAGe;EACf,UAAU;;EAEV,SAAS;;cAGE;UACH;UACA;WACC;WACA;UACD;UACA;UACA;EAER,YAAY,OAAO,YAAY,MAAM,oBAAoB,SAAS;;EAS5D,UAAU,sBAAwC;;MAYpD,WAAW;;;;;EAST,KAAK,SAAS,cAAc;IAAU;IAAe,QAAQ;;;;;;;;EA2B7D,eAAe,SAAS,wBAAwB,QAAQ;;;EAqBxD,gBAAgB,eAAe,qBAAqB;;EAcpD,QAAQ;IAAW;IAAe;IAAgB;MAAmB;;;;;;;;EAerE,gBAAgB,qBAAqB,QAAQ;;;;;;EAsB7C,iBAAiB;IACrB;IACA;IACA;IACA;MACE;MAqBA;MAGA;;;;;;;iBAUgB,qBACpB,OAAO,YACP,oBACC;EACD;EACA,UAAU;EACV,iBAAiB;EACjB,eAAe;EACf,oBAAoB;;;;KC5MV;UAEK;EACf;;;;;;;EAOA,MAAM;EACN;;EAEA;EACA;;EAEA;EACA;;EAEA;EACA;;;;;;EAMA;;iBAGoB,aACpB,OAAO,YACP,oBACC,QAAQ;;iBAuCW,iBAAiB,OAAO,aAAa,QAAQ;;;UC/ElD;EACf;EACA;EACA;;UAGe;;EAEf,cAAc;EACd,gBAAgB;EAChB,iBAAiB;;EAEjB;;iBAGc,gBAAgB,SAAS,4BAA4B;;;UCpBpD;EACf;EACA;EACA;EACA;EACA;EACA;EACA;IAAkB;IAAe;;;UAGlB;EACf;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR,UAAU;;EAEV;EACA;EACA;EACA;;UAGe;EACf,KAAK;EACL;;cAGW;UACS;EAApB,YAAoB,OAAO;EAErB,gBAAgB,QAAQ;EAgCxB,gBAAgB,oBAAoB,QAAQ;EAgB5C,aAAa,oBAAoB,QAAQ"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/test-graded-scenario.ts","../../src/builder-eval/builder-session.ts","../../src/builder-eval/three-layer-eval.ts","../../src/builder-eval/correlation.ts","../../src/builder-eval/project-registry.ts"],"mappings":";;;;;UAmBiB;EACf;EACA;EACA,SAAS;;EAET;;EAEA;;EAEA,OAAO;;UAUQ;EACf;EACA,UAAU;EACV,SAAS;EACT;EACA;EACA,eAAe;;;;iBCjBA;EACf;EACA;;EAEA,OAAO;;iBAGQ;EACf,SAAS;EACT,SAAS;;EAET;;iBAGe;EACf,UAAU;;EAEV,SAAS;;qBAGE;UACH;UACA;WACC;WACA;UACD;UACA;UACA;EAER,YAAY,OAAO,YAAY,MAAM,oBAAoB,SAAS;;EAS5D,UAAU,sBAAwC;;MAYpD,WAAW;;;;;EAST,KAAK,SAAS,cAAc;IAAU;IAAe,QAAQ;;;;;;;;EA2B7D,eAAe,SAAS,wBAAwB,QAAQ;;;EAqBxD,gBAAgB,eAAe,qBAAqB;;EAcpD,QAAQ;IAAW;IAAe;IAAgB;MAAmB;;;;;;;;EAerE,gBAAgB,qBAAqB,QAAQ;;;;;;EAsB7C,iBAAiB;IACrB;IACA;IACA;IACA;MACE;MAqBA;MAGA;;;;;;;wBAUgB,qBACpB,OAAO,YACP,oBACC;EACD;EACA,UAAU;EACV,iBAAiB;EACjB,eAAe;EACf,oBAAoB;;;;YC5MV;iBAEK;EACf;;;;;;;EAOA,MAAM;EACN;;EAEA;EACA;;EAEA;EACA;;EAEA;EACA;;;;;;EAMA;;wBAGoB,aACpB,OAAO,YACP,oBACC,QAAQ;;wBAuCW,iBAAiB,OAAO,aAAa,QAAQ;;;iBC/ElD;EACf;EACA;EACA;;iBAGe;;EAEf,cAAc;EACd,gBAAgB;EAChB,iBAAiB;;EAEjB;;wBAGc,gBAAgB,SAAS,4BAA4B;;;iBCpBpD;EACf;EACA;EACA;EACA;EACA;EACA;EACA;IAAkB;IAAe;;;iBAGlB;EACf;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR,UAAU;;EAEV;EACA;EACA;EACA;;iBAGe;EACf,KAAK;EACL;;qBAGW;UACS;EAApB,YAAoB,OAAO;EAErB,gBAAgB,QAAQ;EAgCxB,gBAAgB,oBAAoB,QAAQ;EAgB5C,aAAa,oBAAoB,QAAQ"}

package/dist/builder-eval/index.js

@@ -1,8 +1,8 @@
-import { a as spearmanR, r as pearsonR } from "../descriptive-1V17A-qa.js";
+import { a as spearmanR, r as pearsonR } from "../descriptive-D9LUFk1-.js";
 import { s as judgeSpans } from "../query-DlV0pdx4.js";
 import { t as newRecordId } from "../record-id-DUgsK5qp.js";
 import { t as TraceEmitter } from "../emitter-DbMXUIVP.js";
-import { n as runBoundedProcess } from "../bounded-process-BBZob7vl.js";
+import { n as runBoundedProcess } from "../bounded-process-Cj9YjXbE.js";
 //#region src/sandbox-harness.ts
 /**
 * SandboxHarness — executes a scenario in an isolated environment and
@@ -27,18 +27,20 @@ var SubprocessSandboxDriver = class {
 		this.defaultEnv = options.env;
 	}
 	async exec(phase, command, config) {
+		const effectiveCwd = config.cwd ?? this.defaultCwd;
+		const effectiveEnv = {
+			...process.env,
+			...this.defaultEnv ?? {},
+			...config.env ?? {}
+		};
 		const result = await runBoundedProcess({
 			command,
 			shell: true,
-			cwd: config.cwd ?? this.defaultCwd,
-			env: {
-				...process.env,
-				...this.defaultEnv ?? {},
-				...config.env ?? {}
-			},
+			cwd: effectiveCwd,
+			env: effectiveEnv,
 			envMode: "replace",
-			timeoutMs: config.timeoutMs ?? 10 * 6e4,
-			maxOutputBytes: config.maxOutputBytes ?? 16 * 1024 * 1024
+			timeoutMs: config.timeoutMs ?? 6e5,
+			maxOutputBytes: config.maxOutputBytes ?? 16777216
 		});
 		const parsed = !result.killedByTimeout && phase === "test" && config.testParser ? config.testParser.parse(result.stdout, result.stderr, result.exitCode) : void 0;
 		return {