@schwabyio/ata 0.0.0-stage → 0.20.0

package/dist/ata.js

@@ -0,0 +1,1938 @@
+#!/usr/bin/env node
+import { createRequire as __ataCreateRequire } from 'node:module';
+const require = __ataCreateRequire(import.meta.url);
+import {
+  DEFAULT_SETTINGS,
+  DEFAULT_SOURCE,
+  ProjectError,
+  SETTING_KEYS,
+  SettingsError,
+  UsageError,
+  colorWanted,
+  envNameOf,
+  failureDetails,
+  field,
+  idOf,
+  isDirectory,
+  loadProject,
+  nameCell,
+  nameWidthFor,
+  paint,
+  parseArgs,
+  rule,
+  selectCollections,
+  stepCountOf,
+  summary,
+  tableHeader,
+  tableRow,
+  tableWidth,
+  tally,
+  totalsOf
+} from "./chunks/chunk-I3XKICH2.js";
+import {
+  CALLOUTS,
+  COLLECTIONS_DIR,
+  MARK_GLYPH,
+  PROJECT_FILE,
+  RULES_FILE,
+  RulesError,
+  TEARDOWN_AFTER_STOP_MS,
+  bodyAsObject,
+  buildChecks,
+  canonical,
+  checkedBody,
+  checkedDiffersFromRaw,
+  codeTokens,
+  formatPath,
+  isInside,
+  iterationName,
+  lintProject,
+  loadRules,
+  markCode,
+  markHeaders,
+  markInlineCode,
+  markLines,
+  markStatus,
+  markText,
+  parseMarkdown,
+  parsePath,
+  readProject,
+  referenceProblems,
+  resolvePath,
+  resultName,
+  ruleDoc,
+  ruleValueText,
+  samePath,
+  sortArraysBy,
+  toJsonLines,
+  unattempted,
+  waitText,
+  wireNote
+} from "./chunks/chunk-IY7FUPUW.js";
+
+// src/main.ts
+import fs from "node:fs/promises";
+import path2 from "node:path";
+
+// src/pool.ts
+import { Worker } from "node:worker_threads";
+var REPORT_MS = 5e3;
+function workerRunner(workerUrl2, timeoutMs) {
+  return (job) => new Promise((resolve) => {
+    const worker = new Worker(workerUrl2, { workerData: job });
+    const timedOut = `Timed out after ${timeoutMs} ms (timeoutCollection)`;
+    let late = false;
+    let settled = false;
+    let gone;
+    const settle = (outcome) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      clearTimeout(gone);
+      resolve(outcome);
+      void worker.terminate();
+    };
+    const timer = setTimeout(() => {
+      late = true;
+      worker.postMessage({ type: "timeout" });
+      gone = setTimeout(
+        () => settle({ ok: false, message: timedOut }),
+        TEARDOWN_AFTER_STOP_MS + REPORT_MS
+      );
+    }, timeoutMs);
+    worker.once(
+      "message",
+      (outcome) => settle(late ? timedOutAfter(timedOut, outcome) : 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})` })
+    );
+  });
+}
+function timedOutAfter(message, outcome) {
+  const teardown = outcome.ok ? outcome.summary.results.filter((r) => r.stage === "teardown") : [];
+  if (teardown.length === 0) return { ok: false, message };
+  const passed = teardown.filter((result) => result.status === "pass").length;
+  return {
+    ok: false,
+    message: `${message}. Teardown ran after it: ${passed} of ${teardown.length} passed.`
+  };
+}
+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/rules.ts
+import path from "node:path";
+
+// src/json.ts
+var JSON_FORMAT_VERSION = 1;
+var BODY_LIMIT = 256 * 1024;
+function jsonReport(run2, reports) {
+  const totals = totalsOf(run2.collections.map((c) => c.tally));
+  const failed = totals.collections.failed;
+  return {
+    formatVersion: JSON_FORMAT_VERSION,
+    tool: { name: "ata", 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,
+    leftOut: {
+      excluded: run2.excluded,
+      excludedSteps: run2.excludedSteps ?? [],
+      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 clip2 = (field2, text) => {
+    if (text === null || text.length <= BODY_LIMIT) return text;
+    truncated[field2] = text.length;
+    return text.slice(0, BODY_LIMIT);
+  };
+  const request = { ...result.request, body: clip2("request.body", result.request.body) };
+  const response = result.response ? { ...result.response, body: clip2("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,
+    settings: { values: options.settings.values, sources: options.settings.sources },
+    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,
+      excludedSteps: options.excludedSteps,
+      untagged: options.untagged
+    },
+    problems: options.problems
+  };
+}
+var fileOf = (collection) => `collections/${collection.relativePath}`;
+var jsonError = (message, exitCode) => ({
+  formatVersion: JSON_FORMAT_VERSION,
+  error: { message, exitCode }
+});
+
+// src/rules.ts
+async function openRules(root) {
+  const info = await readProject(root);
+  if (info.source === null && !await isDirectory(path.join(root, COLLECTIONS_DIR))) {
+    throw new ProjectError(
+      `There is no ${COLLECTIONS_DIR}/ or ${PROJECT_FILE} in ${root}.
+ata lint and ata rules run from a project folder, or a global project's.`
+    );
+  }
+  if (info.problems.length > 0) {
+    throw new ProjectError(
+      `${PROJECT_FILE} must be fixed first, to know which rules apply:
+` + info.problems.map((problem) => `  ${problem.message}`).join("\n")
+    );
+  }
+  return {
+    root,
+    name: info.doc?.name ?? path.basename(root),
+    uses: info.global?.uses ?? null,
+    global: info.global ? { root: info.global.root } : null,
+    loaded: await loadRules(root, info.global)
+  };
+}
+function rulesLine(project, p) {
+  if (project.loaded.files.length > 0) return field("Rules from", project.loaded.files.join(", "));
+  const where = project.uses ? `no ${RULES_FILE} here or in ${project.uses}` : `no ${RULES_FILE} here`;
+  return field("Rules", p.dim(`none: ${where}`));
+}
+var PADDED_VALUE = 32;
+async function rulesCommand(root, { out, emit, p }) {
+  const project = await openRules(root);
+  const { settings } = project.loaded;
+  if (emit) {
+    emit({
+      formatVersion: JSON_FORMAT_VERSION,
+      project: { name: project.name, root: project.root },
+      files: project.loaded.files,
+      rules: settings.map((setting) => ({ ...setting, doc: ruleDoc(setting.rule) })),
+      guides: project.loaded.guides
+    });
+    return;
+  }
+  out(field("Project", `${project.name} ${p.dim(project.root)}`));
+  out(rulesLine(project, p));
+  if (settings.length > 0) {
+    out("");
+    const ruleWidth = Math.max(...settings.map((s) => s.rule.length));
+    const widths = settings.map((s) => ruleValueText(s.value).length);
+    const valueWidth = Math.max(0, ...widths.filter((width) => width <= PADDED_VALUE));
+    for (const setting of settings) {
+      const value = ruleValueText(setting.value).padEnd(valueWidth);
+      out(
+        `${p.bold(setting.rule.padEnd(ruleWidth))}  ${setting.on ? value : p.dim(value)}  ${p.dim(setting.source)}`
+      );
+      out(`    ${ruleDoc(setting.rule)}`);
+    }
+  }
+  for (const guide of project.loaded.guides) {
+    out("");
+    out(`${p.bold("Guide")} ${p.dim(`(${guide.source})`)}`);
+    for (const line of guide.text.trimEnd().split("\n")) out(line === "" ? "" : `  ${line}`);
+  }
+}
+var plural = (n, one, many) => `${n} ${n === 1 ? one : many}`;
+function checkedLine(checked) {
+  return [
+    plural(checked.collections, "collection", "collections"),
+    plural(checked.requests, "reusable requests file", "reusable requests files"),
+    plural(checked.bases, "base collection", "base collections"),
+    plural(checked.endpoints, "endpoints file", "endpoints files")
+  ].join(", ");
+}
+function findingLine(finding, p) {
+  const place = finding.line === null ? finding.file : `${finding.file}:${finding.line}`;
+  if (finding.rule === null) return `${place}  ${p.red(finding.message)}`;
+  return `${place}  ${finding.message}  ${p.dim(`[${finding.rule} from ${finding.source}]`)}`;
+}
+async function lintCommand(root, { out, emit, p }) {
+  const project = await openRules(root);
+  const { loaded } = project;
+  const result = loaded.settings.some((setting) => setting.on) ? await lintProject(root, loaded, project.global) : { findings: [], checked: { collections: 0, requests: 0, bases: 0, endpoints: 0 } };
+  const found = result.findings.length > 0;
+  if (emit) {
+    emit({
+      formatVersion: JSON_FORMAT_VERSION,
+      project: { name: project.name, root: project.root },
+      files: loaded.files,
+      rules: loaded.rules,
+      checked: result.checked,
+      findings: result.findings
+    });
+    return found;
+  }
+  out(field("Project", `${project.name} ${p.dim(project.root)}`));
+  out(rulesLine(project, p));
+  const inEffect = loaded.settings.filter((setting) => setting.on).length;
+  if (inEffect === 0) {
+    out(p.dim("Nothing to check."));
+    return false;
+  }
+  out(field("In effect", `${plural(inEffect, "rule", "rules")} ${p.dim("(ata rules lists them)")}`));
+  out(field("Checked", checkedLine(result.checked)));
+  out("");
+  for (const finding of result.findings) out(findingLine(finding, p));
+  if (found) {
+    const files = new Set(result.findings.map((finding) => finding.file)).size;
+    out("");
+    out(
+      p.red(
+        `${plural(result.findings.length, "finding", "findings")} in ${plural(files, "file", "files")}`
+      )
+    );
+  } else {
+    out(p.green("No findings: every file follows the rules."));
+  }
+  return found;
+}
+
+// src/html.ts
+var BODY_LIMIT2 = 256 * 1024;
+var BINARY_LIMIT = 1024 * 1024;
+var REPO_URL = "https://github.com/schwabyio/accelerator";
+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";
+};
+var collectionStatus = (t) => t.skipped ? "skipped" : t.passed ? "passed" : "failed";
+function summaryPage(run2) {
+  const tallies = run2.collections.map((c) => c.tally);
+  const sum = (pick) => tallies.reduce((n, t) => n + pick(t), 0);
+  const statuses = tallies.map(collectionStatus);
+  const count = (status) => statuses.filter((s) => s === status).length;
+  const passed = count("failed") === 0;
+  const none = '<span class="dim">none</span>';
+  const leftOut = (n, word = "collection") => `<a href="#not-run">${plural2(n, word)} \u2193</a>`;
+  const excludedSteps = run2.excludedSteps ?? [];
+  const settings = [
+    ["Environment", run2.environment ? escape(run2.environment) : none],
+    ["Concurrency Limit", String(run2.concurrency)],
+    ["Collection Timeout", timeoutText(run2.timeoutCollection)],
+    ["Tags", run2.tags.length > 0 ? escape(run2.tags.join(", ")) : none],
+    ...run2.notTags?.length ? [["Not Tags", escape(run2.notTags.join(", "))]] : [],
+    ["Feature Flags", flagChips(run2.flags ?? {}) || none],
+    ...run2.flagCommand ? [["Flag Command", `<code>${escape(run2.flagCommand)}</code>`]] : [],
+    ...run2.bail ? [["Bail", "on"]] : [],
+    ["Excluded", run2.excluded.length > 0 ? leftOut(run2.excluded.length) : none],
+    ...excludedSteps.length > 0 ? [["Excluded Steps", leftOut(excludedSteps.length, "step")]] : [],
+    ...run2.untagged > 0 ? [["Left Out By Tags", leftOut(run2.untagged)]] : []
+  ];
+  const rows = run2.collections.map((c, i) => {
+    const t = c.tally;
+    const status = statuses[i];
+    return `<tr class="s-${status}" data-status="${status}" data-search="${escape(c.id.toLowerCase())}"><td class="r n">${i + 1}</td><td class="name"><a href="${escape(encodeURI(pageOf(c.id)))}" target="_blank" rel="noopener">${breakable(c.id)}</a></td><td class="r">${duration(c.durationMs)}</td><td class="r gs">${t.steps.total}</td><td class="r">${num(t.steps.passed)}</td><td class="r">${num(t.steps.failed, true)}</td><td class="r">${num(t.steps.errored, true)}</td><td class="r">${num(t.steps.skipped)}</td><td class="r gs">${t.assertions.total}</td><td class="r">${num(t.assertions.passed)}</td><td class="r">${num(t.assertions.failed, true)}</td><td class="gs">${pill(status)}</td></tr>`;
+  }).join("\n");
+  const notRun = run2.excluded.length > 0 || excludedSteps.length > 0 || run2.untagged > 0 ? card(
+    "Not Run",
+    [
+      run2.excluded.length > 0 ? `<h3 class="group-h">Excluded <span class="dim">\xB7 ${run2.excluded.length} \xB7 <code>exclude: true</code> in the collection file</span></h3>
+<ul class="excluded">${run2.excluded.map((id) => `<li>${escape(id)}</li>`).join("")}</ul>` : "",
+      excludedSteps.length > 0 ? `<h3 class="group-h">Excluded steps <span class="dim">\xB7 ${excludedSteps.length} \xB7 <code>exclude: true</code> on the step</span></h3>
+<ul class="excluded">${excludedSteps.map((step) => `<li>${escape(step.id)} \u203A ${escape(step.name)}</li>`).join("")}</ul>` : "",
+      run2.untagged > 0 ? `<h3 class="group-h">Left out by tags <span class="dim">\xB7 ${plural2(run2.untagged, "collection")}</span></h3>` : ""
+    ].join("\n"),
+    { id: "not-run" }
+  ) : "";
+  return page({
+    title: `${passed ? "PASSED" : "FAILED"} \xB7 ${run2.project} \xB7 ata Summary Results`,
+    run: run2,
+    body: `${pageHead(passed ? "passed" : "failed", `${escape(run2.project)} <span class="kind">\xB7 Summary Results</span>`, run2.startedAt)}
+
+${card("Settings", `<dl class="pairs">
+${settings.map(([label, value]) => `<div><dt>${label}</dt><dd>${value}</dd></div>`).join("\n")}
+</dl>`)}
+
+${card(
+      "Summary Stats",
+      `<div class="stats">
+${ringStat("Collections", [
+        ["passed", count("passed")],
+        ["failed", count("failed")],
+        ["skipped", count("skipped")]
+      ])}
+${ringStat("Tests", [
+        ["passed", sum((t) => t.steps.passed)],
+        ["failed", sum((t) => t.steps.failed)],
+        ["errored", sum((t) => t.steps.errored)],
+        ["skipped", sum((t) => t.steps.skipped)]
+      ])}
+${ringStat("Assertions", [
+        ["passed", sum((t) => t.assertions.passed)],
+        ["failed", sum((t) => t.assertions.failed)]
+      ])}
+${timeStat("Total Run Time", run2.durationMs)}
+</div>`
+    )}
+
+${card(
+      "Results Overview",
+      `<div class="scroll-x"><table class="overview">
+<thead><tr class="groups"><th colspan="3"></th><th colspan="5" class="gs">Tests</th><th colspan="3" class="gs">Assertions</th><th class="gs"></th></tr>
+<tr><th class="r">#</th><th>Collection ID</th><th class="r">Run Time</th><th class="r gs">Total</th><th class="r">Passed</th><th class="r">Failed</th><th class="r">Errored</th><th class="r">Skipped</th><th class="r gs">Total</th><th class="r">Passed</th><th class="r">Failed</th><th class="gs">Result</th></tr></thead>
+<tbody>
+${rows}
+</tbody></table></div>`,
+      {
+        flush: true,
+        // As a collection page's Tests: the search by the title, what to show at the far end.
+        tools: `${searchBox("Search collections")}<div class="tools-end">${chips({ passed: count("passed"), failed: count("failed"), skipped: count("skipped") })}</div>`
+      }
+    )}
+${notRun}`
+  });
+}
+function collectionPage(run2, c) {
+  const t = c.tally;
+  const status = collectionStatus(t);
+  const results = c.outcome.ok ? c.outcome.summary.results : [];
+  const tests = !c.outcome.ok ? "" : [
+    ...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 groups = results.map((r) => group(statusOf(r)));
+  const data = c.outcome.ok ? c.outcome.data : null;
+  return page({
+    title: `${status.toUpperCase()} \xB7 ${c.id} \xB7 ata Collection Results`,
+    run: run2,
+    body: `<nav class="crumbs"><a href="${SUMMARY_PAGE}">Summary</a><span aria-hidden="true">/</span><span>${escape(c.id)}</span></nav>
+${pageHead(status, escape(c.id), c.startedAt)}
+
+${card(
+      "Results Overview",
+      [
+        c.docs?.trim() ? markdown(c.docs) : "",
+        data ? `<dl class="pairs"><div><dt>Data File</dt><dd><code>${escape(data.file)}</code></dd></div><div><dt>Iterations</dt><dd>${thousands(data.rows)}</dd></div></dl>` : "",
+        !c.outcome.ok ? `<section class="sub problem"><h3>Error</h3><pre>${escape(c.outcome.message)}</pre></section>` : "",
+        `<div class="stats">
+${ringStat("Tests", [
+          ["passed", t.steps.passed],
+          ["failed", t.steps.failed],
+          ["errored", t.steps.errored],
+          ["skipped", t.steps.skipped]
+        ])}
+${ringStat("Assertions", [
+          ["passed", t.assertions.passed],
+          ["failed", t.assertions.failed]
+        ])}
+${timeStat("Total Run Time", c.durationMs)}
+</div>`
+      ].filter(Boolean).join("\n"),
+      { tools: `<code class="file">${escape(c.file)}</code>` }
+    )}
+
+<div class="toolbar"><h2>Tests</h2>${groups.length > 0 ? searchBox("Search tests") : ""}<div class="tools-end">${chips(
+      {
+        passed: groups.filter((g) => g === "passed").length,
+        failed: groups.filter((g) => g === "failed").length,
+        skipped: groups.filter((g) => g === "skipped").length
+      }
+    )}${groups.length === 0 ? "" : (
+      // Says what a click does: expand while any test is closed, as passed and skipped ones start.
+      `<button type="button" class="btn" id="expand-all">${groups.some((g) => g !== "failed") ? "Expand All" : "Collapse All"}</button>`
+    )}</div></div>
+<div class="tests">
+${tests || '<p class="dim empty">No tests were run.</p>'}
+</div>`
+  });
+}
+var statusOf = (r) => r.status === "pass" ? "passed" : r.status === "fail" ? "failed" : r.status === "error" ? "errored" : "skipped";
+var group = (status) => status === "errored" ? "failed" : status;
+function testSection(r, index, ref) {
+  const status = statusOf(r);
+  const named = iterationName(resultName(r), ref);
+  const name = r.use ? `${escape(named)} <span class="dim">(${escape(r.use.set)} ${r.use.child + 1}/${r.use.of})</span>` : escape(named);
+  const method = r.request.method.toUpperCase();
+  const res = r.response;
+  const waits = method === "WAIT";
+  const outcome = r.skipped ? '<span class="dim">skipped</span>' : waits ? !r.error ? `<span class="dim">waited ${duration(r.durationMs)}</span>` : r.error.code === "ABORTED" ? `<span class="c-failed">stopped after ${duration(r.durationMs)}</span>` : '<span class="c-failed">did not wait</span>' : res ? `${statusCode(res)}<span class="dim">${duration(res.timings.totalMs)}</span>` : r.error?.elapsedMs !== void 0 ? `<span class="c-failed">no response after ${duration(r.error.elapsedMs)}</span>` : '<span class="c-failed">no response</span>';
+  const id = `t${index + 1}`;
+  const body = r.skipped ? `<p class="skip-reason">${escape(r.skipped.reason)} \u2014 this test was not run</p>` : waits ? r.error ? errorSection(r) : `<p class="wait-note">Waited ${escape(waitedFor(r.request.url))} before the next step. Nothing was sent.</p>` : [
+    r.error ? errorSection(r) : "",
+    requestSection(r.request),
+    responseSection(r, id),
+    assertionsSection(r.assertions),
+    r.logs?.length ? consoleSection(r) : ""
+  ].filter(Boolean).join("\n");
+  return `<details class="test s-${status}" id="${id}" data-status="${group(status)}" data-search="${escape(named.toLowerCase())}"${status === "passed" || status === "skipped" ? "" : " open"}>
+<summary><span class="n">${index + 1}</span><span class="method ${methodClass(method)}">${escape(method)}</span><span class="name">${name}</span><span class="res">${outcome}${mark(status)}<span class="chev" aria-hidden="true">\u25B6</span></span></summary>
+<div class="test-body">
+${body}
+</div>
+</details>`;
+}
+function notRunSection(count) {
+  return `<details class="test s-skipped" data-status="skipped" data-search="">
+<summary><span class="n"></span><span class="name">${plural2(count, "test")} not run</span><span class="res">${mark("skipped")}<span class="chev" aria-hidden="true">\u25B6</span></span></summary>
+<div class="test-body"><p class="skip-reason">The collection stopped at its first failure (bail), so ${count === 1 ? "this test was" : "these tests were"} not run.</p></div>
+</details>`;
+}
+function errorSection(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 `<section class="sub problem"><h3>${escape(capitalise(e.phase))} Error</h3><pre>${escape(`${where ? `(${where}) ` : ""}${e.message}${detail}`)}</pre></section>`;
+}
+function rawRequest(request) {
+  const head = [`${request.method} ${request.url}`, ...request.headers.map(headerLine)].join("\n");
+  return request.body ? `${head}
+
+${request.body}` : head;
+}
+function rawResponse(response) {
+  const head = [
+    [response.httpVersion, response.status, response.statusText].filter(Boolean).join(" "),
+    ...response.headers.map(headerLine)
+  ].join("\n");
+  const body = response.bodyEncoding === "base64" ? `[binary body, ${bytes(response.sizeBytes)}]` : response.body;
+  return body ? `${head}
+
+${body}` : head;
+}
+var headerLine = (header) => `${header.name}: ${header.value}`;
+var exchange = (title, formatted, raw, rawNote, rawId = "") => `<section class="sub" data-switch data-exchange>
+<div class="sub-h"><h3>${title}</h3><span class="seg" role="group" aria-label="${title} view"><button type="button" data-show="formatted" aria-pressed="true">Formatted</button><button type="button" data-show="raw" aria-pressed="false">Raw</button></span></div>
+<div data-part="formatted">
+${formatted}
+</div>
+<div data-part="raw" hidden>${part(title === "Request" ? "As sent" : "As received", rawNote, copyButton("raw"), `<pre class="raw" data-raw${rawId ? ` id="${rawId}"` : ""}>${escape(clip(raw))}</pre>`)}</div>
+</section>`;
+function requestSection(request) {
+  const { headers, body } = request;
+  const missing = [headers.length === 0 && "no headers", !body && "no body"].filter(Boolean);
+  const formatted = [
+    `<div class="line"><span class="method ${methodClass(request.method)}">${escape(request.method.toUpperCase())}</span><code class="url">${escape(request.url || "\u2014")}</code>${request.url ? copyButton("url", "Copy URL") : ""}</div>`,
+    headers.length > 0 ? part("Headers", String(headers.length), copyButton("headers"), headerTable(headers)) : "",
+    body ? part(
+      "Body",
+      [headerValue(headers, "content-type"), bytes(Buffer.byteLength(body))].filter(Boolean).map((s) => escape(s)).join(" \xB7 "),
+      copyButton("body"),
+      codeView(requestBodyLines(body), false)
+    ) : "",
+    missing.length > 0 ? `<p class="dim small none">${capitalise(missing.join(" \xB7 "))}</p>` : ""
+  ].filter(Boolean).join("\n");
+  return exchange(
+    "Request",
+    formatted,
+    rawRequest(request),
+    "method and URL, headers, a blank line, then the body"
+  );
+}
+function requestBodyLines(body) {
+  if (/^\s*[{[]/.test(body)) {
+    try {
+      return toJsonLines(JSON.parse(body)).map((line) => ({
+        text: line.text,
+        html: highlightJson(line.text)
+      }));
+    } catch {
+    }
+  }
+  return body.split("\n").map((text) => ({ text, html: escape(text) }));
+}
+var ENDED_BY = {
+  close: "closed by the server",
+  maxEvents: "stopped at maxEvents",
+  streamTimeout: "stopped at streamTimeout",
+  untilEvent: "stopped at untilEvent",
+  testsPassed: "stopped once the tests passed",
+  limit: "stopped at the safety limit",
+  stopped: "stopped by hand",
+  held: "took the events held"
+};
+var connectionNote = (stream) => stream.connection ? `, connection ${stream.connection.name} ${stream.connection.open ? "open" : "closed"}` : "";
+function noResponse(r) {
+  const e = r.error;
+  if (e?.elapsedMs === void 0) return "No response was received.";
+  const wire = wireNote(e);
+  return `No response was received: the request failed after ${duration(e.elapsedMs)}${wire ? `, sent over ${wire}` : ""}.`;
+}
+function responseSection(r, id) {
+  const res = r.response;
+  if (!res) {
+    return `<section class="sub"><h3>Response</h3><p class="c-failed none">${escape(noResponse(r))}</p></section>`;
+  }
+  const checks = buildChecks(r.assertions);
+  const status = markStatus(checks).mark;
+  const extra = [
+    `first byte ${duration(res.timings.ttfbMs)}`,
+    bytes(res.sizeBytes),
+    res.redirectCount > 0 ? plural2(res.redirectCount, "redirect") : "",
+    res.stream ? `${plural2(res.stream.at.length, "event")}, ${ENDED_BY[res.stream.endedBy]}${connectionNote(res.stream)}` : "",
+    wireNote(res) ?? ""
+  ].filter(Boolean);
+  const formatted = [
+    `<div class="line">${statusCode(res)}${status ? `<span class="mk-inline mk-${status}" title="${status === "fail" ? "A status check failed" : "Status checked"}">${MARK_GLYPH[status]}</span>` : ""}<span class="dim small">${duration(res.timings.totalMs)} \xB7 ${escape(extra.join(" \xB7 "))}</span></div>`,
+    res.headers.length > 0 ? part(
+      "Headers",
+      String(res.headers.length),
+      copyButton("headers"),
+      headerTable(res.headers, markHeaders(res.headers, checks))
+    ) : "",
+    responseBody(r, res, checks, id)
+  ].filter(Boolean).join("\n");
+  return exchange(
+    "Response",
+    formatted,
+    rawResponse(res),
+    "status, headers, a blank line, then the body",
+    `${id}-raw`
+  );
+}
+function responseBody(r, res, checks, id) {
+  if (res.bodyKind === "empty") return '<p class="dim small none">Empty body</p>';
+  const rawId = `${id}-raw`;
+  const type = headerValue(res.headers, "content-type") ?? res.bodyKind;
+  const how = checkedDiffersFromRaw(res, r.sortedBy) ? [
+    res.bodyKind === "xml" ? "converted from XML" : "",
+    res.bodyKind === "events" ? "read as events" : "",
+    r.sortedBy?.length ? `sorted by ${r.sortedBy.join(", ")}` : ""
+  ].filter(Boolean) : [];
+  const meta = escape([type, bytes(res.sizeBytes), ...how].join(" \xB7 "));
+  if (res.bodyEncoding === "base64") return binaryBody(res, meta, id);
+  const copy = copyButton("body");
+  const checked = checkedBody(res, r.sortedBy);
+  if (!checked.ok) {
+    return part(
+      "Body",
+      meta,
+      copy,
+      `<p class="${res.bodyKind === "binary" ? "dim" : "c-failed"} small pad">${escape(checked.message)}</p><pre class="raw">${escape(clip(res.body))}</pre>`
+    );
+  }
+  const ignored = (r.ignored ?? []).map((entry) => parsePath(entry.path));
+  const marks = markLines(checked.lines, checks, ignored);
+  const structured = res.bodyKind !== "text" && res.bodyKind !== "html";
+  const value = structured ? checkedValue(res, r.sortedBy) : void 0;
+  const noted = /* @__PURE__ */ new Set();
+  const lines = checked.lines.map((line, i) => {
+    const marked = marks[i];
+    const failing = marked.mark === "fail" ? marked.about.filter((k) => checks[k].assertion.status === "fail" && !noted.has(k)) : [];
+    for (const k of failing) noted.add(k);
+    const note = failing.length ? `<span class="note">${MARK_GLYPH.fail} ${escape(failing.map((k) => checks[k].assertion.message ?? checks[k].assertion.name).join("; "))}</span>` : "";
+    const viewer = value === void 0 ? null : stringViewer(value, line, `${rawId}-v${i}`);
+    return {
+      text: line.text,
+      html: viewer?.html ?? (structured ? highlightJson(line.text) : escape(line.text)),
+      mark: marked.mark,
+      note: `${viewer?.button ?? ""}${note}`,
+      after: viewer?.panel
+    };
+  });
+  const view = codeView(lines, true);
+  if (res.bodyKind === "html") {
+    return part(
+      "Body",
+      meta,
+      `${renderSwitch()}${copy}`,
+      `<div data-part="rendered">${htmlFrame(rawId, true, "The response body, rendered")}</div>
+<div data-part="source" hidden>${view}</div>`,
+      true
+    );
+  }
+  return part("Body", meta, copy, view);
+}
+function binaryBody(res, meta, id) {
+  const type = (headerValue(res.headers, "content-type") ?? "").split(";")[0].trim().toLowerCase();
+  if (res.sizeBytes > BINARY_LIMIT) {
+    return part(
+      "Body",
+      meta,
+      "",
+      `<p class="dim small pad">Over ${bytes(BINARY_LIMIT)}, too big to put in the report.</p>`
+    );
+  }
+  const uri = escape(`data:${type || "application/octet-stream"};base64,${res.body}`);
+  if (type.startsWith("image/")) {
+    return part(
+      "Body",
+      meta,
+      copyButton("image", "Copy data URI"),
+      `<div class="img-view"><span class="checker"><img loading="lazy" src="${uri}" alt="The response body"></span><span class="dim small"><span data-dims></span>${escape(type)}</span></div>`
+    );
+  }
+  const subtype = type.split("/")[1] ?? "";
+  const extension = /^[a-z0-9]{1,8}$/.test(subtype) ? subtype : "bin";
+  return part(
+    "Body",
+    meta,
+    `<a class="btn sm" href="${uri}" download="${id}-body.${extension}">Download</a>`,
+    '<p class="dim small pad">Binary, so not shown as text. Download saves it as it came.</p>'
+  );
+}
+function checkedValue(res, sortedBy) {
+  const parsed = bodyAsObject(res);
+  if (!parsed.ok) return void 0;
+  return sortedBy ? sortArraysBy(parsed.body, sortedBy) : parsed.body;
+}
+function stringViewer(value, line, id) {
+  if (line.path.length === 0 || !/"[,]?$/.test(line.text)) return null;
+  const found = resolvePath(value, line.path)[0]?.value;
+  if (typeof found !== "string") return null;
+  const path3 = formatPath(line.path);
+  const close = `<button type="button" class="btn sm" data-close="${id}">Close</button>`;
+  if (DATA_IMAGE.test(found)) {
+    const literal = JSON.stringify(found);
+    const at = line.text.lastIndexOf(literal);
+    const shown = `${line.text.slice(0, at)}${JSON.stringify(`${found.slice(0, 40)}\u2026`)}${line.text.slice(at + literal.length)}`;
+    const comma = found.indexOf(",");
+    const size = Math.floor((found.length - comma - 1) * 3 / 4) - (found.match(/=+$/)?.[0].length ?? 0);
+    return {
+      html: `${highlightJson(shown)}<span class="dim"> (${bytes(found.length)})</span>`,
+      button: `<button type="button" class="peek" data-peek="${id}" aria-expanded="false">View image</button>`,
+      panel: `<div class="peek-row" id="${id}" hidden><div class="peek-panel">
+<div class="peek-h"><code>${escape(path3)}</code><span class="dim">${escape(found.slice(5, found.indexOf(";")))} \xB7 <span data-dims></span>${bytes(size)}</span><span class="end"><button type="button" class="btn sm" data-copy="image">Copy data URI</button>${close}</span></div>
+<div class="img-view"><span class="checker"><img loading="lazy" src="${escape(found)}" alt="The image at ${escape(path3)}"></span></div>
+</div></div>`
+    };
+  }
+  if (looksLikeHtml(found)) {
+    return {
+      button: `<button type="button" class="peek" data-peek="${id}" aria-expanded="false">View HTML</button>`,
+      panel: `<div class="peek-row" id="${id}" hidden><div class="peek-panel" data-switch>
+<div class="peek-h"><code>${escape(path3)}</code><span class="dim">HTML \xB7 ${bytes(Buffer.byteLength(found))}</span><span class="end">${renderSwitch()}<button type="button" class="btn sm" data-copy="source">Copy</button>${close}</span></div>
+<div data-part="rendered">${htmlFrame(`${id}-source`, false, `The HTML at ${path3}, rendered`)}</div>
+<pre class="raw" data-part="source" id="${id}-source" hidden>${escape(found)}</pre>
+</div></div>`
+    };
+  }
+  return null;
+}
+var DATA_IMAGE = /^data:image\/[\w.+-]+;base64,[A-Za-z0-9+/]+=*$/;
+var looksLikeHtml = (text) => /^\s*<(!doctype\s+html|[a-z][a-z0-9-]*)[\s>/]/i.test(text) && /<\/[a-z][a-z0-9-]*\s*>/i.test(text);
+var htmlFrame = (from, body, title) => `<div class="html-frame"><iframe sandbox="" title="${escape(title)}" data-from="${from}"${body ? " data-body" : ""}></iframe></div><p class="frame-note">Sandboxed: scripts don't run, and nothing loads from the network.</p>`;
+var renderSwitch = () => '<span class="seg" role="group" aria-label="HTML view"><button type="button" data-show="rendered" aria-pressed="true">Rendered</button><button type="button" data-show="source" aria-pressed="false">Source</button></span>';
+function headerTable(headers, marks) {
+  const anyMarked = marks?.some((m) => m.mark !== null) ?? false;
+  return `<table class="kv">${headers.map((h, i) => {
+    const mark2 = marks?.[i]?.mark ?? null;
+    return `<tr${mark2 ? ` class="mk-${mark2}"` : ""}>${anyMarked ? `<td class="mk">${mark2 ? MARK_GLYPH[mark2] : ""}</td>` : ""}<td class="k">${escape(h.name)}</td><td>${escape(h.value)}</td></tr>`;
+  }).join("")}</table>`;
+}
+function assertionsSection(assertions) {
+  const failed = assertions.filter((a) => a.status === "fail").length;
+  const head = `<h3>Assertions <span class="dim">${assertions.length} \xB7 ${assertions.length - failed} passed \xB7 ${failed} failed</span></h3>`;
+  if (assertions.length === 0)
+    return `<section class="sub">${head}<p class="dim small none">No assertions.</p></section>`;
+  const items = assertions.map((a) => {
+    const failing = a.status === "fail";
+    const detail = [
+      a.message ? `<div class="check-msg">${escape(a.message)}</div>` : "",
+      failing && (a.expected !== void 0 || a.actual !== void 0) ? `<dl class="ea">${a.expected !== void 0 ? `<dt>expected</dt><dd><code>${escape(a.expected)}</code></dd>` : ""}${a.actual !== void 0 ? `<dt>actual</dt><dd><code>${escape(a.actual)}</code></dd>` : ""}</dl>` : "",
+      a.unasserted?.length ? `<dl class="ea"><dt>not asserted</dt><dd><code>${escape(a.unasserted.join(", "))}</code></dd></dl>` : ""
+    ].join("");
+    const status = failing ? "failed" : "passed";
+    return `<li class="s-${status}">${mark(status)}<div class="check"><div class="check-name">${escape(a.name)}</div>${detail}</div>${a.source ? `<span class="src">${escape(sourceText(a.source))}</span>` : ""}</li>`;
+  });
+  return `<section class="sub">${head}<ul class="checks">
+${items.join("\n")}
+</ul></section>`;
+}
+var sourceText = (source) => `${source.script === "step" ? "tests" : `${source.script} tests`}:${source.line}${source.check ? ` \xB7 ${source.check.file}:${source.check.line}` : ""}`;
+function consoleSection(r) {
+  const lines = r.logs.map(
+    (l) => `<span class="log-${l.level}">[${escape(l.phase)} ${l.level}] ${escape(l.message)}</span>`
+  );
+  return `<section class="sub"><h3>Console</h3><pre class="console">${lines.join("\n")}</pre></section>`;
+}
+function codeView(all, marked) {
+  const { lines, more } = cutLines(all);
+  const rows = lines.map(
+    (line, i) => `<div class="ln${line.mark ? ` mk-${line.mark}` : ""}"><span class="no">${i + 1}</span>${marked ? `<span class="mk" aria-hidden="true">${line.mark ? MARK_GLYPH[line.mark] : ""}</span>` : ""}<span class="tx">${line.html}${line.note ?? ""}</span></div>${line.after ?? ""}`
+  );
+  if (more > 0) {
+    rows.push(
+      `<div class="ln cut"><span class="no"></span><span class="tx">\u2026 ${bytes(more)} more not shown</span></div>`
+    );
+  }
+  return `<div class="codeview">${rows.join("\n")}</div>`;
+}
+function cutLines(lines) {
+  let left = BODY_LIMIT2;
+  for (let i = 0; i < lines.length; i++) {
+    const length = lines[i].text.length + 1;
+    if (length > left) {
+      const total = lines.reduce((n, line) => n + line.text.length + 1, 0) - 1;
+      const kept = lines.slice(0, i);
+      const cut = lines[i].text.slice(0, left);
+      if (cut) kept.push({ text: cut, html: escape(cut) });
+      return { lines: kept, more: total - BODY_LIMIT2 };
+    }
+    left -= length;
+  }
+  return { lines, more: 0 };
+}
+function highlightJson(text) {
+  const match = /^(\s*)("(?:[^"\\]|\\.)*": )?(.*?)(,?)$/.exec(text);
+  if (!match) return escape(text);
+  const [, indent = "", key, value = "", comma = ""] = match;
+  const kind = value.startsWith('"') ? "j-s" : /^-?\d/.test(value) ? "j-n" : /^(true|false|null)$/.test(value) ? "j-l" : "";
+  return `${indent}${key ? `<span class="j-k">${escape(key.slice(0, -2))}</span>: ` : ""}${kind ? `<span class="${kind}">${escape(value)}</span>` : escape(value)}${comma}`;
+}
+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>
+<main class="page">
+${options.body}
+<footer class="foot">Generated by <a href="${REPO_URL}" target="_blank" rel="noopener noreferrer" title="Accelerator Test Automation on GitHub">ata ${escape(options.run.version)} <span aria-hidden="true">\u2197</span></a></footer>
+</main>
+</body>
+</html>
+`;
+}
+var pageHead = (status, title, startedAt) => `<header class="head"><div class="title">${pill(status, true)}<h1>${title}</h1></div><div class="meta"><span>${escape(timeOfRun(startedAt))}</span></div></header>`;
+var card = (title, body, options = {}) => `<section class="card"${options.id ? ` id="${options.id}"` : ""}><div class="card-h"><h2>${title}</h2>${options.tools ?? ""}</div><div class="card-body${options.flush ? " flush" : ""}">
+${body}
+</div></section>`;
+var part = (title, meta, tools, body, switches = false) => `<div class="part"${switches ? " data-switch" : ""}><div class="part-h"><span>${title}</span><span class="dim">${meta}</span><span class="end">${tools}</span></div>${body}</div>`;
+var copyButton = (what, label = "Copy") => `<button type="button" class="btn sm" data-copy="${what}">${label}</button>`;
+var pill = (status, solid = false) => `<span class="pill${solid ? " solid" : ""} s-${status}">${status}</span>`;
+var MARKS = { passed: "\u2713", failed: "\u2715", errored: "!", skipped: "\u2298" };
+var mark = (status) => `<span class="mark s-${status}" role="img" aria-label="${status}">${MARKS[status]}</span>`;
+var num = (n, bad = false) => n === 0 ? '<span class="zero">0</span>' : bad ? `<span class="hot">${n}</span>` : String(n);
+function statusCode(res) {
+  const kind = res.status >= 500 ? "server" : res.status >= 400 ? "client" : res.status >= 300 ? "redirect" : "ok";
+  return `<span class="status-code k-${kind}">${escape(`${res.status} ${res.statusText}`.trim())}</span>`;
+}
+var methodClass = (method) => `m-${method.toLowerCase().replace(/[^a-z]/g, "")}`;
+var waitedFor = (url) => {
+  const ms = /^(\d+) ms$/.exec(url)?.[1];
+  return ms === void 0 ? url : waitText(Number(ms));
+};
+function ringStat(label, parts) {
+  const total = parts.reduce((n, [, v]) => n + v, 0);
+  const passed = parts.find(([s]) => s === "passed")?.[1] ?? 0;
+  const ran = total - (parts.find(([s]) => s === "skipped")?.[1] ?? 0);
+  const rate = ran === 0 ? "\u2014" : `${Math.floor(passed / ran * 100)}%`;
+  return `<div class="stat"><div class="ring" title="${thousands(passed)} of ${thousands(ran)} that ran passed">${ring(parts)}<b>${rate}</b></div><div><div class="stat-label">${label}</div><div class="stat-total">${thousands(total)}</div><div class="legend">${parts.map(([s, v]) => `<span class="${v ? `s-${s}` : "zero"}"><i></i>${thousands(v)} ${s}</span>`).join("")}</div></div></div>`;
+}
+var timeStat = (label, ms) => `<div class="stat"><div class="ring clock">${clock}</div><div><div class="stat-label">${label}</div><div class="stat-time" title="${thousands(Math.round(ms))} ms">${runTime(ms).replace(/(\d) /g, "$1&nbsp;")}</div></div></div>`;
+var clock = `<svg viewBox="0 0 64 64" width="64" height="64" aria-hidden="true"><circle cx="32" cy="32" r="25" fill="none" stroke-width="7" style="stroke:var(--surface-alt)"/><path d="M32 19v13l9 6" fill="none" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" style="stroke:var(--dim)"/></svg>`;
+function ring(parts) {
+  const R = 25;
+  const C = 2 * Math.PI * R;
+  const live = parts.filter(([, v]) => v > 0);
+  const total = live.reduce((n, [, v]) => n + v, 0);
+  const track = `<circle cx="32" cy="32" r="${R}" fill="none" stroke-width="7" style="stroke:var(--surface-alt)"/>`;
+  if (total === 0)
+    return `<svg viewBox="0 0 64 64" width="64" height="64" aria-hidden="true">${track}</svg>`;
+  const gap = live.length > 1 ? 2 : 0;
+  const lengths = live.map(([, v]) => Math.max(v / total * C, 5));
+  const biggest = lengths.indexOf(Math.max(...lengths));
+  lengths[biggest] -= lengths.reduce((a, b) => a + b, 0) - C;
+  let offset = 0;
+  const arcs = live.map(([s], i) => {
+    const length = lengths[i];
+    const arc = `<circle class="s-${s}" cx="32" cy="32" r="${R}" fill="none" stroke-width="7" style="stroke:var(--s)" stroke-dasharray="${(length - gap).toFixed(2)} ${(C - length + gap).toFixed(2)}" stroke-dashoffset="${(-offset).toFixed(2)}" transform="rotate(-90 32 32)"/>`;
+    offset += length;
+    return arc;
+  });
+  return `<svg viewBox="0 0 64 64" width="64" height="64" aria-hidden="true">${track}${arcs.join("")}</svg>`;
+}
+var flagChips = (flags) => Object.entries(flags).map(([name, value]) => `<code class="flag">${escape(`${name}=${value}`)}</code>`).join("");
+var chips = (counts) => ["passed", "failed", "skipped"].filter((s) => counts[s] > 0).map(
+  (s) => `<button type="button" class="chip s-${s}" data-hide="${s}" aria-pressed="true" title="Show or hide ${s}">${mark(s)}${capitalise(s)} <b>${counts[s]}</b></button>`
+).join("");
+var searchBox = (label) => `<input type="search" class="search" placeholder="${label}" aria-label="${label}">`;
+var headerValue = (headers, name) => headers.find((h) => h.name.toLowerCase() === name)?.value;
+function clip(text) {
+  return text.length > BODY_LIMIT2 ? `${text.slice(0, BODY_LIMIT2)}
+\u2026 ${bytes(text.length - BODY_LIMIT2)} more not shown` : 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 plural2 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var thousands = (n) => n.toLocaleString("en-US");
+var duration = (ms) => ms < 1e3 ? `${Math.round(ms)} ms` : `${(ms / 1e3).toFixed(2)} s`;
+function runTime(ms) {
+  const hundredths = Math.round(ms / 10);
+  const hours = Math.floor(hundredths / 36e4);
+  const minutes = Math.floor(hundredths % 36e4 / 6e3);
+  const seconds2 = hundredths % 6e3;
+  return [
+    hours > 0 ? plural2(hours, "hour") : "",
+    minutes > 0 ? plural2(minutes, "minute") : "",
+    seconds2 > 0 || hundredths < 6e3 ? `${(seconds2 / 100).toFixed(2)} seconds` : ""
+  ].filter(Boolean).join(" ");
+}
+function timeoutText(ms) {
+  const round = ms >= 36e5 && ms % 36e5 === 0 ? `${ms / 36e5} h` : ms >= 6e4 && ms % 6e4 === 0 ? `${ms / 6e4} min` : ms >= 1e3 && ms % 1e3 === 0 ? `${ms / 1e3} s` : "";
+  return `${ms.toLocaleString("en-US")} ms${round ? ` <span class="dim">\xB7 ${round}</span>` : ""}`;
+}
+var timeOfRun = (epochMs) => {
+  const at = new Date(epochMs);
+  return `${at.toLocaleDateString("en-US", { weekday: "short", month: "short", day: "numeric", year: "numeric" })} \xB7 ${at.toLocaleTimeString("en-US", { hour: "numeric", minute: "2-digit", second: "2-digit", timeZoneName: "short" })}`;
+};
+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`;
+}
+var breakable = (value) => escape(value).replace(/([_/.-])/g, "$1<wbr>");
+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">${markCode(
+        codeTokens(block.text, block.language) ?? [{ text: block.text, kind: null }]
+      ).map((piece) => {
+        const classes = [piece.kind && `tok-${piece.kind}`, piece.variable && "md-var"].filter(Boolean).join(" ");
+        return classes ? `<span class="${classes}">${escape(piece.text)}</span>` : escape(piece.text);
+      }).join("")}</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 "callout": {
+      const { label, icon } = CALLOUTS[block.kind];
+      return `<div class="md-callout md-callout-${block.kind}" role="note"><p class="md-callout-title"><svg viewBox="0 0 16 16" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="${icon}"/></svg>${label}</p>${block.blocks.map(mdBlock).join("")}</div>`;
+    }
+    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 markText(node.text).map(mdMark).join("");
+      case "code":
+        return `<code class="md-inline-code">${markInlineCode(node.text).map(mdMark).join("")}</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("");
+}
+function mdMark(piece) {
+  const text = escape(piece.text);
+  switch (piece.mark) {
+    case null:
+      return text;
+    case "variable":
+      return `<span class="md-var">${text}</span>`;
+    case "method":
+      return `<span class="md-method m-${piece.method.toLowerCase()}">${text}</span>`;
+    case "status":
+      return `<span class="md-status md-status-${piece.status}">${text}</span>`;
+  }
+}
+var STYLE = `
+:root{color-scheme:light dark;--bg:#f6f7f9;--surface:#fff;--surface-alt:#eef0f4;--border:#d6dae2;--border-soft:#e6e9ee;--text:#16181d;--dim:#6a7280;--faint:#9aa1ad;--accent:#2f6df6;--link:#1f5fd6;--passed:#107a48;--failed:#cc1f43;--errored:#a65f00;--skipped:#0b7fb8;--on-status:#fff;--ok:#107a48;--redirect:#8a6100;--client:#b23c17;--server:#a01a2b;--m-get:#1f5fd6;--m-post:#0b7a43;--m-put:#946200;--m-patch:#0b7f84;--m-delete:#c42b2b;--m-head:#7c45d0;--m-options:#3f5f80;--j-key:#7c45d0;--j-str:#8a5a2b;--j-num:#0b7f84;--j-lit:#946200;--canvas:#fff;--check-a:#fff;--check-b:#eceef2;--sans:system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue",sans-serif;--mono:ui-monospace,SFMono-Regular,"SF Mono",Menlo,Consolas,monospace}
+@media (prefers-color-scheme:dark){:root{--bg:#11131a;--surface:#171a22;--surface-alt:#1e222c;--border:#2b303c;--border-soft:#232733;--text:#e6e8ee;--dim:#949bab;--faint:#666e7e;--accent:#5b8cff;--link:#6b9bff;--passed:#46c98a;--failed:#ff5b78;--errored:#f2a93b;--skipped:#56c2ee;--on-status:#11131a;--ok:#46c98a;--redirect:#e0b24d;--client:#f08a5d;--server:#f0607a;--m-get:#6b9bff;--m-post:#4fd08f;--m-put:#eab54e;--m-patch:#4fd1d1;--m-delete:#ff6f6f;--m-head:#b991ff;--m-options:#8fb4dc;--j-key:#b991ff;--j-str:#d9a066;--j-num:#4fd1d1;--j-lit:#eab54e;--check-a:#262b36;--check-b:#1d212a}}
+*{box-sizing:border-box}
+[hidden]{display:none!important}
+body{margin:0;background:var(--bg);color:var(--text);font:14px/1.5 var(--sans);-webkit-font-smoothing:antialiased}
+.page{max-width:1320px;margin:0 auto;padding:28px clamp(16px,3vw,32px) 24px}
+a{color:var(--link);text-decoration:none}
+a:hover{text-decoration:underline}
+:focus-visible{outline:2px solid var(--accent);outline-offset:2px}
+code,pre{font-family:var(--mono);font-size:12.5px}
+pre{margin:0;white-space:pre-wrap;word-break:break-word}
+.dim{color:var(--dim)}
+.small{font-size:12.5px}
+.hidden,.unmatched{display:none!important}
+.s-passed{--s:var(--passed)}.s-failed{--s:var(--failed)}.s-errored{--s:var(--errored)}.s-skipped{--s:var(--skipped)}
+.c-failed{color:var(--failed)}
+.crumbs{display:flex;flex-wrap:wrap;gap:4px 8px;font-size:13px;color:var(--dim);margin-bottom:10px;overflow-wrap:anywhere}
+.head{display:flex;flex-wrap:wrap;align-items:center;justify-content:space-between;gap:8px 24px;margin-bottom:18px}
+.title{display:flex;align-items:center;gap:12px;min-width:0}
+.title h1{margin:0;font-size:20px;font-weight:650;letter-spacing:-.01em;overflow-wrap:anywhere}
+.kind{color:var(--dim);font-weight:400}
+.meta{display:flex;flex-wrap:wrap;gap:4px 14px;color:var(--dim);font-size:13px;font-variant-numeric:tabular-nums}
+.card{background:var(--surface);border:1px solid var(--border);border-radius:8px;margin-bottom:16px;min-width:0}
+.card-h{display:flex;flex-wrap:wrap;align-items:center;gap:8px 10px;padding:10px 16px;border-bottom:1px solid var(--border-soft)}
+.card-h h2{margin:0 6px 0 0;font-size:13.5px;font-weight:650}
+.card-h .file{margin-left:auto}
+.card-h .file{color:var(--dim);overflow-wrap:anywhere}
+.card-body{padding:16px}
+.card-body>*+*{margin-top:16px}
+.card-body.flush{padding:0}
+.pairs{display:grid;grid-template-columns:repeat(auto-fill,minmax(190px,1fr));gap:14px 28px;margin:0}
+.pairs dt{font-size:12px;color:var(--dim);margin-bottom:1px}
+.pairs dd{margin:0;overflow-wrap:anywhere}
+.flag{font-size:12px;padding:1px 6px;border-radius:4px;background:var(--surface-alt);display:inline-block;margin:0 4px 2px 0}
+.stats{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(220px,100%),1fr));gap:20px 36px}
+.stat{display:flex;gap:16px;align-items:center;min-width:0}
+.ring{position:relative;width:64px;height:64px;flex:none}
+.ring svg{display:block}
+.ring b{position:absolute;inset:0;display:grid;place-items:center;font-size:13.5px;font-variant-numeric:tabular-nums}
+.stat-label{font-size:12px;color:var(--dim)}
+.stat-total{font-size:24px;font-weight:650;font-variant-numeric:tabular-nums;line-height:1;margin-top:3px}
+.stat-time{font-size:17px;font-weight:650;font-variant-numeric:tabular-nums;line-height:1.25;margin-top:3px}
+.legend{display:flex;flex-wrap:wrap;gap:4px 12px;margin-top:6px;font-size:12.5px;font-variant-numeric:tabular-nums}
+.legend span{display:inline-flex;align-items:center;gap:5px}
+.legend i{width:8px;height:8px;border-radius:2px;background:var(--s)}
+.legend .zero i{background:var(--border)}
+.zero{color:var(--faint)}
+.hot{color:var(--failed);font-weight:700}
+.pill{display:inline-flex;align-items:center;padding:3px 10px;border-radius:999px;font-size:11px;font-weight:700;letter-spacing:.07em;text-transform:uppercase;color:var(--s);background:color-mix(in srgb,var(--s) 14%,transparent);white-space:nowrap}
+.pill.solid{background:var(--s);color:var(--on-status)}
+.mark{flex:none;display:inline-grid;place-items:center;width:18px;height:18px;border-radius:50%;color:var(--s);background:color-mix(in srgb,var(--s) 16%,transparent);font-size:10.5px;font-weight:800;line-height:1}
+.status-code{font:600 12.5px var(--mono);white-space:nowrap}
+.k-ok{color:var(--ok)}.k-redirect{color:var(--redirect)}.k-client{color:var(--client)}.k-server{color:var(--server)}
+.method{font:700 11.5px var(--mono);letter-spacing:.02em}
+.m-get{color:var(--m-get)}.m-post{color:var(--m-post)}.m-put{color:var(--m-put)}.m-patch{color:var(--m-patch)}.m-delete{color:var(--m-delete)}.m-head{color:var(--m-head)}.m-options{color:var(--m-options)}
+.search{font:inherit;font-size:13px;padding:6px 10px;border:1px solid var(--border);border-radius:6px;background:var(--surface);color:var(--text);min-width:0;flex:1 1 180px;max-width:300px}
+.chip{font:inherit;font-size:12.5px;display:inline-flex;align-items:center;gap:6px;padding:3px 10px 3px 4px;border-radius:999px;border:1px solid var(--border);background:var(--surface);color:var(--text);cursor:pointer;white-space:nowrap}
+.chip b{font-variant-numeric:tabular-nums}
+.chip[aria-pressed="false"]{opacity:.45}
+.btn{font:inherit;font-size:12.5px;padding:4px 12px;border:1px solid var(--border);border-radius:6px;background:var(--surface);color:var(--text);cursor:pointer;white-space:nowrap}
+.btn.sm{font-size:11.5px;padding:2px 9px;border-radius:5px}
+.btn:hover,.chip:hover{border-color:var(--faint)}
+.seg{display:inline-flex;border:1px solid var(--border);border-radius:7px;padding:1px;background:var(--surface-alt)}
+.seg button{font:inherit;font-size:11.5px;border:none;background:none;color:var(--dim);padding:2px 9px;border-radius:5px;cursor:pointer}
+.seg button[aria-pressed="true"]{background:var(--surface);color:var(--text);box-shadow:0 1px 2px rgba(0,0,0,.1)}
+.scroll-x{overflow-x:auto}
+.overview{width:100%;border-collapse:collapse;font-variant-numeric:tabular-nums;font-size:13px}
+.overview th{font-size:11.5px;font-weight:600;color:var(--dim);text-align:left;padding:6px 10px;white-space:nowrap}
+.overview thead tr:last-child th{border-bottom:1px solid var(--border)}
+.overview .groups th{padding:10px 10px 0;text-transform:uppercase;letter-spacing:.08em;font-size:10.5px;color:var(--faint)}
+.overview td{padding:7px 10px;border-bottom:1px solid var(--border-soft);vertical-align:top}
+.overview tbody tr:last-child td{border-bottom:none}
+.overview .r{text-align:right}
+.overview .gs{border-left:1px solid var(--border-soft)}
+.overview td.name{min-width:10rem;overflow-wrap:anywhere}
+@media (max-width:960px){.overview th,.overview td{padding-left:6px;padding-right:6px}.overview .groups th{padding-left:6px;padding-right:6px}}
+.overview td.n{color:var(--faint)}
+.overview tbody tr:hover td{background:var(--surface-alt)}
+.overview tr.s-failed td:first-child{box-shadow:inset 3px 0 0 var(--failed)}
+.group-h{margin:0 0 8px;font-size:13px;font-weight:600}
+.group-h .dim{font-weight:400}
+.excluded{list-style:none;margin:0;padding:0;display:grid;grid-template-columns:repeat(auto-fill,minmax(220px,1fr));gap:6px 24px}
+.excluded li{font:12.5px var(--mono);display:flex;gap:8px;align-items:center;overflow-wrap:anywhere}
+.excluded li::before{content:"\u2298";color:var(--faint);font-family:var(--sans)}
+.toolbar{display:flex;flex-wrap:wrap;align-items:center;gap:10px 12px;margin:28px 0 10px}
+.toolbar h2{margin:0 8px 0 0;font-size:17px;font-weight:650}
+.tools-end{margin-left:auto;display:flex;flex-wrap:wrap;gap:6px;align-items:center}
+.tests{border:1px solid var(--border);border-radius:8px;background:var(--surface);overflow:hidden}
+.test+.test{border-top:1px solid var(--border)}
+.test>summary{display:flex;align-items:center;gap:10px;padding:11px 14px;cursor:pointer;list-style:none}
+.test>summary::-webkit-details-marker{display:none}
+.test>summary .n{width:1.6em;color:var(--faint);font-variant-numeric:tabular-nums;text-align:right;flex:none}
+.test>summary .method{width:52px;flex:none}
+.test>summary .name{flex:1;min-width:0;font-weight:500;overflow-wrap:anywhere}
+.test>summary .res{display:flex;align-items:center;gap:10px;font-size:12.5px;flex:none;font-variant-numeric:tabular-nums}
+.chev{color:var(--faint);font-size:12px;transition:transform .15s}
+.test[open]>summary .chev{transform:rotate(90deg)}
+.test[open]>summary{background:var(--surface-alt)}
+.test.s-failed>summary,.test.s-errored>summary{box-shadow:inset 3px 0 0 var(--s)}
+.test-body{padding:16px;display:grid;gap:20px;border-top:1px solid var(--border-soft);min-width:0}
+.empty{margin:0;padding:16px}
+.skip-reason{margin:0;color:var(--skipped)}
+.wait-note{margin:0;color:var(--dim)}
+.sub{min-width:0}
+.sub h3{margin:0 0 8px;font-size:11px;font-weight:650;text-transform:uppercase;letter-spacing:.08em;color:var(--dim)}
+.sub h3 .dim{text-transform:none;letter-spacing:0;font-weight:400;margin-left:6px}
+.sub-h{display:flex;flex-wrap:wrap;align-items:center;gap:6px 10px;margin-bottom:8px}
+.sub-h h3{margin:0}
+.line{display:flex;flex-wrap:wrap;align-items:baseline;gap:4px 10px;min-width:0}
+.line .url{overflow-wrap:anywhere;min-width:0}
+.line .btn{margin-left:auto;align-self:center}
+.mk-inline{font-weight:700}
+.none{margin:8px 0 0}
+.part{margin-top:10px;border:1px solid var(--border-soft);border-radius:6px;overflow:hidden;background:var(--surface);min-width:0}
+.part-h{display:flex;flex-wrap:wrap;align-items:center;gap:4px 8px;padding:5px 6px 5px 10px;background:var(--surface-alt);font-size:12px;font-weight:600;border-bottom:1px solid var(--border-soft)}
+.part-h .dim{font-weight:400;overflow-wrap:anywhere}
+.end{margin-left:auto;display:flex;flex-wrap:wrap;gap:6px;align-items:center}
+.pad{margin:0;padding:8px 10px}
+.kv{width:100%;border-collapse:collapse;font:12px/1.45 var(--mono)}
+.kv td{padding:3px 10px;border-top:1px solid var(--border-soft);vertical-align:top;overflow-wrap:anywhere}
+.kv tr:first-child td{border-top:none}
+.kv .k{color:var(--dim);white-space:nowrap;width:1%}
+.kv .mk{width:1%;padding-right:0;text-align:center}
+.raw{max-height:440px;overflow:auto;padding:8px 10px;font:12px/1.55 var(--mono);white-space:pre-wrap;word-break:break-all}
+.codeview{font:12px/1.6 var(--mono);max-height:min(70vh,640px);overflow:auto;padding:6px 0}
+.codeview:has(.peek-row:not([hidden])){max-height:none}
+.ln{display:flex;padding-right:12px}
+.ln .no{flex:none;width:3.2em;text-align:right;padding-right:10px;color:var(--faint);user-select:none}
+.ln .mk{flex:none;width:1.4em;text-align:center;user-select:none}
+.ln .tx{flex:1;min-width:0;white-space:pre-wrap;word-break:break-all}
+.ln.cut .tx{color:var(--dim);font-style:italic}
+.ln.mk-fail,.kv .mk-fail{background:color-mix(in srgb,var(--failed) 12%,transparent)}
+.mk-pass .mk,.mk-inline.mk-pass{color:var(--passed)}
+.mk-fail .mk,.mk-inline.mk-fail{color:var(--failed);font-weight:700}
+.mk-unasserted .mk,.mk-inline.mk-unasserted{color:var(--errored);font-weight:700}
+.mk-ignored .mk{color:var(--faint)}
+.ln .note{color:var(--failed);font:600 11.5px var(--sans);margin-left:12px;white-space:normal}
+.j-k{color:var(--j-key)}.j-s{color:var(--j-str)}.j-n{color:var(--j-num)}.j-l{color:var(--j-lit)}
+.peek{font:600 11px var(--sans);margin-left:10px;padding:1px 9px;border-radius:999px;border:1px solid var(--border);background:var(--surface);color:var(--link);cursor:pointer;white-space:nowrap}
+.peek[aria-expanded="true"]{background:var(--surface-alt);border-color:var(--faint)}
+.peek-row{padding:4px 12px 10px 4.6em}
+.peek-panel{border:1px solid var(--border);border-radius:8px;background:var(--surface);overflow:hidden;font:13px/1.5 var(--sans)}
+.peek-h{display:flex;flex-wrap:wrap;align-items:center;gap:4px 8px;padding:5px 6px 5px 10px;background:var(--surface-alt);border-bottom:1px solid var(--border-soft);font-size:12px}
+.peek-h code{font-weight:600;overflow-wrap:anywhere}
+.html-frame{height:300px;min-height:120px;resize:vertical;overflow:hidden;background:var(--canvas)}
+.html-frame iframe{display:block;width:100%;height:100%;border:0}
+.frame-note{margin:0;padding:5px 10px;font-size:11.5px;color:var(--dim);border-top:1px solid var(--border-soft)}
+.img-view{display:flex;flex-wrap:wrap;align-items:flex-end;gap:8px 12px;padding:12px}
+.checker{display:inline-block;max-width:100%;padding:10px;border-radius:6px;background-color:var(--check-a);background-image:conic-gradient(var(--check-b) 25%,transparent 0 50%,var(--check-b) 0 75%,transparent 0);background-size:16px 16px}
+.checker img{display:block;max-width:100%;height:auto}
+.checks{list-style:none;margin:0;padding:0;border:1px solid var(--border-soft);border-radius:6px;background:var(--surface)}
+.checks li{display:flex;gap:10px;padding:8px 10px;align-items:flex-start}
+.checks li+li{border-top:1px solid var(--border-soft)}
+.check{flex:1;min-width:0}
+.check-name{font:12.5px var(--mono);overflow-wrap:anywhere}
+.check-msg{font-size:13px;margin-top:2px;color:var(--dim)}
+.s-failed .check-msg{color:var(--failed)}
+.ea{display:grid;grid-template-columns:auto 1fr;gap:2px 10px;margin:6px 0 0;font-size:12.5px}
+.ea dt{color:var(--dim)}
+.ea dd{margin:0;overflow-wrap:anywhere}
+.src{font:11.5px var(--mono);color:var(--faint);flex:none;white-space:nowrap}
+.problem pre{color:var(--failed);background:color-mix(in srgb,var(--failed) 7%,var(--surface));border:1px solid color-mix(in srgb,var(--failed) 30%,var(--border));border-radius:6px;padding:8px 10px}
+.console{background:var(--surface-alt);border-radius:6px;padding:8px 10px}
+.console .log-warn{color:var(--errored)}.console .log-error{color:var(--failed)}
+.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(--surface-alt);border-radius:6px}
+.md-inline-code{background:var(--surface-alt);padding:1px 4px;border-radius:3px}
+.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(--surface-alt)}
+.md-code .tok-name,.md-code .tok-tag,.md-code .tok-function{color:var(--j-key)}.md-code .tok-string{color:var(--j-str)}.md-code .tok-number,.md-code .tok-attribute{color:var(--j-num)}.md-code .tok-literal{color:var(--j-lit)}.md-code .tok-keyword{color:var(--accent)}.md-code .tok-comment{color:var(--dim);font-style:italic}.md-code .tok-punctuation,.md-code .tok-meta{color:var(--dim)}
+.md .md-var{color:var(--accent);background:color-mix(in srgb,var(--accent) 12%,transparent);border-radius:3px}
+.md-method{font-weight:700}.md-status{font-weight:600}.md-status-1xx{color:var(--dim)}.md-status-2xx{color:var(--ok)}.md-status-3xx{color:var(--redirect)}.md-status-4xx{color:var(--client)}.md-status-5xx{color:var(--server)}
+.md-callout{margin:0 0 8px;padding:8px 12px;border-left:3px solid var(--callout);border-radius:0 6px 6px 0;background:color-mix(in srgb,var(--callout) 8%,transparent)}.md-callout>:last-child{margin-bottom:0}
+.md-callout-title{display:flex;align-items:center;gap:6px;margin:0 0 4px;color:var(--callout);font-weight:600}
+.md-callout-note{--callout:var(--accent)}.md-callout-tip{--callout:var(--ok)}.md-callout-important{--callout:var(--m-head)}.md-callout-warning{--callout:var(--redirect)}.md-callout-caution{--callout:var(--server)}
+.foot{margin-top:28px;padding-top:16px;border-top:1px solid var(--border-soft);display:flex;justify-content:center;align-items:center;gap:8px;color:var(--dim);font-size:12.5px}
+.foot a{display:inline-flex;align-items:center;gap:6px;padding:4px 12px;border:1px solid var(--border);border-radius:999px;background:var(--surface);color:var(--text);font-weight:600}
+.foot a:hover{border-color:var(--faint);text-decoration:none}
+.foot a span{color:var(--dim);font-weight:400}
+@media (max-width:560px){.test>summary .res .status-code,.test>summary .method{display:none}}
+@media (prefers-reduced-motion:reduce){.chev{transition:none}}
+`;
+var SCRIPT = String.raw`
+// What an HTML frame may do beyond showing itself: nothing it could load from.
+const SANDBOX = '<meta http-equiv="Content-Security-Policy" content="default-src \'none\'; img-src data:; style-src \'unsafe-inline\'; font-src data:; form-action \'none\'">'
+function filter() {
+  const hidden = new Set([...document.querySelectorAll('[data-hide][aria-pressed="false"]')].map((b) => b.dataset.hide))
+  const input = document.querySelector('.search')
+  const query = input ? input.value.trim().toLowerCase() : ''
+  for (const el of document.querySelectorAll('[data-status][data-search]')) {
+    el.classList.toggle('hidden', hidden.has(el.dataset.status))
+    el.classList.toggle('unmatched', query !== '' && !el.dataset.search.includes(query))
+  }
+}
+// The button says what a click will do: Expand All while any test is closed,
+// Collapse All once every one is open — however they got that way.
+const tests = () => [...document.querySelectorAll('details.test')]
+function syncExpandAll() {
+  const button = document.getElementById('expand-all')
+  if (button) button.textContent = tests().some((d) => !d.open) ? 'Expand All' : 'Collapse All'
+}
+// A frame is filled when first shown, from the text it names: a response's raw
+// text, whose body follows the first blank line, or a viewer's source.
+function loadFrames(scope) {
+  for (const frame of scope.querySelectorAll('iframe[data-from]:not([srcdoc])')) {
+    if (frame.offsetParent === null) continue
+    const text = document.getElementById(frame.dataset.from).textContent
+    const html = frame.hasAttribute('data-body') ? text.slice(text.indexOf('\n\n') + 2) : text
+    frame.srcdoc = SANDBOX + html.replace(/<meta[^>]*http-equiv\s*=\s*["']?refresh[^>]*>/gi, '')
+  }
+}
+// Every part of a request or response is read from its raw text, as sent or received.
+function copied(button) {
+  const what = button.dataset.copy
+  if (what === 'image') return button.closest('.peek-panel, .part').querySelector('img').getAttribute('src')
+  if (what === 'source') return button.closest('.peek-panel').querySelector('[data-part="source"]').textContent
+  const raw = button.closest('[data-exchange]').querySelector('[data-raw]').textContent
+  const blank = raw.indexOf('\n\n')
+  const head = (blank < 0 ? raw : raw.slice(0, blank)).split('\n')
+  if (what === 'raw') return raw
+  if (what === 'body') return blank < 0 ? '' : raw.slice(blank + 2)
+  if (what === 'headers') return head.slice(1).join('\n')
+  return head[0].replace(/^\S+ /, '')
+}
+function copy(text, button) {
+  button.dataset.label ??= button.textContent
+  const done = (label) => {
+    button.textContent = label
+    setTimeout(() => { button.textContent = button.dataset.label }, 1500)
+  }
+  const byHand = () => {
+    const area = document.createElement('textarea')
+    area.value = text
+    area.style.position = 'fixed'
+    area.style.opacity = '0'
+    document.body.append(area)
+    area.select()
+    const ok = document.execCommand('copy')
+    area.remove()
+    done(ok ? 'Copied' : 'Copy failed')
+  }
+  if (navigator.clipboard) navigator.clipboard.writeText(text).then(() => done('Copied'), byHand)
+  else byHand()
+}
+document.addEventListener('click', (event) => {
+  const button = event.target.closest('button')
+  if (!button) return
+  if (button.dataset.hide) {
+    button.setAttribute('aria-pressed', String(button.getAttribute('aria-pressed') === 'false'))
+    filter()
+  } else if (button.id === 'expand-all') {
+    const open = tests().some((d) => !d.open)
+    for (const d of tests()) d.open = open
+    syncExpandAll()
+  } else if (button.dataset.show) {
+    const box = button.closest('[data-switch]')
+    for (const b of box.querySelectorAll('[data-show]')) {
+      if (b.closest('[data-switch]') === box) b.setAttribute('aria-pressed', String(b === button))
+    }
+    for (const part of box.querySelectorAll(':scope > [data-part]')) part.hidden = part.dataset.part !== button.dataset.show
+    loadFrames(box)
+  } else if (button.dataset.peek) {
+    const open = button.getAttribute('aria-expanded') !== 'true'
+    button.setAttribute('aria-expanded', String(open))
+    const panel = document.getElementById(button.dataset.peek)
+    panel.hidden = !open
+    if (open) loadFrames(panel)
+  } else if (button.dataset.close) {
+    document.getElementById(button.dataset.close).hidden = true
+    document.querySelector('[data-peek="' + button.dataset.close + '"]')?.setAttribute('aria-expanded', 'false')
+  } else if (button.dataset.copy) {
+    copy(copied(button), button)
+  }
+})
+document.addEventListener('input', (event) => {
+  if (event.target.matches('.search')) filter()
+})
+document.addEventListener('toggle', (event) => {
+  if (!event.target.matches('details.test')) return
+  syncExpandAll()
+  if (event.target.open) loadFrames(event.target)
+}, true)
+// An image's size, once it has loaded.
+document.addEventListener('load', (event) => {
+  const dims = event.target.tagName === 'IMG' && event.target.closest('.peek-panel, .part')?.querySelector('[data-dims]')
+  if (dims) dims.textContent = event.target.naturalWidth + ' × ' + event.target.naturalHeight + ' · '
+}, true)
+document.addEventListener('DOMContentLoaded', () => {
+  syncExpandAll()
+  loadFrames(document)
+})
+`;
+
+// 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: `ata: ${run2.project}`,
+      ...total,
+      time: seconds(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: seconds(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: seconds(durationMs) })}`;
+  if (body.length === 0) return [`${open}/>`];
+  return [`${open}>`, ...body.map((line) => `      ${line}`), "    </testcase>"];
+}
+var caseName = (result) => result.use ? `${resultName(result)} [${result.use.set} ${result.use.child + 1}/${result.use.of}]` : resultName(result);
+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 seconds = (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/main.ts
+var VERSION = true ? "0.20.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 };
+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 command = args.command;
+    if (command === "lint" || command === "rules") {
+      const given = [
+        ...Object.keys(args.overrides).map((key) => `--${key}`),
+        ...args.flags.map(() => "--flag")
+      ];
+      if (given.length > 0) {
+        throw new UsageError(`ata ${command} takes no settings or flags: ${given.join(", ")}`);
+      }
+      const root = await canonical(ctx.cwd);
+      const output = { out: ctx.out, emit, p };
+      if (command === "rules") {
+        await rulesCommand(root, output);
+        return EXIT.passed;
+      }
+      return await lintCommand(root, output) ? EXIT.failed : EXIT.passed;
+    }
+    const project = await openProject(ctx, args.overrides, args.flags);
+    for (const warning of project.warnings) ctx.err(p.yellow(`warning: ${warning}`));
+    if (command === "g" || command === "get") {
+      const selection = selectFor(project, { kind: "all" });
+      const problems = await listingProblems(project, selection);
+      const code = problems.length > 0 || selection.targets.some((target) => target.broken) ? EXIT.failed : EXIT.passed;
+      if (emit) {
+        emit(
+          jsonListing({
+            project: { name: project.name, root: project.root },
+            environments: project.environments,
+            environmentType: project.settings.environmentType,
+            settings: { values: project.settings, sources: project.settingSources },
+            flags: project.flags,
+            tags: project.settings.tags,
+            notTags: project.settings.notTags,
+            targets: selection.targets,
+            excluded: selection.excluded,
+            excludedSteps: selection.excludedSteps,
+            untagged: selection.untagged,
+            problems
+          })
+        );
+        return code;
+      }
+      list(project, selection, problems, ctx, p);
+      return code;
+    }
+    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 || cause instanceof RulesError) {
+      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;
+  }
+}
+var openProject = async (ctx, overrides, flagArgs = []) => loadProject({ root: await canonical(ctx.cwd), env: ctx.env, overrides, flagArgs });
+var selectFor = (project, request) => selectCollections(project.collections, request, {
+  tags: project.settings.tags,
+  notTags: project.settings.notTags
+});
+async function listingProblems(project, selection) {
+  const listed = new Set(selection.targets.map((target) => target.id));
+  const stepsExcluded = new Set(selection.excludedSteps.map((step) => step.id));
+  const problems = [];
+  for (const collection of project.collections) {
+    const id = idOf(collection);
+    const leftOut = listed.has(id) ? null : collection.doc.exclude === true || stepsExcluded.has(id) ? "excluded" : "tags";
+    if (collection.problems.length > 0) {
+      const message = collection.problems.map((problem) => problem.message).join("; ");
+      if (leftOut) problems.push({ id, leftOut, step: null, message });
+      continue;
+    }
+    for (const problem of await referenceProblems(collection.doc, collection.path)) {
+      problems.push({ id, leftOut, ...problem });
+    }
+  }
+  return problems;
+}
+function list(project, selection, problems, 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(", ")));
+  for (const line of settingLines(project, p)) ctx.out(line);
+  ctx.out("");
+  const width = nameWidthFor(selection.targets.map((t) => t.id));
+  const dirWidth = Math.max(
+    "Folder".length,
+    ...selection.targets.map((t) => (t.collection.directory ?? "").length)
+  );
+  ctx.out(
+    p.bold(
+      `${"#".padStart(4)}  ${"Collection".padEnd(width)} ${"Steps".padStart(7)} ${"Rows".padStart(5)}  ${"Folder".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}`);
+  }
+  const leftOut = { excluded: " (excluded)", tags: " (left out by tags)" };
+  for (const problem of problems) {
+    const step = problem.step === null ? "" : `, ${problem.stage ? `${problem.stage} ` : ""}step ${problem.step + 1}`;
+    const where = `${problem.id}${problem.leftOut ? leftOut[problem.leftOut] : ""}${step}`;
+    ctx.out(`${p.red("broken")} ${where}: ${problem.message}`);
+  }
+  const excluded = [
+    ...selection.excluded,
+    ...selection.excludedSteps.map((step) => `${step.id} \u203A ${step.name}`)
+  ];
+  if (excluded.length > 0) {
+    ctx.out(field("Excluded", `${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`));
+}
+function settingLines(project, p) {
+  const rows = Object.keys(SETTING_KEYS).filter((key) => project.settingSources[key] !== DEFAULT_SOURCE).map((key) => ({
+    cell: `${key}: ${shownSetting(project.settings[key])}`,
+    source: project.settingSources[key]
+  }));
+  if (rows.length === 0) return [field("Settings", p.dim("all defaults"))];
+  const width = Math.max(...rows.map((row) => row.cell.length));
+  const indent = " ".repeat(field("Settings", "").length);
+  return rows.map(
+    (row, i) => `${i === 0 ? field("Settings", "") : indent}${row.cell.padEnd(width)}  ${p.dim(row.source)}`
+  );
+}
+var shownSetting = (value) => Array.isArray(value) ? value.length > 0 ? value.join(", ") : "[]" : String(value ?? "none");
+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(`ata ${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 excludedSteps = selection.excludedSteps.length;
+  const leftOut = [
+    selection.excluded.length > 0 ? `${selection.excluded.length} excluded` : "",
+    excludedSteps > 0 ? `${excludedSteps} ${excludedSteps === 1 ? "step" : "steps"} 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,
+    excludedSteps: selection.excludedSteps,
+    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 fs.mkdir(path2.dirname(target), { recursive: true });
+        await fs.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("ata")} ${VERSION} \u2014 Accelerator Test Automation`,
+    "",
+    `  ${p.bold("Usage:")} ata <command> [--settingsKey value]...`,
+    "",
+    "  Run from a project folder: the one holding collections/ and settings.yml.",
+    "",
+    `  ${p.bold("Commands:")}`,
+    "    g, get          List the collections `ata all` would run, without running them.",
+    "                    Exits 1 on a broken collection, or a use:, extends: or body",
+    "                    file that would stop a run, in any collection.",
+    "    a, all          Run every collection, less those and the steps with",
+    "                    exclude: true.",
+    "    <list>          Run the collections and folders named, comma separated,",
+    "                    in that order: smoke,checkout/sessions,payments",
+    "                    A folder leaves out its excluded collections and steps;",
+    "                    a collection named on its own runs every step.",
+    "                    A collection called all, get, lint or rules: give it as all.yml.",
+    "    lint            Check the project\u2019s files against its rules: its rules.yml,",
+    "                    over its global project\u2019s. Exits 1 on a finding.",
+    "    rules           List the rules in effect, the file each came from, what each",
+    "                    means, and the project\u2019s guide. Neither needs settings.yml.",
+    "",
+    `  ${p.bold("Options:")}`,
+    "    --json          Print the results as JSON on stdout instead of the table; with",
+    "                    get, the collections it would run; with lint and rules, the",
+    "                    findings and the rules. Errors are JSON too.",
+    "    --flag name=value",
+    "                    Override a feature flag for this run; any number of them.",
+    "                    ATA_FLAG_<name>=value does the same from the environment.",
+    "",
+    `  ${p.bold("Settings")} (the global project's settings.yml, then this project's, then`,
+    "  ATA_* environment variables, then --flags; ata get shows where each came from):",
+    ...settings,
+    "",
+    `  ${p.bold("Exit code:")} 0 passed, 1 failed, 2 could not run (or write a report).`
+  ].join("\n");
+}
+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: ata deletes its test results folder before each run, so point it at a folder of its own.`;
+  }
+  let entries;
+  try {
+    entries = await fs.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 fs.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 ata 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 fs.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/ata.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
+});