@outerlayer/cli 0.34.0-next.20261028010245 → 0.34.0-next.20261028122415

package/dist/{work-proofs-record-LIQGUDWH.js → chunk-BEGMZKMG.js}

@@ -1,87 +1,131 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
-import { resolveProofsItem, ownPullRequest, proofsCommentId, otherPullRequestHeads, classifyProofsAt, kindProblem, proofsCommentBody, runWorkProofs } from './chunk-NCKH3KCM.js';
-import { runWorkComment } from './chunk-D6SH7DWA.js';
-import './chunk-6CK2OC4Q.js';
-import { runEmitDemo } from './chunk-WSVE5QGL.js';
-import { readNewestDemo } from './chunk-ER6KQCVJ.js';
-import { runEmitArtifact } from './chunk-3XOLOV5A.js';
-import { runSync } from './chunk-32FAPJFD.js';
-import './chunk-NOEJGR4X.js';
-import './chunk-ESVW4MJY.js';
-import './chunk-TBT347UY.js';
-import './chunk-2PGI6RDE.js';
-import './chunk-D3CT6XQ4.js';
-import { WorkCommandError, resolveCredentials, getJson } from './chunk-GJYGOFF3.js';
-import './chunk-IP7BIBXJ.js';
-import './chunk-BTDBDTUY.js';
-import './chunk-4J5GRWAY.js';
-import './chunk-NWHU5G6R.js';
-import './chunk-G2JWZDFA.js';
-import './chunk-ANPNT6PM.js';
-import './chunk-IXPH4EXK.js';
-import './chunk-LYCJQOO2.js';
-import { defaultFetch } from './chunk-PAGB3DCI.js';
-import './chunk-PJDQPF5N.js';
-import './chunk-VKYU4HHW.js';
-import './chunk-57WFXHCB.js';
-import './chunk-ZJSNLVCE.js';
-import './chunk-2O5KA67H.js';
-import './chunk-BKO6JEZI.js';
-import './chunk-HCVLP7XA.js';
-import './chunk-BJ3KTMDH.js';
-import './chunk-OVNF4LLC.js';
-import { resolveRepoIdentity } from './chunk-A6PJSNP6.js';
-import './chunk-5BHIBJDA.js';
-import './chunk-CDDED64E.js';
-import './chunk-RA3O54FC.js';
-import './chunk-T2Q7ISPE.js';
-import './chunk-WZBHBH3J.js';
-import './chunk-CRB3POP4.js';
-import './chunk-URIZRCRY.js';
-import './chunk-YQR6E6OV.js';
-import './chunk-TUSYOL2O.js';
+import { sanitizeTerminal } from './chunk-IXPH4EXK.js';
+import { resolvePackRoot } from './chunk-OVNF4LLC.js';
 import { parseProofsConfig } from './chunk-XFJ7YOPD.js';
-import { ARTIFACT_MAX_CAPTION_LENGTH } from './chunk-DINRXUQA.js';
-import './chunk-VNVZDWO3.js';
-import './chunk-AJTGTSNA.js';
-import './chunk-L2OARQKP.js';
-import './chunk-MESOOLF4.js';
-import './chunk-Z5GEFMRW.js';
-import { spawnSync, spawn } from 'child_process';
-import { mkdtempSync, rmSync, openSync, closeSync, readdirSync, readFileSync } from 'fs';
-import { tmpdir } from 'os';
+import { CHECK_ITEM_REASON_MAX_LENGTH, CheckItemsSchema } from './chunk-DINRXUQA.js';
+import { createHash } from 'crypto';
 import { join } from 'path';
+import { pathToFileURL } from 'url';
 
 createRequire(import.meta.url);
