@schwabyio/gta 0.13.0 → 0.14.1

package/dist/gta.js

@@ -1,318 +1,68 @@
 #!/usr/bin/env node
 import { createRequire as __gtaCreateRequire } from 'node:module';
 const require = __gtaCreateRequire(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-4W4TFJ53.js";
 import {
   COLLECTIONS_DIR,
-  DOC_EXTENSION,
-  SETTINGS_FILE,
-  TagSchema,
-  __toESM,
-  allSkipped,
+  MARK_GLYPH,
+  PROJECT_FILE,
+  RULES_FILE,
+  RulesError,
+  bodyAsObject,
+  buildChecks,
   canonical,
-  discoverProject,
-  environmentNames,
-  external_exports,
-  flagOverrides,
+  checkedBody,
+  checkedDiffersFromRaw,
+  formatPath,
   isInside,
   iterationName,
-  loadProjectCollections,
-  loadProjectTls,
-  parseEventStream,
+  lintProject,
+  loadRules,
+  markHeaders,
+  markLines,
+  markStatus,
   parseMarkdown,
-  projectEnvironments,
+  parsePath,
   readProject,
   referenceProblems,
-  relativePosix,
-  require_dist,
-  resolveFlags,
+  resolvePath,
   resultName,
+  ruleDoc,
   samePath,
-  stepsForTags,
+  sortArraysBy,
+  toJsonLines,
   unattempted
-} from "./chunks/chunk-ABBBM5UZ.js";
-
-// src/args.ts
-var UsageError = class extends Error {
-  name = "UsageError";
-};
-function parseArgs(argv) {
-  const parsed = {
-    command: null,
-    overrides: {},
-    help: false,
-    version: false,
-    json: false,
-    flags: []
-  };
-  for (let i = 0; i < argv.length; i++) {
-    const word = argv[i];
-    if (word === "-h" || word === "--help") {
-      parsed.help = true;
-    } else if (word === "-v" || word === "--version") {
-      parsed.version = true;
-    } else if (word === "--json") {
-      parsed.json = true;
-    } else if (word === "--flag" || word.startsWith("--flag=")) {
-      const value = word === "--flag" ? argv[++i] : word.slice("--flag=".length);
-      if (value === void 0 || value.startsWith("--")) {
-        throw new UsageError("--flag needs name=value, such as --flag newCheckout=true");
-      }
-      parsed.flags.push(value);
-    } else if (word.startsWith("--")) {
-      const body = word.slice(2);
-      const equals = body.indexOf("=");
-      if (equals > 0) {
-        parsed.overrides[body.slice(0, equals)] = body.slice(equals + 1);
-      } else {
-        const next = argv[i + 1];
-        if (next !== void 0 && !next.startsWith("--")) {
-          parsed.overrides[body] = next;
-          i++;
-        } else {
-          parsed.overrides[body] = true;
-        }
-      }
-    } else if (word.startsWith("-") && word.length > 1) {
-      throw new UsageError(`Unknown option ${word}. Settings are given as --settingsKey value.`);
-    } else if (parsed.command === null) {
-      parsed.command = word;
-    } else {
-      throw new UsageError(
-        `Unexpected "${word}". To run several collections, separate them with commas: gta ${parsed.command},${word}`
-      );
-    }
-  }
-  return parsed;
-}
-
-// src/select.ts
-var idOf = (collection) => collection.name;
-var placeOf = (collection) => collection.relativePath.slice(0, -DOC_EXTENSION.length);
-var normalize = (selector) => {
-  const cleaned = selector.normalize("NFC").trim().replace(/\\/g, "/").replace(/^(\.\/)+/, "").replace(/^collections\//, "");
-  return {
-    name: cleaned.replace(/\/+$/, "").replace(/\.yml$/, ""),
-    directoryOnly: cleaned.endsWith("/")
-  };
-};
-function selectCollections(collections, request, options) {
-  const excluded = /* @__PURE__ */ new Set();
-  const inGroup = (group) => group.filter((c) => {
-    if (c.doc.exclude === true) excluded.add(c);
-    return c.doc.exclude !== true;
-  });
-  let chosen;
-  if (request.kind === "list") {
-    const unknown = [];
-    chosen = [];
-    for (const selector of request.selectors) {
-      const { name, directoryOnly } = normalize(selector);
-      const exact = directoryOnly ? void 0 : collections.find((c) => idOf(c) === name) ?? collections.find((c) => placeOf(c).normalize("NFC") === name);
-      const inDirectory = collections.filter((c) => c.directory?.normalize("NFC") === name);
-      const found = exact ? [exact] : inDirectory.length > 0 ? inGroup(inDirectory) : null;
-      if (found) chosen.push(...found.filter((c) => !chosen.includes(c)));
-      else unknown.push(selector);
-    }
-    if (unknown.length > 0) {
-      throw new UsageError(
-        `No collection or directory is called ${unknown.map((u) => `"${u}"`).join(", ")}. List them with: gta get`
-      );
-    }
-  } else {
-    chosen = inGroup(collections);
-  }
-  const targets = [];
-  let untagged = 0;
-  for (const collection of chosen) {
-    const id = idOf(collection);
-    if (collection.problems.length > 0) {
-      const broken = collection.problems.map((p) => p.message).join("; ");
-      targets.push({ id, collection, steps: null, broken });
-      continue;
-    }
-    const picked = stepsForTags(collection.doc, options.tags, options.notTags ?? []);
-    if (picked.length === 0 && (options.tags.length > 0 || (options.notTags ?? []).length > 0)) {
-      untagged++;
-      continue;
-    }
-    const all = picked.length === collection.doc.steps.length;
-    targets.push({ id, collection, steps: all ? null : picked, broken: null });
-  }
-  return {
-    targets,
-    // Named on its own, an excluded collection ran: it was not left out.
-    excluded: [...excluded].filter((c) => !chosen.includes(c)).map(idOf),
-    untagged
-  };
-}
-var stepCountOf = (target) => target.steps?.length ?? target.collection.doc.steps.length;
-
-// src/report.ts
-function paint(enabled) {
-  const wrap = (open, close) => (text) => enabled ? `\x1B[${open}m${text}\x1B[${close}m` : text;
-  return {
-    red: wrap(31, 39),
-    green: wrap(32, 39),
-    cyan: wrap(36, 39),
-    yellow: wrap(33, 39),
-    dim: wrap(2, 22),
-    bold: wrap(1, 22)
-  };
-}
-function colorWanted(stream, env) {
-  if (env.FORCE_COLOR !== void 0 && env.FORCE_COLOR !== "0") return true;
-  if (env.NO_COLOR !== void 0 && env.NO_COLOR !== "") return false;
-  return stream.isTTY === true;
-}
-function tally(target, outcome, durationMs) {
-  if (!outcome.ok) {
-    const total = stepCountOf(target);
-    return {
-      id: target.id,
-      passed: false,
-      durationMs,
-      steps: { total, passed: 0, failed: 0, errored: 0, skipped: total },
-      assertions: { total: 0, passed: 0, failed: 0 },
-      skipped: false,
-      error: outcome.message,
-      problems: []
-    };
-  }
-  const { summary: summary2 } = outcome;
-  const assertions = summary2.results.flatMap((r) => r.assertions);
-  const failed = assertions.filter((a) => a.status === "fail").length;
-  return {
-    id: target.id,
-    passed: summary2.failed === 0 && summary2.errored === 0,
-    durationMs,
-    steps: {
-      total: summary2.total,
-      passed: summary2.passed,
-      failed: summary2.failed,
-      errored: summary2.errored,
-      skipped: summary2.skipped
-    },
-    assertions: { total: assertions.length, passed: assertions.length - failed, failed },
-    skipped: allSkipped(summary2),
-    error: null,
-    // Named for the row they ran with, when a data file drove the collection.
-    problems: summary2.results.flatMap(
-      (r, i) => r.status === "fail" || r.status === "error" ? [{ ...r, item: { ...r.item, name: iterationName(resultName(r), outcome.steps[i]) } }] : []
-    )
-  };
-}
-var seconds = (ms) => `${(ms / 1e3).toFixed(3)}s`;
-var rule = (p, width = 100) => p.dim("\u2500".repeat(width));
-var field = (label, value, width = 14) => `${`${label}:`.padEnd(width)}${value}`;
-var NUMBER_COLUMNS = [
-  ["Time", 9],
-  ["Steps", 6],
-  ["Pass", 5],
-  ["Fail", 5],
-  ["Error", 6],
-  ["Skip", 5],
-  ["Asserts", 8],
-  ["Pass", 5],
-  ["Fail", 5]
-];
-var nameWidthFor = (ids) => Math.min(80, Math.max("Collection".length, ...ids.map((id) => id.length)));
-var tableWidth = (nameWidth) => 4 + 2 + nameWidth + 1 + NUMBER_COLUMNS.reduce((n, [, w]) => n + w + 1, 0) - 1 + 2 + "passed".length;
-function tableHeader(nameWidth, p) {
-  const cells = NUMBER_COLUMNS.map(([label, width]) => label.padStart(width));
-  return p.bold(`${"#".padStart(4)}  ${"Collection".padEnd(nameWidth)} ${cells.join(" ")}  Result`);
-}
-var nameCell = (id, width) => id.length > width ? `${id.slice(0, width - 1)}\u2026` : id.padEnd(width);
-function tableRow(n, t, nameWidth, p) {
-  const name = nameCell(t.id, nameWidth);
-  const values = [
-    seconds(t.durationMs),
-    t.steps.total,
-    t.steps.passed,
-    t.steps.failed,
-    t.steps.errored,
-    t.steps.skipped,
-    t.assertions.total,
-    t.assertions.passed,
-    t.assertions.failed
-  ];
-  const cells = values.map((value, i) => String(value).padStart(NUMBER_COLUMNS[i][1]));
-  const result = t.skipped ? p.cyan("skipped") : t.passed ? p.green("passed") : p.red("failed");
-  return `${String(n).padStart(4)}  ${name} ${cells.join(" ")}  ${result}`;
-}
-var clip = (text, max = 300) => text.length > max ? `${text.slice(0, max)}\u2026 (${text.length - max} more characters)` : text;
-function failureDetails(tallies, p) {
-  const lines = [];
-  for (const t of tallies) {
-    if (t.passed) continue;
-    lines.push(p.bold(t.id));
-    if (t.error) lines.push(`  ${p.red("\u2717")} ${t.error}`);
-    for (const result of t.problems) {
-      const where = result.use ? ` ${p.dim(`(${result.use.set} ${result.use.child + 1}/${result.use.of})`)}` : "";
-      const status = result.response ? ` ${p.dim(String(result.response.status))}` : "";
-      lines.push(`  ${p.red("\u2717")} ${result.item.name}${where}${status}`);
-      if (result.error) {
-        const { phase, script, line, message } = result.error;
-        const at = [script && `${script} script`, line && `line ${line}`].filter(Boolean).join(", ");
-        lines.push(`      ${p.red(`${phase} error${at ? ` (${at})` : ""}:`)} ${clip(message)}`);
-      }
-      for (const assertion of result.assertions) {
-        if (assertion.status !== "fail") continue;
-        const message = assertion.message ? `: ${assertion.message}` : "";
-        lines.push(`      ${assertion.name}${message}`);
-        if (assertion.expected !== void 0) {
-          lines.push(`        ${p.dim("expected")} ${clip(assertion.expected)}`);
-        }
-        if (assertion.actual !== void 0) {
-          lines.push(`        ${p.dim("actual  ")} ${clip(assertion.actual)}`);
-        }
-        if (assertion.unasserted?.length) {
-          lines.push(`        ${p.dim("not asserted")} ${clip(assertion.unasserted.join(", "))}`);
-        }
-      }
-    }
-    lines.push("");
-  }
-  return lines;
-}
-function totalsOf(tallies) {
-  const sum = (pick) => tallies.reduce((n, t) => n + pick(t), 0);
-  return {
-    collections: {
-      total: tallies.length,
-      passed: tallies.filter((t) => t.passed).length,
-      failed: tallies.filter((t) => !t.passed).length
-    },
-    steps: {
-      total: sum((t) => t.steps.total),
-      passed: sum((t) => t.steps.passed),
-      failed: sum((t) => t.steps.failed),
-      errored: sum((t) => t.steps.errored),
-      skipped: sum((t) => t.steps.skipped)
-    },
-    assertions: {
-      total: sum((t) => t.assertions.total),
-      passed: sum((t) => t.assertions.passed),
-      failed: sum((t) => t.assertions.failed)
-    }
-  };
-}
-function summary(totals, durationMs, p) {
-  const { collections: c, steps: s, assertions: a } = totals;
-  const passed = c.failed === 0;
-  return [
-    field("Collections", `${c.total} total, ${c.passed} passed, ${c.failed} failed`),
-    field(
-      "Steps",
-      `${s.total} total, ${s.passed} passed, ${s.failed} failed, ${s.errored} errored, ${s.skipped} skipped`
-    ),
-    field("Assertions", `${a.total} total, ${a.passed} passed, ${a.failed} failed`),
-    field("Run time", seconds(durationMs)),
-    field("Result", passed ? p.green(p.bold("PASSED")) : p.red(p.bold("FAILED")))
-  ];
-}
+} from "./chunks/chunk-S563G22M.js";
 
 // src/main.ts
-import fs2 from "node:fs/promises";
+import fs from "node:fs/promises";
 import path2 from "node:path";
 
 // src/pool.ts
@@ -348,8 +98,239 @@ async function runPool(items, limit, run2) {
   await Promise.all(Array.from({ length: Math.min(limit, items.length) }, lane));
 }
 
-// src/html.ts
+// 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: "gta", version: run2.version },
+    project: { name: run2.project, root: run2.root },
+    run: {
+      result: failed === 0 ? "passed" : "failed",
+      startedAt: new Date(run2.startedAt).toISOString(),
+      durationMs: Math.round(run2.durationMs),
+      environment: run2.environment,
+      /** The feature flag values the run used, where each came from, and the command run (SPEC.md §2.9). */
+      flags: {
+        values: run2.flags ?? {},
+        sources: run2.flagSources ?? {},
+        command: run2.flagCommand ?? null
+      },
+      settings: {
+        limitConcurrency: run2.concurrency,
+        timeoutCollection: run2.timeoutCollection,
+        bail: run2.bail,
+        tags: run2.tags,
+        notTags: run2.notTags ?? []
+      }
+    },
+    totals,
+    leftOut: { excluded: run2.excluded, untagged: run2.untagged },
+    reports,
+    collections: run2.collections.map(collectionOf)
+  };
+}
+function collectionOf(c) {
+  const { outcome, tally: tally2 } = c;
+  return {
+    id: c.id,
+    file: c.file,
+    status: tally2.skipped ? "skipped" : tally2.passed ? "passed" : "failed",
+    startedAt: new Date(c.startedAt).toISOString(),
+    durationMs: Math.round(c.durationMs),
+    counts: { steps: tally2.steps, assertions: tally2.assertions },
+    /** Why it did not run at all, or null when it ran. */
+    error: outcome.ok ? null : outcome.message,
+    /** The data file that ran it once per row (SPEC.md §2.8), or null. */
+    dataFile: outcome.ok ? outcome.data : null,
+    /** Steps a bail left unrun. */
+    notRun: outcome.ok ? unattempted(outcome.summary) : tally2.steps.total,
+    steps: outcome.ok ? outcome.summary.results.map(
+      (result, i) => stepOf(result, outcome.steps[i] ?? { index: i, line: null })
+    ) : []
+  };
+}
+function stepOf(result, ref) {
+  const truncated = {};
+  const 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, 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}.
+gta lint and gta 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 shownValue = (value) => value === null ? "off" : Array.isArray(value) ? `[${value.join(", ")}]` : String(value);
+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 valueWidth = Math.max(...settings.map((s) => shownValue(s.value).length));
+    for (const setting of settings) {
+      const value = shownValue(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("(gta 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/gravity";
 var SUMMARY_PAGE = "summary.html";
 function htmlReport(run2) {
   return [
@@ -362,197 +343,235 @@ 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 failedCollections = tallies.filter((t) => !t.passed).length;
-  const passed = failedCollections === 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) => `<a href="#not-run">${plural2(n, "collection")} \u2193</a>`;
   const settings = [
-    ["Project Name", run2.project],
-    ["Collection Timeout", `${run2.timeoutCollection} ms`],
-    ["Environment", run2.environment ?? "none"],
+    ["Environment", run2.environment ? escape(run2.environment) : none],
     ["Concurrency Limit", String(run2.concurrency)],
-    ["Tags", run2.tags.length > 0 ? run2.tags.join(", ") : "none"],
-    ...run2.notTags?.length ? [["Not Tags", run2.notTags.join(", ")]] : [],
-    ["Excluded", run2.excluded.length > 0 ? run2.excluded.join(", ") : "none"],
-    ["Feature Flags", flagList(run2.flags ?? {})],
-    ...run2.flagCommand ? [["Flag Command", run2.flagCommand]] : [],
+    ["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"]] : [],
-    ...run2.untagged > 0 ? [
-      ["Left Out By Tags", `${run2.untagged} collection${run2.untagged === 1 ? "" : "s"}`]
-    ] : []
+    ["Excluded", run2.excluded.length > 0 ? leftOut(run2.excluded.length) : none],
+    ...run2.untagged > 0 ? [["Left Out By Tags", leftOut(run2.untagged)]] : []
   ];
-  const overview = run2.collections.map((c, i) => {
+  const rows = run2.collections.map((c, i) => {
     const t = c.tally;
-    const status = t.skipped ? "skipped" : t.passed ? "passed" : "failed";
-    const cells = [
-      seconds2(c.durationMs),
-      t.steps.total,
-      t.steps.passed,
-      t.steps.failed,
-      t.steps.errored,
-      t.steps.skipped,
-      t.assertions.total,
-      t.assertions.passed,
-      t.assertions.failed
-    ];
-    return `<tr class="${status}" data-search="${escape(c.id.toLowerCase())}"><td>${i + 1}</td><td class="name"><a href="${escape(encodeURI(pageOf(c.id)))}">${escape(c.id)}</a></td>${cells.map((v) => `<td>${v}</td>`).join("")}<td>${statusText(status)}</td></tr>`;
+    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)))}">${escape(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 || 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>` : "",
+      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 gta Summary Results`,
     run: run2,
-    body: `<h2 class="page-title">gta Summary Results</h2>
+    body: `${pageHead(passed ? "passed" : "failed", `${escape(run2.project)} <span class="kind">\xB7 Summary Results</span>`, run2.startedAt, run2.durationMs)}
 
-<div class="card"><div class="card-header">Settings</div><div class="card-body"><div class="pairs">
-${settings.map(([label, value]) => field2(label, escape(value))).join("\n")}
-</div></div></div>
+${card("Settings", `<dl class="pairs">
+${settings.map(([label, value]) => `<div><dt>${label}</dt><dd>${value}</dd></div>`).join("\n")}
+</dl>`)}
 
-<div class="card"><div class="card-header">Summary Stats</div><div class="card-body">
-${field2("Time of Run", escape(timeOfRun(run2.startedAt)))}
-${statsTable([
-      ["Total Collections", tallies.length],
-      ["Collections Passed", tallies.length - failedCollections],
-      ["Collections Failed", failedCollections],
-      ["Total Tests", sum((t) => t.steps.total)],
-      ["Tests Passed", sum((t) => t.steps.passed)],
-      ["Tests Failed", sum((t) => t.steps.failed)],
-      ["Tests Errored", sum((t) => t.steps.errored)],
-      ["Tests Skipped", sum((t) => t.steps.skipped)],
-      ["Total Assertions", sum((t) => t.assertions.total)],
-      ["Assertions Passed", sum((t) => t.assertions.passed)],
-      ["Assertions Failed", sum((t) => t.assertions.failed)],
-      ["Total Run Time", seconds2(run2.durationMs)],
-      ["Final Result", finalResult(passed)]
-    ])}
-</div></div>
+${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)]
+      ])}
+</div>`
+    )}
 
-<div class="toolbar above">${searchBox("Search collections", "tr[data-search]")}<div class="buttons">${hideButtons(
-      tallies.some((t) => t.passed && !t.skipped),
-      failedCollections > 0,
-      tallies.some((t) => t.skipped)
-    )}</div></div>
-<div class="card"><div class="card-header">Results Overview</div><div class="card-body">
-<table class="overview">
-<tr><th>Collection #</th><th>Collection ID</th><th>Collection Run Time</th><th>Total Tests</th><th>Tests Passed</th><th>Tests Failed</th><th>Tests Errored</th><th>Tests Skipped</th><th>Total Assertions</th><th>Assertions Passed</th><th>Assertions Failed</th><th>Collection Result</th></tr>
-${overview}
-</table>
-</div></div>`
+${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,
+        tools: `${chips({ passed: count("passed"), failed: count("failed"), skipped: count("skipped") })}${searchBox("Search collections")}`
+      }
+    )}
+${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 ? "" : [
-    ...c.outcome.summary.results.map(
-      (r, i) => testSection(r, i, c.outcome.ok ? c.outcome.steps[i] : void 0)
-    ),
+    ...results.map((r, i) => testSection(r, i, c.outcome.ok ? c.outcome.steps[i] : void 0)),
     unattempted(c.outcome.summary) > 0 ? notRunSection(unattempted(c.outcome.summary)) : ""
   ].join("\n");
-  const statuses = c.outcome.ok ? c.outcome.summary.results.map(statusOf) : [];
+  const groups = results.map((r) => group(statusOf(r)));
+  const data = c.outcome.ok ? c.outcome.data : null;
   return page({
-    title: `${t.skipped ? "SKIPPED" : t.passed ? "PASSED" : "FAILED"} \xB7 ${c.id} \xB7 gta Collection Results`,
+    title: `${status.toUpperCase()} \xB7 ${c.id} \xB7 gta Collection Results`,
     run: run2,
-    body: `<h2 class="page-title">gta Collection Results</h2>
-
-<div class="card"><div class="card-header">Results Overview</div><div class="card-body">
-${field2("Collection ID", escape(c.id), "wide")}
-${c.docs?.trim() ? field2("Collection Docs", markdown(c.docs), "wide") : ""}
-${c.outcome.ok && c.outcome.data ? field2("Data File", escape(c.outcome.data.file), "wide") : ""}
-${c.outcome.ok && c.outcome.data ? field2("Iterations", String(c.outcome.data.rows)) : ""}
-${!c.outcome.ok ? field2("Error", `<pre class="c-failed">${escape(c.outcome.message)}</pre>`, "wide") : ""}
-${field2("Time of Run", escape(timeOfRun(c.startedAt)))}
-${statsTable([
-      ["Collection Run Time", seconds2(c.durationMs)],
-      ["Total Tests", t.steps.total],
-      ["Tests Passed", t.steps.passed],
-      ["Tests Failed", t.steps.failed],
-      ["Tests Errored", t.steps.errored],
-      ["Tests Skipped", t.steps.skipped],
-      ["Total Assertions", t.assertions.total],
-      ["Assertions Passed", t.assertions.passed],
-      ["Assertions Failed", t.assertions.failed],
-      ["Overall Result", t.skipped ? '<span class="c-skipped">SKIPPED</span>' : finalResult(t.passed)]
-    ])}
-</div></div>
+    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, c.durationMs)}
 
