@schwabyio/gta 0.9.0

package/dist/gta.js

@@ -0,0 +1,1703 @@
+#!/usr/bin/env node
+import { createRequire as __gtaCreateRequire } from 'node:module';
+const require = __gtaCreateRequire(import.meta.url);
+import {
+  COLLECTIONS_DIR,
+  DOC_EXTENSION,
+  SETTINGS_FILE,
+  TagSchema,
+  __toESM,
+  allSkipped,
+  canonical,
+  discoverProject,
+  environmentNames,
+  external_exports,
+  flagOverrides,
+  isInside,
+  iterationName,
+  loadProjectCollections,
+  loadProjectTls,
+  parseMarkdown,
+  projectEnvironments,
+  readProject,
+  relativePosix,
+  require_dist,
+  resolveFlags,
+  samePath,
+  stepsForTags,
+  unattempted
+} from "./chunks/chunk-VRAFYQNE.js";
+
+// src/args.ts
+var UsageError = class extends Error {
+  name = "UsageError";
+};
+function parseArgs(argv) {
+  const parsed = {
+    command: null,
+    overrides: {},
+    help: false,
+    version: false,
+    json: false,
+    flags: []
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const word = argv[i];
+    if (word === "-h" || word === "--help") {
+      parsed.help = true;
+    } else if (word === "-v" || word === "--version") {
+      parsed.version = true;
+    } else if (word === "--json") {
+      parsed.json = true;
+    } else if (word === "--flag" || word.startsWith("--flag=")) {
+      const value = word === "--flag" ? argv[++i] : word.slice("--flag=".length);
+      if (value === void 0 || value.startsWith("--")) {
+        throw new UsageError("--flag needs name=value, such as --flag newCheckout=true");
+      }
+      parsed.flags.push(value);
+    } else if (word.startsWith("--")) {
+      const body = word.slice(2);
+      const equals = body.indexOf("=");
+      if (equals > 0) {
+        parsed.overrides[body.slice(0, equals)] = body.slice(equals + 1);
+      } else {
+        const next = argv[i + 1];
+        if (next !== void 0 && !next.startsWith("--")) {
+          parsed.overrides[body] = next;
+          i++;
+        } else {
+          parsed.overrides[body] = true;
+        }
+      }
+    } else if (word.startsWith("-") && word.length > 1) {
+      throw new UsageError(`Unknown option ${word}. Settings are given as --settingsKey value.`);
+    } else if (parsed.command === null) {
+      parsed.command = word;
+    } else {
+      throw new UsageError(
+        `Unexpected "${word}". To run several collections, separate them with commas: gta ${parsed.command},${word}`
+      );
+    }
+  }
+  return parsed;
+}
+
+// src/select.ts
+var idOf = (collection) => collection.name;
+var placeOf = (collection) => collection.relativePath.slice(0, -DOC_EXTENSION.length);
+var normalize = (selector) => {
+  const cleaned = selector.normalize("NFC").trim().replace(/\\/g, "/").replace(/^(\.\/)+/, "").replace(/^collections\//, "");
+  return {
+    name: cleaned.replace(/\/+$/, "").replace(/\.yml$/, ""),
+    directoryOnly: cleaned.endsWith("/")
+  };
+};
+function selectCollections(collections, request, options) {
+  const excluded = /* @__PURE__ */ new Set();
+  const inGroup = (group) => group.filter((c) => {
+    if (c.doc.exclude === true) excluded.add(c);
+    return c.doc.exclude !== true;
+  });
+  let chosen;
+  if (request.kind === "list") {
+    const unknown = [];
+    chosen = [];
+    for (const selector of request.selectors) {
+      const { name, directoryOnly } = normalize(selector);
+      const exact = directoryOnly ? void 0 : collections.find((c) => idOf(c) === name) ?? collections.find((c) => placeOf(c).normalize("NFC") === name);
+      const inDirectory = collections.filter((c) => c.directory?.normalize("NFC") === name);
+      const found = exact ? [exact] : inDirectory.length > 0 ? inGroup(inDirectory) : null;
+      if (found) chosen.push(...found.filter((c) => !chosen.includes(c)));
+      else unknown.push(selector);
+    }
+    if (unknown.length > 0) {
+      throw new UsageError(
+        `No collection or directory is called ${unknown.map((u) => `"${u}"`).join(", ")}. List them with: gta get`
+      );
+    }
+  } else {
+    chosen = inGroup(collections);
+  }
+  const targets = [];
+  let untagged = 0;
+  for (const collection of chosen) {
+    const id = idOf(collection);
+    if (collection.problems.length > 0) {
+      const broken = collection.problems.map((p) => p.message).join("; ");
+      targets.push({ id, collection, steps: null, broken });
+      continue;
+    }
+    const picked = stepsForTags(collection.doc, options.tags, options.notTags ?? []);
+    if (picked.length === 0 && (options.tags.length > 0 || (options.notTags ?? []).length > 0)) {
+      untagged++;
+      continue;
+    }
+    const all = picked.length === collection.doc.steps.length;
+    targets.push({ id, collection, steps: all ? null : picked, broken: null });
+  }
+  return {
+    targets,
+    // Named on its own, an excluded collection ran: it was not left out.
+    excluded: [...excluded].filter((c) => !chosen.includes(c)).map(idOf),
+    untagged
+  };
+}
+var stepCountOf = (target) => target.steps?.length ?? target.collection.doc.steps.length;
+
+// src/report.ts
+function paint(enabled) {
+  const wrap = (open, close) => (text) => enabled ? `\x1B[${open}m${text}\x1B[${close}m` : text;
+  return {
+    red: wrap(31, 39),
+    green: wrap(32, 39),
+    cyan: wrap(36, 39),
+    yellow: wrap(33, 39),
+    dim: wrap(2, 22),
+    bold: wrap(1, 22)
+  };
+}
+function colorWanted(stream, env) {
+  if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "0") return true;
+  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
+  return stream.isTTY === true;
+}
+function tally(target, outcome, durationMs) {
+  if (!outcome.ok) {
+    const total = stepCountOf(target);
+    return {
+      id: target.id,
+      passed: false,
+      durationMs,
+      steps: { total, passed: 0, failed: 0, errored: 0, skipped: total },
+      assertions: { total: 0, passed: 0, failed: 0 },
+      skipped: false,
+      error: outcome.message,
+      problems: []
+    };
+  }
+  const { summary: summary2 } = outcome;
+  const assertions = summary2.results.flatMap((r) => r.assertions);
+  const failed = assertions.filter((a) => a.status === "fail").length;
+  return {
+    id: target.id,
+    passed: summary2.failed === 0 && summary2.errored === 0,
+    durationMs,
+    steps: {
+      total: summary2.total,
+      passed: summary2.passed,
+      failed: summary2.failed,
+      errored: summary2.errored,
+      skipped: summary2.skipped
+    },
+    assertions: { total: assertions.length, passed: assertions.length - failed, failed },
+    skipped: allSkipped(summary2),
+    error: null,
+    // Named for the row they ran with, when a data file drove the collection.
+    problems: summary2.results.flatMap(
+      (r, i) => r.status === "fail" || r.status === "error" ? [{ ...r, item: { ...r.item, name: iterationName(r.item.name, outcome.steps[i]) } }] : []
+    )
+  };
+}
+var seconds = (ms) => `${(ms / 1e3).toFixed(3)}s`;
+var rule = (p, width = 100) => p.dim("\u2500".repeat(width));
+var field = (label, value, width = 14) => `${`${label}:`.padEnd(width)}${value}`;
+var NUMBER_COLUMNS = [
+  ["Time", 9],
+  ["Steps", 6],
+  ["Pass", 5],
+  ["Fail", 5],
+  ["Error", 6],
+  ["Skip", 5],
+  ["Asserts", 8],
+  ["Pass", 5],
+  ["Fail", 5]
+];
+var nameWidthFor = (ids) => Math.min(80, Math.max("Collection".length, ...ids.map((id) => id.length)));
+var tableWidth = (nameWidth) => 4 + 2 + nameWidth + 1 + NUMBER_COLUMNS.reduce((n, [, w]) => n + w + 1, 0) - 1 + 2 + "passed".length;
+function tableHeader(nameWidth, p) {
+  const cells = NUMBER_COLUMNS.map(([label, width]) => label.padStart(width));
+  return p.bold(`${"#".padStart(4)}  ${"Collection".padEnd(nameWidth)} ${cells.join(" ")}  Result`);
+}
+var nameCell = (id, width) => id.length > width ? `${id.slice(0, width - 1)}\u2026` : id.padEnd(width);
+function tableRow(n, t, nameWidth, p) {
+  const name = nameCell(t.id, nameWidth);
+  const values = [
+    seconds(t.durationMs),
+    t.steps.total,
+    t.steps.passed,
+    t.steps.failed,
+    t.steps.errored,
+    t.steps.skipped,
+    t.assertions.total,
+    t.assertions.passed,
+    t.assertions.failed
+  ];
+  const cells = values.map((value, i) => String(value).padStart(NUMBER_COLUMNS[i][1]));
+  const result = t.skipped ? p.cyan("skipped") : t.passed ? p.green("passed") : p.red("failed");
+  return `${String(n).padStart(4)}  ${name} ${cells.join(" ")}  ${result}`;
+}
+var clip = (text, max = 300) => text.length > max ? `${text.slice(0, max)}\u2026 (${text.length - max} more characters)` : text;
+function failureDetails(tallies, p) {
+  const lines = [];
+  for (const t of tallies) {
+    if (t.passed) continue;
+    lines.push(p.bold(t.id));
+    if (t.error) lines.push(`  ${p.red("\u2717")} ${t.error}`);
+    for (const result of t.problems) {
+      const where = result.use ? ` ${p.dim(`(${result.use.set} ${result.use.child + 1}/${result.use.of})`)}` : "";
+      const status = result.response ? ` ${p.dim(String(result.response.status))}` : "";
+      lines.push(`  ${p.red("\u2717")} ${result.item.name}${where}${status}`);
+      if (result.error) {
+        const { phase, script, line, message } = result.error;
+        const at = [script && `${script} script`, line && `line ${line}`].filter(Boolean).join(", ");
+        lines.push(`      ${p.red(`${phase} error${at ? ` (${at})` : ""}:`)} ${clip(message)}`);
+      }
+      for (const assertion of result.assertions) {
+        if (assertion.status !== "fail") continue;
+        const message = assertion.message ? `: ${assertion.message}` : "";
+        lines.push(`      ${assertion.name}${message}`);
+        if (assertion.expected !== void 0) {
+          lines.push(`        ${p.dim("expected")} ${clip(assertion.expected)}`);
+        }
+        if (assertion.actual !== void 0) {
+          lines.push(`        ${p.dim("actual  ")} ${clip(assertion.actual)}`);
+        }
+        if (assertion.unasserted?.length) {
+          lines.push(`        ${p.dim("not asserted")} ${clip(assertion.unasserted.join(", "))}`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function totalsOf(tallies) {
+  const sum = (pick) => tallies.reduce((n, t) => n + pick(t), 0);
+  return {
+    collections: {
+      total: tallies.length,
+      passed: tallies.filter((t) => t.passed).length,
+      failed: tallies.filter((t) => !t.passed).length
+    },
+    steps: {
+      total: sum((t) => t.steps.total),
+      passed: sum((t) => t.steps.passed),
+      failed: sum((t) => t.steps.failed),
+      errored: sum((t) => t.steps.errored),
+      skipped: sum((t) => t.steps.skipped)
+    },
+    assertions: {
+      total: sum((t) => t.assertions.total),
+      passed: sum((t) => t.assertions.passed),
+      failed: sum((t) => t.assertions.failed)
+    }
+  };
+}
+function summary(totals, durationMs, p) {
+  const { collections: c, steps: s, assertions: a } = totals;
+  const passed = c.failed === 0;
+  return [
+    field("Collections", `${c.total} total, ${c.passed} passed, ${c.failed} failed`),
+    field(
+      "Steps",
+      `${s.total} total, ${s.passed} passed, ${s.failed} failed, ${s.errored} errored, ${s.skipped} skipped`
+    ),
+    field("Assertions", `${a.total} total, ${a.passed} passed, ${a.failed} failed`),
+    field("Run time", seconds(durationMs)),
+    field("Result", passed ? p.green(p.bold("PASSED")) : p.red(p.bold("FAILED")))
+  ];
+}
+
+// src/main.ts
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+
+// src/pool.ts
+import { Worker } from "node:worker_threads";
+function workerRunner(workerUrl2, timeoutMs) {
+  return (job) => new Promise((resolve) => {
+    const worker = new Worker(workerUrl2, { workerData: job });
+    let settled = false;
+    const settle = (outcome) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(outcome);
+      void worker.terminate();
+    };
+    const timer = setTimeout(
+      () => settle({ ok: false, message: `Timed out after ${timeoutMs} ms (timeoutCollection)` }),
+      timeoutMs
+    );
+    worker.once("message", (outcome) => settle(outcome));
+    worker.once("error", (error) => settle({ ok: false, message: error.message }));
+    worker.once(
+      "exit",
+      (code) => settle({ ok: false, message: `The run stopped before it finished (exit code ${code})` })
+    );
+  });
+}
+async function runPool(items, limit, run2) {
+  let next = 0;
+  const lane = async () => {
+    while (next < items.length) await run2(items[next++]);
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, lane));
+}
+
+// src/html.ts
+var BODY_LIMIT = 256 * 1024;
+var SUMMARY_PAGE = "summary.html";
+function htmlReport(run2) {
+  return [
+    { path: SUMMARY_PAGE, html: summaryPage(run2) },
+    ...run2.collections.map((c) => ({ path: pageOf(c.id), html: collectionPage(run2, c) }))
+  ];
+}
+var pageOf = (id) => `${id}.html`;
+var flagList = (flags) => {
+  const entries = Object.entries(flags);
+  return entries.length > 0 ? entries.map(([name, value]) => `${name}=${value}`).join(", ") : "none";
+};
+function summaryPage(run2) {
+  const tallies = run2.collections.map((c) => c.tally);
+  const sum = (pick) => tallies.reduce((n, t) => n + pick(t), 0);
+  const failedCollections = tallies.filter((t) => !t.passed).length;
+  const passed = failedCollections === 0;
+  const settings = [
+    ["Project Name", run2.project],
+    ["Collection Timeout", `${run2.timeoutCollection} ms`],
+    ["Environment", run2.environment ?? "none"],
+    ["Concurrency Limit", String(run2.concurrency)],
+    ["Tags", run2.tags.length > 0 ? run2.tags.join(", ") : "none"],
+    ...run2.notTags?.length ? [["Not Tags", run2.notTags.join(", ")]] : [],
+    ["Excluded", run2.excluded.length > 0 ? run2.excluded.join(", ") : "none"],
+    ["Feature Flags", flagList(run2.flags ?? {})],
+    ...run2.flagCommand ? [["Flag Command", run2.flagCommand]] : [],
+    ...run2.bail ? [["Bail", "on"]] : [],
+    ...run2.untagged > 0 ? [
+      ["Left Out By Tags", `${run2.untagged} collection${run2.untagged === 1 ? "" : "s"}`]
+    ] : []
+  ];
+  const overview = run2.collections.map((c, i) => {
+    const t = c.tally;
+    const status = t.skipped ? "skipped" : t.passed ? "passed" : "failed";
+    const cells = [
+      seconds2(c.durationMs),
+      t.steps.total,
+      t.steps.passed,
+      t.steps.failed,
+      t.steps.errored,
+      t.steps.skipped,
+      t.assertions.total,
+      t.assertions.passed,
+      t.assertions.failed
+    ];
+    return `<tr class="${status}" data-search="${escape(c.id.toLowerCase())}"><td>${i + 1}</td><td class="name"><a href="${escape(encodeURI(pageOf(c.id)))}">${escape(c.id)}</a></td>${cells.map((v) => `<td>${v}</td>`).join("")}<td>${statusText(status)}</td></tr>`;
+  }).join("\n");
+  return page({
+    title: `${passed ? "PASSED" : "FAILED"} \xB7 ${run2.project} \xB7 gta Summary Results`,
+    run: run2,
+    body: `<h2 class="page-title">gta Summary Results</h2>
+
+<div class="card"><div class="card-header">Settings</div><div class="card-body"><div class="pairs">
+${settings.map(([label, value]) => field2(label, escape(value))).join("\n")}
+</div></div></div>
+
+<div class="card"><div class="card-header">Summary Stats</div><div class="card-body">
+${field2("Time of Run", escape(timeOfRun(run2.startedAt)))}
+${statsTable([
+      ["Total Collections", tallies.length],
+      ["Collections Passed", tallies.length - failedCollections],
+      ["Collections Failed", failedCollections],
+      ["Total Tests", sum((t) => t.steps.total)],
+      ["Tests Passed", sum((t) => t.steps.passed)],
+      ["Tests Failed", sum((t) => t.steps.failed)],
+      ["Tests Errored", sum((t) => t.steps.errored)],
+      ["Tests Skipped", sum((t) => t.steps.skipped)],
+      ["Total Assertions", sum((t) => t.assertions.total)],
+      ["Assertions Passed", sum((t) => t.assertions.passed)],
+      ["Assertions Failed", sum((t) => t.assertions.failed)],
+      ["Total Run Time", seconds2(run2.durationMs)],
+      ["Final Result", finalResult(passed)]
+    ])}
+</div></div>
+
+<div class="toolbar above">${searchBox("Search collections", "tr[data-search]")}<div class="buttons">${hideButtons(
+      tallies.some((t) => t.passed && !t.skipped),
+      failedCollections > 0,
+      tallies.some((t) => t.skipped)
+    )}</div></div>
+<div class="card"><div class="card-header">Results Overview</div><div class="card-body">
+<table class="overview">
+<tr><th>Collection #</th><th>Collection ID</th><th>Collection Run Time</th><th>Total Tests</th><th>Tests Passed</th><th>Tests Failed</th><th>Tests Errored</th><th>Tests Skipped</th><th>Total Assertions</th><th>Assertions Passed</th><th>Assertions Failed</th><th>Collection Result</th></tr>
+${overview}
+</table>
+</div></div>`
+  });
+}
+function collectionPage(run2, c) {
+  const t = c.tally;
+  const tests = !c.outcome.ok ? "" : [
+    ...c.outcome.summary.results.map(
+      (r, i) => testSection(r, i, c.outcome.ok ? c.outcome.steps[i] : void 0)
+    ),
+    unattempted(c.outcome.summary) > 0 ? notRunSection(unattempted(c.outcome.summary)) : ""
+  ].join("\n");
+  const statuses = c.outcome.ok ? c.outcome.summary.results.map(statusOf) : [];
+  return page({
+    title: `${t.skipped ? "SKIPPED" : t.passed ? "PASSED" : "FAILED"} \xB7 ${c.id} \xB7 gta Collection Results`,
+    run: run2,
+    body: `<h2 class="page-title">gta Collection Results</h2>
+
+<div class="card"><div class="card-header">Results Overview</div><div class="card-body">
+${field2("Collection ID", escape(c.id), "wide")}
+${c.docs?.trim() ? field2("Collection Docs", markdown(c.docs), "wide") : ""}
+${c.outcome.ok && c.outcome.data ? field2("Data File", escape(c.outcome.data.file), "wide") : ""}
+${c.outcome.ok && c.outcome.data ? field2("Iterations", String(c.outcome.data.rows)) : ""}
+${!c.outcome.ok ? field2("Error", `<pre class="c-failed">${escape(c.outcome.message)}</pre>`, "wide") : ""}
+${field2("Time of Run", escape(timeOfRun(c.startedAt)))}
+${statsTable([
+      ["Collection Run Time", seconds2(c.durationMs)],
+      ["Total Tests", t.steps.total],
+      ["Tests Passed", t.steps.passed],
+      ["Tests Failed", t.steps.failed],
+      ["Tests Errored", t.steps.errored],
+      ["Tests Skipped", t.steps.skipped],
+      ["Total Assertions", t.assertions.total],
+      ["Assertions Passed", t.assertions.passed],
+      ["Assertions Failed", t.assertions.failed],
+      ["Overall Result", t.skipped ? '<span class="c-skipped">SKIPPED</span>' : finalResult(t.passed)]
+    ])}
+</div></div>
+
+<div class="toolbar"><h3>Tests</h3>${statuses.length > 0 ? searchBox("Search steps", "details[data-search]") : ""}<div class="buttons">
+${hideButtons(
+      statuses.includes("passed"),
+      statuses.some((s) => s === "failed" || s === "errored"),
+      statuses.includes("skipped")
+    )}
+${statuses.length === 0 ? "" : (
+      // Says what a click does: expand while any test is closed, as passed ones start.
+      `<button type="button" class="btn" id="expand-all" onclick="expandAll()">${statuses.some((s) => s === "passed" || s === "skipped") ? "Expand All" : "Collapse All"}</button>`
+    )}
+<a class="btn" href="${SUMMARY_PAGE}">Summary</a>
+</div></div>
+<div class="tests">
+${tests || '<p class="dim">No tests were run.</p>'}
+</div>`
+  });
+}
+var statusOf = (r) => r.status === "pass" ? "passed" : r.status === "fail" ? "failed" : r.status === "error" ? "errored" : "skipped";
+function testSection(r, index, ref) {
+  const status = statusOf(r);
+  const named = escape(iterationName(r.item.name, ref));
+  const name = r.use ? `${named} <span class="dim">(${escape(r.use.set)} ${r.use.child + 1}/${r.use.of})</span>` : named;
+  if (r.skipped) {
+    return `<details class="acc skipped skipped" data-search="${escape(iterationName(r.item.name, ref).toLowerCase())}">
+<summary><span>Test ${index + 1}: ${name}</span>${icon("skipped")}</summary>
+<div class="acc-body">
+${card("Skipped", field2("Feature Flag", `<span class="c-skipped">${escape(r.skipped.reason)} \u2014 this test was not run</span>`, "wide"))}
+</div>
+</details>`;
+  }
+  const cards = [
+    r.error ? errorCard(r) : "",
+    requestCard(r),
+    responseCard(r),
+    assertionsCard(r.assertions),
+    r.logs?.length ? consoleCard(r) : ""
+  ].filter(Boolean);
+  const group = status === "passed" ? "passed" : status === "skipped" ? "skipped" : "failed";
+  const search = iterationName(r.item.name, ref).toLowerCase();
+  return `<details class="acc ${group} ${status}" data-search="${escape(search)}"${status === "passed" ? "" : " open"}>
+<summary><span>Test ${index + 1}: ${name}</span>${icon(status)}</summary>
+<div class="acc-body">
+${cards.join("\n")}
+</div>
+</details>`;
+}
+function notRunSection(count) {
+  return `<details class="acc skipped">
+<summary><span>${count} test${count === 1 ? "" : "s"} not run</span>${icon("skipped")}</summary>
+<div class="acc-body"><p class="c-skipped">The collection stopped at its first failure (bail), so ${count === 1 ? "this test was" : "these tests were"} not run.</p></div>
+</details>`;
+}
+function errorCard(r) {
+  const e = r.error;
+  const where = [e.script && `${e.script} script`, e.line && `line ${e.line}`].filter(Boolean).join(", ");
+  const detail = e.stack ? `
+
+${userFrames(e.stack)}` : "";
+  return card(
+    "Error",
+    field2(
+      `${capitalise(e.phase)} Error`,
+      `<pre class="c-failed">${escape(`${where ? `(${where}) ` : ""}${e.message}${detail}`)}</pre>`,
+      "wide"
+    )
+  );
+}
+function requestCard(r) {
+  const { request } = r;
+  return card(
+    "Request",
+    [
+      field2("Request Method", escape(request.method)),
+      field2("Request URL", escape(request.url || "\u2014"), "wide"),
+      request.headers.length > 0 ? field2("Request Headers", scrollPre(headerText(request.headers)), "wide") : "",
+      request.body ? field2("Request Body", scrollPre(clip2(request.body)), "wide") : ""
+    ].filter(Boolean).join("\n")
+  );
+}
+function responseCard(r) {
+  const res = r.response;
+  if (!res) {
+    return card(
+      "Response",
+      field2("Failure", '<span class="c-failed">No response was received.</span>', "wide")
+    );
+  }
+  const body = res.bodyKind === "json" ? prettyJson(res.body) : res.body;
+  const extra = [
+    `first byte ${Math.round(res.timings.ttfbMs)}ms`,
+    bytes(res.sizeBytes),
+    res.redirectCount > 0 ? `${res.redirectCount} redirect${res.redirectCount === 1 ? "" : "s"}` : ""
+  ].filter(Boolean);
+  return card(
+    "Response",
+    [
+      field2("Response Code", escape(`${res.status} ${res.statusText}`.trim())),
+      res.headers.length > 0 ? field2("Response Headers", scrollPre(headerText(res.headers)), "wide") : "",
+      body ? field2("Response Body", scrollPre(clip2(body)), "wide") : "",
+      field2(
+        "Response Time",
+        `${Math.round(res.timings.totalMs)}ms <span class="dim">\xB7 ${extra.join(" \xB7 ")}</span>`
+      )
+    ].filter(Boolean).join("\n")
+  );
+}
+function assertionsCard(assertions) {
+  const failed = assertions.filter((a) => a.status === "fail").length;
+  const counts = statsTable(
+    [
+      ["Total Assertions", assertions.length],
+      ["Assertions Passed", assertions.length - failed],
+      ["Assertions Failed", failed]
+    ],
+    "small"
+  );
+  if (assertions.length === 0) return card("Assertions", counts);
+  const list2 = assertions.map((a) => {
+    const failing = a.status === "fail";
+    const extra = [
+      a.message ? `<div class="c-failed">${escape(a.message)}</div>` : "",
+      failing && a.expected !== void 0 ? `<div class="ea"><span class="dim">expected</span> <code>${escape(a.expected)}</code></div>` : "",
+      failing && a.actual !== void 0 ? `<div class="ea"><span class="dim">actual</span> <code>${escape(a.actual)}</code></div>` : "",
+      a.unasserted?.length ? `<div class="ea"><span class="dim">not asserted</span> <code>${escape(a.unasserted.join(", "))}</code></div>` : ""
+    ].join("");
+    const result = failing ? '<span class="c-failed">FAILED</span>' : '<span class="c-passed">PASSED</span>';
+    return `<div class="detail-row"><div>${escape(a.name)}${extra}</div>${result}</div>`;
+  }).join("\n");
+  return card(
+    "Assertions",
+    `${counts}
+<div class="card inner"><div class="card-header"><div class="detail-row head"><span>Detail</span><span>Result</span></div></div><div class="card-body">
+${list2}
+</div></div>`
+  );
+}
+function consoleCard(r) {
+  const lines = r.logs.map(
+    (l) => `<span class="log-${l.level}">[${escape(l.phase)} ${l.level}] ${escape(l.message)}</span>`
+  );
+  return card("Console", `<pre class="console">${lines.join("\n")}</pre>`);
+}
+function page(options) {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${escape(options.title)}</title>
+<style>${STYLE}</style>
+<script>${SCRIPT}</script>
+</head>
+<body>
+<div class="container">
+${options.body}
+</div>
+<footer class="container">
+<span class="btn static">gta Version ${escape(options.run.version)}</span>
+<div class="dim small-print">Run in ${escape(options.run.root)}</div>
+</footer>
+</body>
+</html>
+`;
+}
+var card = (title, body) => `<div class="card"><div class="card-header">${title}</div><div class="card-body">
+${body}
+</div></div>`;
+var field2 = (label, valueHtml, width = "fit") => `<div class="field"><div class="label">${escape(label)}</div><div class="value ${width}">${valueHtml}</div></div>`;
+function statsTable(cells, size = "") {
+  return `<table class="stats${size ? ` ${size}` : ""}"><tr>${cells.map(([label]) => `<td>${escape(label)}</td>`).join("")}</tr><tr>${cells.map(([, value]) => `<td>${value}</td>`).join("")}</tr></table>`;
+}
+var finalResult = (passed) => passed ? '<span class="c-passed">PASSED</span>' : '<span class="c-failed">FAILED</span>';
+var statusText = (status) => `<span class="c-${status}">${status}</span>`;
+var ICONS = { passed: "\u2713", failed: "!", errored: "!", skipped: "\u2013" };
+var icon = (status) => `<span class="icon ${status}" role="img" aria-label="${status}">${ICONS[status]}</span>`;
+var searchBox = (label, target) => `<input type="search" class="search" placeholder="${label}" aria-label="${label}" data-target="${escape(target)}" oninput="search(this)">`;
+var hideButtons = (anyPassed, anyFailed, anySkipped = false) => [
+  anyPassed ? `<button type="button" class="btn" onclick="toggle(this,'passed','Passed')">Hide Passed</button>` : "",
+  anyFailed ? `<button type="button" class="btn" onclick="toggle(this,'failed','Failed')">Hide Failed</button>` : "",
+  anySkipped ? `<button type="button" class="btn" onclick="toggle(this,'skipped','Skipped')">Hide Skipped</button>` : ""
+].join("");
+var headerText = (headers) => headers.map((h) => `${h.name}: ${h.value}`).join("\n");
+var scrollPre = (text) => `<div class="scroll"><pre>${escape(text)}</pre></div>`;
+function clip2(text) {
+  return text.length > BODY_LIMIT ? `${text.slice(0, BODY_LIMIT)}
+\u2026 ${bytes(text.length - BODY_LIMIT)} more not shown` : text;
+}
+function prettyJson(text) {
+  try {
+    return JSON.stringify(JSON.parse(text), null, 2);
+  } catch {
+    return text;
+  }
+}
+var userFrames = (stack) => stack.split("\n").filter((line) => !/^\s+at .*(\bnode:|file:\/\/)/.test(line)).join("\n");
+var capitalise = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+var seconds2 = (ms) => `${(ms / 1e3).toFixed(3)}s`;
+var timeOfRun = (epochMs) => new Date(epochMs).toLocaleString("en-US", {
+  weekday: "short",
+  month: "long",
+  day: "2-digit",
+  year: "numeric",
+  hour: "numeric",
+  minute: "2-digit",
+  second: "2-digit",
+  timeZoneName: "long"
+});
+function bytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  return `${(n / 1024 / 1024).toFixed(1)} MB`;
+}
+function escape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function markdown(source) {
+  return `<div class="md">${parseMarkdown(source).map(mdBlock).join("")}</div>`;
+}
+function mdBlock(block) {
+  switch (block.type) {
+    case "code":
+      return `<pre class="md-code">${escape(block.text)}</pre>`;
+    case "heading": {
+      const level = Math.min(block.level + 3, 6);
+      return `<h${level} class="md-h">${mdInline(block.content)}</h${level}>`;
+    }
+    case "rule":
+      return '<hr class="md-hr">';
+    case "table":
+      return `<table class="md-table"><thead><tr>${block.header.map((cell) => `<th>${mdInline(cell)}</th>`).join("")}</tr></thead><tbody>${block.rows.map((row) => `<tr>${row.map((cell) => `<td>${mdInline(cell)}</td>`).join("")}</tr>`).join("")}</tbody></table>`;
+    case "quote":
+      return `<blockquote class="md-quote">${block.blocks.map(mdBlock).join("")}</blockquote>`;
+    case "list": {
+      const tag = block.ordered ? "ol" : "ul";
+      return `<${tag} class="md-list">${block.items.map(
+        (item) => `<li>${mdInline(item.content)}${item.children ? mdBlock(item.children) : ""}</li>`
+      ).join("")}</${tag}>`;
+    }
+    case "paragraph":
+      return `<p class="md-p">${mdInline(block.content)}</p>`;
+  }
+}
+function mdInline(nodes) {
+  return nodes.map((node) => {
+    switch (node.type) {
+      case "text":
+        return escape(node.text);
+      case "code":
+        return `<code class="md-inline-code">${escape(node.text)}</code>`;
+      case "strong":
+        return `<strong>${mdInline(node.children)}</strong>`;
+      case "em":
+        return `<em>${mdInline(node.children)}</em>`;
+      case "link":
+        return `<a href="${escape(node.href)}" target="_blank" rel="noreferrer noopener">${escape(node.label)}</a>`;
+    }
+  }).join("");
+}
+var STYLE = `
+:root{color-scheme:light dark;--bg:#f8f9fa;--card:#fff;--head:#eef0f3;--border:#dee2e6;--text:#212529;--dim:#6c757d;--passed:#198754;--failed:#d0104c;--errored:#b86e00;--skipped:#0f86b6;--open:#e3e8f0;--link:#0d6efd;--btn:#6c757d;--icon-text:#fff;--mono:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}
+@media (prefers-color-scheme:dark){:root{--bg:#212529;--card:#212529;--head:#2b3035;--border:#495057;--text:#dee2e6;--dim:#adb5bd;--passed:#87EA67;--failed:#F50F55;--errored:#F5A623;--skipped:#4FC3E8;--open:#393D47;--link:#6ea8fe;--btn:#adb5bd;--icon-text:#212529}}
+*{box-sizing:border-box}
+body{margin:0;background:var(--bg);color:var(--text);font:16px/1.5 system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue",sans-serif;padding:48px 0 32px}
+.container{max-width:1320px;margin:0 auto;padding:0 12px}
+.page-title{text-align:center;font-weight:500;font-size:2rem;margin:0 0 32px}
+.card{border:1px solid var(--border);border-radius:6px;margin-bottom:24px;background:var(--card)}
+.card-header{padding:8px 16px;background:var(--head);border-bottom:1px solid var(--border);border-radius:6px 6px 0 0}
+.card-body{padding:16px}
+.card.inner{margin:16px 0 0}
+.acc-body .card{margin-bottom:16px}
+.pairs{display:grid;grid-template-columns:1fr 1fr;gap:0 24px}
+@media (max-width:800px){.pairs{grid-template-columns:1fr}}
+.field{display:flex;gap:12px;margin-bottom:16px;align-items:flex-start;min-width:0}
+.label{flex:0 0 190px}
+.value{border:1px solid var(--border);border-radius:6px;padding:0 8px;min-width:0;overflow-wrap:anywhere}
+.value.wide{flex:1}
+.value pre{margin:0;padding:4px 0}
+.md{padding:6px 0}
+.md>*:first-child{margin-top:0}.md>*:last-child{margin-bottom:0}
+.md-p{margin:0 0 8px}
+.md-h{margin:12px 0 6px;font-size:1rem;font-weight:600}
+.md-list{margin:0 0 8px;padding-left:24px}
+.md-list .md-list{margin:2px 0 0}
+.md-code{margin:0 0 8px;padding:8px 10px;background:var(--head);border-radius:4px}
+.md-inline-code{background:var(--head);padding:1px 4px;border-radius:3px;font-size:13px}
+.md-quote{margin:0 0 8px;padding-left:12px;border-left:3px solid var(--border);color:var(--dim)}
+.md-hr{border:none;border-top:1px solid var(--border);margin:10px 0}
+.md-table{border-collapse:collapse;margin:0 0 8px}
+.md-table th,.md-table td{border:1px solid var(--border);padding:4px 8px;text-align:left}
+.md-table th{background:var(--head)}
+.scroll{max-height:200px;overflow:auto}
+pre{margin:0;font-family:var(--mono);font-size:14px;white-space:pre-wrap;word-break:break-word}
+code{font-family:var(--mono);font-size:14px}
+.stats{width:100%;border-collapse:collapse;text-align:center;border:1px solid var(--border);font-variant-numeric:tabular-nums}
+.stats td{padding:8px}
+.stats tr:first-child td{background:var(--head)}
+.stats tr+tr td{border-top:1px solid var(--border)}
+.stats.small{width:50%;margin:0 auto}
+@media (max-width:800px){.stats.small{width:100%}}
+.overview{width:100%;border-collapse:collapse;font-variant-numeric:tabular-nums}
+.overview th,.overview td{border:1px solid var(--border);padding:8px;text-align:left;vertical-align:top}
+.overview th{background:var(--head);font-weight:600}
+.overview td.name{word-break:break-word}
+a{color:var(--link)}
+.dim{color:var(--dim)}
+.c-passed{color:var(--passed)}.c-failed{color:var(--failed)}.c-errored{color:var(--errored)}.c-skipped{color:var(--skipped)}
+.toolbar{display:flex;justify-content:space-between;align-items:center;gap:12px;flex-wrap:wrap;margin:40px 0 8px}
+.toolbar h3{margin:0;font-weight:500;font-size:1.75rem}
+.buttons{display:flex;gap:6px;justify-content:flex-end;flex-wrap:wrap}
+.toolbar.above{margin:40px 0 8px}
+.search{flex:1;min-width:200px;max-width:480px;font:inherit;padding:6px 12px;border:1px solid var(--btn);border-radius:6px;background:var(--card);color:var(--text)}
+.toolbar h3+.search{margin-left:16px}
+.toolbar .buttons{margin-left:auto}
+.unmatched{display:none}
+.btn{font:inherit;color:var(--btn);background:none;border:1px solid var(--btn);border-radius:6px;padding:6px 12px;cursor:pointer;text-decoration:none;display:inline-block}
+.btn:hover{background:var(--btn);color:var(--bg)}
+.btn.static{cursor:default}
+.btn.static:hover{background:none;color:var(--btn)}
+.hidden{display:none}
+.tests details.acc{border:1px solid var(--border);border-top:none;background:var(--card)}
+.tests details.acc:first-child{border-top:1px solid var(--border);border-radius:6px 6px 0 0}
+.tests details.acc:last-child{border-radius:0 0 6px 6px}
+.tests details.acc:only-child{border-radius:6px}
+details.acc>summary{list-style:none;cursor:pointer;padding:16px 20px;display:flex;align-items:center;justify-content:space-between;gap:12px}
+details.acc>summary::-webkit-details-marker{display:none}
+details.acc[open]>summary{background:var(--open)}
+.icon{flex:none;width:18px;height:18px;border-radius:3px;display:inline-grid;place-items:center;font-size:12px;font-weight:800;color:var(--icon-text)}
+.icon.passed{background:var(--passed)}.icon.failed{background:var(--failed)}.icon.errored{background:var(--errored)}.icon.skipped{background:var(--skipped)}
+.acc-body{padding:16px 20px}
+.detail-row{display:flex;justify-content:space-between;gap:16px;padding:6px 0}
+.detail-row+.detail-row{border-top:1px solid var(--border)}
+.detail-row.head{padding:0}
+.ea{font-size:14px;margin-top:2px}
+.console .log-warn{color:var(--errored)}.console .log-error{color:var(--failed)}
+footer.container{text-align:center;margin:48px auto 0}
+.small-print{margin-top:8px;font-size:12px;overflow-wrap:anywhere}
+`;
+var SCRIPT = `
+function toggle(button, status, noun) {
+  const hide = button.dataset.hidden !== 'true'
+  button.dataset.hidden = String(hide)
+  button.textContent = (hide ? 'Show ' : 'Hide ') + noun
+  for (const el of document.querySelectorAll('tr.' + status + ', details.acc.' + status)) el.classList.toggle('hidden', hide)
+}
+// The button says what a click will do: Expand All while any test is closed,
+// Collapse All once every one is open \u2014 however they got that way.
+const tests = () => [...document.querySelectorAll('details.acc')]
+function syncExpandAll() {
+  const button = document.getElementById('expand-all')
+  if (button) button.textContent = tests().some((d) => !d.open) ? 'Expand All' : 'Collapse All'
+}
+function search(input) {
+  const query = input.value.trim().toLowerCase()
+  for (const el of document.querySelectorAll(input.dataset.target)) {
+    el.classList.toggle('unmatched', query !== '' && !el.dataset.search.includes(query))
+  }
+}
+function expandAll() {
+  const open = tests().some((d) => !d.open)
+  for (const d of tests()) d.open = open
+  syncExpandAll()
+}
+document.addEventListener('DOMContentLoaded', () => {
+  for (const d of tests()) d.addEventListener('toggle', syncExpandAll)
+  syncExpandAll()
+})
+`;
+
+// src/junit.ts
+import os from "node:os";
+function junitReport(run2) {
+  const suites = run2.collections.map(
+    (collection) => suite(collection, run2.environment, run2.flags ?? {})
+  );
+  const total = suites.reduce(
+    (sum, s) => ({
+      tests: sum.tests + s.counts.tests,
+      failures: sum.failures + s.counts.failures,
+      errors: sum.errors + s.counts.errors,
+      skipped: sum.skipped + s.counts.skipped
+    }),
+    { tests: 0, failures: 0, errors: 0, skipped: 0 }
+  );
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    `<testsuites${attributes({
+      name: `gta: ${run2.project}`,
+      ...total,
+      time: seconds3(run2.durationMs),
+      timestamp: timestamp(run2.startedAt)
+    })}>`,
+    ...suites.flatMap((s) => s.lines),
+    "</testsuites>",
+    ""
+  ].join("\n");
+}
+function suite(collection, environment, flags) {
+  const cases = [];
+  const counts = { tests: 0, failures: 0, errors: 0, skipped: 0 };
+  const { outcome, id } = collection;
+  if (!outcome.ok) {
+    counts.tests = 1;
+    counts.errors = 1;
+    cases.push(
+      testcase(id, "(collection)", 0, [
+        `<error${attributes({ message: outcome.message, type: "collection" })}>${escape2(outcome.message)}</error>`
+      ])
+    );
+  } else {
+    for (const [i, result] of outcome.summary.results.entries()) {
+      counts.tests++;
+      const body = [];
+      if (result.status === "error") {
+        counts.errors++;
+        const { phase, message, stack } = result.error ?? {
+          phase: "http",
+          message: "no response",
+          stack: void 0
+        };
+        body.push(
+          `<error${attributes({ message: `${phase} error: ${message}`, type: phase })}>${escape2(userFrames2(stack) ?? message)}</error>`
+        );
+      } else if (result.status === "fail") {
+        counts.failures++;
+        const failed = result.assertions.filter((a) => a.status === "fail");
+        body.push(
+          `<failure${attributes({
+            message: failed.map(summarize).join("; "),
+            type: "assertion"
+          })}>${escape2(failed.map(describe).join("\n\n"))}</failure>`
+        );
+      } else if (result.status === "skipped") {
+        counts.skipped++;
+        body.push(
+          result.skipped ? `<skipped${attributes({ message: result.skipped.reason })}/>` : "<skipped/>"
+        );
+      }
+      if (result.logs?.length) {
+        const logged = result.logs.map((log) => `[${log.phase} ${log.level}] ${log.message}`);
+        body.push(`<system-out>${escape2(logged.join("\n"))}</system-out>`);
+      }
+      cases.push(
+        testcase(id, iterationName(caseName(result), outcome.steps[i]), result.durationMs, body)
+      );
+    }
+    const unrun = unattempted(outcome.summary);
+    if (unrun > 0) {
+      counts.tests++;
+      counts.skipped++;
+      const message = `${unrun} step${unrun === 1 ? "" : "s"} not run: the collection stopped at its first failure (bail)`;
+      cases.push(testcase(id, "(not run)", 0, [`<skipped${attributes({ message })}/>`]));
+    }
+  }
+  return {
+    counts,
+    lines: [
+      `  <testsuite${attributes({
+        name: id,
+        ...counts,
+        time: seconds3(collection.durationMs),
+        timestamp: timestamp(collection.startedAt),
+        hostname: os.hostname()
+      })}>`,
+      "    <properties>",
+      `      <property${attributes({ name: "environment", value: environment ?? "" })}/>`,
+      ...Object.entries(flags).map(
+        ([name, value]) => `      <property${attributes({ name: `flag.${name}`, value: String(value) })}/>`
+      ),
+      "    </properties>",
+      ...cases.flat(),
+      "  </testsuite>"
+    ]
+  };
+}
+function testcase(classname, name, durationMs, body) {
+  const open = `    <testcase${attributes({ name, classname, time: seconds3(durationMs) })}`;
+  if (body.length === 0) return [`${open}/>`];
+  return [`${open}>`, ...body.map((line) => `      ${line}`), "    </testcase>"];
+}
+var caseName = (result) => result.use ? `${result.item.name} [${result.use.set} ${result.use.child + 1}/${result.use.of}]` : result.item.name;
+var summarize = (a) => a.message ? `${a.name}: ${a.message}` : a.name;
+function describe(a) {
+  const lines = [summarize(a)];
+  if (a.expected !== void 0) lines.push(`  expected: ${a.expected}`);
+  if (a.actual !== void 0) lines.push(`  actual:   ${a.actual}`);
+  if (a.unasserted?.length) lines.push(`  not asserted: ${a.unasserted.join(", ")}`);
+  return lines.join("\n");
+}
+var userFrames2 = (stack) => stack?.split("\n").filter((line) => !/^\s+at .*(\bnode:|file:\/\/)/.test(line)).join("\n");
+var seconds3 = (ms) => (ms / 1e3).toFixed(3);
+var timestamp = (epochMs) => new Date(epochMs).toISOString().slice(0, 19);
+function attributes(values) {
+  return Object.entries(values).map(([key, value]) => ` ${key}="${escapeAttribute(String(value))}"`).join("");
+}
+var escapeAttribute = (value) => escape2(value).replace(/"/g, "&quot;").replace(/\n/g, "&#10;").replace(/\r/g, "&#13;").replace(/\t/g, "&#9;");
+function escape2(value) {
+  let kept = "";
+  for (const char of value) if (allowedInXml(char.codePointAt(0))) kept += char;
+  return kept.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+var allowedInXml = (code) => code === 9 || code === 10 || code === 13 || code >= 32 && code <= 55295 || code >= 57344 && code <= 65533 || code >= 65536;
+
+// src/json.ts
+var JSON_FORMAT_VERSION = 1;
+var BODY_LIMIT2 = 256 * 1024;
+function jsonReport(run2, reports) {
+  const tallies = run2.collections.map((c) => c.tally);
+  const sum = (pick) => tallies.reduce((n, t) => n + pick(t), 0);
+  const failed = tallies.filter((t) => !t.passed).length;
+  return {
+    formatVersion: JSON_FORMAT_VERSION,
+    tool: { name: "gta", version: run2.version },
+    project: { name: run2.project, root: run2.root },
+    run: {
+      result: failed === 0 ? "passed" : "failed",
+      startedAt: new Date(run2.startedAt).toISOString(),
+      durationMs: Math.round(run2.durationMs),
+      environment: run2.environment,
+      /** The feature flag values the run used, where each came from, and the command run (SPEC.md §2.9). */
+      flags: {
+        values: run2.flags ?? {},
+        sources: run2.flagSources ?? {},
+        command: run2.flagCommand ?? null
+      },
+      settings: {
+        limitConcurrency: run2.concurrency,
+        timeoutCollection: run2.timeoutCollection,
+        bail: run2.bail,
+        tags: run2.tags,
+        notTags: run2.notTags ?? []
+      }
+    },
+    totals: {
+      collections: { total: tallies.length, passed: tallies.length - failed, failed },
+      steps: {
+        total: sum((t) => t.steps.total),
+        passed: sum((t) => t.steps.passed),
+        failed: sum((t) => t.steps.failed),
+        errored: sum((t) => t.steps.errored),
+        skipped: sum((t) => t.steps.skipped)
+      },
+      assertions: {
+        total: sum((t) => t.assertions.total),
+        passed: sum((t) => t.assertions.passed),
+        failed: sum((t) => t.assertions.failed)
+      }
+    },
+    leftOut: { excluded: run2.excluded, untagged: run2.untagged },
+    reports,
+    collections: run2.collections.map(collectionOf)
+  };
+}
+function collectionOf(c) {
+  const { outcome, tally: tally2 } = c;
+  return {
+    id: c.id,
+    file: c.file,
+    status: tally2.skipped ? "skipped" : tally2.passed ? "passed" : "failed",
+    startedAt: new Date(c.startedAt).toISOString(),
+    durationMs: Math.round(c.durationMs),
+    counts: { steps: tally2.steps, assertions: tally2.assertions },
+    /** Why it did not run at all, or null when it ran. */
+    error: outcome.ok ? null : outcome.message,
+    /** The data file that ran it once per row (SPEC.md §2.8), or null. */
+    dataFile: outcome.ok ? outcome.data : null,
+    /** Steps a bail left unrun. */
+    notRun: outcome.ok ? unattempted(outcome.summary) : tally2.steps.total,
+    steps: outcome.ok ? outcome.summary.results.map(
+      (result, i) => stepOf(result, outcome.steps[i] ?? { index: i, line: null })
+    ) : []
+  };
+}
+function stepOf(result, ref) {
+  const truncated = {};
+  const clip3 = (field3, text) => {
+    if (text === null || text.length <= BODY_LIMIT2) return text;
+    truncated[field3] = text.length;
+    return text.slice(0, BODY_LIMIT2);
+  };
+  const request = { ...result.request, body: clip3("request.body", result.request.body) };
+  const response = result.response ? { ...result.response, body: clip3("response.body", result.response.body) ?? "" } : null;
+  return {
+    /** The step's place in the file's `steps`, from 0, and its line, from 1. */
+    step: { index: ref.index, line: ref.line },
+    /** The data file row it ran with, from 1, or null without a data file. */
+    iteration: ref.iteration ?? null,
+    ...result,
+    request,
+    response,
+    /** Fields cut short, with their full length in characters. */
+    ...Object.keys(truncated).length > 0 ? { truncated } : {}
+  };
+}
+function jsonListing(options) {
+  return {
+    formatVersion: JSON_FORMAT_VERSION,
+    project: options.project,
+    environments: options.environments,
+    environmentType: options.environmentType,
+    flags: { values: options.flags.values, sources: options.flags.sources },
+    tags: options.tags,
+    notTags: options.notTags ?? [],
+    collections: options.targets.map((target) => ({
+      id: target.id,
+      file: fileOf(target.collection),
+      directory: target.collection.directory,
+      steps: target.steps ?? target.collection.doc.steps.map((_, i) => i),
+      stepCount: target.collection.doc.steps.length,
+      dataFile: target.collection.dataFile ? {
+        file: `collections/${target.collection.dataFile.relativePath}`,
+        rows: target.collection.dataFile.rows
+      } : null,
+      tags: target.collection.doc.tags ?? [],
+      broken: target.broken
+    })),
+    leftOut: { excluded: options.excluded, untagged: options.untagged }
+  };
+}
+var fileOf = (collection) => `collections/${collection.relativePath}`;
+var jsonError = (message, exitCode) => ({
+  formatVersion: JSON_FORMAT_VERSION,
+  error: { message, exitCode }
+});
+
+// src/settings.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+var import_yaml = __toESM(require_dist(), 1);
+var SETTING_KEYS = {
+  environmentType: {
+    kind: "string",
+    doc: "The environment to run against, by name: environments/<name>.yml (the global project\u2019s too). Unset: no environment."
+  },
+  limitConcurrency: {
+    kind: "integer",
+    doc: "How many collections run at once. Steps within a collection always run in order."
+  },
+  timeoutCollection: {
+    kind: "integer",
+    doc: "Milliseconds a collection may take before it is stopped and reported failed."
+  },
+  bail: {
+    kind: "boolean",
+    doc: "Stop a collection at its first failing step; the rest are reported skipped."
+  },
+  tags: {
+    kind: "list",
+    doc: "Run only what has one of these tags (SPEC.md \xA72.4). Empty: everything."
+  },
+  notTags: {
+    kind: "list",
+    doc: "Leave out what has one of these tags: a collection tagged so, or a step where steps carry tags."
+  },
+  generateJUnitResults: {
+    kind: "boolean",
+    doc: "Write a JUnit XML report of the run to <testResultsBasePath>/junit/junit.xml, for CI."
+  },
+  generateJsonResults: {
+    kind: "boolean",
+    doc: "Write the run as JSON to <testResultsBasePath>/json/results.json, for tools and agents."
+  },
+  generateHtmlResults: {
+    kind: "boolean",
+    doc: "Write an HTML report of the run: <testResultsBasePath>/html/summary.html and a page per collection."
+  },
+  autoOpenTestResultHtml: {
+    kind: "boolean",
+    doc: "Write the HTML report and open its summary in the browser when the run ends."
+  },
+  testResultsBasePath: {
+    kind: "string",
+    doc: "Where reports are written: relative to the project folder, or absolute."
+  }
+};
+var KEYS = Object.keys(SETTING_KEYS);
+var positiveInteger = external_exports.number().int().min(1);
+var SettingsSchema = external_exports.strictObject({
+  environmentType: external_exports.string().trim().min(1).nullable().default(null),
+  limitConcurrency: positiveInteger.default(1),
+  timeoutCollection: positiveInteger.default(36e5),
+  bail: external_exports.boolean().default(false),
+  tags: external_exports.array(TagSchema).default([]),
+  notTags: external_exports.array(TagSchema).default([]),
+  generateJUnitResults: external_exports.boolean().default(false),
+  generateJsonResults: external_exports.boolean().default(false),
+  generateHtmlResults: external_exports.boolean().default(false),
+  autoOpenTestResultHtml: external_exports.boolean().default(false),
+  testResultsBasePath: external_exports.string().trim().min(1).default("test-results")
+});
+var DEFAULT_SETTINGS = SettingsSchema.parse({});
+var SettingsError = class extends Error {
+  name = "SettingsError";
+};
+var envNameOf = (key) => `GTA_${key.replace(/[A-Z]/g, (c) => `_${c}`).toUpperCase()}`;
+async function loadSettings(options) {
+  const { root, overrides = {}, env = process.env } = options;
+  const file = path.join(root, SETTINGS_FILE);
+  let source;
+  try {
+    source = await fs.readFile(file, "utf8");
+  } catch {
+    throw new SettingsError(
+      `There is no ${SETTINGS_FILE} in ${root}.
+gta runs from a project folder: the one holding collections/ and ${SETTINGS_FILE}.
+A minimal ${SETTINGS_FILE}:
+
+  environmentType: demo
+  limitConcurrency: 4
+`
+    );
+  }
+  let fromFile;
+  try {
+    fromFile = (0, import_yaml.parse)(source) ?? {};
+  } catch (cause) {
+    throw new SettingsError(`${SETTINGS_FILE} will not parse: ${cause.message}`);
+  }
+  if (typeof fromFile !== "object" || fromFile === null || Array.isArray(fromFile)) {
+    throw new SettingsError(
+      `${SETTINGS_FILE} must be a map of settings, such as limitConcurrency: 4`
+    );
+  }
+  const origin = /* @__PURE__ */ new Map();
+  const merged = {};
+  for (const [key, value] of Object.entries(fromFile)) {
+    checkKey(key, SETTINGS_FILE);
+    merged[key] = value;
+    origin.set(key, SETTINGS_FILE);
+  }
+  for (const key of KEYS) {
+    const value = env[envNameOf(key)];
+    if (value === void 0 || value === "") continue;
+    merged[key] = coerce(key, value, envNameOf(key));
+    origin.set(key, envNameOf(key));
+  }
+  for (const [key, value] of Object.entries(overrides)) {
+    checkKey(key, `--${key}`);
+    merged[key] = coerce(key, value, `--${key}`);
+    origin.set(key, `--${key}`);
+  }
+  const result = SettingsSchema.safeParse(merged);
+  if (!result.success) {
+    const lines = result.error.issues.map((issue) => {
+      const key = String(issue.path[0] ?? "");
+      return `  ${key} (from ${origin.get(key) ?? SETTINGS_FILE}): ${issue.message}`;
+    });
+    throw new SettingsError(`Settings are not valid:
+${lines.join("\n")}`);
+  }
+  return result.data;
+}
+function checkKey(key, where) {
+  if (!Object.hasOwn(SETTING_KEYS, key)) {
+    throw new SettingsError(
+      `Unknown setting "${key}" (from ${where}). Settings are: ${KEYS.join(", ")}`
+    );
+  }
+}
+function coerce(key, value, where) {
+  const { kind } = SETTING_KEYS[key];
+  if (value === true) {
+    if (kind === "boolean") return true;
+    throw new SettingsError(`${where} needs a value`);
+  }
+  switch (kind) {
+    case "integer":
+      return /^\s*\d+\s*$/.test(value) ? Number(value) : value;
+    case "boolean":
+      return value === "true" ? true : value === "false" ? false : value;
+    case "list":
+      return value.split(",").map((item) => item.trim()).filter((item) => item !== "");
+    case "string":
+      return value;
+  }
+}
+
+// src/main.ts
+var VERSION = true ? "0.9.0" : "0.0.0-dev";
+var JUNIT_DIR = "junit";
+var JUNIT_FILE = "junit.xml";
+var HTML_DIR = "html";
+var JSON_DIR = "json";
+var JSON_FILE = "results.json";
+var EXIT = { passed: 0, failed: 1, unusable: 2 };
+var ProjectError = class extends Error {
+  name = "ProjectError";
+};
+async function main(argv, cli) {
+  let ctx = cli;
+  let p = paint(ctx.color);
+  let emit = null;
+  try {
+    const args = parseArgs(argv);
+    if (args.json && !args.help && !args.version && args.command !== null) {
+      emit = (value) => cli.out(JSON.stringify(value, null, 2));
+      ctx = { ...cli, out: () => {
+      }, color: false };
+      p = paint(false);
+    }
+    if (args.version) {
+      ctx.out(VERSION);
+      return EXIT.passed;
+    }
+    if (args.help || args.command === null || args.command === "help") {
+      ctx.out(usage(p));
+      return EXIT.passed;
+    }
+    const project = await openProject(ctx, args.overrides, args.flags);
+    for (const warning of project.warnings) ctx.err(p.yellow(`warning: ${warning}`));
+    const command = args.command;
+    if (command === "g" || command === "get") {
+      const selection = selectFor(project, { kind: "all" });
+      if (emit) {
+        emit(
+          jsonListing({
+            project: { name: project.name, root: project.root },
+            environments: project.environments,
+            environmentType: project.settings.environmentType,
+            flags: project.flags,
+            tags: project.settings.tags,
+            notTags: project.settings.notTags,
+            targets: selection.targets,
+            excluded: selection.excluded,
+            untagged: selection.untagged
+          })
+        );
+        return EXIT.passed;
+      }
+      return list(project, selection, ctx, p);
+    }
+    const request = command === "a" || command === "all" ? { kind: "all" } : { kind: "list", selectors: command.split(",").filter((s) => s.trim() !== "") };
+    return await run(project, selectFor(project, request), ctx, p, emit);
+  } catch (cause) {
+    if (cause instanceof UsageError || cause instanceof SettingsError || cause instanceof ProjectError) {
+      ctx.err(p.red(cause.message));
+      const json = emit ?? (argv.includes("--json") ? (v) => cli.out(JSON.stringify(v, null, 2)) : null);
+      json?.(jsonError(cause.message, EXIT.unusable));
+      return EXIT.unusable;
+    }
+    throw cause;
+  }
+}
+async function openProject(ctx, overrides, flagArgs = []) {
+  const root = await canonical(ctx.cwd);
+  if (!await isDirectory(path2.join(root, COLLECTIONS_DIR))) {
+    throw new ProjectError(
+      `There is no ${COLLECTIONS_DIR}/ in ${root}.
+gta runs from a project folder: the one holding ${COLLECTIONS_DIR}/ and ${SETTINGS_FILE}.`
+    );
+  }
+  const settings = await loadSettings({ root, overrides, env: ctx.env });
+  const info = await readProject(root);
+  const layout = await discoverProject(root);
+  const collections = await loadProjectCollections(root, layout.files);
+  const environments = environmentNames(await projectEnvironments(root, info.global));
+  if (settings.environmentType && !environments.includes(settings.environmentType)) {
+    throw new ProjectError(
+      `environmentType: there is no environment called "${settings.environmentType}". ` + (environments.length > 0 ? `This project has: ${environments.join(", ")}` : `This project has no environments/.`)
+    );
+  }
+  let flags;
+  try {
+    flags = await resolveFlags({
+      root,
+      environmentName: settings.environmentType,
+      overrides: flagOverrides(flagArgs, ctx.env),
+      env: { ...process.env, ...ctx.env }
+    });
+  } catch (cause) {
+    throw new ProjectError(cause.message);
+  }
+  const tls = await loadProjectTls(root, info);
+  if (tls.problems.length > 0) {
+    throw new ProjectError(
+      `A certificate in tls.ca cannot be used:
+` + tls.problems.map((problem) => `  ${problem.path}: ${problem.message}`).join("\n")
+    );
+  }
+  return {
+    root,
+    name: info.doc?.name ?? path2.basename(root),
+    settings,
+    flags,
+    collections,
+    environments,
+    caFiles: tls.files.map(
+      (file) => `${relativePosix(root, file.file)} (${file.certificates.map((c) => c.subject).join(", ")})`
+    ),
+    warnings: [...info.problems, ...layout.problems].map(
+      (problem) => problem.path ? `${problem.path}: ${problem.message}` : problem.message
+    )
+  };
+}
+var selectFor = (project, request) => selectCollections(project.collections, request, {
+  tags: project.settings.tags,
+  notTags: project.settings.notTags
+});
+function list(project, selection, ctx, p) {
+  const { settings } = project;
+  ctx.out(field("Project", `${project.name} ${p.dim(project.root)}`));
+  ctx.out(
+    field(
+      "Environments",
+      project.environments.length > 0 ? project.environments.map((name) => name === settings.environmentType ? p.bold(`${name} \u25C0`) : name).join(", ") : p.dim("none")
+    )
+  );
+  ctx.out(field("Flags", flagLine(project.flags, p)));
+  if (project.caFiles.length > 0) ctx.out(field("CA files", project.caFiles.join(", ")));
+  if (settings.tags.length > 0) ctx.out(field("Tags", settings.tags.join(", ")));
+  if (settings.notTags.length > 0) ctx.out(field("Not tags", settings.notTags.join(", ")));
+  ctx.out("");
+  const width = nameWidthFor(selection.targets.map((t) => t.id));
+  const dirWidth = Math.max(
+    "Directory".length,
+    ...selection.targets.map((t) => (t.collection.directory ?? "").length)
+  );
+  ctx.out(
+    p.bold(
+      `${"#".padStart(4)}  ${"Collection".padEnd(width)} ${"Steps".padStart(7)} ${"Rows".padStart(5)}  ${"Directory".padEnd(dirWidth)}  Tags`
+    )
+  );
+  selection.targets.forEach((target, i) => {
+    const { doc } = target.collection;
+    const count = target.broken ? "broken" : target.steps ? `${target.steps.length}/${doc.steps.length}` : String(doc.steps.length);
+    const steps2 = target.broken ? p.red(count.padStart(7)) : count.padStart(7);
+    const tags = [.../* @__PURE__ */ new Set([...doc.tags ?? [], ...doc.steps.flatMap((s) => s.tags ?? [])])];
+    const rows = target.collection.dataFile ? String(target.collection.dataFile.rows) : "";
+    ctx.out(
+      `${String(i + 1).padStart(4)}  ${nameCell(target.id, width)} ${steps2} ${rows.padStart(5)}  ${(target.collection.directory ?? "").padEnd(dirWidth)}  ${p.dim(tags.join(", "))}`
+    );
+  });
+  ctx.out("");
+  for (const target of selection.targets.filter((t) => t.broken)) {
+    ctx.out(`${p.red("broken")} ${target.id}: ${target.broken}`);
+  }
+  if (selection.excluded.length > 0) {
+    ctx.out(field("Excluded", `${selection.excluded.join(", ")} ${p.dim("(exclude: true)")}`));
+  }
+  if (selection.untagged > 0) {
+    ctx.out(field("By tags", `${selection.untagged} collection(s) left out by tags`));
+  }
+  const steps = selection.targets.reduce((n, t) => n + stepCountOf(t), 0);
+  ctx.out(field("Total", `${selection.targets.length} collections, ${steps} steps`));
+  return EXIT.passed;
+}
+async function run(project, selection, ctx, p, emit = null) {
+  const { settings } = project;
+  const width = nameWidthFor(selection.targets.map((t) => t.id));
+  const line = rule(p, tableWidth(width));
+  ctx.out(line);
+  ctx.out(p.bold(`gta ${VERSION}`));
+  ctx.out(line);
+  ctx.out(field("Project", `${project.name} ${p.dim(project.root)}`));
+  ctx.out(field("Environment", settings.environmentType ?? p.dim("none")));
+  ctx.out(field("Concurrency", String(settings.limitConcurrency)));
+  ctx.out(field("Flags", flagLine(project.flags, p)));
+  ctx.out(field("Timeout", `${settings.timeoutCollection} ms per collection`));
+  if (project.caFiles.length > 0) ctx.out(field("CA files", project.caFiles.join(", ")));
+  if (settings.tags.length > 0) ctx.out(field("Tags", settings.tags.join(", ")));
+  if (settings.notTags.length > 0) ctx.out(field("Not tags", settings.notTags.join(", ")));
+  if (settings.bail) ctx.out(field("Bail", "on: a collection stops at its first failing step"));
+  const reportNames = [
+    settings.generateJUnitResults ? `${JUNIT_DIR}/${JUNIT_FILE}` : "",
+    settings.generateJsonResults ? `${JSON_DIR}/${JSON_FILE}` : "",
+    wantsHtml(settings) ? `${HTML_DIR}/${SUMMARY_PAGE}` : ""
+  ].filter(Boolean);
+  if (reportNames.length > 0) {
+    ctx.out(
+      field("Reports", reportNames.map((n) => `${settings.testResultsBasePath}/${n}`).join(", "))
+    );
+  }
+  const leftOut = [
+    selection.excluded.length > 0 ? `${selection.excluded.length} excluded` : "",
+    selection.untagged > 0 ? `${selection.untagged} left out by tags` : ""
+  ].filter(Boolean);
+  ctx.out(
+    field(
+      "Collections",
+      `${selection.targets.length} to run${leftOut.length > 0 ? p.dim(` (${leftOut.join(", ")})`) : ""}`
+    )
+  );
+  ctx.out(line);
+  if (selection.targets.length === 0) {
+    ctx.err(p.red("Nothing to run: no collection matched."));
+    emit?.(jsonError("Nothing to run: no collection matched.", EXIT.failed));
+    return EXIT.failed;
+  }
+  ctx.out(tableHeader(width, p));
+  const base = settings.testResultsBasePath;
+  const reportsDir = path2.isAbsolute(base) ? path2.resolve(base) : path2.resolve(project.root, ...base.split(/[\\/]+/));
+  const htmlDir = path2.join(reportsDir, HTML_DIR);
+  const problem = await clearResults(reportsDir, project.root);
+  if (problem) {
+    ctx.err(p.red(problem));
+    emit?.(jsonError(problem, EXIT.unusable));
+    return EXIT.unusable;
+  }
+  const runner = ctx.runner(settings);
+  const tallies = [];
+  const finished = /* @__PURE__ */ new Map();
+  const startedAt = Date.now();
+  const started = performance.now();
+  await runPool(selection.targets, settings.limitConcurrency, async (target) => {
+    const collectionStartedAt = Date.now();
+    const collectionStarted = performance.now();
+    const outcome = target.broken ? { ok: false, message: target.broken } : await runner({
+      file: target.collection.path,
+      projectRoot: project.root,
+      environment: settings.environmentType,
+      steps: target.steps,
+      bail: settings.bail,
+      flags: project.flags.values
+    });
+    const collectionMs = performance.now() - collectionStarted;
+    const result = tally(target, outcome, collectionMs);
+    finished.set(target, {
+      id: target.id,
+      file: `${COLLECTIONS_DIR}/${target.collection.relativePath}`,
+      outcome,
+      startedAt: collectionStartedAt,
+      durationMs: collectionMs,
+      tally: result,
+      docs: target.collection.doc.docs
+    });
+    tallies.push(result);
+    ctx.out(tableRow(tallies.length, result, width, p));
+  });
+  const durationMs = performance.now() - started;
+  ctx.out(line);
+  const details = failureDetails(tallies, p);
+  if (details.length > 0) {
+    ctx.out(p.bold("Failures"));
+    ctx.out("");
+    for (const detail of details) ctx.out(detail);
+    ctx.out(line);
+  }
+  const totals = totalsOf(tallies);
+  for (const total of summary(totals, durationMs, p)) ctx.out(total);
+  const run2 = {
+    flags: project.flags.values,
+    flagSources: project.flags.sources,
+    flagCommand: project.flags.command?.command ?? null,
+    project: project.name,
+    root: project.root,
+    version: VERSION,
+    environment: settings.environmentType,
+    concurrency: settings.limitConcurrency,
+    timeoutCollection: settings.timeoutCollection,
+    tags: settings.tags,
+    notTags: settings.notTags,
+    bail: settings.bail,
+    excluded: selection.excluded,
+    untagged: selection.untagged,
+    startedAt,
+    durationMs,
+    // In the order selected, whichever finished first, so two reports compare.
+    collections: selection.targets.flatMap((target) => finished.get(target) ?? [])
+  };
+  const reports = [];
+  if (settings.generateJUnitResults) {
+    reports.push({
+      label: "JUnit",
+      dir: path2.join(reportsDir, JUNIT_DIR),
+      shown: JUNIT_FILE,
+      files: () => [{ path: JUNIT_FILE, text: junitReport(run2) }]
+    });
+  }
+  const paths = {
+    ...settings.generateJUnitResults ? { junit: path2.join(reportsDir, JUNIT_DIR, JUNIT_FILE) } : {},
+    ...wantsHtml(settings) ? { html: path2.join(htmlDir, SUMMARY_PAGE) } : {},
+    ...settings.generateJsonResults ? { json: path2.join(reportsDir, JSON_DIR, JSON_FILE) } : {}
+  };
+  if (settings.generateJsonResults) {
+    reports.push({
+      label: "JSON",
+      dir: path2.join(reportsDir, JSON_DIR),
+      shown: JSON_FILE,
+      files: () => [
+        { path: JSON_FILE, text: `${JSON.stringify(jsonReport(run2, paths), null, 2)}
+` }
+      ]
+    });
+  }
+  if (wantsHtml(settings)) {
+    reports.push({
+      label: "HTML",
+      dir: htmlDir,
+      shown: SUMMARY_PAGE,
+      files: () => htmlReport(run2).map((page2) => ({ path: page2.path, text: page2.html }))
+    });
+  }
+  let reportFailed = false;
+  for (const report of reports) {
+    const shown = path2.join(report.dir, report.shown);
+    try {
+      for (const file of report.files()) {
+        const target = path2.join(report.dir, ...file.path.split("/"));
+        await fs2.mkdir(path2.dirname(target), { recursive: true });
+        await fs2.writeFile(target, file.text);
+      }
+      ctx.out(field(report.label, shown));
+      if (report.label === "HTML" && settings.autoOpenTestResultHtml) ctx.open(shown);
+    } catch (cause) {
+      ctx.err(
+        p.red(`Could not write the ${report.label} report to ${shown}: ${cause.message}`)
+      );
+      reportFailed = true;
+    }
+  }
+  ctx.out(line);
+  emit?.(jsonReport(run2, paths));
+  if (reportFailed) return EXIT.unusable;
+  return totals.collections.failed === 0 ? EXIT.passed : EXIT.failed;
+}
+function usage(p) {
+  const settings = Object.keys(SETTING_KEYS).flatMap((key) => {
+    const fallback = DEFAULT_SETTINGS[key];
+    const shown = Array.isArray(fallback) ? fallback.length > 0 ? fallback.join(",") : "none" : String(fallback ?? "none");
+    return [
+      `    ${p.bold(`--${key}`)} ${p.dim(`(default ${shown}; ${envNameOf(key)})`)}`,
+      `        ${SETTING_KEYS[key].doc}`
+    ];
+  });
+  return [
+    `${p.bold("gta")} ${VERSION} \u2014 Gravity Test Automation`,
+    "",
+    `  ${p.bold("Usage:")} gta <command> [--settingsKey value]...`,
+    "",
+    "  Run from a project folder: the one holding collections/ and settings.yml.",
+    "",
+    `  ${p.bold("Commands:")}`,
+    "    g, get          List the collections `gta all` would run, without running them.",
+    "    a, all          Run every collection, less those with exclude: true.",
+    "    <list>          Run the collections and directories named, comma separated,",
+    "                    in that order: smoke,checkout/sessions,payments",
+    "                    A directory leaves out its excluded collections;",
+    "                    one named on its own runs.",
+    "                    A collection called all or get: give it as all.yml.",
+    "",
+    `  ${p.bold("Options:")}`,
+    "    --json          Print the results as JSON on stdout instead of the table; with",
+    "                    get, the collections it would run. Errors are JSON too.",
+    "    --flag name=value",
+    "                    Override a feature flag for this run; any number of them.",
+    "                    GTA_FLAG_<name>=value does the same from the environment.",
+    "",
+    `  ${p.bold("Settings")} (settings.yml, then GTA_* environment variables, then --flags):`,
+    ...settings,
+    "",
+    `  ${p.bold("Exit code:")} 0 passed, 1 failed, 2 could not run (or write a report).`
+  ].join("\n");
+}
+async function isDirectory(target) {
+  try {
+    return (await fs2.stat(target)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+var wantsHtml = (settings) => settings.generateHtmlResults || settings.autoOpenTestResultHtml;
+var RESULT_DIRS = {
+  [JUNIT_DIR]: (name) => name === JUNIT_FILE,
+  [HTML_DIR]: (name) => name.endsWith(".html"),
+  [JSON_DIR]: (name) => name === JSON_FILE
+};
+var SYSTEM_FILES = /* @__PURE__ */ new Set([".DS_Store", "Thumbs.db"]);
+async function clearResults(dir, projectRoot) {
+  if (samePath(dir, projectRoot) || isInside(dir, projectRoot)) {
+    return `testResultsBasePath is ${dir}, which holds the project: gta deletes its test results folder before each run, so point it at a folder of its own.`;
+  }
+  let entries;
+  try {
+    entries = await fs2.readdir(dir);
+  } catch {
+    return null;
+  }
+  const others = entries.filter((entry) => !(entry in RESULT_DIRS) && !SYSTEM_FILES.has(entry));
+  for (const [folder, ours] of Object.entries(RESULT_DIRS)) {
+    if (!entries.includes(folder)) continue;
+    const inside = await fs2.readdir(path2.join(dir, folder)).catch(() => []);
+    others.push(
+      ...inside.filter((name) => !ours(name) && !SYSTEM_FILES.has(name)).map((name) => `${folder}/${name}`)
+    );
+  }
+  if (others.length > 0) {
+    return `${dir} holds files gta did not write (${others.slice(0, 5).join(", ")}${others.length > 5 ? ", \u2026" : ""}), so it will not delete it before the run. Point testResultsBasePath somewhere else, or remove them.`;
+  }
+  try {
+    await fs2.rm(dir, { recursive: true, force: true });
+    return null;
+  } catch (cause) {
+    return `Could not delete ${dir} before the run: ${cause.message}`;
+  }
+}
+function flagLine(flags, p) {
+  const list2 = flagList(flags.values);
+  const overridden = Object.values(flags.sources).filter((s) => s === "override").length;
+  const notes = [
+    flags.command ? `from ${flags.command.command}` : "",
+    overridden > 0 ? `${overridden} overridden` : ""
+  ].filter(Boolean);
+  return notes.length > 0 ? `${list2} ${p.dim(`(${notes.join("; ")})`)}` : list2;
+}
+
+// src/open.ts
+import { spawn } from "node:child_process";
+function openFile(file) {
+  const [command, args] = process.platform === "darwin" ? ["open", [file]] : process.platform === "win32" ? ["explorer.exe", [file]] : ["xdg-open", [file]];
+  try {
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+// src/gta.ts
+var workerUrl = new URL("./worker.js", import.meta.url);
+process.exitCode = await main(process.argv.slice(2), {
+  cwd: process.cwd(),
+  env: process.env,
+  out: (line) => process.stdout.write(`${line}
+`),
+  err: (line) => process.stderr.write(`${line}
+`),
+  color: colorWanted(process.stdout, process.env),
+  runner: (settings) => workerRunner(workerUrl, settings.timeoutCollection),
+  open: openFile
+});