thunderjar 0.1.2 → 0.1.3-preview-eee7160

package/dist/cli.js

@@ -100,7 +100,7 @@ import { EventEmitter } from "events";
 import childProcess from "child_process";
 import path from "path";
 import fs from "fs";
-import process from "process";
+import process2 from "process";
 import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
 
 // node_modules/commander/lib/help.js
@@ -737,13 +737,13 @@ class Command extends EventEmitter {
     this._showSuggestionAfterError = true;
     this._savedState = null;
     this._outputConfiguration = {
-      writeOut: (str) => process.stdout.write(str),
-      writeErr: (str) => process.stderr.write(str),
+      writeOut: (str) => process2.stdout.write(str),
+      writeErr: (str) => process2.stderr.write(str),
       outputError: (str, write) => write(str),
-      getOutHelpWidth: () => process.stdout.isTTY ? process.stdout.columns : undefined,
-      getErrHelpWidth: () => process.stderr.isTTY ? process.stderr.columns : undefined,
-      getOutHasColors: () => useColor() ?? (process.stdout.isTTY && process.stdout.hasColors?.()),
-      getErrHasColors: () => useColor() ?? (process.stderr.isTTY && process.stderr.hasColors?.()),
+      getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
+      getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
+      getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
+      getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
       stripColor: (str) => stripVTControlCharacters2(str)
     };
     this._hidden = false;
@@ -951,7 +951,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     if (this._exitCallback) {
       this._exitCallback(new CommanderError(exitCode, code, message));
     }
-    process.exit(exitCode);
+    process2.exit(exitCode);
   }
   action(fn) {
     const listener = (args) => {
@@ -1143,16 +1143,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     parseOptions = parseOptions || {};
     if (argv === undefined && parseOptions.from === undefined) {
-      if (process.versions?.electron) {
+      if (process2.versions?.electron) {
         parseOptions.from = "electron";
       }
-      const execArgv = process.execArgv ?? [];
+      const execArgv = process2.execArgv ?? [];
       if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
         parseOptions.from = "eval";
       }
     }
     if (argv === undefined) {
-      argv = process.argv;
+      argv = process2.argv;
     }
     this.rawArgs = argv.slice();
     let userArgs;
@@ -1163,7 +1163,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         userArgs = argv.slice(2);
         break;
       case "electron":
-        if (process.defaultApp) {
+        if (process2.defaultApp) {
           this._scriptPath = argv[1];
           userArgs = argv.slice(2);
         } else {
@@ -1277,24 +1277,24 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     const launchWithNode = sourceExt.includes(path.extname(executableFile));
     let proc;
-    if (process.platform !== "win32") {
+    if (process2.platform !== "win32") {
       if (launchWithNode) {
         args.unshift(executableFile);
-        args = incrementNodeInspectorPort(process.execArgv).concat(args);
-        proc = childProcess.spawn(process.argv[0], args, { stdio: "inherit" });
+        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
+        proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
       } else {
         proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
       }
     } else {
       this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
       args.unshift(executableFile);
-      args = incrementNodeInspectorPort(process.execArgv).concat(args);
-      proc = childProcess.spawn(process.execPath, args, { stdio: "inherit" });
+      args = incrementNodeInspectorPort(process2.execArgv).concat(args);
+      proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
     }
     if (!proc.killed) {
       const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
       signals.forEach((signal) => {
-        process.on(signal, () => {
+        process2.on(signal, () => {
           if (proc.killed === false && proc.exitCode === null) {
             proc.kill(signal);
           }
@@ -1305,7 +1305,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
     proc.on("close", (code) => {
       code = code ?? 1;
       if (!exitCallback) {
-        process.exit(code);
+        process2.exit(code);
       } else {
         exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
       }
@@ -1317,7 +1317,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         throw new Error(`'${executableFile}' not executable`);
       }
       if (!exitCallback) {
-        process.exit(1);
+        process2.exit(1);
       } else {
         const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
         wrappedError.nestedError = err;
@@ -1666,11 +1666,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
   }
   _parseOptionsEnv() {
     this.options.forEach((option) => {
-      if (option.envVar && option.envVar in process.env) {
+      if (option.envVar && option.envVar in process2.env) {
         const optionKey = option.attributeName();
         if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
           if (option.required || option.optional) {
-            this.emit(`optionEnv:${option.name()}`, process.env[option.envVar]);
+            this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
           } else {
             this.emit(`optionEnv:${option.name()}`);
           }
@@ -1969,7 +1969,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   }
   help(contextOptions) {
     this.outputHelp(contextOptions);
-    let exitCode = Number(process.exitCode ?? 0);
+    let exitCode = Number(process2.exitCode ?? 0);
     if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
       exitCode = 1;
     }
@@ -2035,9 +2035,9 @@ function incrementNodeInspectorPort(args) {
   });
 }
 function useColor() {
-  if (process.env.NO_COLOR || process.env.FORCE_COLOR === "0" || process.env.FORCE_COLOR === "false")
+  if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
     return false;
-  if (process.env.FORCE_COLOR || process.env.CLICOLOR_FORCE !== undefined)
+  if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== undefined)
     return true;
   return;
 }
@@ -2047,7 +2047,7 @@ var program = new Command;
 // package.json
 var package_default = {
   name: "thunderjar",
-  version: "0.1.2",
+  version: "0.1.3-preview-eee7160",
   type: "module",
   description: "Thunderjar",
   license: "MIT",
@@ -2058,19 +2058,27 @@ var package_default = {
   bin: {
     thunderjar: "./dist/cli.js"
   },
+  main: "./src/index.ts",
+  types: "./src/index.ts",
   files: [
-    "dist"
+    "dist",
+    "src"
   ],
   publishConfig: {
     access: "public"
   },
   scripts: {
     build: "bun build src/cli/index.ts --target bun --outfile dist/cli.js",
-    lint: "oxlint",
+    lint: "bun scripts/sync-oxlint-layout.ts && bun scripts/sync-oxlint-layout.ts --check && oxlint",
     typecheck: "tsc --noEmit",
     test: "bun test",
+    "test:prepare": "bun scripts/prepare-tests.ts",
+    "test:docker": "THUNDERJAR_TEST_DOCKER=1 bun test docker",
+    fixture: "bun scripts/fixture.ts",
+    "dev:link": "bun scripts/dev-link.ts",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
+    "docs:build:versions": "bun scripts/build-versioned-docs.ts",
     "docs:preview": "vitepress preview docs",
     changeset: "changeset",
     version: "changeset version",
@@ -2084,6 +2092,7 @@ var package_default = {
   },
   devDependencies: {
     "@changesets/cli": "^2.31.0",
+    "@changesets/get-release-plan": "^4.0.16",
     "@types/bun": "^1.4.3",
     oxlint: "^1.88.0",
     typescript: "^7.0.2",
@@ -2091,24 +2100,2142 @@ var package_default = {
   }
 };
 
+// src/platform/path.ts
+function isAbsolute(path2) {
+  return path2.startsWith("/");
+}
+function normalize(path2) {
+  if (path2 === "")
+    return ".";
+  const absolute = isAbsolute(path2);
+  const trailing = path2.endsWith("/");
+  const out = [];
+  for (const part of path2.split("/")) {
+    if (part === "" || part === ".")
+      continue;
+    if (part === "..") {
+      if (out.length > 0 && out.at(-1) !== "..")
+        out.pop();
+      else if (!absolute)
+        out.push("..");
+    } else
+      out.push(part);
+  }
+  let result = (absolute ? "/" : "") + out.join("/");
+  if (result === "")
+    result = absolute ? "/" : ".";
+  if (trailing && !result.endsWith("/"))
+    result += "/";
+  return result;
+}
+function join(...parts) {
+  const joined = parts.filter((part) => part !== "").join("/");
+  return joined === "" ? "." : normalize(joined);
+}
+function resolve(...parts) {
+  let path2 = "";
+  for (let i = parts.length - 1;i >= 0 && !isAbsolute(path2); i--) {
+    const part = parts[i];
+    if (part !== "")
+      path2 = path2 === "" ? part : `${part}/${path2}`;
+  }
+  if (!isAbsolute(path2))
+    path2 = `${process.cwd()}/${path2}`;
+  const normal = normalize(path2);
+  return normal.length > 1 && normal.endsWith("/") ? normal.slice(0, -1) : normal;
+}
+function relative(from, to) {
+  const a = resolve(from).split("/").filter(Boolean);
+  const b = resolve(to).split("/").filter(Boolean);
+  let common = 0;
+  while (common < a.length && common < b.length && a[common] === b[common])
+    common++;
+  return [...Array(a.length - common).fill(".."), ...b.slice(common)].join("/");
+}
+function dirname(path2) {
+  if (path2 === "")
+    return ".";
+  const trimmed = path2.length > 1 ? path2.replace(/\/+$/, "") : path2;
+  const at = trimmed.lastIndexOf("/");
+  if (at === -1)
+    return ".";
+  if (at === 0)
+    return "/";
+  return trimmed.slice(0, at);
+}
+function basename(path2, ext) {
+  const trimmed = path2.length > 1 ? path2.replace(/\/+$/, "") : path2;
+  const base = trimmed.slice(trimmed.lastIndexOf("/") + 1);
+  return ext && base !== ext && base.endsWith(ext) ? base.slice(0, -ext.length) : base;
+}
+function extname(path2) {
+  const base = basename(path2);
+  const at = base.lastIndexOf(".");
+  return at <= 0 ? "" : base.slice(at);
+}
+
+// src/adapters/docker/docker.ts
+class DockerBuildError extends Error {
+  ref;
+  exitCode;
+  constructor(ref, exitCode) {
+    super(`docker build of ${ref} exited ${exitCode}`);
+    this.ref = ref;
+    this.exitCode = exitCode;
+  }
+}
+
+class DockerCommandError extends Error {
+  args;
+  exitCode;
+  stderr;
+  constructor(args, exitCode, stderr) {
+    super(`docker ${args[0]} exited ${exitCode}${stderr.trim() ? `: ${stderr.trim().split(`
+`).at(-1)}` : ""}`);
+    this.args = args;
+    this.exitCode = exitCode;
+    this.stderr = stderr;
+  }
+}
+async function docker(binary, args, output) {
+  const stdio = {
+    collect: { stdout: "ignore", stderr: "pipe" },
+    stderr: { stdout: 2, stderr: 2 },
+    stdout: { stdout: "pipe", stderr: 2 }
+  };
+  const child = Bun.spawn([binary, ...args], { stdin: "ignore", ...stdio[output] });
+  const text = (stream) => stream instanceof ReadableStream ? new Response(stream).text() : Promise.resolve("");
+  const [stdout, stderr] = await Promise.all([text(child.stdout), text(child.stderr), child.exited]);
+  return { exitCode: child.exitCode ?? 1, stdout, stderr };
+}
+function dockerCli(binary = process.env.THUNDERJAR_DOCKER || "docker") {
+  const must = async (args) => {
+    const { exitCode, stderr } = await docker(binary, args, "collect");
+    if (exitCode !== 0)
+      throw new DockerCommandError(args, exitCode, stderr);
+  };
+  return {
+    async unreachable() {
+      try {
+        const { exitCode, stderr } = await docker(binary, ["version", "--format", "{{.Server.Version}}"], "collect");
+        if (exitCode === 0)
+          return;
+        return stderr.trim().split(`
+`).at(-1) || `\`${binary} version\` exited ${exitCode}`;
+      } catch (error) {
+        if (error.code === "ENOENT")
+          return `\`${binary}\` was not found`;
+        throw error;
+      }
+    },
+    async imageExists(ref) {
+      return (await docker(binary, ["image", "inspect", "--format", "{{.Id}}", ref], "collect")).exitCode === 0;
+    },
+    async build(contextDir, ref) {
+      const { exitCode } = await docker(binary, ["build", "--tag", ref, contextDir], "stderr");
+      if (exitCode !== 0)
+        throw new DockerBuildError(ref, exitCode);
+    },
+    async run(ref, name, script) {
+      const { exitCode, stdout } = await docker(binary, ["run", "--name", name, "--entrypoint", "sh", ref, "-c", script], "stdout");
+      return { exitCode, stdout };
+    },
+    async commit(name, ref, like) {
+      const format = "{{json .Config.Entrypoint}}\t{{json .Config.Cmd}}";
+      const inspected = await docker(binary, ["image", "inspect", "--format", format, like], "stdout");
+      if (inspected.exitCode !== 0)
+        throw new DockerCommandError(["image", "inspect", like], inspected.exitCode, "");
+      const [entrypoint, cmd] = inspected.stdout.trim().split("\t");
+      const changes = [`ENTRYPOINT ${entrypoint === "null" ? '[""]' : entrypoint}`, `CMD ${cmd === "null" ? '["sh"]' : cmd}`];
+      await must(["commit", ...changes.flatMap((change) => ["--change", change]), name, ref]);
+    },
+    create: (ref, name) => must(["create", "--name", name, "--entrypoint", "sh", ref]),
+    copyFrom: (name, path2, dest) => must(["cp", `${name}:${path2}`, dest]),
+    removeContainer: (name) => must(["rm", "--force", name])
+  };
+}
+
+// src/platform/fs.ts
+var {$ } = globalThis.Bun;
+function tmpdir() {
+  return (Bun.env.TMPDIR ?? "/tmp").replace(/\/+$/, "") || "/";
+}
+async function makeTempDir(prefix) {
+  return (await $`mktemp -d ${join(tmpdir(), `${prefix}XXXXXX`)}`.quiet().text()).trim();
+}
+async function makeDir(dir) {
+  await $`mkdir -p ${dir}`.quiet();
+}
+async function remove(path2) {
+  await $`rm -rf ${path2}`.quiet();
+}
+async function copy(from, to) {
+  if (await isDirectory(from)) {
+    await makeDir(to);
+    await $`cp -RP ${from}/. ${to}`.quiet();
+  } else {
+    await $`cp -P ${from} ${to}`.quiet();
+  }
+}
+async function move(from, to) {
+  await $`mv -f ${from} ${to}`.quiet();
+}
+async function exists(path2) {
+  return (await $`test -e ${path2}`.quiet().nothrow()).exitCode === 0;
+}
+async function isDirectory(path2) {
+  return (await $`test -d ${path2}`.quiet().nothrow()).exitCode === 0;
+}
+function existsSync(path2) {
+  return Bun.spawnSync(["test", "-e", path2]).exitCode === 0;
+}
+function isDirectorySync(path2) {
+  return Bun.spawnSync(["test", "-d", path2]).exitCode === 0;
+}
+function readBytesSync(path2) {
+  const result = Bun.spawnSync(["cat", "--", path2], { stderr: "pipe" });
+  if (result.exitCode !== 0)
+    throw new Error(`can't read ${path2}: ${result.stderr.toString().trim()}`);
+  return new Uint8Array(result.stdout);
+}
+function listFilesSync(dir) {
+  if (!isDirectorySync(dir))
+    throw new Error(`not a directory: ${dir}`);
+  return [...new Bun.Glob("**").scanSync({ cwd: dir, dot: true, onlyFiles: true, followSymlinks: false })].toSorted();
+}
+function listEntries(dir, { recursive = false } = {}) {
+  if (!isDirectorySync(dir))
+    throw new Error(`not a directory: ${dir}`);
+  const pattern = new Bun.Glob(recursive ? "**" : "*");
+  const scan = (onlyFiles) => [...pattern.scanSync({ cwd: dir, dot: true, onlyFiles, followSymlinks: false })];
+  const files = new Set(scan(true));
+  const isRealDirectory = (path2) => Bun.spawnSync(["sh", "-c", 'test -d "$1" && test ! -L "$1"', "sh", join(dir, path2)]).exitCode === 0;
+  return scan(false).toSorted().map((path2) => ({ path: path2, isDirectory: !files.has(path2) && isRealDirectory(path2) }));
+}
+
+// src/api/declarations.ts
+var DECLARED_BY = Symbol.for("thunderjar.declaredBy");
+function declaredBy(value) {
+  if ((typeof value !== "object" || value === null) && typeof value !== "function")
+    return;
+  const mark = value[DECLARED_BY];
+  return typeof mark === "string" ? mark : undefined;
+}
+
+// src/instruments/instruments.ts
+var aggregateMethods = {
+  fileCreated: ["rate", "count"],
+  grep: ["mean", "median", "min", "max", "sum"],
+  templateTest: ["sum", "mean"]
+};
+var show = (value) => JSON.stringify(value) ?? String(value);
+var checkPath = (field, value, what) => typeof value === "string" && value !== "" ? [] : [[field, `must be ${what}, got ${show(value)}`]];
+var fileCreated = {
+  async evaluate({ glob }, ctx) {
+    return { outcome: "measured", data: (await ctx.glob(glob)).length > 0 };
+  },
+  checkConfig(config) {
+    return checkPath("config.glob", config?.glob, "a glob pattern");
+  }
+};
+var lines = (text) => text === "" ? [] : text.replace(/\r?\n$/, "").split(/\r?\n/);
+var grep = {
+  async evaluate({ glob, pattern }, ctx) {
+    const files = await ctx.glob(glob);
+    if (files.length === 0)
+      return { outcome: "skipped", reason: `no file matches ${glob}` };
+    const regex = new RegExp(pattern);
+    let count = 0;
+    for (const file of files) {
+      for (const line of lines(await ctx.readFile(file)))
+        if (regex.test(line))
+          count++;
+    }
+    return { outcome: "measured", data: count };
+  },
+  checkConfig(config) {
+    const { glob, pattern } = config ?? {};
+    const problems = checkPath("config.glob", glob, "a glob pattern");
+    if (typeof pattern !== "string") {
+      problems.push(["config.pattern", `must be a JavaScript regular expression, got ${show(pattern)}`]);
+    } else {
+      try {
+        new RegExp(pattern);
+      } catch (error) {
+        problems.push(["config.pattern", `${show(pattern)} is not a valid regular expression: ${error.message}`]);
+      }
+    }
+    return problems;
+  }
+};
+var shellWord = (text) => `'${text.replaceAll("'", `'\\''`)}'`;
+var LOADERS = {
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".jsx": "jsx",
+  ".tsx": "tsx"
+};
+var identifier = (stem) => {
+  const name = stem.replace(/[^\w$]/g, "_");
+  return /^[0-9]/.test(name) ? `_${name}` : name || "subject";
+};
+
+class CannotBind extends Error {
+}
+async function render(template, subject, ctx) {
+  const dir = dirname(subject);
+  const file = basename(subject);
+  const stem = basename(file, extname(file));
+  const loader = LOADERS[extname(file)] ?? "ts";
+  let exports;
+  try {
+    exports = new Bun.Transpiler({ loader }).scan(await ctx.readFile(subject)).exports;
+  } catch (error) {
+    throw new CannotBind(`can't read the exports of ${subject}: ${error.message}`);
+  }
+  if (exports.length === 0)
+    throw new CannotBind(`${subject} has no export to bind {{defaultExport}} to`);
+  if (exports.length > 1) {
+    throw new CannotBind(`${subject} has ${exports.length} exports (${exports.join(", ")}); {{defaultExport}} binds to a single one`);
+  }
+  let defaultExport = exports[0];
+  let subjectPath = `./${file}`;
+  if (defaultExport === "default") {
+    defaultExport = identifier(stem);
+    subjectPath = `./${stem}.templateTest.bind.ts`;
+    await ctx.writeFile(join(dir, subjectPath), `export { default as ${defaultExport} } from "./${file}";
+`);
+  }
+  const values = { defaultExport, subjectPath };
+  const rendered = template.replace(/\{\{\s*(\w+)\s*\}\}/g, (placeholder, name) => {
+    if (!Object.hasOwn(values, name))
+      throw new CannotBind(`the template has an unknown placeholder ${placeholder}`);
+    return values[name];
+  });
+  const testPath = join(dir, `${stem}.templateTest.test.ts`);
+  await ctx.writeFile(testPath, rendered);
+  return testPath;
+}
+async function runTest(testPath, ctx) {
+  const { stdout, stderr } = await ctx.exec(`bun test ${shellWord(`./${testPath}`)}`);
+  const output = `${stdout}
+${stderr}`;
+  const count = (label) => Number(new RegExp(`^\\s*(\\d+) ${label}$`, "m").exec(output)?.[1] ?? "0");
+  const ran = /^Ran (\d+) tests? /m.exec(output);
+  if (!ran || ran[1] === "0")
+    throw new CannotBind(`bun test ${testPath} reported no results`);
+  if (count("errors?") > 0) {
+    const error = /^\w*error: .*$/im.exec(output)?.[0];
+    throw new CannotBind(`bun test ${testPath} failed outside any test${error ? `: ${error}` : ""}`);
+  }
+  return { passed: count("pass"), failed: count("fail") };
+}
+var templateTest = {
+  async evaluate({ subject, template }, ctx) {
+    const subjects = await ctx.glob(subject);
+    if (subjects.length === 0)
+      return { outcome: "skipped", reason: `no file matches ${subject}` };
+    const source = await Bun.file(template).text();
+    const total = { passed: 0, failed: 0 };
+    try {
+      for (const path2 of subjects) {
+        const { passed, failed } = await runTest(await render(source, path2, ctx), ctx);
+        total.passed += passed;
+        total.failed += failed;
+      }
+    } catch (error) {
+      if (error instanceof CannotBind)
+        return { outcome: "erroredWhileMeasuring", error };
+      throw error;
+    }
+    return { outcome: "measured", data: total };
+  },
+  checkConfig(config) {
+    const { subject, template } = config ?? {};
+    return [
+      ...checkPath("config.subject", subject, "a glob pattern"),
+      ...checkPath("config.template", template, "a path relative to the measurement file")
+    ];
+  },
+  bundledFiles: ["template"]
+};
+var instruments = { fileCreated, grep, templateTest };
+var isInstrumentName = (name) => typeof name === "string" && Object.hasOwn(instruments, name);
+
+// src/project/config.ts
+class ConfigError extends Error {
+}
+
+class ThunderjarRootNotFoundError extends ConfigError {
+  constructor(startDir) {
+    super(`error: no .thunderjar/ folder found in ${startDir} or any parent directory.
+Run \`thunderjar init\` first.`);
+  }
+}
+
+class TestCaseNotFoundError extends ConfigError {
+  constructor(name, path2) {
+    super(`error: no test case named "${name}" (expected ${path2})`);
+  }
+}
+
+class InvalidConfigError extends ConfigError {
+  problems;
+  constructor(problems) {
+    super(problems.map(({ file, field, message }) => `error: .thunderjar/${file}: ${field ? `${field}: ` : ""}${message}`).join(`
+`));
+    this.problems = problems;
+  }
+}
+function findThunderjarRoot(startDir = process.cwd()) {
+  let dir = resolve(startDir);
+  for (;; ) {
+    const candidate = join(dir, ".thunderjar");
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      throw new ThunderjarRootNotFoundError(startDir);
+    dir = parent;
+  }
+}
+async function loadDeclaration(root, file, declareFn, problems) {
+  let module;
+  try {
+    module = await import(join(root, file));
+  } catch (error) {
+    problems.push({ file, message: `could not be loaded: ${error instanceof Error ? error.message : String(error)}` });
+    return;
+  }
+  if (!("default" in module) || module.default === undefined) {
+    problems.push({ file, message: `has no default export. Export \`${declareFn}(...)\` as the default.` });
+    return;
+  }
+  const by = declaredBy(module.default);
+  if (by !== declareFn) {
+    problems.push({
+      file,
+      message: by ? `default export is wrapped in ${by}, expected ${declareFn}.` : `default export is not wrapped in ${declareFn}(...).`
+    });
+    return;
+  }
+  return module.default;
+}
+var show2 = (value) => JSON.stringify(value) ?? String(value);
+function requireFile(root, testCaseFile, field, name, file, problems) {
+  if (existsSync(join(root, file)))
+    return true;
+  problems.push({ file: testCaseFile, field, message: `${show2(name)} has no matching ${file}` });
+  return false;
+}
+var FOLDER_PARAMETERS = [
+  ["baseImage", "baseImages", "declareBaseImage"],
+  ["codeState", "codeStates", "declareCodeState"],
+  ["promptSet", "promptSets", "declarePromptSet"]
+];
+var ARRAY_FIELDS = ["baseImage", "codeState", "promptSet", "harnessModel", "initialPrompt"];
+var PAIR = /^([^@/]+)@([^/]+)\/(.+)$/;
+function parseHarnessModelPair(pair) {
+  const match = PAIR.exec(pair);
+  if (!match)
+    return;
+  const [, family, version, model] = match;
+  return { family, version, model };
+}
+async function collectMeasurements(root, task, problems) {
+  const dir = `test-case-parameters/tasks/${task}/measurements`;
+  if (!existsSync(join(root, dir)))
+    return [];
+  const files = [...new Bun.Glob("*.ts").scanSync({ cwd: join(root, dir) })].filter((name) => !basename(name, ".ts").includes(".")).toSorted();
+  const measurements = [];
+  for (const name of files) {
+    const file = `${dir}/${name}`;
+    const declaration = await loadDeclaration(root, file, "declareMeasurement", problems);
+    if (!declaration)
+      continue;
+    const { instrument, config, aggregate } = declaration;
+    if (!isInstrumentName(instrument)) {
+      problems.push({
+        file,
+        field: "instrument",
+        message: `${show2(instrument)} is not a known instrument. Known instruments: ${Object.keys(instruments).join(", ")}`
+      });
+      continue;
+    }
+    const before = problems.length;
+    const { checkConfig, bundledFiles = [] } = instruments[instrument];
+    const configProblems = checkConfig(config);
+    for (const [field, message] of configProblems)
+      problems.push({ file, field, message });
+    if (configProblems.length === 0) {
+      for (const key of bundledFiles) {
+        const path2 = config[key];
+        requireFile(root, file, `config.${key}`, path2, join(dir, path2), problems);
+      }
+    }
+    if (!Array.isArray(aggregate)) {
+      problems.push({ file, field: "aggregate", message: `must be an array of aggregation methods, got ${show2(aggregate)}` });
+    } else {
+      const menu = aggregateMethods[instrument];
+      for (const method of aggregate) {
+        if (menu.includes(method))
+          continue;
+        problems.push({
+          file,
+          field: "aggregate",
+          message: `${show2(method)} is not a way ${instrument}'s values combine. Use one of: ${menu.join(", ")}`
+        });
+      }
+    }
+    if (problems.length === before) {
+      measurements.push({ ...declaration, name: basename(name, ".ts"), dir: join(root, dir) });
+    }
+  }
+  return measurements;
+}
+async function loadMeasurements(root, task) {
+  const problems = [];
+  const measurements = await collectMeasurements(root, task, problems);
+  if (problems.length > 0)
+    throw new InvalidConfigError(problems);
+  return measurements;
+}
+async function checkTestCase(root, file, testCase, problems) {
+  const parameters = "test-case-parameters";
+  const names = {};
+  for (const field of ARRAY_FIELDS) {
+    const value = testCase[field];
+    if (!Array.isArray(value)) {
+      problems.push({ file, field, message: `must be an array of names, got ${show2(value)}` });
+    } else if (value.length === 0) {
+      problems.push({ file, field, message: "must name at least one value, got []" });
+    } else if (value.some((v) => typeof v !== "string")) {
+      problems.push({ file, field, message: `must be an array of names, got ${show2(value)}` });
+    } else {
+      names[field] = value;
+    }
+  }
+  const iterations = testCase.iterations;
+  if (typeof iterations !== "number" || !Number.isInteger(iterations) || iterations < 1) {
+    problems.push({ file, field: "iterations", message: `must be a positive integer, got ${show2(iterations)}` });
+  }
+  for (const [field, folder, declareFn] of FOLDER_PARAMETERS) {
+    for (const name of names[field] ?? []) {
+      const index = `${parameters}/${folder}/${name}/index.ts`;
+      if (requireFile(root, file, field, name, index, problems)) {
+        await loadDeclaration(root, index, declareFn, problems);
+      }
+    }
+  }
+  const task = testCase.task;
+  let taskExists = false;
+  if (typeof task !== "string") {
+    problems.push({ file, field: "task", message: `must be a task name, got ${show2(task)}` });
+  } else {
+    taskExists = requireFile(root, file, "task", task, `${parameters}/tasks/${task}/`, problems);
+  }
+  if (taskExists) {
+    await collectMeasurements(root, task, problems);
+    for (const name of names.initialPrompt ?? []) {
+      const prompt = `${parameters}/tasks/${task}/initial-prompts/${name}.ts`;
+      if (existsSync(join(root, prompt))) {
+        await loadDeclaration(root, prompt, "declareInitialPrompt", problems);
+        continue;
+      }
+      const owner = new Bun.Glob(`${parameters}/tasks/*/initial-prompts/${name}.ts`).scanSync({ cwd: root }).next().value;
+      problems.push({
+        file,
+        field: "initialPrompt",
+        message: owner ? `${show2(name)} belongs to task ${show2(owner.split("/")[2])}, not ${show2(task)}` : `${show2(name)} has no matching ${prompt}`
+      });
+    }
+  }
+  for (const pair of names.harnessModel ?? []) {
+    const parsed = parseHarnessModelPair(pair);
+    if (!parsed) {
+      problems.push({ file, field: "harnessModel", message: `${show2(pair)} is not of the form family@version/model` });
+      continue;
+    }
+    const { family, version, model } = parsed;
+    const familyDir = `${parameters}/harnessModels/${family}`;
+    if (!requireFile(root, file, "harnessModel", pair, `${familyDir}/`, problems))
+      continue;
+    const familyProblems = [];
+    await loadDeclaration(root, `${familyDir}/index.ts`, "declareHarness", familyProblems);
+    await loadDeclaration(root, `${familyDir}/collectTokenCosts.ts`, "declareTokenCostCollector", familyProblems);
+    const versions = await loadDeclaration(root, `${familyDir}/versions.ts`, "declareHarnessVersions", familyProblems);
+    const models = await loadDeclaration(root, `${familyDir}/models.ts`, "declareHarnessModels", familyProblems);
+    for (const p of familyProblems) {
+      if (!problems.some((q) => q.file === p.file && q.message === p.message))
+        problems.push(p);
+    }
+    if (versions && !Object.hasOwn(versions, version)) {
+      problems.push({
+        file,
+        field: "harnessModel",
+        message: `${show2(pair)}: version ${show2(version)} is not in ${familyDir}/versions.ts`
+      });
+    }
+    if (models && !Object.hasOwn(models, model)) {
+      problems.push({
+        file,
+        field: "harnessModel",
+        message: `${show2(pair)}: model ${show2(model)} is not in ${familyDir}/models.ts`
+      });
+    }
+  }
+}
+async function loadTestCase(root, name) {
+  const file = `test-cases/${name}.ts`;
+  const path2 = join(root, file);
+  if (!existsSync(path2))
+    throw new TestCaseNotFoundError(name, path2);
+  const problems = [];
+  const testCase = await loadDeclaration(root, file, "declareTestCase", problems);
+  if (testCase)
+    await checkTestCase(root, file, testCase, problems);
+  if (problems.length > 0)
+    throw new InvalidConfigError(problems);
+  return testCase;
+}
+
+// src/matrix/permutations.ts
+var AXES = ["baseImage", "codeState", "promptSet", "harnessModel", "initialPrompt"];
+function matrixShape(testCase) {
+  return AXES.map((axis) => testCase[axis].length);
+}
+function expandPermutations(testCase) {
+  const permutations = [];
+  for (const baseImage of testCase.baseImage)
+    for (const codeState of testCase.codeState)
+      for (const promptSet of testCase.promptSet)
+        for (const harnessModel of testCase.harnessModel)
+          for (const initialPrompt of testCase.initialPrompt)
+            permutations.push({ baseImage, codeState, promptSet, harnessModel, initialPrompt });
+  return permutations;
+}
+function permutationRows(permutations) {
+  const cells = permutations.map((p) => AXES.map((axis) => p[axis]));
+  const widths = AXES.map((_, i) => Math.max(...cells.map((row) => row[i].length)));
+  return cells.map((row) => row.map((cell, i) => i === AXES.length - 1 ? cell : cell.padEnd(widths[i])).join(" | "));
+}
+
+// src/matrix/hashing.ts
+var sha256 = (data) => new Bun.CryptoHasher("sha256").update(data).digest("hex");
+function canonical(value) {
+  if (typeof value === "function")
+    return JSON.stringify(value.toString());
+  if (Array.isArray(value))
+    return `[${value.map(canonical).join(",")}]`;
+  if (typeof value === "object" && value !== null) {
+    const keys = Object.keys(value).toSorted();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${canonical(value[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+var hashValue = (value) => sha256(canonical(value));
+var abbreviateHash = (hash) => hash.slice(0, 8);
+function hashFolder(dir, exclude = []) {
+  const files = listFilesSync(dir).filter((file) => !exclude.includes(file));
+  return hashValue(files.map((file) => [file, sha256(readBytesSync(join(dir, file)))]));
+}
+var hashBaseImage = (path2) => hashFolder(path2);
+var hashCodeState = (path2) => hashFolder(path2);
+var hashPromptSet = (path2) => hashFolder(path2);
+var hashInitialPrompt = (path2) => sha256(readBytesSync(path2));
+var FAMILY_MAP_FILES = ["models.ts", "versions.ts", "collectTokenCosts.ts"];
+var EXECUTION_OVERRIDES = ["applyParameter", "cli", "requiredEnv"];
+async function loadMap(file) {
+  const module = await import(file);
+  return module.default ?? {};
+}
+async function hashHarnessModelPair(family, version, model) {
+  const versions = await loadMap(join(family, "versions.ts"));
+  const models = await loadMap(join(family, "models.ts"));
+  if (!Object.hasOwn(versions, version))
+    throw new Error(`version "${version}" is not in ${family}/versions.ts`);
+  if (!Object.hasOwn(models, model))
+    throw new Error(`model "${model}" is not in ${family}/models.ts`);
+  const entry = versions[version];
+  if (typeof entry.version !== "string") {
+    throw new Error(`version "${version}" in ${family}/versions.ts has no pinned version; floating versions are not supported yet`);
+  }
+  const overrides = Object.fromEntries(EXECUTION_OVERRIDES.filter((k) => (k in entry)).map((k) => [k, entry[k]]));
+  return hashValue({
+    shared: hashFolder(family, FAMILY_MAP_FILES),
+    version: entry.version,
+    overrides,
+    modelId: models[model]
+  });
+}
+var hashPermutation = (hashes) => hashValue(hashes);
+function hashMeasurement({ instrument, config, dir }) {
+  const keys = isInstrumentName(instrument) ? instruments[instrument].bundledFiles ?? [] : [];
+  if (keys.length === 0)
+    return hashValue({ instrument, config });
+  if (dir === undefined)
+    throw new Error(`a ${instrument} measurement's hash needs the folder its bundled files are in`);
+  const paths = config;
+  const files = Object.fromEntries(keys.map((key) => [key, sha256(readBytesSync(resolve(dir, paths[key])))]));
+  return hashValue({ instrument, config, files });
+}
+
+// src/matrix/tags.ts
+var prerunTag = (permutationHash) => `prerun-h${abbreviateHash(permutationHash)}`;
+var postrunTag = (executionId, permutationHash, iterationIndex) => `postrun-e${executionId}-h${abbreviateHash(permutationHash)}-i${String(iterationIndex).padStart(2, "0")}`;
+var imageRef = (repository, tag) => `${repository}:${tag}`;
+
+// src/images/prerun.ts
+var LOCAL_REPOSITORY = "thunderjar";
+var prerunImageRef = (repository, permutationHash) => imageRef(repository, prerunTag(permutationHash));
+var PARAMETER_DIRS = {
+  baseImage: "parameters/baseImage",
+  harness: "parameters/harnessModel",
+  codeState: "parameters/codeState",
+  promptSet: "parameters/promptSet"
+};
+var importDefault = async (path2) => (await import(path2)).default;
+async function loadPrerunParameters(root, task, permutation) {
+  const parameters = join(root, "test-case-parameters");
+  const folder = async (dir, owner) => {
+    const { config, applyParameter } = await importDefault(join(dir, "index.ts"));
+    return { owner, dir, config, applyParameter };
+  };
+  const { family, version } = parseHarnessModelPair(permutation.harnessModel);
+  const familyDir = join(parameters, "harnessModels", family);
+  const harness = await importDefault(join(familyDir, "index.ts"));
+  const entry = (await importDefault(join(familyDir, "versions.ts")))[version];
+  if (!("version" in entry))
+    throw new Error(`${permutation.harnessModel}: floating versions are not supported yet`);
+  const initialPrompt = await importDefault(join(parameters, "tasks", task, "initial-prompts", `${permutation.initialPrompt}.ts`));
+  return {
+    baseImage: await folder(join(parameters, "baseImages", permutation.baseImage), `base image "${permutation.baseImage}"`),
+    harness: {
+      owner: `harness/model pair "${permutation.harnessModel}"`,
+      dir: familyDir,
+      exclude: FAMILY_MAP_FILES,
+      config: harness.config,
+      applyParameter: entry.applyParameter ?? harness.applyParameter,
+      version: entry.version
+    },
+    codeState: await folder(join(parameters, "codeStates", permutation.codeState), `code state "${permutation.codeState}"`),
+    promptSet: await folder(join(parameters, "promptSets", permutation.promptSet), `prompt set "${permutation.promptSet}"`),
+    initialPrompt: {
+      owner: `initial prompt "${permutation.initialPrompt}"`,
+      config: initialPrompt.config,
+      applyParameter: initialPrompt.applyParameter
+    }
+  };
+}
+var COMMIT = /^[0-9a-f]{4,64}$/i;
+function recordingGit(owner, needs) {
+  const checkCommit = (method, commit) => {
+    if (!COMMIT.test(commit)) {
+      throw new Error(`error: ${owner}: ctx.git.${method} needs a commit hash, got ${JSON.stringify(commit)}.`);
+    }
+  };
+  return {
+    bundle(commit) {
+      checkCommit("bundle", commit);
+      const path2 = `git/${commit}.bundle`;
+      needs.push({ kind: "bundle", owner, commit, path: path2 });
+      return path2;
+    },
+    show(commit, file) {
+      checkCommit("show", commit);
+      const normal = normalize(file);
+      if (file === "" || isAbsolute(file) || normal === "." || normal.split("/").includes("..")) {
+        throw new Error(`error: ${owner}: ctx.git.show needs a path inside the repository, got ${JSON.stringify(file)}.`);
+      }
+      const path2 = `git/${commit}/${normal}`;
+      needs.push({ kind: "file", owner, commit, file: normal, path: path2 });
+      return path2;
+    }
+  };
+}
+function renderPrerun(parameters) {
+  const git = [];
+  const ctx = (role) => ({ git: recordingGit(parameters[role].owner, git), dir: PARAMETER_DIRS[role] });
+  const { baseImage, harness, codeState, promptSet, initialPrompt } = parameters;
+  const steps = [
+    baseImage.applyParameter(baseImage.config, ctx("baseImage")),
+    harness.applyParameter(harness.config, { ...ctx("harness"), version: harness.version }),
+    "WORKDIR /workspace",
+    codeState.applyParameter(codeState.config, ctx("codeState")),
+    promptSet.applyParameter(promptSet.config, ctx("promptSet")),
+    initialPrompt.applyParameter(initialPrompt.config, { git: recordingGit(initialPrompt.owner, git) })
+  ];
+  return { dockerfile: `${steps.filter((step) => step.trim() !== "").join(`
+`)}
+`, git };
+}
+
+class MissingCommitsError extends Error {
+}
+async function checkCommits(needs, repository) {
+  const problems = new Set;
+  const present = new Map;
+  for (const need of needs) {
+    if (!present.has(need.commit))
+      present.set(need.commit, await repository.resolveCommit(need.commit) !== undefined);
+    if (!present.get(need.commit)) {
+      problems.add(`error: commit ${need.commit} (${need.owner}) is not in this repository.
+Fetch it, or check that it has been pushed.`);
+    } else if (need.kind === "file" && await repository.readFile(need.commit, need.file) === undefined) {
+      problems.add(`error: ${need.file} is not in commit ${need.commit} (${need.owner}).`);
+    }
+  }
+  if (problems.size > 0)
+    throw new MissingCommitsError([...problems].join(`
+`));
+}
+async function assembleBuildContext(parameters, repository, dir) {
+  const { dockerfile, git } = renderPrerun(parameters);
+  await remove(dir);
+  await makeDir(dir);
+  await Bun.write(join(dir, "Dockerfile"), dockerfile);
+  for (const role of Object.keys(PARAMETER_DIRS)) {
+    const { dir: source, exclude = [] } = parameters[role];
+    const target = join(dir, PARAMETER_DIRS[role]);
+    await copy(source, target);
+    for (const path2 of exclude)
+      await remove(join(target, path2));
+  }
+  const written = new Set;
+  for (const need of git) {
+    if (written.has(need.path))
+      continue;
+    written.add(need.path);
+    if (!repository)
+      throw new Error(`${need.owner} reads commit ${need.commit}, but there is no repository to read it from`);
+    const dest = join(dir, need.path);
+    await makeDir(dirname(dest));
+    if (need.kind === "bundle") {
+      const full = await repository.resolveCommit(need.commit);
+      if (!full)
+        throw new Error(`commit ${need.commit} is not in the repository`);
+      await repository.bundle(full, dest);
+    } else {
+      const contents = await repository.readFile(need.commit, need.file);
+      if (contents === undefined)
+        throw new Error(`${need.file} is not in commit ${need.commit}`);
+      await Bun.write(dest, contents);
+    }
+  }
+}
+async function prerunStatuses(docker2, repository, permutations) {
+  const unreachable = await docker2.unreachable();
+  if (unreachable !== undefined)
+    return { unreachable };
+  const statuses = new Map;
+  for (const { hash } of permutations) {
+    if (statuses.has(hash))
+      continue;
+    statuses.set(hash, await docker2.imageExists(prerunImageRef(repository, hash)) ? "exists" : "missing");
+  }
+  return { statuses };
+}
+var showPrerunStatus = (status) => status === "exists" ? " (exists, reused)" : status === "missing" ? " (will build)" : "";
+var unreachableNote = (reason) => `Docker can't be reached (${reason}), so whether each prerun image exists is unknown.`;
+
+// src/images/repository.ts
+async function git(cwd, args) {
+  const child = Bun.spawn(["git", ...args], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+  const [stdout, stderr] = await Promise.all([
+    new Response(child.stdout).arrayBuffer(),
+    new Response(child.stderr).text(),
+    child.exited
+  ]);
+  return { exitCode: child.exitCode ?? 1, stdout: Buffer.from(stdout), stderr };
+}
+async function gitOrThrow(cwd, args) {
+  const result = await git(cwd, args);
+  if (result.exitCode !== 0)
+    throw new Error(`git ${args.join(" ")} failed in ${cwd}:
+${result.stderr.trim()}`);
+  return result.stdout;
+}
+async function findRepository(dir) {
+  const { exitCode, stdout, stderr } = await git(dir, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (exitCode !== 0 && /not a git repository/i.test(stderr))
+    return;
+  if (exitCode !== 0)
+    throw new Error(`error: git can't read the repository ${dir} is in:
+${stderr.trim()}`);
+  const objects = join(stdout.toString("utf8").trim(), "objects");
+  return {
+    async resolveCommit(commit) {
+      const { exitCode: exitCode2, stdout: stdout2 } = await git(dir, ["rev-parse", "--verify", "--quiet", `${commit}^{commit}`]);
+      return exitCode2 === 0 ? stdout2.toString("utf8").trim() : undefined;
+    },
+    async readFile(commit, path2) {
+      const { exitCode: exitCode2, stdout: stdout2 } = await git(dir, ["show", `${commit}:${path2}`]);
+      return exitCode2 === 0 ? stdout2 : undefined;
+    },
+    async bundle(commit, dest) {
+      const scratch = await makeTempDir("thunderjar-bundle-");
+      try {
+        await gitOrThrow(scratch, ["init", "--quiet", "--bare"]);
+        await Bun.write(join(scratch, "objects", "info", "alternates"), `${objects}
+`);
+        await gitOrThrow(scratch, ["update-ref", "refs/heads/code-state", commit]);
+        await gitOrThrow(scratch, ["symbolic-ref", "HEAD", "refs/heads/code-state"]);
+        await gitOrThrow(scratch, ["bundle", "create", "--quiet", dest, "HEAD", "code-state"]);
+      } finally {
+        await remove(scratch);
+      }
+    }
+  };
+}
+
+// src/images/prerun-builds.ts
+var buildContextDir = (rootDir, permutationHash) => join(rootDir, "builds", prerunTag(permutationHash));
+async function preparePrerunBuilds(options) {
+  const { root, task, permutations, docker: docker2, repository, rootDir, purpose } = options;
+  const found = await prerunStatuses(docker2, repository, permutations);
+  if ("unreachable" in found) {
+    throw new Error(`error: Docker can't be reached (${found.unreachable}). ${purpose} needs Docker.`);
+  }
+  const parameters = new Map;
+  for (const permutation of permutations) {
+    if (found.statuses.get(permutation.hash) !== "missing")
+      continue;
+    parameters.set(permutation.hash, await loadPrerunParameters(root, task, permutation));
+  }
+  const gitNeeds = [...parameters.values()].flatMap((p) => renderPrerun(p).git);
+  let repo;
+  if (gitNeeds.length > 0) {
+    const projectDir = dirname(root);
+    repo = await findRepository(projectDir);
+    if (!repo) {
+      const [{ owner, commit }] = gitNeeds;
+      throw new Error(`error: ${projectDir} is not in a git repository, but ${owner} reads commit ${commit} from it.`);
+    }
+    await checkCommits(gitNeeds, repo);
+  }
+  const missing = new Set(parameters.keys());
+  return {
+    missing,
+    async build(permutationHash) {
+      const declared = parameters.get(permutationHash);
+      if (!declared || !missing.has(permutationHash))
+        throw new Error(`prerun image ${permutationHash} isn't missing`);
+      const ref = prerunImageRef(repository, permutationHash);
+      const contextDir = buildContextDir(rootDir, permutationHash);
+      await assembleBuildContext(declared, repo, contextDir);
+      try {
+        await docker2.build(contextDir, ref);
+      } catch (error) {
+        if (!(error instanceof DockerBuildError))
+          throw error;
+        throw new Error(`error: building ${ref} failed (docker build exited ${error.exitCode}).
+Its build context is kept in ${contextDir}`);
+      }
+      missing.delete(permutationHash);
+    }
+  };
+}
+
+// src/matrix/resolve.ts
+async function resolveTestCase(root, testCase) {
+  const parameters = join(root, "test-case-parameters");
+  const hashParameter = {
+    baseImage: (n) => hashBaseImage(join(parameters, "baseImages", n)),
+    codeState: (n) => hashCodeState(join(parameters, "codeStates", n)),
+    promptSet: (n) => hashPromptSet(join(parameters, "promptSets", n)),
+    harnessModel: (n) => {
+      const { family, version, model } = parseHarnessModelPair(n);
+      return hashHarnessModelPair(join(parameters, "harnessModels", family), version, model);
+    },
+    initialPrompt: (n) => hashInitialPrompt(join(parameters, "tasks", testCase.task, "initial-prompts", `${n}.ts`))
+  };
+  const hashes = {};
+  for (const axis of AXES) {
+    hashes[axis] = new Map;
+    for (const n of testCase[axis])
+      hashes[axis].set(n, await hashParameter[axis](n));
+  }
+  const permutations = expandPermutations(testCase).map((permutation) => ({
+    ...permutation,
+    hash: hashPermutation({
+      baseImage: hashes.baseImage.get(permutation.baseImage),
+      codeState: hashes.codeState.get(permutation.codeState),
+      promptSet: hashes.promptSet.get(permutation.promptSet),
+      harnessModel: hashes.harnessModel.get(permutation.harnessModel),
+      initialPrompt: hashes.initialPrompt.get(permutation.initialPrompt)
+    })
+  }));
+  return { hashes, permutations };
+}
+
+// src/platform/signals.ts
+var COMMON = {
+  SIGHUP: 1,
+  SIGINT: 2,
+  SIGQUIT: 3,
+  SIGILL: 4,
+  SIGTRAP: 5,
+  SIGABRT: 6,
+  SIGIOT: 6,
+  SIGFPE: 8,
+  SIGKILL: 9,
+  SIGSEGV: 11,
+  SIGPIPE: 13,
+  SIGALRM: 14,
+  SIGTERM: 15,
+  SIGXCPU: 24,
+  SIGXFSZ: 25,
+  SIGVTALRM: 26,
+  SIGPROF: 27,
+  SIGWINCH: 28
+};
+var LINUX = {
+  SIGBUS: 7,
+  SIGUSR1: 10,
+  SIGUSR2: 12,
+  SIGSTKFLT: 16,
+  SIGCHLD: 17,
+  SIGCONT: 18,
+  SIGSTOP: 19,
+  SIGTSTP: 20,
+  SIGTTIN: 21,
+  SIGTTOU: 22,
+  SIGURG: 23,
+  SIGIO: 29,
+  SIGPOLL: 29,
+  SIGPWR: 30,
+  SIGSYS: 31
+};
+var BSD = {
+  SIGEMT: 7,
+  SIGBUS: 10,
+  SIGSYS: 12,
+  SIGURG: 16,
+  SIGSTOP: 17,
+  SIGTSTP: 18,
+  SIGCONT: 19,
+  SIGCHLD: 20,
+  SIGTTIN: 21,
+  SIGTTOU: 22,
+  SIGIO: 23,
+  SIGINFO: 29,
+  SIGUSR1: 30,
+  SIGUSR2: 31
+};
+var SIGNALS = { ...COMMON, ...process.platform === "linux" ? LINUX : BSD };
+function signalNumber(signal) {
+  if (typeof signal === "number")
+    return signal;
+  const number = SIGNALS[signal];
+  if (number === undefined)
+    throw new Error(`unknown signal: ${signal}`);
+  return number;
+}
+
+// src/running/runner.ts
+var defaultRootDir = () => join(tmpdir(), "thunderjar");
+var exitCodeOf = (proc) => proc.exitCode ?? 128 + signalNumber(proc.signalCode);
+var shellQuote = (text) => `'${text.replaceAll("'", `'\\''`)}'`;
+var containerWrapper = (command, timeoutSeconds) => [
+  "mkdir -p /thunderjar",
+  "start=$(date +%s%3N)",
+  `timeout -k 5 ${timeoutSeconds} sh -c ${shellQuote(command)} >&2`,
+  "code=$?",
+  "end=$(date +%s%3N)",
+  `echo "{\\"startedAt\\":$start,\\"finishedAt\\":$end,\\"exitCode\\":$code}" > /thunderjar/run.json`,
+  "cat /thunderjar/run.json"
+].join(`
+`);
+function createDockerRunner(docker2, repository) {
+  return {
+    async runContainer(run) {
+      const prerun = imageRef(repository, run.prerunTag);
+      const name = `thunderjar-${run.postrunTag}-${crypto.randomUUID().slice(0, 8)}`;
+      try {
+        const { exitCode, stdout } = await docker2.run(prerun, name, containerWrapper(run.command, run.timeoutSeconds));
+        const runJson = stdout.trim().split(`
+`).at(-1) ?? "";
+        if (exitCode !== 0 || !runJson.startsWith("{")) {
+          throw new Error(`error: running a container from ${prerun} failed (docker run exited ${exitCode}).`);
+        }
+        await docker2.commit(name, imageRef(repository, run.postrunTag), prerun);
+        return JSON.parse(runJson);
+      } finally {
+        await docker2.removeContainer(name).catch(() => {});
+      }
+    }
+  };
+}
+async function exec(command, cwd) {
+  const child = Bun.spawn(["sh", "-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+  const [stdout, stderr] = await Promise.all([new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited]);
+  return { stdout, stderr, exitCode: exitCodeOf(child) };
+}
+function createDockerMeasurementOpener(docker2, repository) {
+  return {
+    async openMeasurementContext(postrunTag2) {
+      const scratch = await makeTempDir("thunderjar-measure-");
+      const workdir = join(scratch, "workspace");
+      const name = `thunderjar-measure-${crypto.randomUUID().slice(0, 8)}`;
+      try {
+        await makeDir(workdir);
+        await docker2.create(imageRef(repository, postrunTag2), name);
+        await docker2.copyFrom(name, "/workspace/.", workdir);
+        const resultPath = join(scratch, "result.json");
+        await docker2.copyFrom(name, "/thunderjar/result.json", resultPath).catch(() => {});
+        const harnessResult = await exists(resultPath) ? await Bun.file(resultPath).text() : "";
+        return scratchContext(workdir, harnessResult, scratch);
+      } catch (error) {
+        await remove(scratch);
+        throw error;
+      } finally {
+        await docker2.removeContainer(name).catch(() => {});
+      }
+    }
+  };
+}
+function scratchContext(workdir, harnessResult, scratch) {
+  return {
+    workdir,
+    harnessResult,
+    exec: (command) => exec(command, workdir),
+    readFile: (path2) => Bun.file(resolve(workdir, path2)).text(),
+    async writeFile(path2, contents) {
+      await Bun.write(resolve(workdir, path2), contents);
+    },
+    glob: async (pattern) => (await Array.fromAsync(new Bun.Glob(pattern).scan({ cwd: workdir, dot: true }))).toSorted(),
+    close: () => remove(scratch)
+  };
+}
+
+// src/cli/commands/format.ts
+var count = (n, noun) => `${n} ${noun}${n === 1 ? "" : "s"}`;
+var showValue = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? `{${Object.entries(value).map(([key, v]) => `${key}: ${showValue(v)}`).join(", ")}}` : JSON.stringify(value) ?? String(value);
+var showOutcome = (outcome) => outcome.outcome === "measured" ? showValue(outcome.data) : outcome.outcome === "skipped" ? "skipped" : `erroredWhileMeasuring: ${outcome.error.message}`;
+var seconds = (ms) => `${(ms / 1000).toFixed(2)}s`;
+var duration = ({ startedAt, finishedAt }) => seconds(finishedAt - startedAt);
+var minute = (iso) => iso.slice(0, 16).replace("T", " ");
+
+// src/cli/commands/options.ts
+function valueOption(flags, description) {
+  return new Option(flags, description).argParser((value, previous) => {
+    if (previous !== undefined)
+      throw new InvalidArgumentError("It may only be given once.");
+    if (value.startsWith("-"))
+      throw new InvalidArgumentError("It needs a value, not another flag.");
+    return value;
+  });
+}
+var imagePrefixOption = (description) => valueOption("--image-prefix <name>", description);
+var dataDirOption = () => valueOption("--data-dir <dir>", "keep the run data store in this folder, in place of .thunderjar/.data/");
+
+// src/cli/commands/build/build.ts
+async function build(name, options = {}) {
+  const {
+    cwd = process.cwd(),
+    log = (text) => console.log(text),
+    docker: docker2 = dockerCli(),
+    dryRun = false,
+    repository = LOCAL_REPOSITORY,
+    rootDir = defaultRootDir(),
+    now = Date.now
+  } = options;
+  const root = findThunderjarRoot(cwd);
+  const testCase = await loadTestCase(root, name);
+  const { permutations } = await resolveTestCase(root, testCase);
+  const rows = permutationRows(permutations);
+  const numberWidth = Math.max(2, String(permutations.length).length);
+  const pad = " ".repeat(numberWidth + 2);
+  if (dryRun) {
+    log(`Dockerfiles for ${name} (${count(permutations.length, "permutation")}). Nothing is built.`);
+    for (const [n, permutation] of permutations.entries()) {
+      const { dockerfile } = renderPrerun(await loadPrerunParameters(root, testCase.task, permutation));
+      log("");
+      log(`${String(n + 1).padStart(numberWidth)}  ${rows[n]}`);
+      log(`${pad}${prerunImageRef(repository, permutation.hash)}`);
+      log("");
+      log(dockerfile.trimEnd().replace(/^(?=.)/gm, pad));
+    }
+    return;
+  }
+  const builds = await preparePrerunBuilds({
+    root,
+    task: testCase.task,
+    permutations,
+    docker: docker2,
+    repository,
+    rootDir,
+    purpose: "Building prerun images"
+  });
+  const toBuild = builds.missing.size;
+  if (toBuild > 0) {
+    log(`Building ${count(toBuild, "prerun image")} for ${name} (${count(permutations.length, "permutation")})`);
+    log(`Build contexts in ${join(rootDir, "builds")}`);
+  } else {
+    log(`Every prerun image for ${name} exists (${count(permutations.length, "permutation")})`);
+  }
+  for (const [n, permutation] of permutations.entries()) {
+    const ref = prerunImageRef(repository, permutation.hash);
+    log("");
+    log(`${String(n + 1).padStart(numberWidth)}  ${rows[n]}`);
+    if (!builds.missing.has(permutation.hash)) {
+      log(`${pad}${ref}  reused`);
+      continue;
+    }
+    const started = now();
+    await builds.build(permutation.hash);
+    log(`${pad}${ref}  built (${seconds(now() - started)})`);
+  }
+  log("");
+  log(`${count(permutations.length, "prerun image")}: ${toBuild} built, ${permutations.length - toBuild} reused`);
+}
+function createBuildCommand() {
+  return new Command("build").description("Build a test case's prerun images.").argument("<test case>", "the test case whose prerun images to build").option("--dry-run", "print each permutation's Dockerfile instead of building").addOption(imagePrefixOption("the image repository prerun images are tagged in")).action(async (name, options) => {
+    await build(name, { dryRun: options.dryRun ?? false, repository: options.imagePrefix });
+  });
+}
+
+// src/store/run-data-store.ts
+var runDataStorePath = (cwd, dataDir) => join(dataDir === undefined ? join(findThunderjarRoot(cwd), ".data") : resolve(cwd, dataDir), "runs.json");
+function summarizeExecutions(records) {
+  const byId = new Map;
+  for (const { executionId, testCase, ranAt } of records) {
+    const summary = byId.get(executionId);
+    if (!summary)
+      byId.set(executionId, { executionId, testCase, ranAt, containerRuns: 1 });
+    else {
+      summary.containerRuns++;
+      if (ranAt < summary.ranAt)
+        summary.ranAt = ranAt;
+    }
+  }
+  const newestFirst = (a, b) => a < b ? 1 : a > b ? -1 : 0;
+  return [...byId.values()].toSorted((a, b) => newestFirst(a.ranAt, b.ranAt) || newestFirst(a.executionId, b.executionId));
+}
+function inExecutionOrder(records) {
+  const place = matrixPlaces(records);
+  return records.toSorted((a, b) => place.get(a.permutationHash) - place.get(b.permutationHash) || a.iteration - b.iteration);
+}
+function matrixPlaces(records) {
+  const place = new Map;
+  for (const { permutationHash } of records)
+    if (!place.has(permutationHash))
+      place.set(permutationHash, place.size);
+  return place;
+}
+function jsonFileStore(path2) {
+  const read = async () => {
+    let text;
+    try {
+      text = await Bun.file(path2).text();
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return { containerRuns: [] };
+      throw error;
+    }
+    return JSON.parse(text);
+  };
+  const write = async (data) => {
+    await makeDir(dirname(path2));
+    const temp = `${path2}.${crypto.randomUUID()}.tmp`;
+    await Bun.write(temp, `${JSON.stringify(data, null, 2)}
+`);
+    await move(temp, path2);
+  };
+  return {
+    async recordContainerRun(record) {
+      const data = await read();
+      data.containerRuns.push(record);
+      await write(data);
+    },
+    async recordMeasures(postrunImage, measures) {
+      const data = await read();
+      const record = data.containerRuns.find((r) => r.postrunImage === postrunImage);
+      if (!record)
+        throw new Error(`no container run recorded for ${postrunImage}`);
+      record.result = { ...record.result, ...measures };
+      await write(data);
+    },
+    async listExecutions(testCase) {
+      const { containerRuns } = await read();
+      return summarizeExecutions(testCase === undefined ? containerRuns : containerRuns.filter((r) => r.testCase === testCase));
+    },
+    async getExecution(executionId) {
+      const { containerRuns } = await read();
+      return inExecutionOrder(containerRuns.filter((r) => r.executionId === executionId));
+    },
+    async getContainerRun(postrunImage) {
+      const { containerRuns } = await read();
+      return containerRuns.find((r) => r.postrunImage === postrunImage);
+    },
+    async recordAggregationResult(result) {
+      const data = await read();
+      const results = data.aggregationResults ??= [];
+      const same = results.findIndex((r) => r.executionId === result.executionId && r.permutationHash === result.permutationHash);
+      if (same === -1)
+        results.push(result);
+      else
+        results[same] = result;
+      await write(data);
+    },
+    async getAggregationResults(executionId) {
+      const { containerRuns, aggregationResults = [] } = await read();
+      const place = matrixPlaces(containerRuns.filter((r) => r.executionId === executionId));
+      const placeOf = ({ permutationHash }) => place.get(permutationHash) ?? place.size;
+      return aggregationResults.filter((r) => r.executionId === executionId).toSorted((a, b) => placeOf(a) - placeOf(b));
+    }
+  };
+}
+
+// src/cli/commands/executions/executions.ts
+async function executions(testCase, { cwd = process.cwd(), dataDir } = {}) {
+  const store = jsonFileStore(runDataStorePath(cwd, dataDir));
+  const listed = await store.listExecutions(testCase);
+  if (listed.length === 0) {
+    return testCase === undefined ? "No executions recorded." : `No executions recorded for ${testCase}.`;
+  }
+  const width = Math.max(...listed.map((e) => e.testCase.length));
+  return listed.map((e) => `${e.executionId}  ${e.testCase.padEnd(width)}  ${minute(e.ranAt)}`).join(`
+`);
+}
+function createExecutionsCommand() {
+  return new Command("executions").description("List recorded executions.").argument("[test case]", "list only this test case's executions").addOption(dataDirOption()).action(async (testCase, options) => {
+    console.log(await executions(testCase, { dataDir: options.dataDir }));
+  });
+}
+
+// src/cli/commands/generate/parameter-names.ts
+async function listDirNames(dir) {
+  try {
+    return listEntries(dir).filter((entry) => entry.isDirectory).map((entry) => entry.path).sort();
+  } catch {
+    return [];
+  }
+}
+async function listFileStems(dir) {
+  try {
+    return listEntries(dir).filter((entry) => !entry.isDirectory && entry.path.endsWith(".ts")).map((entry) => entry.path.slice(0, -".ts".length)).sort();
+  } catch {
+    return [];
+  }
+}
+async function loadFamilyNames(root, family, problems) {
+  const familyDir = `test-case-parameters/harnessModels/${family}`;
+  const models = await loadDeclaration(root, `${familyDir}/models.ts`, "declareHarnessModels", problems);
+  const versions = await loadDeclaration(root, `${familyDir}/versions.ts`, "declareHarnessVersions", problems);
+  return {
+    models: Object.keys(models ?? {}).sort(),
+    versions: Object.keys(versions ?? {}).sort()
+  };
+}
+async function collectParameterNames(root) {
+  const parameters = join(root, "test-case-parameters");
+  const [baseImages, codeStates, promptSets, taskNames, familyNames] = await Promise.all([
+    listDirNames(join(parameters, "baseImages")),
+    listDirNames(join(parameters, "codeStates")),
+    listDirNames(join(parameters, "promptSets")),
+    listDirNames(join(parameters, "tasks")),
+    listDirNames(join(parameters, "harnessModels"))
+  ]);
+  const tasks = {};
+  for (const task of taskNames) {
+    tasks[task] = await listFileStems(join(parameters, "tasks", task, "initial-prompts"));
+  }
+  const harnessFamilies = {};
+  const problems = [];
+  for (const family of familyNames) {
+    harnessFamilies[family] = await loadFamilyNames(root, family, problems);
+  }
+  if (problems.length > 0)
+    throw new InvalidConfigError(problems);
+  return { baseImages, codeStates, promptSets, tasks, harnessFamilies };
+}
+function literalUnion(names) {
+  return names.length === 0 ? "never" : names.map((name) => JSON.stringify(name)).join(" | ");
+}
+function renderParameterNames(names) {
+  const lines2 = [
+    "// _generated/parameter-names.d.ts \u2014 generated by `thunderjar generate`, not edited",
+    "",
+    `type BaseImageName = ${literalUnion(names.baseImages)};`,
+    `type CodeStateName = ${literalUnion(names.codeStates)};`,
+    `type PromptSetName = ${literalUnion(names.promptSets)};`,
+    `type TaskName = ${literalUnion(Object.keys(names.tasks))};`
+  ];
+  const tasks = Object.entries(names.tasks);
+  if (tasks.length === 0) {
+    lines2.push("type InitialPromptNames = Record<string, never>;");
+  } else {
+    lines2.push("type InitialPromptNames = {");
+    for (const [task, prompts] of tasks) {
+      lines2.push(`  ${JSON.stringify(task)}: ${literalUnion(prompts)};`);
+    }
+    lines2.push("};");
+  }
+  const pairs = Object.entries(names.harnessFamilies).filter(([, { versions, models }]) => versions.length > 0 && models.length > 0).map(([family, { versions, models }]) => "`" + family + "@${" + literalUnion(versions) + "}/${" + literalUnion(models) + "}`");
+  if (pairs.length === 0) {
+    lines2.push("type HarnessModelName = never;");
+  } else if (pairs.length === 1) {
+    lines2.push(`type HarnessModelName = ${pairs[0]};`);
+  } else {
+    lines2.push("type HarnessModelName =");
+    lines2.push(...pairs.map((pair) => `  | ${pair}`));
+    lines2[lines2.length - 1] += ";";
+  }
+  lines2.push("");
+  return lines2.join(`
+`);
+}
+async function writeGeneratedTypes(root) {
+  const names = await collectParameterNames(root);
+  const content = renderParameterNames(names);
+  const path2 = join(root, "_generated", "parameter-names.d.ts");
+  await Bun.write(path2, content);
+  return { path: path2, content };
+}
+
 // src/cli/commands/generate/generate.ts
+async function generate(cwd = process.cwd()) {
+  const root = findThunderjarRoot(cwd);
+  const { path: path2 } = await writeGeneratedTypes(root);
+  return { path: path2 };
+}
 function createGenerateCommand() {
-  return new Command("generate").description("Generate thunderjar output.").action(() => {
-    console.log("nothing here yet");
+  return new Command("generate").description("Write the parameter-name types for this project.").action(async () => {
+    const { path: path2 } = await generate();
+    console.log(`generated ${path2}`);
   });
 }
 
 // src/cli/commands/init/init.ts
+var config = `import { declareConfig, sqliteStore } from "thunderjar";
+
+export default declareConfig({
+  imageStore: { repository: "ghcr.io/your-org/thunderjar-images" },
+  runDataStore: sqliteStore({ path: "./.thunderjar/.data/runs.sqlite" }),
+});
+`;
+var stub = (fn, body) => `import { ${fn} } from "thunderjar";
+
+export default ${fn}(${body});
+`;
+var baseImage = stub("declareBaseImage", `{
+  applyParameter: () => \`FROM node:20-bookworm\`,
+}`);
+var codeState = `import { checkoutCommit, declareCodeState } from "thunderjar";
+
+export default declareCodeState({
+  config: { commit: "a1b2c3" },
+  applyParameter: (config, ctx) => \`\${checkoutCommit(ctx, config.commit)}\\nRUN npm ci\`,
+});
+`;
+var promptSet = stub("declarePromptSet", `{
+  config: { commit: "e4f5a6" },
+  applyParameter: (config, ctx) => \`COPY \${ctx.git.show(config.commit, "prompts/snerk.md")} /workspace/CLAUDE.md\`,
+}`);
+var harnessIndex = stub("declareHarness", `{
+  applyParameter: (_config, ctx) => \`RUN npm install -g @anthropic-ai/claude-code@\${ctx.version}\`,
+  cli: (ctx) => \`claude -p "\${ctx.initialPrompt}" --model \${ctx.modelId} > \${ctx.resultPath}\`,
+  requiredEnv: ["ANTHROPIC_API_KEY"],
+}`);
+var harnessModels = stub("declareHarnessModels", `{
+  "haiku-4-5": "claude-haiku-4-5-20251001",
+}`);
+var harnessVersions = stub("declareHarnessVersions", `{
+  "2.1.283": { version: "2.1.283" },
+}`);
+var collectTokenCosts = stub("declareTokenCostCollector", `(_raw, _ctx) => {
+  return { outcome: "unavailable", reason: "notReported" };
+}`);
+var initialPrompt = stub("declareInitialPrompt", `{
+  prompt: "Create a file isPrime.ts exporting a function that tests for primality.",
+  timeoutSeconds: 600,
+  applyParameter: () => \`\`,
+}`);
+var measurement = stub("declareMeasurement", `{
+  instrument: "fileCreated",
+  config: { glob: "**/isPrime.ts" },
+  aggregate: ["rate"],
+}`);
+var testCase = stub("declareTestCase", `{
+  baseImage: ["node20"],
+  codeState: ["baseline"],
+  promptSet: ["snerk"],
+  harnessModel: ["claude-code@2.1.283/haiku-4-5"],
+  task: "is-prime",
+  initialPrompt: ["plain"],
+  iterations: 1,
+}`);
+var tsconfig = JSON.stringify({
+  compilerOptions: {
+    target: "ESNext",
+    module: "ESNext",
+    moduleResolution: "bundler",
+    strict: true,
+    noEmit: true,
+    skipLibCheck: true,
+    allowImportingTsExtensions: true
+  },
+  include: ["**/*.ts"],
+  exclude: ["node_modules", ".data", "**/*.template.ts"]
+}, null, 2) + `
+`;
+var P = "test-case-parameters";
+function scaffold() {
+  return {
+    "thunderjar.config.ts": config,
+    "tsconfig.json": tsconfig,
+    "test-cases/example.ts": testCase,
+    [`${P}/baseImages/node20/index.ts`]: baseImage,
+    [`${P}/codeStates/baseline/index.ts`]: codeState,
+    [`${P}/promptSets/snerk/index.ts`]: promptSet,
+    [`${P}/harnessModels/claude-code/index.ts`]: harnessIndex,
+    [`${P}/harnessModels/claude-code/models.ts`]: harnessModels,
+    [`${P}/harnessModels/claude-code/versions.ts`]: harnessVersions,
+    [`${P}/harnessModels/claude-code/collectTokenCosts.ts`]: collectTokenCosts,
+    [`${P}/tasks/is-prime/initial-prompts/plain.ts`]: initialPrompt,
+    [`${P}/tasks/is-prime/measurements/isPrimeTsExists.ts`]: measurement
+  };
+}
+async function init(projectRoot) {
+  const root = join(projectRoot, ".thunderjar");
+  const nested = !existsSync(join(projectRoot, "package.json"));
+  const files = scaffold();
+  if (nested) {
+    files["package.json"] = JSON.stringify({ name: "thunderjar-config", private: true, type: "module", dependencies: { thunderjar: "latest" } }, null, 2) + `
+`;
+  }
+  files[".gitignore"] = ["_generated/", ".data/", ...nested ? ["node_modules/"] : []].join(`
+`) + `
+`;
+  const result = { created: [], skipped: [] };
+  for (const [rel, content] of Object.entries(files)) {
+    const path2 = join(root, rel);
+    if (existsSync(path2)) {
+      result.skipped.push(rel);
+      continue;
+    }
+    await Bun.write(path2, content);
+    result.created.push(rel);
+  }
+  return result;
+}
 function createInitCommand() {
-  return new Command("init").description("Initialise thunderjar in the current project.").action(() => {
-    console.log("nothing here yet");
+  return new Command("init").description("Create .thunderjar/ in this project.").action(async () => {
+    const { created, skipped } = await init(process.cwd());
+    for (const f of created)
+      console.log(`created  .thunderjar/${f}`);
+    for (const f of skipped)
+      console.log(`exists   .thunderjar/${f}`);
+  });
+}
+
+// src/cli/commands/plan/plan.ts
+var LABELS = ["baseImage", "codeState", "promptSet", "harnessModel", "task", "initialPrompt"];
+var LABEL_WIDTH = Math.max(...LABELS.map((label) => label.length)) + 2;
+async function plan(name, cwd = process.cwd(), options = {}) {
+  const { docker: docker2 = dockerCli(), repository = LOCAL_REPOSITORY } = options;
+  const root = findThunderjarRoot(cwd);
+  const testCase2 = await loadTestCase(root, name);
+  const { hashes, permutations } = await resolveTestCase(root, testCase2);
+  const found = await prerunStatuses(docker2, repository, permutations);
+  const status = (hash) => ("statuses" in found) ? showPrerunStatus(found.statuses.get(hash)) : "";
+  const parameterLines = LABELS.map((label) => {
+    const value = label === "task" ? testCase2.task : testCase2[label].map((n) => `${n} (${abbreviateHash(hashes[label].get(n))})`).join(", ");
+    return `${(label + ":").padEnd(LABEL_WIDTH)}${value}`;
+  });
+  const runs = permutations.length * testCase2.iterations;
+  const summary = `Matrix shape: ${matrixShape(testCase2).join("/")} ` + `(${count(permutations.length, "permutation")} \xD7 ${count(testCase2.iterations, "iteration")} = ${count(runs, "container run")})`;
+  const rows = permutationRows(permutations);
+  const numberWidth = Math.max(2, String(permutations.length).length);
+  const entries = permutations.map((permutation, n) => `${String(n + 1).padStart(numberWidth)}  ${rows[n]}
+` + `${" ".repeat(numberWidth + 2)}${prerunTag(permutation.hash)}${status(permutation.hash)}`);
+  const note = "unreachable" in found ? ["", unreachableNote(found.unreachable)] : [];
+  return [...parameterLines, "", summary, "", entries.join(`
+
+`), ...note].join(`
+`);
+}
+function createPlanCommand() {
+  return new Command("plan").description("Print what a run of a test case would do.").argument("<test case>", "the test case to plan").addOption(imagePrefixOption("the image repository prerun images are looked up in")).action(async (name, options) => {
+    console.log(await plan(name, process.cwd(), { repository: options.imagePrefix }));
+  });
+}
+
+// src/measuring/aggregate.ts
+var sum = (xs) => xs.reduce((a, b) => a + b, 0);
+var mean = (xs) => sum(xs) / xs.length;
+var median = (xs) => {
+  const sorted = xs.toSorted((a, b) => a - b);
+  const mid = sorted.length >> 1;
+  return sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+};
+var byKey = (records, combine) => {
+  const keys = [...new Set(records.flatMap((r) => Object.keys(r)))];
+  return Object.fromEntries(keys.map((key) => [key, combine(records.map((r) => r[key] ?? 0))]));
+};
+var ofBooleans = {
+  rate: (bs) => bs.filter(Boolean).length / bs.length,
+  count: (bs) => bs.filter(Boolean).length
+};
+var ofNumbers = {
+  mean,
+  median,
+  min: (xs) => Math.min(...xs),
+  max: (xs) => Math.max(...xs),
+  sum
+};
+var ofRecords = {
+  sum: (rs) => byKey(rs, sum),
+  mean: (rs) => byKey(rs, mean)
+};
+var isRecordOfNumbers = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((v) => typeof v === "number");
+function menuFor(values) {
+  if (values.every((v) => typeof v === "boolean"))
+    return ["booleans", ofBooleans];
+  if (values.every((v) => typeof v === "number"))
+    return ["numbers", ofNumbers];
+  if (values.every(isRecordOfNumbers))
+    return ["records of numbers", ofRecords];
+  return;
+}
+function combine(values, methods) {
+  if (values.length === 0)
+    return {};
+  const menu = menuFor(values);
+  if (!menu)
+    throw new Error(`can't combine ${JSON.stringify(values)}: not all booleans, numbers or records of numbers`);
+  const [kind, menuMethods] = menu;
+  return Object.fromEntries(methods.map((method) => {
+    const apply = menuMethods[method];
+    if (!apply)
+      throw new Error(`"${method}" doesn't combine ${kind}`);
+    return [method, apply(values)];
+  }));
+}
+function aggregatePermutation(records, measurements) {
+  const [first] = records;
+  if (!first)
+    throw new Error("no container runs to aggregate");
+  const { executionId, permutationHash } = first;
+  if (records.some((r) => r.executionId !== executionId || r.permutationHash !== permutationHash)) {
+    throw new Error("container runs to aggregate must be of one permutation of one execution");
+  }
+  const measures = {};
+  for (const { name, aggregate } of measurements) {
+    const values = records.flatMap(({ result }) => {
+      const outcome = result[name]?.outcome;
+      return outcome?.outcome === "measured" ? [outcome.data] : [];
+    });
+    measures[name] = { measured: values.length, ...combine(values, aggregate) };
+  }
+  const durations = records.map(({ execution }) => execution.finishedAt - execution.startedAt);
+  return {
+    executionId,
+    permutationHash,
+    iterations: records.length,
+    measures,
+    duration: { mean: mean(durations), max: Math.max(...durations) }
+  };
+}
+async function recomputeAggregationResult(store, executionId, permutationHash, measurements) {
+  const records = (await store.getExecution(executionId)).filter((r) => r.permutationHash === permutationHash);
+  const result = aggregatePermutation(records, measurements);
+  await store.recordAggregationResult(result);
+  return result;
+}
+
+// src/measuring/measure.ts
+var message = (error) => error instanceof Error ? error.message : String(error);
+var recordable = (result) => result.outcome === "erroredWhileMeasuring" ? { outcome: "erroredWhileMeasuring", error: { message: message(result.error) } } : result;
+async function evaluate({ instrument, config: config2, dir }, ctx) {
+  try {
+    if (!isInstrumentName(instrument))
+      throw new Error(`unknown instrument ${JSON.stringify(instrument)}`);
+    const chosen = instruments[instrument];
+    const fields = config2;
+    const bundled = Object.fromEntries((chosen.bundledFiles ?? []).map((key) => [key, resolve(dir, fields[key])]));
+    return recordable(await chosen.evaluate({ ...fields, ...bundled }, ctx));
+  } catch (error) {
+    return { outcome: "erroredWhileMeasuring", error: { message: message(error) } };
+  }
+}
+async function measureContainerRun(measurements, open, now = Date.now) {
+  const result = {};
+  for (const measurement2 of measurements) {
+    const ctx = await open();
+    let outcome;
+    try {
+      outcome = await evaluate(measurement2, ctx);
+    } finally {
+      await ctx.close();
+    }
+    result[measurement2.name] = {
+      instrument: measurement2.instrument,
+      contentHash: hashMeasurement(measurement2),
+      measuredAt: new Date(now()).toISOString(),
+      outcome
+    };
+  }
+  return result;
+}
+
+// src/measuring/remeasure.ts
+function measureStatus(recorded, measurement2) {
+  if (recorded === undefined || recorded.outcome.outcome === "erroredWhileMeasuring")
+    return "missing";
+  return recorded.contentHash === hashMeasurement(measurement2) ? "current" : "stale";
+}
+function planRemeasure(records, measurements) {
+  const runs = records.flatMap(({ executionId, postrunImage, result }) => {
+    const measurementNames = measurements.filter((measurement2) => measureStatus(result[measurement2.name], measurement2) !== "current").map(({ name }) => name).toSorted();
+    return measurementNames.length === 0 ? [] : [{ executionId, postrunImage, measurementNames }];
+  });
+  return { runs, executions: summarizeExecutions2(records, measurements) };
+}
+function summarizeExecutions2(records, measurements) {
+  const resultsByExecution = new Map;
+  for (const { executionId, result } of records) {
+    resultsByExecution.set(executionId, [...resultsByExecution.get(executionId) ?? [], result]);
+  }
+  const sorted = measurements.toSorted((a, b) => a.name < b.name ? -1 : 1);
+  const declared = new Set(measurements.map(({ name }) => name));
+  return [...resultsByExecution].map(([executionId, results]) => {
+    const summaries = sorted.map((measurement2) => {
+      const statuses = results.map((result) => measureStatus(result[measurement2.name], measurement2));
+      const status = statuses.includes("missing") ? "missing" : statuses.includes("stale") ? "stale" : "current";
+      return { name: measurement2.name, contentHash: hashMeasurement(measurement2), status };
+    });
+    const storedMeasures = new Map;
+    for (const name of results.flatMap((result) => Object.keys(result)).filter((name2) => !declared.has(name2))) {
+      storedMeasures.set(name, (storedMeasures.get(name) ?? 0) + 1);
+    }
+    const deleted = [...storedMeasures].toSorted(([a], [b]) => a < b ? -1 : 1).map(([name, count2]) => ({ name, storedMeasures: count2 }));
+    return { executionId, measurements: summaries, deleted };
+  });
+}
+
+// src/cli/commands/remeasure/remeasure.ts
+var footer = (updated, recomputed) => [
+  `Updated ${count(updated, "container run")}. Recomputed ${count(recomputed, "aggregation result")}.`,
+  "The agent was not rerun."
+];
+var NOTHING_TO_DO = "Already current, nothing to do.";
+function measuredLines(measured) {
+  const taken = measured.flatMap(({ record, result }) => Object.entries(result).map((entry) => ({ record, entry })));
+  const width = Math.max(...taken.map(({ entry: [name] }) => name.length));
+  return taken.map(({ record: { permutationHash, iteration }, entry: [name, { outcome }] }) => `  ${abbreviateHash(permutationHash)} i${String(iteration).padStart(2, "0")}  ${name.padEnd(width)}  ${showOutcome(outcome)}`);
+}
+function executionReport(task, containerRuns, { executionId, measurements, deleted }, measured, recomputed) {
+  const rows = [
+    ...measurements.map(({ name, contentHash, status }) => [
+      name,
+      status === "current" ? "up to date" : `new / changed (${abbreviateHash(contentHash)})`
+    ]),
+    ...deleted.map(({ name, storedMeasures }) => [
+      name,
+      `deleted from task; ${count(storedMeasures, "stored measure")} kept, excluded from aggregates`
+    ])
+  ];
+  const width = Math.max(...rows.map(([name]) => name.length));
+  return [
+    `Execution ${executionId}  (${count(containerRuns, "container run")})`,
+    `Current measurements for task ${task}:`,
+    ...rows.map(([name, status]) => `  ${name.padEnd(width)}  ${status}`),
+    "",
+    ...measured.length === 0 ? [NOTHING_TO_DO] : ["Measuring from each postrun image:", ...measuredLines(measured), ""],
+    ...footer(measured.length, recomputed)
+  ].join(`
+`);
+}
+function testCaseReport(testCase2, executions2, updated, recomputed) {
+  const rows = executions2.map(({ executionId, containerRuns, ranAt, plan: plan2 }) => ({
+    executionId,
+    runs: count(containerRuns, "run"),
+    day: ranAt.slice(0, 10),
+    current: plan2.runs.length === 0
+  }));
+  const width = Math.max(...rows.map(({ runs }) => runs.length));
+  const total = executions2.reduce((sum2, { containerRuns }) => sum2 + containerRuns, 0);
+  return [
+    `${testCase2} has ${count(executions2.length, "execution")} (${count(total, "container run")})`,
+    ...rows.map(({ executionId, runs, day, current }) => `  ${executionId}  ${runs.padEnd(width)}  ${day}${current ? "  (already current, nothing to do)" : ""}`),
+    "",
+    updated === 0 ? NOTHING_TO_DO : `Measuring ${count(updated, "container run")}...  done`,
+    ...footer(updated, recomputed)
+  ].join(`
+`);
+}
+async function remeasureExecution(cwd, store, opener, executionId) {
+  const records = await store.getExecution(executionId);
+  const measurements = await loadMeasurements(findThunderjarRoot(cwd), records[0].task);
+  const plan2 = planRemeasure(records, measurements);
+  const measured = [];
+  for (const { postrunImage, measurementNames } of plan2.runs) {
+    const record = records.find((r) => r.postrunImage === postrunImage);
+    const planned = measurementNames.map((name) => measurements.find((m) => m.name === name));
+    const result = await measureContainerRun(planned, () => opener.openMeasurementContext(record.postrunImage));
+    await store.recordMeasures(record.postrunImage, result);
+    measured.push({ record, result });
+  }
+  const permutationHashes = new Set(records.map(({ permutationHash }) => permutationHash));
+  for (const permutationHash of permutationHashes) {
+    await recomputeAggregationResult(store, executionId, permutationHash, measurements);
+  }
+  return { records, plan: plan2, measured, recomputed: permutationHashes.size };
+}
+async function remeasure(target, { cwd = process.cwd(), dataDir } = {}) {
+  const store = jsonFileStore(runDataStorePath(cwd, dataDir));
+  const opener = createDockerMeasurementOpener(dockerCli(), LOCAL_REPOSITORY);
+  if ((await store.getExecution(target)).length > 0) {
+    const { records, plan: plan2, measured, recomputed } = await remeasureExecution(cwd, store, opener, target);
+    return executionReport(records[0].task, records.length, plan2.executions[0], measured, recomputed);
+  }
+  const executions2 = await store.listExecutions(target);
+  if (executions2.length > 0) {
+    const planned = [];
+    let updated = 0;
+    let recomputed = 0;
+    for (const execution of executions2) {
+      const { plan: plan2, measured, recomputed: ofExecution } = await remeasureExecution(cwd, store, opener, execution.executionId);
+      planned.push({ ...execution, plan: plan2 });
+      updated += measured.length;
+      recomputed += ofExecution;
+    }
+    return testCaseReport(target, planned, updated, recomputed);
+  }
+  throw new Error(`${target} is not a recorded execution or test case`);
+}
+function createRemeasureCommand() {
+  return new Command("remeasure").description("Apply the current measurements to past runs.").argument("<target>", "an execution ID, or a test case, meaning every execution of it").addOption(dataDirOption()).action(async (target, options) => {
+    console.log(await remeasure(target, { dataDir: options.dataDir }));
+  });
+}
+
+// src/matrix/execution.ts
+var RESULT_PATH = "/thunderjar/result.json";
+var importDefault2 = async (path2) => (await import(path2)).default;
+async function renderCommand(root, task, permutation) {
+  const parameters = join(root, "test-case-parameters");
+  const { family, version, model } = parseHarnessModelPair(permutation.harnessModel);
+  const familyDir = join(parameters, "harnessModels", family);
+  const harness = await importDefault2(join(familyDir, "index.ts"));
+  const versions = await importDefault2(join(familyDir, "versions.ts"));
+  const models = await importDefault2(join(familyDir, "models.ts"));
+  const initialPrompt2 = await importDefault2(join(parameters, "tasks", task, "initial-prompts", `${permutation.initialPrompt}.ts`));
+  const entry = versions[version];
+  if (!("version" in entry)) {
+    throw new Error(`${permutation.harnessModel}: floating versions are not supported yet`);
+  }
+  const cli = entry.cli ?? harness.cli;
+  const ctx = { version: entry.version, modelId: models[model], initialPrompt: initialPrompt2.prompt };
+  return {
+    renderCommand: (resultPath) => cli({ ...ctx, resultPath }),
+    timeoutSeconds: initialPrompt2.timeoutSeconds,
+    harnessModel: { family, version: ctx.version, modelId: ctx.modelId }
+  };
+}
+async function planExecution(root, testCase2, executionId) {
+  const { hashes, permutations } = await resolveTestCase(root, testCase2);
+  const planned = [];
+  for (const permutation of permutations) {
+    const { renderCommand: render2, timeoutSeconds, harnessModel } = await renderCommand(root, testCase2.task, permutation);
+    const command = render2(RESULT_PATH);
+    const parameters = Object.fromEntries(AXES.map((axis) => [axis, { name: permutation[axis], parameterHash: hashes[axis].get(permutation[axis]) }]));
+    planned.push({
+      permutation,
+      parameters,
+      harnessModel,
+      prerunTag: prerunTag(permutation.hash),
+      runs: Array.from({ length: testCase2.iterations }, (_, iterationIndex) => ({
+        executionId,
+        iterationIndex,
+        prerunTag: prerunTag(permutation.hash),
+        postrunTag: postrunTag(executionId, permutation.hash, iterationIndex),
+        command,
+        renderCommand: render2,
+        timeoutSeconds
+      }))
+    });
+  }
+  return { executionId, iterations: testCase2.iterations, permutations: planned };
+}
+
+// src/matrix/ulid.ts
+var ALPHABET = "0123456789abcdefghjkmnpqrstvwxyz";
+function ulid(now = Date.now(), random = crypto.getRandomValues(new Uint8Array(10))) {
+  if (!Number.isInteger(now) || now < 0 || now >= 2 ** 48)
+    throw new RangeError(`ULID time out of range: ${now}`);
+  if (random.length !== 10)
+    throw new RangeError(`ULID randomness must be 10 bytes, got ${random.length}`);
+  let time = "";
+  for (let t = now, i = 0;i < 10; i++, t = Math.floor(t / 32))
+    time = ALPHABET[t % 32] + time;
+  let bits = 0n;
+  for (const byte of random)
+    bits = bits << 8n | BigInt(byte);
+  let rest = "";
+  for (let i = 0;i < 16; i++, bits >>= 5n)
+    rest = ALPHABET[Number(bits & 31n)] + rest;
+  return time + rest;
+}
+
+// src/cli/commands/run/run.ts
+var indent = (text, spaces) => text.split(`
+`).map((line) => " ".repeat(spaces) + line).join(`
+`);
+var ordinal = (n, total) => `${String(n).padStart(String(total).length)}/${total}`;
+var shape = ({ permutations, iterations }) => `${count(permutations.length, "permutation")} \xD7 ${count(iterations, "iteration")}`;
+async function run(name, options) {
+  const {
+    dryRun,
+    cwd = process.cwd(),
+    log = (text) => console.log(text),
+    now = Date.now,
+    newExecutionId = () => ulid(now()),
+    rootDir = defaultRootDir(),
+    docker: docker2 = dockerCli(),
+    repository = LOCAL_REPOSITORY,
+    runner = createDockerRunner(docker2, repository),
+    measurementOpener = createDockerMeasurementOpener(docker2, repository),
+    dataDir
+  } = options;
+  const root = findThunderjarRoot(cwd);
+  const testCase2 = await loadTestCase(root, name);
+  const execution = await planExecution(root, testCase2, newExecutionId());
+  const { executionId, permutations, iterations } = execution;
+  const rows = permutationRows(permutations.map((p) => p.permutation));
+  const permutationLine = (n) => `Permutation ${ordinal(n + 1, permutations.length)}  ${rows[n]}`;
+  if (dryRun) {
+    const found = await prerunStatuses(docker2, repository, permutations.map((p) => p.permutation));
+    log(`Execution ${executionId} (dry run, ${shape(execution)})`);
+    if ("unreachable" in found)
+      log(unreachableNote(found.unreachable));
+    permutations.forEach(({ permutation, prerunTag: prerunTag2, runs }, n) => {
+      log("");
+      log([
+        permutationLine(n),
+        `  ${prerunTag2}${"statuses" in found ? showPrerunStatus(found.statuses.get(permutation.hash)) : ""}`,
+        ...runs.map(({ iterationIndex, postrunTag: postrunTag2, command }) => `  iteration ${ordinal(iterationIndex + 1, iterations)}  ${postrunTag2}
+${indent(command, 4)}`)
+      ].join(`
+`));
+    });
+    return;
+  }
+  const measurements = await loadMeasurements(root, testCase2.task);
+  const nameWidth = Math.max(0, ...measurements.map((m) => m.name.length));
+  const storePath = runDataStorePath(cwd, dataDir);
+  const store = jsonFileStore(storePath);
+  const builds = await preparePrerunBuilds({
+    root,
+    task: testCase2.task,
+    permutations: permutations.map((p) => p.permutation),
+    docker: docker2,
+    repository,
+    rootDir,
+    purpose: "Running a test case"
+  });
+  log(`Execution ${executionId} (${shape(execution)})`);
+  log(`Images in ${repository}`);
+  if (builds.missing.size > 0)
+    log(`Build contexts in ${join(rootDir, "builds")}`);
+  const exitCodes = new Map;
+  for (const [n, { permutation, parameters, harnessModel, prerunTag: prerunTag2, runs }] of permutations.entries()) {
+    log("");
+    log(permutationLine(n));
+    if (builds.missing.has(permutation.hash)) {
+      const started = now();
+      await builds.build(permutation.hash);
+      log(`  ${prerunTag2}  built (${seconds(now() - started)})`);
+    } else {
+      log(`  ${prerunTag2}  reused`);
+    }
+    for (const containerRun of runs) {
+      const { startedAt, finishedAt, exitCode } = await runner.runContainer(containerRun);
+      await store.recordContainerRun({
+        executionId,
+        testCase: name,
+        task: testCase2.task,
+        permutationHash: permutation.hash,
+        iteration: containerRun.iterationIndex,
+        postrunImage: containerRun.postrunTag,
+        ranAt: new Date(startedAt).toISOString(),
+        parameters,
+        harnessModel,
+        result: {},
+        execution: { startedAt, finishedAt, exitCode }
+      });
+      exitCodes.set(exitCode, (exitCodes.get(exitCode) ?? 0) + 1);
+      log(`  iteration ${ordinal(containerRun.iterationIndex + 1, iterations)}  ${containerRun.postrunTag}` + `  exit ${exitCode}  ${duration({ startedAt, finishedAt })}`);
+      if (measurements.length > 0) {
+        const open = () => measurementOpener.openMeasurementContext(containerRun.postrunTag);
+        const result = await measureContainerRun(measurements, open, now);
+        await store.recordMeasures(containerRun.postrunTag, result);
+        log(Object.entries(result).map(([name2, { outcome }]) => `    ${name2.padEnd(nameWidth)}  ${showOutcome(outcome)}`).join(`
+`));
+      }
+      await recomputeAggregationResult(store, executionId, permutation.hash, measurements);
+    }
+  }
+  const total = permutations.length * iterations;
+  const byCode = [...exitCodes].toSorted(([a], [b]) => a - b).map(([code, n]) => `${n} exited ${code}`);
+  log("");
+  log(`${count(total, "container run")}: ${byCode.join(", ")}`);
+  log(`Recorded in ${relative(cwd, storePath)}`);
+}
+function createRunCommand() {
+  return new Command("run").description("Run a test case.").argument("<test case>", "the test case to run").option("--dry-run", "print each container run instead of building or running anything").addOption(imagePrefixOption("the image repository prerun and postrun images are tagged in")).addOption(dataDirOption()).action(async (name, options) => {
+    await run(name, { dryRun: options.dryRun ?? false, repository: options.imagePrefix, dataDir: options.dataDir });
+  });
+}
+
+// src/cli/commands/show/show.ts
+var labelled = (lines2) => {
+  const width = Math.max(...lines2.map(([label]) => label.length));
+  return lines2.map(([label, value]) => `${label.padEnd(width)}  ${value}`);
+};
+function table(rows) {
+  const widths = rows[0].map((_, i) => Math.max(...rows.map((row) => row[i]?.length ?? 0)));
+  return rows.map((row) => row.length === 0 ? "" : `  ${row.map((cell, i) => i === row.length - 1 ? cell : cell.padEnd(widths[i])).join("  ")}`);
+}
+var permutationOf = ({ parameters }) => Object.fromEntries(AXES.map((axis) => [axis, parameters[axis].name]));
+var PLACES = { rate: 2, mean: 1, median: 1 };
+function aggregatedValue(method, value) {
+  const places = PLACES[method];
+  const number = (n) => places === undefined ? showValue(n) : n.toFixed(places);
+  if (typeof value === "number")
+    return number(value);
+  return `{${Object.entries(value).map(([key, n]) => `${key}: ${number(n)}`).join(", ")}}`;
+}
+function aggregateCell({ measured, ...methods }) {
+  if (measured === 0)
+    return "\u2014";
+  return Object.entries(methods).map(([method, value]) => `${method} ${aggregatedValue(method, value)}`).join(", ");
+}
+function exits(runs) {
+  const byCode = new Map;
+  for (const { execution } of runs)
+    byCode.set(execution.exitCode, (byCode.get(execution.exitCode) ?? 0) + 1);
+  return [...byCode].toSorted(([a], [b]) => a - b).map(([code, n]) => `${n}/${runs.length} exited ${code}`).join(", ");
+}
+var summary = (label, value) => `  ${label.padEnd(11)}${value}`;
+function staleness(measurements) {
+  const currentHashes = new Map(measurements.map((measurement2) => [measurement2.name, hashMeasurement(measurement2)]));
+  return (name, { contentHash }) => {
+    const current = currentHashes.get(name);
+    return current !== undefined && current !== contentHash;
+  };
+}
+function aggregationTable({ iterations, measures }, runs, isStale) {
+  const names = Object.keys(measures).toSorted();
+  if (names.length === 0)
+    return ["  no measures"];
+  const staleRow = (name) => runs.some(({ result }) => {
+    const measure = result[name];
+    return measure?.outcome.outcome === "measured" && isStale(name, measure);
+  });
+  return table([
+    ["MEASURE", "MEASURED", "AGGREGATE"],
+    ...names.map((name) => [
+      name,
+      `${measures[name].measured}/${iterations}`,
+      `${aggregateCell(measures[name])}${staleRow(name) ? "  stale, run `remeasure`" : ""}`
+    ])
+  ]);
+}
+var detailed = (outcome) => outcome.outcome === "measured" ? showValue(outcome.data) : outcome.outcome === "skipped" ? `skipped${outcome.reason === undefined ? "" : `  (${outcome.reason})`}` : `error  (${outcome.error.message})`;
+function byPermutation(records) {
+  const groups = new Map;
+  for (const record of records) {
+    const group = groups.get(record.permutationHash);
+    if (group)
+      group.push(record);
+    else
+      groups.set(record.permutationHash, [record]);
+  }
+  return [...groups.values()];
+}
+function showExecution(records, aggregations, measurements, latestOf) {
+  const [{ executionId, testCase: testCase2, task }] = records;
+  const ranAt = records.map((r) => r.ranAt).toSorted()[0];
+  const lines2 = labelled([
+    ["Execution", `${executionId}${latestOf === undefined ? "" : `  (latest of ${latestOf})`}`],
+    ["Test case", testCase2],
+    ["Task", task],
+    ["Date", minute(ranAt)]
+  ]);
+  const permutations = byPermutation(records);
+  const rows = permutationRows(permutations.map(([first]) => permutationOf(first)));
+  const byHash = new Map(aggregations.map((a) => [a.permutationHash, a]));
+  const isStale = staleness(measurements);
+  permutations.forEach((runs, n) => {
+    const aggregation = byHash.get(runs[0].permutationHash);
+    lines2.push("", `Permutation ${abbreviateHash(runs[0].permutationHash)}  (${count(runs.length, "iteration")})`, `  ${rows[n]}`, "", ...aggregation ? aggregationTable(aggregation, runs, isStale) : ["  no aggregation result recorded"], "", summary("exit", exits(runs)), ...aggregation ? [summary("duration", `mean ${seconds(aggregation.duration.mean)}, max ${seconds(aggregation.duration.max)}`)] : []);
+  });
+  return lines2.join(`
+`);
+}
+function showContainerRun(record, measurements) {
+  const { postrunImage, executionId, testCase: testCase2, permutationHash, iteration, ranAt, parameters, result, execution } = record;
+  const names = Object.keys(result).toSorted();
+  const isStale = staleness(measurements);
+  const cell = (name) => `${detailed(result[name].outcome)}${isStale(name, result[name]) ? " (stale)" : ""}`;
+  return [
+    ...labelled([
+      ["Container run", postrunImage],
+      ["Execution", `${executionId}  (${testCase2})`],
+      ["Permutation", `${abbreviateHash(permutationHash)}, iteration ${iteration + 1}`],
+      ["Ran at", minute(ranAt)]
+    ]),
+    "",
+    "Parameters",
+    ...table(AXES.map((axis) => [axis, parameters[axis].name, parameters[axis].parameterHash.slice(0, 4)])),
+    "",
+    "Measures",
+    ...names.length === 0 ? ["  none"] : table(names.map((name) => [name, cell(name)])),
+    "",
+    `Duration  ${duration(execution)}   exit code ${execution.exitCode}`
+  ].join(`
+`);
+}
+async function show3(target, { cwd = process.cwd(), dataDir } = {}) {
+  const store = jsonFileStore(runDataStorePath(cwd, dataDir));
+  const todays = (task) => loadMeasurements(findThunderjarRoot(cwd), task);
+  const containerRun = await store.getContainerRun(target);
+  if (containerRun)
+    return showContainerRun(containerRun, await todays(containerRun.task));
+  const execution = await store.getExecution(target);
+  if (execution.length > 0) {
+    return showExecution(execution, await store.getAggregationResults(target), await todays(execution[0].task));
+  }
+  const [latest] = await store.listExecutions(target);
+  if (latest) {
+    const { executionId } = latest;
+    const records = await store.getExecution(executionId);
+    return showExecution(records, await store.getAggregationResults(executionId), await todays(records[0].task), target);
+  }
+  throw new Error(`${target} is not a recorded container run, execution or test case`);
+}
+function createShowCommand() {
+  return new Command("show").description("Show a test case, an execution or a container run.").argument("<target>", "a container run's postrun tag, an execution ID, or a test case, meaning its latest execution").addOption(dataDirOption()).action(async (target, options) => {
+    console.log(await show3(target, { dataDir: options.dataDir }));
   });
 }
 
 // src/cli/program.ts
 function createProgram() {
-  return new Command().name("thunderjar").description(package_default.description).version(package_default.version).addCommand(createInitCommand()).addCommand(createGenerateCommand());
+  const program2 = new Command().name("thunderjar").description(package_default.description).version(package_default.version).showHelpAfterError().addCommand(createInitCommand()).addCommand(createGenerateCommand()).addCommand(createPlanCommand()).addCommand(createBuildCommand()).addCommand(createRunCommand()).addCommand(createExecutionsCommand()).addCommand(createShowCommand()).addCommand(createRemeasureCommand());
+  for (const command of program2.commands)
+    command.showHelpAfterError();
+  return program2;
 }
 
 // src/cli/index.ts
-await createProgram().parseAsync();
+try {
+  await createProgram().parseAsync();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 1;
+}