-<div class="toolbar"><h3>Tests</h3>${statuses.length > 0 ? searchBox("Search steps", "details[data-search]") : ""}<div class="buttons">
-${hideButtons(
-      statuses.includes("passed"),
-      statuses.some((s) => s === "failed" || s === "errored"),
-      statuses.includes("skipped")
-    )}
-${statuses.length === 0 ? "" : (
-      // Says what a click does: expand while any test is closed, as passed ones start.
-      `<button type="button" class="btn" id="expand-all" onclick="expandAll()">${statuses.some((s) => s === "passed" || s === "skipped") ? "Expand All" : "Collapse All"}</button>`
+${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>${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]
+        ])}
+</div>`
+      ].filter(Boolean).join("\n"),
+      { tools: `<code class="file">${escape(c.file)}</code>` }
     )}
-<a class="btn" href="${SUMMARY_PAGE}">Summary</a>
-</div></div>
+
+<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">No tests were run.</p>'}
+${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 = escape(iterationName(resultName(r), ref));
-  const name = r.use ? `${named} <span class="dim">(${escape(r.use.set)} ${r.use.child + 1}/${r.use.of})</span>` : named;
-  if (r.skipped) {
-    return `<details class="acc skipped skipped" data-search="${escape(iterationName(resultName(r), ref).toLowerCase())}">
-<summary><span>Test ${index + 1}: ${name}</span>${icon("skipped")}</summary>
-<div class="acc-body">
-${card("Skipped", field2("Reason", `<span class="c-skipped">${escape(r.skipped.reason)} \u2014 this test was not run</span>`, "wide"))}
-</div>
-</details>`;
-  }
-  const cards = [
-    r.error ? errorCard(r) : "",
-    requestCard(r),
-    responseCard(r),
-    assertionsCard(r.assertions),
-    r.logs?.length ? consoleCard(r) : ""
-  ].filter(Boolean);
-  const group = status === "passed" ? "passed" : status === "skipped" ? "skipped" : "failed";
-  const search = iterationName(resultName(r), ref).toLowerCase();
-  return `<details class="acc ${group} ${status}" data-search="${escape(search)}"${status === "passed" ? "" : " open"}>
-<summary><span>Test ${index + 1}: ${name}</span>${icon(status)}</summary>
-<div class="acc-body">
-${cards.join("\n")}
+  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 outcome = r.skipped ? '<span class="dim">skipped</span>' : res ? `${statusCode(res)}<span class="dim">${duration(res.timings.totalMs)}</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>` : [
+    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="acc skipped">
-<summary><span>${count} test${count === 1 ? "" : "s"} not run</span>${icon("skipped")}</summary>
-<div class="acc-body"><p class="c-skipped">The collection stopped at its first failure (bail), so ${count === 1 ? "this test was" : "these tests were"} not run.</p></div>
+  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 errorCard(r) {
+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 card(
-    "Error",
-    field2(
-      `${capitalise(e.phase)} Error`,
-      `<pre class="c-failed">${escape(`${where ? `(${where}) ` : ""}${e.message}${detail}`)}</pre>`,
-      "wide"
-    )
-  );
+  return `<section class="sub problem"><h3>${escape(capitalise(e.phase))} Error</h3><pre>${escape(`${where ? `(${where}) ` : ""}${e.message}${detail}`)}</pre></section>`;
 }
-function requestCard(r) {
-  const { request } = r;
-  return card(
+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.status} ${response.statusText}`.trim(),
+    ...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",
-    [
-      field2("Request Method", escape(request.method)),
-      field2("Request URL", escape(request.url || "\u2014"), "wide"),
-      request.headers.length > 0 ? field2("Request Headers", scrollPre(headerText(request.headers)), "wide") : "",
-      request.body ? field2("Request Body", scrollPre(clip2(request.body)), "wide") : ""
-    ].filter(Boolean).join("\n")
+    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",
@@ -563,70 +582,226 @@ var ENDED_BY = {
   held: "took the events held"
 };
 var connectionNote = (stream) => stream.connection ? `, connection ${stream.connection.name} ${stream.connection.open ? "open" : "closed"}` : "";
-function responseCard(r) {
+function responseSection(r, id) {
   const res = r.response;
   if (!res) {
-    return card(
-      "Response",
-      field2("Failure", '<span class="c-failed">No response was received.</span>', "wide")
-    );
+    return `<section class="sub"><h3>Response</h3><p class="c-failed none">No response was received.</p></section>`;
   }
-  const events = res.bodyKind === "events";
-  const body = res.bodyKind === "json" ? prettyJson(res.body) : events ? JSON.stringify(parseEventStream(res.body), null, 2) : res.body;
+  const checks = buildChecks(r.assertions);
+  const status = markStatus(checks).mark;
   const extra = [
-    `first byte ${Math.round(res.timings.ttfbMs)}ms`,
+    `first byte ${duration(res.timings.ttfbMs)}`,
     bytes(res.sizeBytes),
-    res.redirectCount > 0 ? `${res.redirectCount} redirect${res.redirectCount === 1 ? "" : "s"}` : "",
-    res.stream ? `${res.stream.at.length} event${res.stream.at.length === 1 ? "" : "s"}, ${ENDED_BY[res.stream.endedBy]}${connectionNote(res.stream)}` : ""
+    res.redirectCount > 0 ? plural2(res.redirectCount, "redirect") : "",
+    res.stream ? `${plural2(res.stream.at.length, "event")}, ${ENDED_BY[res.stream.endedBy]}${connectionNote(res.stream)}` : ""
   ].filter(Boolean);
-  return card(
+  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",
-    [
-      field2("Response Code", escape(`${res.status} ${res.statusText}`.trim())),
-      res.headers.length > 0 ? field2("Response Headers", scrollPre(headerText(res.headers)), "wide") : "",
-      body ? field2(events ? "Response Events" : "Response Body", scrollPre(clip2(body)), "wide") : "",
-      field2(
-        "Response Time",
-        `${Math.round(res.timings.totalMs)}ms <span class="dim">\xB7 ${extra.join(" \xB7 ")}</span>`
-      )
-    ].filter(Boolean).join("\n")
+    formatted,
+    rawResponse(res),
+    "status, headers, a blank line, then the body",
+    `${id}-raw`
   );
 }
-function assertionsCard(assertions) {
-  const failed = assertions.filter((a) => a.status === "fail").length;
-  const counts = statsTable(
-    [
-      ["Total Assertions", assertions.length],
-      ["Assertions Passed", assertions.length - failed],
-      ["Assertions Failed", failed]
-    ],
-    "small"
+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>'
   );
-  if (assertions.length === 0) return card("Assertions", counts);
-  const list2 = assertions.map((a) => {
+}
+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 extra = [
-      a.message ? `<div class="c-failed">${escape(a.message)}</div>` : "",
-      failing && a.expected !== void 0 ? `<div class="ea"><span class="dim">expected</span> <code>${escape(a.expected)}</code></div>` : "",
-      failing && a.actual !== void 0 ? `<div class="ea"><span class="dim">actual</span> <code>${escape(a.actual)}</code></div>` : "",
-      a.unasserted?.length ? `<div class="ea"><span class="dim">not asserted</span> <code>${escape(a.unasserted.join(", "))}</code></div>` : ""
+    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 result = failing ? '<span class="c-failed">FAILED</span>' : '<span class="c-passed">PASSED</span>';
-    return `<div class="detail-row"><div>${escape(a.name)}${extra}</div>${result}</div>`;
-  }).join("\n");
-  return card(
-    "Assertions",
-    `${counts}
-<div class="card inner"><div class="card-header"><div class="detail-row head"><span>Detail</span><span>Result</span></div></div><div class="card-body">
-${list2}
-</div></div>`
-  );
+    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>`;
 }
-function consoleCard(r) {
+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 card("Console", `<pre class="console">${lines.join("\n")}</pre>`);
+  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>
@@ -639,60 +814,79 @@ function page(options) {
 <script>${SCRIPT}</script>
 </head>
 <body>
-<div class="container">
+<main class="page">
 ${options.body}
-</div>
-<footer class="container">
-<span class="btn static">gta Version ${escape(options.run.version)}</span>
-<div class="dim small-print">Run in ${escape(options.run.root)}</div>
-</footer>
+<footer class="foot">Generated by <a href="${REPO_URL}" target="_blank" rel="noopener noreferrer" title="Gravity Test Automation on GitHub">gta ${escape(options.run.version)} <span aria-hidden="true">\u2197</span></a></footer>
+</main>
 </body>
 </html>
 `;
 }
-var card = (title, body) => `<div class="card"><div class="card-header">${title}</div><div class="card-body">
+var pageHead = (status, title, startedAt, ms) => `<header class="head"><div class="title">${pill(status, true)}<h1>${title}</h1></div><div class="meta"><span>${escape(timeOfRun(startedAt))}</span><span>${duration(ms)}</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></div>`;
-var field2 = (label, valueHtml, width = "fit") => `<div class="field"><div class="label">${escape(label)}</div><div class="value ${width}">${valueHtml}</div></div>`;
-function statsTable(cells, size = "") {
-  return `<table class="stats${size ? ` ${size}` : ""}"><tr>${cells.map(([label]) => `<td>${escape(label)}</td>`).join("")}</tr><tr>${cells.map(([, value]) => `<td>${value}</td>`).join("")}</tr></table>`;
-}
-var finalResult = (passed) => passed ? '<span class="c-passed">PASSED</span>' : '<span class="c-failed">FAILED</span>';
-var statusText = (status) => `<span class="c-${status}">${status}</span>`;
-var ICONS = { passed: "\u2713", failed: "!", errored: "!", skipped: "\u2013" };
-var icon = (status) => `<span class="icon ${status}" role="img" aria-label="${status}">${ICONS[status]}</span>`;
-var searchBox = (label, target) => `<input type="search" class="search" placeholder="${label}" aria-label="${label}" data-target="${escape(target)}" oninput="search(this)">`;
-var hideButtons = (anyPassed, anyFailed, anySkipped = false) => [
-  anyPassed ? `<button type="button" class="btn" onclick="toggle(this,'passed','Passed')">Hide Passed</button>` : "",
-  anyFailed ? `<button type="button" class="btn" onclick="toggle(this,'failed','Failed')">Hide Failed</button>` : "",
-  anySkipped ? `<button type="button" class="btn" onclick="toggle(this,'skipped','Skipped')">Hide Skipped</button>` : ""
-].join("");
-var headerText = (headers) => headers.map((h) => `${h.name}: ${h.value}`).join("\n");
-var scrollPre = (text) => `<div class="scroll"><pre>${escape(text)}</pre></div>`;
-function clip2(text) {
-  return text.length > BODY_LIMIT ? `${text.slice(0, BODY_LIMIT)}
-\u2026 ${bytes(text.length - BODY_LIMIT)} more not shown` : text;
-}
-function prettyJson(text) {
-  try {
-    return JSON.stringify(JSON.parse(text), null, 2);
-  } catch {
-    return text;
-  }
+</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, "")}`;
+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="${passed} of ${ran} that ran passed">${ring(parts)}<b>${rate}</b></div><div><div class="stat-label">${label}</div><div class="stat-total">${total}</div><div class="legend">${parts.map(([s, v]) => `<span class="${v ? `s-${s}` : "zero"}"><i></i>${v} ${s}</span>`).join("")}</div></div></div>`;
+}
+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 seconds2 = (ms) => `${(ms / 1e3).toFixed(3)}s`;
-var timeOfRun = (epochMs) => new Date(epochMs).toLocaleString("en-US", {
-  weekday: "short",
-  month: "long",
-  day: "2-digit",
-  year: "numeric",
-  hour: "numeric",
-  minute: "2-digit",
-  second: "2-digit",
-  timeZoneName: "long"
-});
+var plural2 = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var duration = (ms) => ms < 1e3 ? `${Math.round(ms)} ms` : `${(ms / 1e3).toFixed(2)} s`;
+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`;
@@ -745,112 +939,294 @@ function mdInline(nodes) {
   }).join("");
 }
 var STYLE = `
-:root{color-scheme:light dark;--bg:#f8f9fa;--card:#fff;--head:#eef0f3;--border:#dee2e6;--text:#212529;--dim:#6c757d;--passed:#198754;--failed:#d0104c;--errored:#b86e00;--skipped:#0f86b6;--open:#e3e8f0;--link:#0d6efd;--btn:#6c757d;--icon-text:#fff;--mono:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace}
-@media (prefers-color-scheme:dark){:root{--bg:#212529;--card:#212529;--head:#2b3035;--border:#495057;--text:#dee2e6;--dim:#adb5bd;--passed:#87EA67;--failed:#F50F55;--errored:#F5A623;--skipped:#4FC3E8;--open:#393D47;--link:#6ea8fe;--btn:#adb5bd;--icon-text:#212529}}
+: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}
-body{margin:0;background:var(--bg);color:var(--text);font:16px/1.5 system-ui,-apple-system,"Segoe UI",Roboto,"Helvetica Neue",sans-serif;padding:48px 0 32px}
-.container{max-width:1320px;margin:0 auto;padding:0 12px}
-.page-title{text-align:center;font-weight:500;font-size:2rem;margin:0 0 32px}
-.card{border:1px solid var(--border);border-radius:6px;margin-bottom:24px;background:var(--card)}
-.card-header{padding:8px 16px;background:var(--head);border-bottom:1px solid var(--border);border-radius:6px 6px 0 0}
+[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 .search,.card-h .file{margin-left:auto}
+.card-h .file{color:var(--dim);overflow-wrap:anywhere}
 .card-body{padding:16px}
-.card.inner{margin:16px 0 0}
-.acc-body .card{margin-bottom:16px}
-.pairs{display:grid;grid-template-columns:1fr 1fr;gap:0 24px}
-@media (max-width:800px){.pairs{grid-template-columns:1fr}}
-.field{display:flex;gap:12px;margin-bottom:16px;align-items:flex-start;min-width:0}
-.label{flex:0 0 190px}
-.value{border:1px solid var(--border);border-radius:6px;padding:0 8px;min-width:0;overflow-wrap:anywhere}
-.value.wide{flex:1}
-.value pre{margin:0;padding:4px 0}
-.md{padding:6px 0}
+.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}
+.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:17rem}
+.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)}
+.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(--head);border-radius:4px}
-.md-inline-code{background:var(--head);padding:1px 4px;border-radius:3px;font-size:13px}
+.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(--head)}
-.scroll{max-height:200px;overflow:auto}
-pre{margin:0;font-family:var(--mono);font-size:14px;white-space:pre-wrap;word-break:break-word}
-code{font-family:var(--mono);font-size:14px}
-.stats{width:100%;border-collapse:collapse;text-align:center;border:1px solid var(--border);font-variant-numeric:tabular-nums}
-.stats td{padding:8px}
-.stats tr:first-child td{background:var(--head)}
-.stats tr+tr td{border-top:1px solid var(--border)}
-.stats.small{width:50%;margin:0 auto}
-@media (max-width:800px){.stats.small{width:100%}}
-.overview{width:100%;border-collapse:collapse;font-variant-numeric:tabular-nums}
-.overview th,.overview td{border:1px solid var(--border);padding:8px;text-align:left;vertical-align:top}
-.overview th{background:var(--head);font-weight:600}
-.overview td.name{word-break:break-word}
-a{color:var(--link)}
-.dim{color:var(--dim)}
-.c-passed{color:var(--passed)}.c-failed{color:var(--failed)}.c-errored{color:var(--errored)}.c-skipped{color:var(--skipped)}
-.toolbar{display:flex;justify-content:space-between;align-items:center;gap:12px;flex-wrap:wrap;margin:40px 0 8px}
-.toolbar h3{margin:0;font-weight:500;font-size:1.75rem}
-.buttons{display:flex;gap:6px;justify-content:flex-end;flex-wrap:wrap}
-.toolbar.above{margin:40px 0 8px}
-.search{flex:1;min-width:200px;max-width:480px;font:inherit;padding:6px 12px;border:1px solid var(--btn);border-radius:6px;background:var(--card);color:var(--text)}
-.toolbar h3+.search{margin-left:16px}
-.toolbar .buttons{margin-left:auto}
-.unmatched{display:none}
-.btn{font:inherit;color:var(--btn);background:none;border:1px solid var(--btn);border-radius:6px;padding:6px 12px;cursor:pointer;text-decoration:none;display:inline-block}
-.btn:hover{background:var(--btn);color:var(--bg)}
-.btn.static{cursor:default}
-.btn.static:hover{background:none;color:var(--btn)}
-.hidden{display:none}
-.tests details.acc{border:1px solid var(--border);border-top:none;background:var(--card)}
-.tests details.acc:first-child{border-top:1px solid var(--border);border-radius:6px 6px 0 0}
-.tests details.acc:last-child{border-radius:0 0 6px 6px}
-.tests details.acc:only-child{border-radius:6px}
-details.acc>summary{list-style:none;cursor:pointer;padding:16px 20px;display:flex;align-items:center;justify-content:space-between;gap:12px}
-details.acc>summary::-webkit-details-marker{display:none}
-details.acc[open]>summary{background:var(--open)}
-.icon{flex:none;width:18px;height:18px;border-radius:3px;display:inline-grid;place-items:center;font-size:12px;font-weight:800;color:var(--icon-text)}
-.icon.passed{background:var(--passed)}.icon.failed{background:var(--failed)}.icon.errored{background:var(--errored)}.icon.skipped{background:var(--skipped)}
-.acc-body{padding:16px 20px}
-.detail-row{display:flex;justify-content:space-between;gap:16px;padding:6px 0}
-.detail-row+.detail-row{border-top:1px solid var(--border)}
-.detail-row.head{padding:0}
-.ea{font-size:14px;margin-top:2px}
-.console .log-warn{color:var(--errored)}.console .log-error{color:var(--failed)}
-footer.container{text-align:center;margin:48px auto 0}
-.small-print{margin-top:8px;font-size:12px;overflow-wrap:anywhere}
+.md-table th{background:var(--surface-alt)}
+.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 = `
-function toggle(button, status, noun) {
-  const hide = button.dataset.hidden !== 'true'
-  button.dataset.hidden = String(hide)
-  button.textContent = (hide ? 'Show ' : 'Hide ') + noun
-  for (const el of document.querySelectorAll('tr.' + status + ', details.acc.' + status)) el.classList.toggle('hidden', hide)
+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 \u2014 however they got that way.
-const tests = () => [...document.querySelectorAll('details.acc')]
+// 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'
 }
-function search(input) {
-  const query = input.value.trim().toLowerCase()
-  for (const el of document.querySelectorAll(input.dataset.target)) {
-    el.classList.toggle('unmatched', query !== '' && !el.dataset.search.includes(query))
+// 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, '')
   }
 }
-function expandAll() {
-  const open = tests().some((d) => !d.open)
-  for (const d of tests()) d.open = open
-  syncExpandAll()
+// 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', () => {
-  for (const d of tests()) d.addEventListener('toggle', syncExpandAll)
   syncExpandAll()
+  loadFrames(document)
 })
 `;
 