-var runShell = (command, params) => {
-  const logPath = join(params.logDir, `${params.groups.length}-${Date.now()}.log`);
-  const fd = openSync(logPath, "w");
-  return new Promise((resolve) => {
-    const child = spawn("sh", ["-c", command], { cwd: params.cwd, env: params.env, detached: true, stdio: ["ignore", fd, fd] });
-    closeSync(fd);
-    if (child.pid !== void 0) params.groups.push(child.pid);
-    let timedOut = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      try {
-        process.kill(-child.pid, "SIGKILL");
-      } catch {
-      }
-    }, params.timeoutMs);
-    const finish = (status) => {
-      clearTimeout(timer);
-      let text = "";
-      try {
-        text = readFileSync(logPath, "utf8");
-      } catch {
-      }
-      resolve({ status, timedOut, tail: text.trimEnd().split("\n").slice(-8).join("\n") });
+var ARTIFACT_PROOF_REASON = "Its declared artifact proves it; the judge does not judge artifacts.";
+var NO_CITING_TEST_REASON = "No test cites this criterion, and it declares no artifact proof.";
+var NO_TEST_FILES_REASON = "No file at this commit is recognized as a test. Name the repository's test files with a runner glob in `.outerlayer-proofs.yaml`.";
+var NO_VERDICT_REASON = "The judge gave no result for this criterion.";
+function criterionInputs(input) {
+  const paths = [...new Set((input.citations[input.criterion.id] ?? []).map((citation) => citation.path))].sort();
+  const hash = createHash("sha256");
+  const part = (text) => {
+    hash.update(`${Buffer.byteLength(text)}:`);
+    hash.update(text);
+  };
+  part("judge-criterion-v1");
+  part(input.brief);
+  part(input.criterion.id);
+  part(input.criterion.text);
+  part(input.criterion.proof ?? "");
+  for (const path2 of paths) {
+    part(path2);
+    part(input.testFiles.get(path2) ?? "");
+  }
+  return hash.digest("hex");
+}
+var HTTPS_LINK = /^https:\/\/\S+$/;
+function refsFor(id, citations) {
+  const refs = (citations[id] ?? []).slice(0, 20).map((citation) => ({
+    path: citation.path,
+    line: citation.line,
+    // Only an https link becomes an href on a page; any other is left off rather than refusing the check.
+    ...HTTPS_LINK.test(citation.href ?? "") ? { href: citation.href } : {}
+  }));
+  return refs.length === 0 ? void 0 : refs;
+}
+function planCriteria(input) {
+  const previousById = new Map(input.previous.map((item) => [item.id, item]));
+  const settled = [];
+  const toJudge = [];
+  for (const criterion of input.criteria) {
+    const inputs = input.inputs.get(criterion.id);
+    const base = { id: criterion.id, criterion: criterion.id, ...inputs === void 0 ? {} : { inputs } };
+    const refs = refsFor(criterion.id, input.citations);
+    if (criterion.proof !== null) {
+      settled.push({ ...base, result: "skipped", reason: ARTIFACT_PROOF_REASON });
+      continue;
+    }
+    if (refs === void 0) {
+      settled.push({ ...base, result: "fail", reason: input.noTestFiles === true ? NO_TEST_FILES_REASON : NO_CITING_TEST_REASON });
+      continue;
+    }
+    const kept = previousById.get(criterion.id);
+    if (kept !== void 0 && inputs !== void 0 && kept.inputs === inputs && (kept.result === "pass" || kept.result === "fail")) {
+      settled.push({ ...base, result: kept.result, ...kept.reason === void 0 ? {} : { reason: kept.reason }, refs });
+      continue;
+    }
+    toJudge.push(criterion);
+  }
+  return { settled, toJudge };
+}
+var MAX_ANSWER_ENTRIES = 500;
+function readAnswer(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return { ok: false, problem: "expected an object" };
+  const { result, items } = raw;
+  if (result !== void 0 && result !== "pass" && result !== "fail") return { ok: false, problem: 'result: must be "pass" or "fail"' };
+  if (items !== void 0 && !Array.isArray(items)) return { ok: false, problem: "items: must be an array" };
+  const entries = items ?? [];
+  if (entries.length > MAX_ANSWER_ENTRIES) return { ok: false, problem: `items: at most ${MAX_ANSWER_ENTRIES} entries` };
+  const read = [];
+  for (const [index, entry] of entries.entries()) {
+    const { id, result: itemResult, reason } = typeof entry === "object" && entry !== null ? entry : {};
+    if (typeof id !== "string" || id === "" || id.length > 200) return { ok: false, problem: `items.${index}.id: must be text of 1 to 200 characters` };
+    if (itemResult !== "pass" && itemResult !== "fail") return { ok: false, problem: `items.${index}.result: must be "pass" or "fail"` };
+    if (reason !== void 0 && typeof reason !== "string") return { ok: false, problem: `items.${index}.reason: must be text` };
+    read.push({ id, result: itemResult, ...reason === void 0 ? {} : { reason } });
+  }
+  return { ok: true, answer: { ...result === void 0 ? {} : { result }, items: read } };
+}
+function parseJudgeAnswer(text) {
+  if (text === void 0 || text.trim() === "") return void 0;
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return { ok: false, reason: "the judge's items.json is not JSON" };
+  }
+  const read = readAnswer(raw);
+  return read.ok ? read : { ok: false, reason: `the judge's items.json does not match its shape: ${read.problem}` };
+}
+function oneLineReason(text) {
+  if (text === void 0) return void 0;
+  const line = text.replace(/\s+/g, " ").trim();
+  if (line === "") return void 0;
+  return line.length <= CHECK_ITEM_REASON_MAX_LENGTH ? line : `${line.slice(0, CHECK_ITEM_REASON_MAX_LENGTH - 1)}\u2026`;
+}
+function judgedItems(input) {
+  return input.toJudge.map((criterion) => {
+    const said = input.results.get(criterion.id);
+    const inputs = input.inputs.get(criterion.id);
+    const refs = refsFor(criterion.id, input.citations);
+    const reason = said === void 0 ? NO_VERDICT_REASON : oneLineReason(said.reason);
+    return {
+      id: criterion.id,
+      criterion: criterion.id,
+      result: said?.result ?? "fail",
+      ...reason === void 0 ? {} : { reason },
+      ...refs === void 0 ? {} : { refs },
+      ...inputs === void 0 || said === void 0 ? {} : { inputs }
     };
-    child.on("error", () => finish(null));
-    child.on("exit", (status) => finish(status));
   });
-};
+}
+function inCriteriaOrder(items, criteria) {
+  const order = new Map(criteria.map((criterion, index) => [criterion.id, index]));
+  return [...items].sort((a, b) => (order.get(a.id) ?? Number.MAX_SAFE_INTEGER) - (order.get(b.id) ?? Number.MAX_SAFE_INTEGER));
+}
+function itemsSentence(items, noun) {
+  const failing = items.filter((item) => item.result === "fail").map((item) => item.id);
+  if (failing.length === 0) return void 0;
+  return `${failing.length} of ${items.length} ${items.length === 1 ? noun.one : noun.many} not satisfied: ${failing.join(", ")}`;
+}
 
 // ../../node_modules/balanced-match/dist/esm/index.js
 var balanced = (a, b, str) => {
@@ -1953,431 +1997,66 @@ minimatch.Minimatch = Minimatch;
 minimatch.escape = escape;
 minimatch.unescape = unescape;
 
-// src/work-proofs-tests.ts
-var ID_CHARACTER = "A-Za-z0-9_-";
-function escapeRegExp(text) {
-  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function containsId(text, id) {
-  return new RegExp(`(?<![${ID_CHARACTER}])${escapeRegExp(id)}(?![${ID_CHARACTER}])`).test(text);
-}
-function runnerFor(path2, runners) {
-  const index = runners.findIndex((runner) => minimatch(path2, runner.files, { dot: true }));
-  return index === -1 ? void 0 : index;
-}
-function planRuns(files, runners) {
-  const plan = /* @__PURE__ */ new Map();
-  for (const file of [...files].sort()) {
-    const index = runnerFor(file, runners);
-    if (index === void 0) continue;
-    plan.set(index, [...plan.get(index) ?? [], file]);
-  }
-  return new Map([...plan].sort(([a], [b]) => a - b));
-}
-function shellQuote(text) {
-  const path2 = text.startsWith("-") ? `./${text}` : text;
-  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(path2)) return path2;
-  return `'${path2.replace(/'/g, `'\\''`)}'`;
-}
-function fillFiles(command, files) {
-  const quoted = files.map(shellQuote).join(" ");
-  return command.split("{files}").join(quoted);
-}
-function proofFileCriterion(name, declared) {
-  const dot = name.lastIndexOf(".");
-  if (dot <= 0) return void 0;
-  const stem = name.slice(0, dot);
-  return declared.has(stem) ? stem : void 0;
-}
-function git(root, args, accepted = [0]) {
-  const result = spawnSync("git", args, { cwd: root, encoding: "utf8", maxBuffer: 268435456 });
-  if (result.error !== void 0 || !accepted.includes(result.status)) {
-    throw new WorkCommandError(`git ${args[0]} failed (${result.error?.message ?? `exit status ${result.status}`}), so the tests that name a proof cannot be found.`);
-  }
-  return result.stdout;
-}
-function discoverTestFiles(root, ids, runners) {
-  const found = /* @__PURE__ */ new Map();
-  if (ids.length === 0 || runners.length === 0) return found;
-  const grep = git(root, ["grep", "-z", "-l", "-I", "-F", ...ids.flatMap((id) => ["-e", id]), "HEAD", "--"], [0, 1]);
-  const paths = grep.split("\0").filter((entry) => entry !== "").map((entry) => entry.slice("HEAD:".length)).filter((path2) => runnerFor(path2, runners) !== void 0).sort();
-  for (const path2 of paths) {
-    const shown = git(root, ["show", `HEAD:${path2}`]);
-    for (const id of ids) {
-      if (containsId(shown, id)) found.set(id, [...found.get(id) ?? [], path2]);
-    }
-  }
-  return found;
-}
-
-// src/work-proofs-record.ts
-var CONFIG_FILE = ".outerlayer-proofs.yaml";
-var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
-var DEMO_PROOFS = /* @__PURE__ */ new Set(["screenshot", "video"]);
-var NO_TEST = "no test at HEAD names this criterion";
-function changedTrackedFiles(root) {
-  const status = spawnSync("git", ["status", "--porcelain=v1", "-z", "--untracked-files=no"], { cwd: root, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
-  if (status.error !== void 0 || status.status !== 0) {
-    throw new WorkCommandError(`git cannot say whether the working copy matches HEAD (${status.error?.message ?? `exit status ${status.status}`}), so nothing was recorded.`);
-  }
-  const fields = status.stdout.split("\0").filter((field) => field !== "");
-  const paths = [];
-  for (let i = 0; i < fields.length; i += 1) {
-    const field = fields[i];
-    paths.push(field.slice(3));
-    if (/[RC]/.test(field.slice(0, 2))) i += 1;
-  }
-  return paths;
+// src/runner-globs.ts
+var MAX_GLOB_ALTERNATIVES = 256;
+var MAX_GLOB_LENGTH = 1024;
+var MAX_GLOB_STARS_PER_SEGMENT = 3;
+var EXTGLOB = /[+*?@!]\(/;
+function compile(glob) {
+  if (glob.length > MAX_GLOB_LENGTH) return `it is longer than ${MAX_GLOB_LENGTH} characters`;
+  if (braceExpand(glob, { braceExpandMax: MAX_GLOB_ALTERNATIVES + 1 }).length > MAX_GLOB_ALTERNATIVES) {
+    return `its braces expand to more than ${MAX_GLOB_ALTERNATIVES} alternatives`;
+  }
+  if (EXTGLOB.test(glob)) return "it uses an extended glob form such as +(...) or !(...), which can take exponential time to match";
+  const crowded = glob.split("/").some((segment) => segment !== "**" && segment.split("*").length - 1 > MAX_GLOB_STARS_PER_SEGMENT);
+  if (crowded) return `a path segment of it holds more than ${MAX_GLOB_STARS_PER_SEGMENT} "*" characters, which can take too long to match`;
+  return new Minimatch(glob, { dot: true });
 }
-function topLevelFiles(folder) {
-  try {
-    return readdirSync(folder, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
-  } catch {
-    return [];
-  }
-}
-function chapterCriteria(manifestPath) {
-  const ids = /* @__PURE__ */ new Set();
-  try {
-    const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
-    for (const chapter of parsed.chapters ?? []) {
-      if (typeof chapter?.criterionId === "string") ids.add(chapter.criterionId);
-    }
-  } catch {
-  }
-  return ids;
-}
-function showAtHead(root, path2) {
-  const shown = spawnSync("git", ["show", `HEAD:${path2}`], { cwd: root, encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
-  return shown.status === 0 ? shown.stdout : void 0;
-}
-function findManifests(folder) {
-  const found = [];
-  let entries = [];
-  try {
-    entries = readdirSync(folder, { withFileTypes: true });
-  } catch {
-  }
-  for (const entry of entries) {
-    const path2 = join(folder, entry.name);
-    if (entry.isDirectory()) found.push(...findManifests(path2));
-    else if (entry.name === "manifest.json" && folder.split("/").pop() === "demo") found.push(path2);
-  }
-  return found;
+function runnerMatcher(runners) {
+  const matchers = runners.map((runner) => {
+    const compiled = compile(runner.files);
+    if (typeof compiled === "string") {
+      process.stderr.write(`The runner glob ${JSON.stringify(sanitizeTerminal(runner.files.slice(0, 80)))} matches no file: ${compiled}.
+`);
+    }
+    return compiled;
+  });
+  return (path2) => {
+    const index = matchers.findIndex((matcher) => typeof matcher !== "string" && matcher.match(path2));
+    return index === -1 ? void 0 : index;
+  };
 }
-function unstoredUploads(result, spooled) {
-  if (typeof result !== "object" || result === null) return [];
-  const { artifactsDropped, artifactsHeld, rejected, uploadedArtifacts } = result;
-  if (Array.isArray(uploadedArtifacts)) {
-    const stored = new Set(uploadedArtifacts.map((a) => a?.artifactId));
-    return spooled.filter((id) => !stored.has(id));
-  }
-  const lost = typeof artifactsDropped === "number" && artifactsDropped > 0 || typeof artifactsHeld === "number" && artifactsHeld > 0 || Array.isArray(rejected) && rejected.length > 0;
-  return lost ? "all" : [];
+var MAX_TEST_FILES = 2e4;
+var MAX_TEST_FILE_BYTES = 1024 * 1024;
+async function loadCitationFinder() {
+  return await import(pathToFileURL(join(resolvePackRoot(), "maintained", "outerlayer-build", "scripts", "criterion-citations.mjs")).href);
 }
-function shortSha(sha) {
-  return sha.slice(0, 7);
+function testFileMatcher(finder, proofsText) {
+  const parsed = proofsText === void 0 ? void 0 : parseProofsConfig(proofsText);
+  const runners = parsed?.ok === true ? parsed.value.runners : [];
+  const runnerFor = runnerMatcher(runners);
+  const inRunnerGlob = (path2) => runnerFor(path2) !== void 0;
+  return (path2) => finder.isTestFile(path2, inRunnerGlob);
 }
-function oneLine(text) {
-  return text.replace(/\s+/g, " ").trim();
+function criteriaOf(workItem) {
+  const criteria = Object(Object(workItem).criteria);
+  if (!Array.isArray(criteria.items)) return void 0;
+  const drafted = criteria.drafted === true;
+  const items = [];
+  for (const entry of criteria.items) {
+    const { id, text, proof } = Object(entry);
+    if (typeof id !== "string" || typeof text !== "string") continue;
+    items.push({ id, text, proof: typeof proof === "string" ? proof : null, drafted });
+  }
+  return items.length === 0 ? void 0 : items;
 }
-async function runWorkProofsRecord(opts) {
-  const env = opts.env ?? process.env;
-  const item = resolveProofsItem({ item: opts.item, env });
-  const cwd = opts.cwd ?? process.cwd();
-  const identity = resolveRepoIdentity(cwd);
-  if (identity.repoRoot === void 0 || identity.commitSha === void 0) {
-    throw new WorkCommandError("this is not a git checkout with a commit. Run this inside the repository, after the tests are committed.");
-  }
-  const { repoRoot: root, commitSha: head } = identity;
-  const changed = changedTrackedFiles(root);
-  if (changed.length > 0) {
-    throw new WorkCommandError(
-      `the working copy differs from HEAD in ${changed.join(", ")}. Only the committed files run, so nothing was recorded. Commit or discard the change, then record again.`
-    );
-  }
-  const fetchImpl = opts.fetchImpl ?? defaultFetch;
-  const creds = resolveCredentials({ ...opts, env });
-  const home = opts.home;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const lines = [];
-  const say = (line) => void lines.push(line);
-  const { data } = await getJson(creds.url, `/v1/work-items/${item}`, creds.apiKey, creds.appId, fetchImpl);
-  const body = data;
-  const own = ownPullRequest(body.pullRequests ?? [], opts.pr, identity.gitRepo);
-  if ("ambiguous" in own) {
-    throw new WorkCommandError(`the item links several open pull requests (${own.ambiguous.map((n) => `#${n}`).join(", ")}). Pass --pr <number> to name this checkout's.`);
-  }
-  const ownPr = own.pr;
-  const postGeneral = async (text, clientCommentId) => {
-    try {
-      await runWorkComment({ ...creds, item, body: text, clientCommentId, cwd, home, env, fetchImpl, quiet: true });
-    } catch (err) {
-      if (!(err instanceof WorkCommandError && err.code === "comment_conflict")) {
-        say(`The comment on the item's thread was not posted: ${oneLine(String(err instanceof Error ? err.message : err))}`);
-      }
-    }
-  };
-  const configText = showAtHead(root, CONFIG_FILE);
-  const parsed = configText === void 0 ? void 0 : parseProofsConfig(configText);
-  if (parsed === void 0 || !parsed.ok) {
-    const problem = parsed === void 0 ? `${CONFIG_FILE} is missing at HEAD. Commit it at the repository root, with the setup, teardown and runners that run the tests.` : `${CONFIG_FILE} cannot be read: ${parsed.problems.join("; ")}`;
-    if (opts.comment) {
-      const text = `No proof was recorded at ${shortSha(head)}. ${problem}`.slice(0, 2e3);
-      await postGeneral(text, proofsCommentId(item, head, [{ id: CONFIG_FILE, proof: "setup file", reason: problem }]));
-    }
-    throw new WorkCommandError(problem);
-  }
-  const config = parsed.value;
-  const heads = /* @__PURE__ */ new Set([head.toLowerCase(), ...otherPullRequestHeads(body.pullRequests ?? [], ownPr, identity.gitRepo)]);
-  const states = classifyProofsAt(body, heads);
-  const todo = states.filter((state) => state.state !== "current").map((state) => state.id);
-  const declared = new Map((body.criteria?.items ?? []).map((criterion) => [criterion.id, criterion]));
-  const proofOf = (id) => declared.get(id).proof;
-  const reasons = /* @__PURE__ */ new Map();
-  const emitted = /* @__PURE__ */ new Map();
-  const found = discoverTestFiles(root, todo, config.runners);
-  for (const id of todo) {
-    if (!found.has(id)) reasons.set(id, NO_TEST);
-  }
-  const plan = planRuns([...new Set([...found.values()].flat())], config.runners);
-  const logDir = mkdtempSync(join(tmpdir(), "outerlayer-proofs-"));
-  const proofOuts = [];
-  const groups = [];
-  const runCommand = opts.runCommand ?? runShell;
-  const baseEnv = { ...process.env, ...env };
-  delete baseEnv.OUTERLAYER_PROOF_OUT;
-  let spooledCount = 0;
-  const spooledCriteria = /* @__PURE__ */ new Set();
-  const emitArtifact = async (emitOpts) => {
-    const result = await (opts.emitArtifact ?? runEmitArtifact)(emitOpts);
-    if (result.spooled) spooledCount += 1;
-    return result;
-  };
-  const common = { url: creds.url, apiKey: creds.apiKey, appId: creds.appId, cwd: root, home, env, fetchImpl, quiet: true };
-  const stopGroups = () => {
-    for (const pid of groups) {
-      try {
-        process.kill(-pid, "SIGTERM");
-      } catch {
-      }
-    }
-  };
-  const cleanUp = () => {
-    rmSync(logDir, { recursive: true, force: true });
-    for (const folder of proofOuts) rmSync(folder, { recursive: true, force: true });
-  };
-  const onSignal = (signal) => {
-    stopGroups();
-    cleanUp();
-    process.exit(signal === "SIGINT" ? 130 : 143);
-  };
-  const onInterrupt = () => onSignal("SIGINT");
-  const onTerminate = () => onSignal("SIGTERM");
-  process.once("SIGINT", onInterrupt);
-  process.once("SIGTERM", onTerminate);
-  const runs = [];
-  try {
-    let setupStarted = false;
-    try {
-      let setupFailed;
-      if (plan.size > 0) {
-        setupStarted = true;
-        for (const command of config.setup) {
-          const result = await runCommand(command, { cwd: root, env: baseEnv, timeoutMs, logDir, groups });
-          if (result.status !== 0) {
-            setupFailed = `setup failed: "${oneLine(command)}" ${result.timedOut ? `timed out after ${Math.round(timeoutMs / 1e3)} s` : `exited with status ${result.status}`}`;
-            say(setupFailed);
-            if (result.tail !== "") say(result.tail);
-            break;
-          }
-        }
-      }
-      for (const [index, files] of plan) {
-        const runner = config.runners[index];
-        const criteria = todo.filter((id) => found.get(id)?.some((file) => files.includes(file)));
-        if (setupFailed !== void 0) {
-          for (const id of criteria) reasons.set(id, setupFailed);
-          continue;
-        }
-        const proofOut = mkdtempSync(join(tmpdir(), "outerlayer-proof-out-"));
-        proofOuts.push(proofOut);
-        const result = await runCommand(fillFiles(runner.command, files), { cwd: root, env: { ...baseEnv, OUTERLAYER_PROOF_OUT: proofOut }, timeoutMs, logDir, groups });
-        const failure = result.timedOut ? `the runner for ${runner.files} timed out after ${Math.round(timeoutMs / 1e3)} s` : result.status === 0 ? void 0 : `the runner for ${runner.files} exited with status ${result.status}`;
-        if (failure !== void 0) {
-          say(failure);
-          if (result.tail !== "") say(result.tail);
-        }
-        runs.push({ glob: runner.files, proofOut, criteria, failure, tail: result.tail });
-      }
-    } finally {
-      if (setupStarted) {
-        for (const command of config.teardown) {
-          const result = await runCommand(command, { cwd: root, env: baseEnv, timeoutMs, logDir, groups });
-          if (result.status !== 0) say(`teardown failed: "${oneLine(command)}" ${result.timedOut ? "timed out" : `exited with status ${result.status}`}`);
-        }
-      }
-      process.off("SIGINT", onInterrupt);
-      process.off("SIGTERM", onTerminate);
-      stopGroups();
-    }
-    if (plan.size > 0) {
-      let left = [];
-      try {
-        left = changedTrackedFiles(root);
-      } catch {
-      }
-      if (left.length > 0) {
-        say(`The run changed tracked files: ${left.join(", ")}. The next --record records nothing until they match HEAD. Make setup, the tests and teardown leave them unchanged.`);
-      }
-    }
-    await emitProofs();
-  } finally {
-    cleanUp();
-  }
-  async function emitProofs() {
-    const notCurrent2 = new Set(todo);
-    const manifests = runs.flatMap((run) => findManifests(run.proofOut));
-    const chapters = /* @__PURE__ */ new Set();
-    if (manifests.length > 1) {
-      say(`Not recorded, the demo: the runners left ${manifests.length} demo manifests, so it is unclear which to store`);
-    } else if (manifests.length === 1) {
-      for (const id of chapterCriteria(manifests[0])) chapters.add(id);
-      await recordDemo(manifests[0], chapters);
-    }
-    for (const run of runs) {
-      const names = topLevelFiles(run.proofOut);
-      for (const name of names) {
-        const id = proofFileCriterion(name, new Set(declared.keys()));
-        if (id === void 0) {
-          say(`Ignored ${name}: its name is not the id of a declared criterion.`);
-          continue;
-        }
-        if (!notCurrent2.has(id)) {
-          say(`Ignored ${name}: the proof for ${id} is current, or no proof is declared for it.`);
-          continue;
-        }
-        if (DEMO_PROOFS.has(proofOf(id)) && chapters.has(id)) {
-          say(`Ignored ${name}: a demo chapter proves ${id}.`);
-          continue;
-        }
-        if (emitted.has(id)) continue;
-        const fail = (reason) => {
-          reasons.set(id, reason);
-          say(`Not recorded, ${id}: ${reason}`);
-        };
-        if (run.failure !== void 0) {
-          fail(`${run.failure}, so its files are not recorded`);
-          continue;
-        }
-        const problem = kindProblem(proofOf(id), name);
-        if (problem !== void 0) {
-          fail(problem);
-          continue;
-        }
-        try {
-          const caption = (declared.get(id).text ?? `Proof for ${id}`).slice(0, ARTIFACT_MAX_CAPTION_LENGTH);
-          const before = spooledCount;
-          const result = await emitArtifact({ ...common, file: join(run.proofOut, name), caption, criterionId: id, ...ownPr === void 0 ? {} : { pr: ownPr } });
-          const artifactId = result.record?.artifactId ?? result.data?.clientArtifactId;
-          if (artifactId === void 0) {
-            fail("the upload returned no artifact id");
-            continue;
-          }
-          emitted.set(id, artifactId);
-          if (spooledCount > before) spooledCriteria.add(id);
-        } catch (err) {
-          fail(`the upload failed: ${oneLine(String(err instanceof Error ? err.message : err))}`);
-        }
-      }
-    }
-    for (const run of runs) {
-      for (const id of run.criteria) {
-        if (emitted.has(id) || reasons.has(id)) continue;
-        reasons.set(id, run.failure ?? `the tests ran and wrote no ${id}.<ext> file under OUTERLAYER_PROOF_OUT`);
-      }
-    }
-  }
-  async function recordDemo(manifest, chapters) {
-    const demoCriteria = todo.filter((id) => DEMO_PROOFS.has(proofOf(id)));
-    let replaces;
-    try {
-      replaces = (await readNewestDemo({ url: creds.url, apiKey: creds.apiKey, appId: creds.appId, item, fetchImpl }))?.artifactId;
-    } catch (err) {
-      replaces = void 0;
-      say(`The previous demo could not be read, so the new demo does not replace it: ${oneLine(String(err instanceof Error ? err.message : err))}`);
-    }
-    const before = spooledCount;
-    let result;
-    try {
-      result = await (opts.emitDemo ?? runEmitDemo)({
-        ...common,
-        manifest,
-        item,
-        ...ownPr === void 0 ? {} : { pr: ownPr },
-        ...replaces === void 0 ? {} : { replaces },
-        emitArtifact
-      });
-    } catch (err) {
-      const reason = `the demo was not stored: ${oneLine(String(err instanceof Error ? err.message : err))}`;
-      for (const id of demoCriteria) reasons.set(id, reason);
-      say(`Not recorded, the demo: ${reason}`);
-      return;
-    }
-    for (const id of demoCriteria) {
-      const artifactId = proofOf(id) === "screenshot" ? result.screenshots.find((shot) => shot.criterionId === id && shot.artifactId !== void 0)?.artifactId : result.clips.find((clip) => clip.criterionId === id && clip.bound)?.clipArtifactId;
-      if (artifactId !== void 0) {
-        emitted.set(id, artifactId);
-        if (spooledCount > before) spooledCriteria.add(id);
-      } else if (chapters.has(id)) {
-        reasons.set(id, result.failures.length > 0 ? `the demo failed a check: ${oneLine(result.failures[0])}` : "the demo has no passing chapter for it");
-      }
-    }
-    for (const failure of result.failures) say(`Demo check failed: ${oneLine(failure)}`);
-  }
-  if (spooledCount > 0) {
-    try {
-      const synced = await (opts.sync ?? (() => runSync({ ...common })))();
-      const unstored = unstoredUploads(
-        synced,
-        [...spooledCriteria].map((id) => emitted.get(id))
-      );
-      const lostIds = unstored === "all" ? [...spooledCriteria] : [...spooledCriteria].filter((id) => unstored.includes(emitted.get(id)));
-      for (const id of lostIds) {
-        emitted.delete(id);
-        reasons.set(id, "the sync did not store the upload, so the proof is stored only in the session record");
-      }
-      if (lostIds.length > 0) say("The sync did not store an upload. The proofs that went through the session record are not stored.");
-    } catch (err) {
-      for (const id of spooledCriteria) {
-        emitted.delete(id);
-        reasons.set(id, "the sync failed, so the proof is stored only in the session record");
-      }
-      say(`The sync failed, so the new proofs are stored only in the session record: ${oneLine(String(err instanceof Error ? err.message : err))}`);
-    }
-  }
-  for (const [criterion, artifactId] of emitted) say(`Recorded ${criterion}: ${artifactId}`);
-  let finalStates = states;
-  try {
-    const { data: fresh } = await getJson(creds.url, `/v1/work-items/${item}`, creds.apiKey, creds.appId, fetchImpl);
-    finalStates = classifyProofsAt(fresh, heads);
-  } catch (err) {
-    say(`The item could not be read again, so the list below may be out of date: ${oneLine(String(err instanceof Error ? err.message : err))}`);
-  }
-  const notCurrent = finalStates.filter((state) => state.state !== "current" && !emitted.has(state.id)).map((state) => ({ id: state.id, proof: state.proof, reason: reasons.get(state.id) ?? "it was not recorded in this run" }));
-  if (opts.comment && notCurrent.length > 0) {
-    await postGeneral(proofsCommentBody(head, notCurrent), proofsCommentId(item, head, notCurrent));
-  }
-  for (const proof of notCurrent) say(`Not current, ${proof.id} (${proof.proof}): ${proof.reason}`);
-  const closing = await runWorkProofs({ ...opts, item, env, quiet: true, checkoutHead: head, fetchImpl });
-  const output = [...lines, closing.output].join("\n");
-  if (!opts.quiet) process.stdout.write(output + "\n");
-  return {
-    exitCode: closing.exitCode,
-    output,
-    emitted: [...emitted].map(([criterion, artifactId]) => ({ criterion, artifactId })),
-    notCurrent
-  };
+function hostItemsOf(workItem, name) {
+  const checks = Object(workItem).checks;
+  if (!Array.isArray(checks)) return [];
+  const check = checks.find((entry) => Object(entry).name === name);
+  if (check?.source !== "host") return [];
+  const parsed = CheckItemsSchema.safeParse(check.items);
+  return parsed.success ? parsed.data : [];
 }
 
-export { runWorkProofsRecord };
+export { MAX_TEST_FILES, MAX_TEST_FILE_BYTES, NO_CITING_TEST_REASON, NO_TEST_FILES_REASON, NO_VERDICT_REASON, criteriaOf, criterionInputs, hostItemsOf, inCriteriaOrder, itemsSentence, judgedItems, loadCitationFinder, oneLineReason, parseJudgeAnswer, planCriteria, runnerMatcher, testFileMatcher };