@@ -874,7 +1250,7 @@ function junitReport(run2) {
     `<testsuites${attributes({
       name: `gta: ${run2.project}`,
       ...total,
-      time: seconds3(run2.durationMs),
+      time: seconds(run2.durationMs),
       timestamp: timestamp(run2.startedAt)
     })}>`,
     ...suites.flatMap((s) => s.lines),
@@ -945,7 +1321,7 @@ function suite(collection, environment, flags) {
       `  <testsuite${attributes({
         name: id,
         ...counts,
-        time: seconds3(collection.durationMs),
+        time: seconds(collection.durationMs),
         timestamp: timestamp(collection.startedAt),
         hostname: os.hostname()
       })}>`,
@@ -961,11 +1337,11 @@ function suite(collection, environment, flags) {
   };
 }
 function testcase(classname, name, durationMs, body) {
-  const open = `    <testcase${attributes({ name, classname, time: seconds3(durationMs) })}`;
+  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}]` : result.item.name;
+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)];
@@ -975,7 +1351,7 @@ function describe(a) {
   return lines.join("\n");
 }
 var userFrames2 = (stack) => stack?.split("\n").filter((line) => !/^\s+at .*(\bnode:|file:\/\/)/.test(line)).join("\n");
-var seconds3 = (ms) => (ms / 1e3).toFixed(3);
+var 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("");
@@ -988,310 +1364,14 @@ function escape2(value) {
 }
 var allowedInXml = (code) => code === 9 || code === 10 || code === 13 || code >= 32 && code <= 55295 || code >= 57344 && code <= 65533 || code >= 65536;
 
-// src/json.ts
-var JSON_FORMAT_VERSION = 1;
-var BODY_LIMIT2 = 256 * 1024;
-function jsonReport(run2, reports) {
-  const tallies = run2.collections.map((c) => c.tally);
-  const sum = (pick) => tallies.reduce((n, t) => n + pick(t), 0);
-  const failed = tallies.filter((t) => !t.passed).length;
-  return {
-    formatVersion: JSON_FORMAT_VERSION,
-    tool: { name: "gta", version: run2.version },
-    project: { name: run2.project, root: run2.root },
-    run: {
-      result: failed === 0 ? "passed" : "failed",
-      startedAt: new Date(run2.startedAt).toISOString(),
-      durationMs: Math.round(run2.durationMs),
-      environment: run2.environment,
-      /** The feature flag values the run used, where each came from, and the command run (SPEC.md §2.9). */
-      flags: {
-        values: run2.flags ?? {},
-        sources: run2.flagSources ?? {},
-        command: run2.flagCommand ?? null
-      },
-      settings: {
-        limitConcurrency: run2.concurrency,
-        timeoutCollection: run2.timeoutCollection,
-        bail: run2.bail,
-        tags: run2.tags,
-        notTags: run2.notTags ?? []
-      }
-    },
-    totals: {
-      collections: { total: tallies.length, passed: tallies.length - failed, failed },
-      steps: {
-        total: sum((t) => t.steps.total),
-        passed: sum((t) => t.steps.passed),
-        failed: sum((t) => t.steps.failed),
-        errored: sum((t) => t.steps.errored),
-        skipped: sum((t) => t.steps.skipped)
-      },
-      assertions: {
-        total: sum((t) => t.assertions.total),
-        passed: sum((t) => t.assertions.passed),
-        failed: sum((t) => t.assertions.failed)
-      }
-    },
-    leftOut: { excluded: run2.excluded, untagged: run2.untagged },
-    reports,
-    collections: run2.collections.map(collectionOf)
-  };
-}
-function collectionOf(c) {
-  const { outcome, tally: tally2 } = c;
-  return {
-    id: c.id,
-    file: c.file,
-    status: tally2.skipped ? "skipped" : tally2.passed ? "passed" : "failed",
-    startedAt: new Date(c.startedAt).toISOString(),
-    durationMs: Math.round(c.durationMs),
-    counts: { steps: tally2.steps, assertions: tally2.assertions },
-    /** Why it did not run at all, or null when it ran. */
-    error: outcome.ok ? null : outcome.message,
-    /** The data file that ran it once per row (SPEC.md §2.8), or null. */
-    dataFile: outcome.ok ? outcome.data : null,
-    /** Steps a bail left unrun. */
-    notRun: outcome.ok ? unattempted(outcome.summary) : tally2.steps.total,
-    steps: outcome.ok ? outcome.summary.results.map(
-      (result, i) => stepOf(result, outcome.steps[i] ?? { index: i, line: null })
-    ) : []
-  };
-}
-function stepOf(result, ref) {
-  const truncated = {};
-  const clip3 = (field3, text) => {
-    if (text === null || text.length <= BODY_LIMIT2) return text;
-    truncated[field3] = text.length;
-    return text.slice(0, BODY_LIMIT2);
-  };
-  const request = { ...result.request, body: clip3("request.body", result.request.body) };
-  const response = result.response ? { ...result.response, body: clip3("response.body", result.response.body) ?? "" } : null;
-  return {
-    /** The step's place in the file's `steps`, from 0, and its line, from 1. */
-    step: { index: ref.index, line: ref.line },
-    /** The data file row it ran with, from 1, or null without a data file. */
-    iteration: ref.iteration ?? null,
-    ...result,
-    request,
-    response,
-    /** Fields cut short, with their full length in characters. */
-    ...Object.keys(truncated).length > 0 ? { truncated } : {}
-  };
-}
-function jsonListing(options) {
-  return {
-    formatVersion: JSON_FORMAT_VERSION,
-    project: options.project,
-    environments: options.environments,
-    environmentType: options.environmentType,
-    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, untagged: options.untagged },
-    problems: options.problems
-  };
-}
-var fileOf = (collection) => `collections/${collection.relativePath}`;
-var jsonError = (message, exitCode) => ({
-  formatVersion: JSON_FORMAT_VERSION,
-  error: { message, exitCode }
-});
-
-// src/settings.ts
-import fs from "node:fs/promises";
-import path from "node:path";
-var import_yaml = __toESM(require_dist(), 1);
-var SETTING_KEYS = {
-  environmentType: {
-    kind: "string",
-    doc: "The environment to run against, by name: environments/<name>.yml (the global project\u2019s too). Unset: no environment."
-  },
-  limitConcurrency: {
-    kind: "integer",
-    doc: "How many collections run at once. Steps within a collection always run in order."
-  },
-  timeoutCollection: {
-    kind: "integer",
-    doc: "Milliseconds a collection may take before it is stopped and reported failed."
-  },
-  bail: {
-    kind: "boolean",
-    doc: "Stop a collection at its first failing step; the rest are reported skipped."
-  },
-  tags: {
-    kind: "list",
-    doc: "Run only what has one of these tags (SPEC.md \xA72.4). Empty: everything."
-  },
-  notTags: {
-    kind: "list",
-    doc: "Leave out what has one of these tags: a collection tagged so, or a step where steps carry tags."
-  },
-  generateJUnitResults: {
-    kind: "boolean",
-    doc: "Write a JUnit XML report of the run to <testResultsBasePath>/junit/junit.xml, for CI."
-  },
-  generateJsonResults: {
-    kind: "boolean",
-    doc: "Write the run as JSON to <testResultsBasePath>/json/results.json, for tools and agents."
-  },
-  generateHtmlResults: {
-    kind: "boolean",
-    doc: "Write an HTML report of the run: <testResultsBasePath>/html/summary.html and a page per collection."
-  },
-  autoOpenTestResultHtml: {
-    kind: "boolean",
-    doc: "Write the HTML report and open its summary in the browser when the run ends."
-  },
-  testResultsBasePath: {
-    kind: "string",
-    doc: "Where reports are written: relative to the project folder, or absolute."
-  }
-};
-var KEYS = Object.keys(SETTING_KEYS);
-var positiveInteger = external_exports.number().int().min(1);
-var SettingsSchema = external_exports.strictObject({
-  environmentType: external_exports.string().trim().min(1).nullable().default(null),
-  limitConcurrency: positiveInteger.default(1),
-  timeoutCollection: positiveInteger.default(36e5),
-  bail: external_exports.boolean().default(false),
-  tags: external_exports.array(TagSchema).default([]),
-  notTags: external_exports.array(TagSchema).default([]),
-  generateJUnitResults: external_exports.boolean().default(false),
-  generateJsonResults: external_exports.boolean().default(false),
-  generateHtmlResults: external_exports.boolean().default(false),
-  autoOpenTestResultHtml: external_exports.boolean().default(false),
-  testResultsBasePath: external_exports.string().trim().min(1).default("test-results")
-});
-var DEFAULT_SETTINGS = SettingsSchema.parse({});
-var SettingsError = class extends Error {
-  name = "SettingsError";
-};
-var envNameOf = (key) => `GTA_${key.replace(/[A-Z]/g, (c) => `_${c}`).toUpperCase()}`;
-var DEFAULT_SOURCE = "default";
-async function loadSettings(options) {
-  const { root, global = null, overrides = {}, env = process.env } = options;
-  const own = await readSettingsFile(path.join(root, SETTINGS_FILE), SETTINGS_FILE);
-  if (own === null) {
-    throw new SettingsError(
-      `There is no ${SETTINGS_FILE} in ${root}.
-gta runs from a project folder: the one holding collections/ and ${SETTINGS_FILE}.
-A minimal ${SETTINGS_FILE}:
-
-  environmentType: demo
-  limitConcurrency: 4
-`
-    );
-  }
-  const sharedLabel = global ? path.posix.join(global.uses, SETTINGS_FILE) : "";
-  const shared = global ? await readSettingsFile(path.join(global.root, SETTINGS_FILE), sharedLabel) : null;
-  const origin = /* @__PURE__ */ new Map();
-  const merged = {};
-  const files = [
-    [sharedLabel, shared],
-    [SETTINGS_FILE, own]
-  ];
-  for (const [label, fromFile] of files) {
-    for (const [key, value] of Object.entries(fromFile ?? {})) {
-      checkKey(key, label);
-      merged[key] = value;
-      origin.set(key, label);
-    }
-  }
-  for (const key of KEYS) {
-    const value = env[envNameOf(key)];
-    if (value === void 0 || value === "") continue;
-    merged[key] = coerce(key, value, envNameOf(key));
-    origin.set(key, envNameOf(key));
-  }
-  for (const [key, value] of Object.entries(overrides)) {
-    checkKey(key, `--${key}`);
-    merged[key] = coerce(key, value, `--${key}`);
-    origin.set(key, `--${key}`);
-  }
-  const result = SettingsSchema.safeParse(merged);
-  if (!result.success) {
-    const lines = result.error.issues.map((issue) => {
-      const key = String(issue.path[0] ?? "");
-      return `  ${key} (from ${origin.get(key) ?? SETTINGS_FILE}): ${issue.message}`;
-    });
-    throw new SettingsError(`Settings are not valid:
-${lines.join("\n")}`);
-  }
-  const sources = Object.fromEntries(
-    KEYS.map((key) => [key, origin.get(key) ?? DEFAULT_SOURCE])
-  );
-  return { settings: result.data, sources };
-}
-async function readSettingsFile(file, label) {
-  let source;
-  try {
-    source = await fs.readFile(file, "utf8");
-  } catch (cause) {
-    if (cause.code === "ENOENT") return null;
-    throw new SettingsError(`${label} cannot be read: ${cause.message}`);
-  }
-  let fromFile;
-  try {
-    fromFile = (0, import_yaml.parse)(source) ?? {};
-  } catch (cause) {
-    throw new SettingsError(`${label} will not parse: ${cause.message}`);
-  }
-  if (typeof fromFile !== "object" || fromFile === null || Array.isArray(fromFile)) {
-    throw new SettingsError(`${label} must be a map of settings, such as limitConcurrency: 4`);
-  }
-  return fromFile;
-}
-function checkKey(key, where) {
-  if (!Object.hasOwn(SETTING_KEYS, key)) {
-    throw new SettingsError(
-      `Unknown setting "${key}" (from ${where}). Settings are: ${KEYS.join(", ")}`
-    );
-  }
-}
-function coerce(key, value, where) {
-  const { kind } = SETTING_KEYS[key];
-  if (value === true) {
-    if (kind === "boolean") return true;
-    throw new SettingsError(`${where} needs a value`);
-  }
-  switch (kind) {
-    case "integer":
-      return /^\s*\d+\s*$/.test(value) ? Number(value) : value;
-    case "boolean":
-      return value === "true" ? true : value === "false" ? false : value;
-    case "list":
-      return value.split(",").map((item) => item.trim()).filter((item) => item !== "");
-    case "string":
-      return value;
-  }
-}
-
 // src/main.ts
-var VERSION = true ? "0.13.0" : "0.0.0-dev";
+var VERSION = true ? "0.14.1" : "0.0.0-dev";
 var JUNIT_DIR = "junit";
 var JUNIT_FILE = "junit.xml";
 var HTML_DIR = "html";
 var JSON_DIR = "json";
 var JSON_FILE = "results.json";
 var EXIT = { passed: 0, failed: 1, unusable: 2 };
-var ProjectError = class extends Error {
-  name = "ProjectError";
-};
 async function main(argv, cli) {
   let ctx = cli;
   let p = paint(ctx.color);
@@ -1312,9 +1392,25 @@ async function main(argv, cli) {
       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(`gta ${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}`));
-    const command = args.command;
     if (command === "g" || command === "get") {
       const selection = selectFor(project, { kind: "all" });
       const problems = await listingProblems(project, selection);
@@ -1343,7 +1439,7 @@ async function main(argv, cli) {
     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) {
+    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));
@@ -1352,63 +1448,7 @@ async function main(argv, cli) {
     throw cause;
   }
 }
-async function openProject(ctx, overrides, flagArgs = []) {
-  const root = await canonical(ctx.cwd);
-  if (!await isDirectory(path2.join(root, COLLECTIONS_DIR))) {
-    throw new ProjectError(
-      `There is no ${COLLECTIONS_DIR}/ in ${root}.
-gta runs from a project folder: the one holding ${COLLECTIONS_DIR}/ and ${SETTINGS_FILE}.`
-    );
-  }
-  const info = await readProject(root);
-  const { settings, sources: settingSources } = await loadSettings({
-    root,
-    global: info.global,
-    overrides,
-    env: ctx.env
-  });
-  const layout = await discoverProject(root);
-  const collections = await loadProjectCollections(root, layout.files);
-  const environments = environmentNames(await projectEnvironments(root, info.global));
-  if (settings.environmentType && !environments.includes(settings.environmentType)) {
-    throw new ProjectError(
-      `environmentType (from ${settingSources.environmentType}): there is no environment called "${settings.environmentType}". ` + (environments.length > 0 ? `This project has: ${environments.join(", ")}` : `This project has no environments/.`)
-    );
-  }
-  let flags;
-  try {
-    flags = await resolveFlags({
-      root,
-      environmentName: settings.environmentType,
-      overrides: flagOverrides(flagArgs, ctx.env),
-      env: { ...process.env, ...ctx.env }
-    });
-  } catch (cause) {
-    throw new ProjectError(cause.message);
-  }
-  const tls = await loadProjectTls(root, info);
-  if (tls.problems.length > 0) {
-    throw new ProjectError(
-      `A certificate in tls.ca cannot be used:
-` + tls.problems.map((problem) => `  ${problem.path}: ${problem.message}`).join("\n")
-    );
-  }
-  return {
-    root,
-    name: info.doc?.name ?? path2.basename(root),
-    settings,
-    settingSources,
-    flags,
-    collections,
-    environments,
-    caFiles: tls.files.map(
-      (file) => `${relativePosix(root, file.file)} (${file.certificates.map((c) => c.subject).join(", ")})`
-    ),
-    warnings: [...info.problems, ...layout.problems].map(
-      (problem) => problem.path ? `${problem.path}: ${problem.message}` : problem.message
-    )
-  };
-}
+var 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
@@ -1445,12 +1485,12 @@ function list(project, selection, problems, ctx, p) {
   ctx.out("");
   const width = nameWidthFor(selection.targets.map((t) => t.id));
   const dirWidth = Math.max(
-    "Directory".length,
+    "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)}  ${"Directory".padEnd(dirWidth)}  Tags`
+      `${"#".padStart(4)}  ${"Collection".padEnd(width)} ${"Steps".padStart(7)} ${"Rows".padStart(5)}  ${"Folder".padEnd(dirWidth)}  Tags`
     )
   );
   selection.targets.forEach((target, i) => {
@@ -1647,8 +1687,8 @@ async function run(project, selection, ctx, p, emit = null) {
     try {
       for (const file of report.files()) {
         const target = path2.join(report.dir, ...file.path.split("/"));
-        await fs2.mkdir(path2.dirname(target), { recursive: true });
-        await fs2.writeFile(target, file.text);
+        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);
@@ -1685,15 +1725,20 @@ function usage(p) {
     "                    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 with exclude: true.",
-    "    <list>          Run the collections and directories named, comma separated,",
+    "    <list>          Run the collections and folders named, comma separated,",
     "                    in that order: smoke,checkout/sessions,payments",
-    "                    A directory leaves out its excluded collections;",
+    "                    A folder leaves out its excluded collections;",
     "                    one named on its own runs.",
-    "                    A collection called all or get: give it as all.yml.",
+    "                    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. Errors are JSON too.",
+    "                    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.",
     "                    GTA_FLAG_<name>=value does the same from the environment.",
@@ -1705,13 +1750,6 @@ function usage(p) {
     `  ${p.bold("Exit code:")} 0 passed, 1 failed, 2 could not run (or write a report).`
   ].join("\n");
 }
-async function isDirectory(target) {
-  try {
-    return (await fs2.stat(target)).isDirectory();
-  } catch {
-    return false;
-  }
-}
 var wantsHtml = (settings) => settings.generateHtmlResults || settings.autoOpenTestResultHtml;
 var RESULT_DIRS = {
   [JUNIT_DIR]: (name) => name === JUNIT_FILE,
@@ -1725,14 +1763,14 @@ async function clearResults(dir, projectRoot) {
   }
   let entries;
   try {
-    entries = await fs2.readdir(dir);
+    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 fs2.readdir(path2.join(dir, folder)).catch(() => []);
+    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}`)
     );
@@ -1741,7 +1779,7 @@ async function clearResults(dir, projectRoot) {
     return `${dir} holds files gta did not write (${others.slice(0, 5).join(", ")}${others.length > 5 ? ", \u2026" : ""}), so it will not delete it before the run. Point testResultsBasePath somewhere else, or remove them.`;
   }
   try {
-    await fs2.rm(dir, { recursive: true, force: true });
+    await fs.rm(dir, { recursive: true, force: true });
     return null;
   } catch (cause) {
     return `Could not delete ${dir} before the run: ${cause.message}`;