apitestcenter 0.4.0 → 0.5.0

package/README.md

@@ -10,6 +10,8 @@ npx apitestcenter suite "Orders API" --env UAT --junit results.xml
 npx apitestcenter run "Orders API/List orders" --env UAT --p95 500 --errors 1 --junit results.xml
 ```
 
+With `npx`, use the full name `apitestcenter`. Installed (`npm install -g apitestcenter`), the short name `atc` works too: `atc suite "Orders API"`.
+
 Build and save your requests in the free [APITestCenter desktop app](https://apitestcenter.com/#download), then run them here. Exit code **0** means everything passed, **1** means something failed, **2** means it could not start.
 
 ## In a pipeline

package/dist/THIRD-PARTY-NOTICES.txt

@@ -1,4 +1,4 @@
-APITestCenter CLI 0.4.0 — third-party notices
+APITestCenter CLI 0.5.0 — third-party notices
 
 This package bundles the open-source packages below. k6 (AGPL-3.0) is not bundled: if it is
 not installed, the CLI downloads the unmodified official release from github.com/grafana/k6.

package/dist/cli.mjs

@@ -50215,9 +50215,9 @@ var LATENCY_BIN_EDGES_MS = [
   1e4,
   Infinity
 ];
-function latencyBin(ms2) {
+function latencyBin(ms3) {
   for (let i = 0; i < LATENCY_BIN_EDGES_MS.length; i++) {
-    if (ms2 <= LATENCY_BIN_EDGES_MS[i]) return i;
+    if (ms3 <= LATENCY_BIN_EDGES_MS[i]) return i;
   }
   return LATENCY_BIN_EDGES_MS.length - 1;
 }
@@ -50757,7 +50757,7 @@ function deltaVsBaseline(current, baseline) {
 
 // ../shared/src/junit.ts
 var esc2 = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-function exportRunJunit(report, verdict, checksRate = 0.99) {
+function exportRunJunit(report, verdict, checksRate2 = 0.99, extra = []) {
   const seconds2 = Math.max(0, (Date.parse(report.endedAt) - Date.parse(report.startedAt)) / 1e3);
   const cases = [];
   let failures = 0;
@@ -50773,9 +50773,10 @@ function exportRunJunit(report, verdict, checksRate = 0.99) {
   for (const c of report.summary.checks) {
     const total = c.passes + c.fails;
     const rate = total ? c.passes / total : 1;
-    add("checks", c.name, rate < checksRate ? `${c.fails} of ${total} failed (${(rate * 100).toFixed(2)}% passed)` : void 0);
+    add("checks", c.name, rate < checksRate2 ? `${c.fails} of ${total} failed (${(rate * 100).toFixed(2)}% passed)` : void 0);
   }
   for (const a of verdict.aspects) add("verdict", a.title, a.level === "fail" ? a.summary : void 0);
+  for (const e of extra) add(e.classname, e.name, e.failure);
   return `<?xml version="1.0" encoding="UTF-8"?>
 <testsuites name="APITestCenter" tests="${cases.length}" failures="${failures}" time="${seconds2.toFixed(1)}">
   <testsuite name="${esc2(report.testName)}" tests="${cases.length}" failures="${failures}" time="${seconds2.toFixed(1)}" timestamp="${esc2(report.startedAt)}">
@@ -50848,7 +50849,7 @@ function suiteHeadline(run) {
   return parts.join(" \xB7 ");
 }
 var xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-var seconds = (ms2) => ((ms2 ?? 0) / 1e3).toFixed(3);
+var seconds = (ms3) => ((ms3 ?? 0) / 1e3).toFixed(3);
 function exportSuiteJunit(run) {
   const t = suiteTotals(run.steps);
   const name = run.collection || "Saved requests";
@@ -50961,6 +50962,132 @@ ${rows2}
 `;
 }
 
+// ../shared/src/before-after.ts
+var LABELS = {
+  p50: ["Typical response time", "p50"],
+  p95: ["Response time", "p95"],
+  p99: ["Slowest 1%", "p99"],
+  rps: ["Requests per second", "throughput"],
+  errorRate: ["Failed requests", "error rate"],
+  checksRate: ["Checks passed", "checks rate"]
+};
+function checksRate(r) {
+  const passes = r.summary.checks.reduce((n, c) => n + c.passes, 0);
+  const fails = r.summary.checks.reduce((n, c) => n + c.fails, 0);
+  return passes + fails ? passes / (passes + fails) : null;
+}
+function plannedLoad(r) {
+  const load = r.definition.load;
+  const rate = load.executor.endsWith("arrival-rate");
+  const peak = rate ? load.rate ?? Math.max(0, ...load.stages.map((s) => s.target)) : Math.max(0, ...load.stages.map((s) => s.target));
+  const ms3 = load.stages.reduce((n, s) => n + durationToMs(s.duration), 0);
+  return { rate, peak, ms: ms3 };
+}
+var pct = (v) => `${Math.round(Math.abs(v) * 100)}%`;
+var ms = (v) => v >= 1e3 ? `${(v / 1e3).toFixed(2)} s` : `${Math.round(v)} ms`;
+var pts = (v) => `${(v * 100).toFixed(v < 0.1 ? 1 : 0)}%`;
+function fairness(before, after) {
+  const unfair = [];
+  const caveats = [];
+  const a = endpointKey(before.definition.method, before.definition.url);
+  const b = endpointKey(after.definition.method, after.definition.url);
+  if (a !== b) unfair.push(`they test different requests (${a} and ${b})`);
+  const pa = plannedLoad(before);
+  const pb = plannedLoad(after);
+  if (pa.rate !== pb.rate) unfair.push("one held a request rate and the other used simulated users");
+  else if (pa.peak !== pb.peak) unfair.push(`the load was different (${pa.peak} vs ${pb.peak} ${pa.rate ? "requests per second" : "users"} at the peak)`);
+  if (pa.ms && pb.ms && Math.abs(pa.ms - pb.ms) / Math.max(pa.ms, pb.ms) > 0.25) caveats.push("the runs were planned for different lengths");
+  for (const [r, which] of [[before, "before"], [after, "after"]]) {
+    if (r.endReason === "stopped") caveats.push(`the ${which} run was stopped early`);
+    if (r.endReason === "target-missed") caveats.push(`the ${which} run stopped early because a goal was missed`);
+  }
+  return { unfair, caveats };
+}
+function compareRuns(before, after, opts = {}) {
+  const minRelative = opts.minRelative ?? 0.05;
+  const minMs = opts.minMs ?? 10;
+  const minRate = opts.minRate ?? 5e-3;
+  const errorHeavy = before.summary.http.failed.rate >= 0.5 || after.summary.http.failed.rate >= 0.5;
+  const metric = (key, b, a, higherIsBetter, kind) => {
+    const [label, tech] = LABELS[key];
+    const base = { key, label, tech, before: b, after: a };
+    if (b == null || a == null) return { ...base, relative: null, absolute: null, direction: "n/a", note: "not measured in both runs" };
+    const absolute = a - b;
+    const relative2 = b > 0 ? a / b - 1 : a > 0 ? null : 0;
+    if (kind === "ms" && errorHeavy) return { ...base, relative: relative2, absolute, direction: "n/a", note: "mostly error responses \u2014 not the API's speed" };
+    const small = kind === "rate" ? Math.abs(absolute) < minRate : Math.abs(relative2 ?? 1) < minRelative || kind === "ms" && Math.abs(absolute) < minMs;
+    const direction = small || absolute === 0 ? "same" : absolute > 0 === higherIsBetter ? "better" : "worse";
+    return { ...base, relative: relative2, absolute, direction };
+  };
+  const s0 = before.summary;
+  const s1 = after.summary;
+  const metrics = [
+    metric("p95", s0.latencyMs.p95, s1.latencyMs.p95, false, "ms"),
+    metric("p50", s0.latencyMs.median, s1.latencyMs.median, false, "ms"),
+    metric("p99", s0.latencyMs.p99, s1.latencyMs.p99, false, "ms"),
+    metric("rps", s0.http.rps.avg, s1.http.rps.avg, true, "count"),
+    metric("errorRate", s0.http.failed.rate, s1.http.failed.rate, false, "rate")
+  ];
+  const c0 = checksRate(before);
+  const c1 = checksRate(after);
+  if (c0 != null || c1 != null) metrics.push(metric("checksRate", c0, c1, true, "rate"));
+  const { unfair, caveats } = fairness(before, after);
+  const by = Object.fromEntries(metrics.map((m) => [m.key, m]));
+  const p95 = by.p95;
+  const errors = by.errorRate;
+  const checks = by.checksRate;
+  let level;
+  let headline;
+  if (unfair.length) {
+    level = "unfair";
+    headline = `Not a fair comparison: ${unfair.join("; ")}. The numbers are shown, but don't read them as better or worse.`;
+  } else if (errors.direction === "worse") {
+    level = "worse";
+    headline = `After fails more often: ${pts(errors.before)} \u2192 ${pts(errors.after)} of requests failed.`;
+  } else if (checks?.direction === "worse") {
+    level = "worse";
+    headline = `After gives more wrong answers: checks passed ${pts(checks.before)} \u2192 ${pts(checks.after)}.`;
+  } else if (p95.direction === "worse") {
+    level = "worse";
+    headline = `After is ${pct(p95.relative ?? 0)} slower: 95% of requests within ${ms(p95.before)} \u2192 ${ms(p95.after)}. That is more than normal run-to-run variation.`;
+  } else if (p95.direction === "better") {
+    const otherWorse = metrics.some((m) => m.direction === "worse");
+    level = otherWorse ? "mixed" : "better";
+    headline = `After is ${pct(p95.relative ?? 0)} faster: 95% of requests within ${ms(p95.before)} \u2192 ${ms(p95.after)}.${otherWorse ? " Some other measures got worse \u2014 see below." : ""}`;
+  } else if (errors.direction === "better") {
+    level = "better";
+    headline = `After fails less often: ${pts(errors.before)} \u2192 ${pts(errors.after)} of requests failed. Speed is about the same.`;
+  } else if (p95.direction === "n/a") {
+    level = "same";
+    headline = "Speed can't be compared: most responses in at least one run were errors.";
+  } else {
+    const worse = metrics.filter((m) => m.direction === "worse");
+    level = worse.length ? "mixed" : "same";
+    headline = worse.length ? `Response time is about the same, but ${worse.map((m) => m.label.toLowerCase()).join(" and ")} got worse.` : "About the same \u2014 the differences are within normal run-to-run variation.";
+  }
+  if (!unfair.length && caveats.length) headline += ` Note: ${caveats.join("; ")}.`;
+  return {
+    before: { id: before.id, name: before.testName, startedAt: before.startedAt },
+    after: { id: after.id, name: after.testName, startedAt: after.startedAt },
+    metrics,
+    fair: unfair.length === 0,
+    reasons: [...unfair, ...caveats],
+    level,
+    headline
+  };
+}
+function slowerThanAllowed(result, maxSlower) {
+  const p95 = result.metrics.find((m) => m.key === "p95");
+  const errors = result.metrics.find((m) => m.key === "errorRate");
+  if (!result.fair) return { failed: false, reason: `not compared: ${result.reasons[0]}` };
+  if (errors.direction === "worse") return { failed: true, reason: `more requests failed than in the baseline (${pts(errors.before)} \u2192 ${pts(errors.after)})` };
+  if (p95.direction === "n/a" || p95.relative == null) return { failed: false, reason: "response times can't be compared" };
+  if (p95.relative > maxSlower && p95.direction === "worse") {
+    return { failed: true, reason: `${pct(p95.relative)} slower than the baseline (p95 ${ms(p95.before)} \u2192 ${ms(p95.after)}), more than the ${pct(maxSlower)} allowed` };
+  }
+  return { failed: false, reason: `p95 ${ms(p95.before)} \u2192 ${ms(p95.after)} (${p95.relative >= 0 ? "+" : "\u2212"}${pct(p95.relative)}), within the ${pct(maxSlower)} allowed` };
+}
+
 // ../shared/src/export.ts
 function exportRunJson(report, exportedAt = (/* @__PURE__ */ new Date()).toISOString()) {
   return `${JSON.stringify(
@@ -51061,9 +51188,9 @@ var C = {
   heat: ["#eef4fc", "#c3d9f5", "#86b6ef", "#3987e5", "#256abf", "#104281"]
 };
 var esc3 = (v) => String(v).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-var ms = (n) => !Number.isFinite(n) ? "\u2014" : n < 10 ? `${n.toFixed(1)} ms` : n >= 1e4 ? `${(n / 1e3).toFixed(1)} s` : `${Math.round(n)} ms`;
+var ms2 = (n) => !Number.isFinite(n) ? "\u2014" : n < 10 ? `${n.toFixed(1)} ms` : n >= 1e4 ? `${(n / 1e3).toFixed(1)} s` : `${Math.round(n)} ms`;
 var rps = (n) => !Number.isFinite(n) ? "\u2014" : n >= 1e3 ? `${(n / 1e3).toFixed(2)}k` : n.toFixed(n >= 100 ? 0 : 1);
-var pct = (n) => `${(n * 100).toFixed(n < 0.01 ? 2 : 1)}%`;
+var pct2 = (n) => `${(n * 100).toFixed(n < 0.01 ? 2 : 1)}%`;
 var num2 = (n) => new Intl.NumberFormat("en-US").format(Math.round(n));
 var bytes = (n) => n < 1024 ? `${n} B` : n < 1024 * 1024 ? `${(n / 1024).toFixed(1)} KB` : `${(n / (1024 * 1024)).toFixed(2)} MB`;
 var secs = (n) => n >= 60 ? `${Math.floor(n / 60)}m ${n % 60 ? `${n % 60}s` : ""}`.trim() : `${n}s`;
@@ -51078,26 +51205,26 @@ function kpiFor(report, key, slo) {
       return { text: `${rps(s.http.rps.max)} rps`, hint: `average ${rps(s.http.rps.avg)}` };
     case "p95": {
       const bar = slo?.p95Ms ?? 500;
-      if (s.http.failed.rate >= 0.5) return { text: ms(s.latencyMs.p95), hint: "mostly error responses \u2014 not the API\u2019s speed" };
+      if (s.http.failed.rate >= 0.5) return { text: ms2(s.latencyMs.p95), hint: "mostly error responses \u2014 not the API\u2019s speed" };
       const tone = s.latencyMs.p95 >= (slo ? bar : 2e3) ? "bad" : s.latencyMs.p95 >= bar * (slo ? 0.8 : 1) ? "warn" : "ok";
-      return { text: ms(s.latencyMs.p95), hint: `slowest 1% ${ms(s.latencyMs.p99)}`, tone };
+      return { text: ms2(s.latencyMs.p95), hint: `slowest 1% ${ms2(s.latencyMs.p99)}`, tone };
     }
     case "p50":
-      return { text: ms(s.latencyMs.median), hint: "half of requests were faster" };
+      return { text: ms2(s.latencyMs.median), hint: "half of requests were faster" };
     case "avg":
-      return { text: ms(s.latencyMs.mean), hint: `typical spread \xB1${ms(s.latencyMs.stdDev)}` };
+      return { text: ms2(s.latencyMs.mean), hint: `typical spread \xB1${ms2(s.latencyMs.stdDev)}` };
     case "p99":
-      return { text: ms(s.latencyMs.p99), hint: `slowest ${ms(s.latencyMs.max)}` };
+      return { text: ms2(s.latencyMs.p99), hint: `slowest ${ms2(s.latencyMs.max)}` };
     case "max":
-      return { text: ms(s.latencyMs.max), hint: `fastest ${ms(s.latencyMs.min)}` };
+      return { text: ms2(s.latencyMs.max), hint: `fastest ${ms2(s.latencyMs.min)}` };
     case "ttfb": {
       const share = s.latencyMs.mean > 0 ? Math.min(1, s.phasesMs.ttfb.avg / s.latencyMs.mean) : 0;
-      return { text: ms(s.phasesMs.ttfb.avg), hint: `${Math.round(share * 100)}% of the response time` };
+      return { text: ms2(s.phasesMs.ttfb.avg), hint: `${Math.round(share * 100)}% of the response time` };
     }
     case "errors": {
       const rate = s.http.failed.rate;
       const tone = rate >= (slo ? slo.errorRate : 0.05) ? "bad" : rate >= (slo ? slo.errorRate * 0.5 : 0.01) ? "warn" : "ok";
-      return { text: pct(rate), hint: `${num2(s.http.failed.count)} failed`, tone };
+      return { text: pct2(rate), hint: `${num2(s.http.failed.count)} failed`, tone };
     }
     case "checks": {
       const passes = s.checks.reduce((n, c) => n + c.passes, 0);
@@ -51105,7 +51232,7 @@ function kpiFor(report, key, slo) {
       if (!passes && !fails) return { text: "\u2014", hint: "no checks set" };
       const rate = passes / (passes + fails);
       const goal = slo?.checksRate ?? 0.99;
-      return { text: pct(rate), hint: `${num2(fails)} failed`, tone: rate >= goal ? "ok" : rate >= goal - 0.05 ? "warn" : "bad" };
+      return { text: pct2(rate), hint: `${num2(fails)} failed`, tone: rate >= goal ? "ok" : rate >= goal - 0.05 ? "warn" : "bad" };
     }
     case "vus":
       return { text: String(s.vus.max), hint: `average ${s.vus.avg.toFixed(1)}` };
@@ -51222,15 +51349,15 @@ function heatmap(report) {
 }
 function scatter(report) {
   const rate = report.definition.load.executor.endsWith("arrival-rate");
-  const pts = report.buckets.filter((b) => b.rps > 0).map((b) => ({ x: rate ? b.rps : b.vus, y: b.p95Ms, t: b.elapsedS }));
-  if (pts.length < 3) return `<p class="empty">Not enough data points.</p>`;
+  const pts2 = report.buckets.filter((b) => b.rps > 0).map((b) => ({ x: rate ? b.rps : b.vus, y: b.p95Ms, t: b.elapsedS }));
+  if (pts2.length < 3) return `<p class="empty">Not enough data points.</p>`;
   const H = 210;
-  const xt = niceMax(Math.max(...pts.map((p) => p.x)));
-  const yt = niceMax(Math.max(...pts.map((p) => p.y)));
+  const xt = niceMax(Math.max(...pts2.map((p) => p.x)));
+  const yt = niceMax(Math.max(...pts2.map((p) => p.y)));
   const sx = (v) => PAD.l + v / xt * (W - PAD.l - PAD.r);
   const sy = (v) => H - PAD.b - v / yt * (H - PAD.t - PAD.b);
-  const dots = pts.map((p) => `<circle cx="${sx(p.x).toFixed(1)}" cy="${sy(p.y).toFixed(1)}" r="4" fill="${C.series[0]}" fill-opacity=".75" stroke="#fff" stroke-width="1.5"><title>${esc3(secs(p.t))}: ${rate ? `${rps(p.x)} rps` : `${p.x} users`} \u2192 ${esc3(ms(p.y))}</title></circle>`).join("");
-  const axes = [0, 0.5, 1].map((k) => `<line x1="${PAD.l}" x2="${W - PAD.r}" y1="${sy(yt * k)}" y2="${sy(yt * k)}" class="g"/><text x="${PAD.l - 6}" y="${sy(yt * k) + 3.5}" class="t" text-anchor="end">${esc3(ms(yt * k))}</text><text x="${sx(xt * k)}" y="${H - 6}" class="t" text-anchor="middle">${esc3(rate ? rps(xt * k) : String(Math.round(xt * k)))}</text>`).join("");
+  const dots = pts2.map((p) => `<circle cx="${sx(p.x).toFixed(1)}" cy="${sy(p.y).toFixed(1)}" r="4" fill="${C.series[0]}" fill-opacity=".75" stroke="#fff" stroke-width="1.5"><title>${esc3(secs(p.t))}: ${rate ? `${rps(p.x)} rps` : `${p.x} users`} \u2192 ${esc3(ms2(p.y))}</title></circle>`).join("");
+  const axes = [0, 0.5, 1].map((k) => `<line x1="${PAD.l}" x2="${W - PAD.r}" y1="${sy(yt * k)}" y2="${sy(yt * k)}" class="g"/><text x="${PAD.l - 6}" y="${sy(yt * k) + 3.5}" class="t" text-anchor="end">${esc3(ms2(yt * k))}</text><text x="${sx(xt * k)}" y="${H - 6}" class="t" text-anchor="middle">${esc3(rate ? rps(xt * k) : String(Math.round(xt * k)))}</text>`).join("");
   return `<svg viewBox="0 0 ${W} ${H}" role="img" aria-label="Load against response time">${axes}${dots}</svg><p class="note">Each dot is one second: ${rate ? "requests per second" : "simulated users"} across, response time (95% of requests) up. Where the dots climb is where the API starts to struggle.</p>`;
 }
 function widgetBody(w, report, opts) {
@@ -51260,8 +51387,8 @@ function widgetBody(w, report, opts) {
     case "latency": {
       const keys = o.percentiles?.length ? o.percentiles : ["p50", "p95", "p99"];
       const pick2 = { p50: (k) => k.p50Ms, p90: (k) => k.p90Ms, p95: (k) => k.p95Ms, p99: (k) => k.p99Ms, p999: (k) => k.p999Ms, max: (k) => k.maxMs };
-      return timeChart(x, keys.map((k) => ({ label: PERCENTILE_LABEL[k], color: C.pct[k], values: b.map((k2) => pick2[k](k2) ?? null) })), ms, {
-        ref: o.showTarget !== false && slo?.p95Ms ? { value: slo.p95Ms, label: `goal ${ms(slo.p95Ms)}` } : void 0
+      return timeChart(x, keys.map((k) => ({ label: PERCENTILE_LABEL[k], color: C.pct[k], values: b.map((k2) => pick2[k](k2) ?? null) })), ms2, {
+        ref: o.showTarget !== false && slo?.p95Ms ? { value: slo.p95Ms, label: `goal ${ms2(slo.p95Ms)}` } : void 0
       });
     }
     case "throughput":
@@ -51269,8 +51396,8 @@ function widgetBody(w, report, opts) {
     case "vus":
       return timeChart(x, [{ label: "Simulated users", color: C.series[6], values: b.map((k) => k.vus) }], (n) => String(Math.round(n)), { area: true });
     case "errors":
-      return timeChart(x, [{ label: "Failed requests", color: C.bad, values: b.map((k) => k.failedRate) }], pct, {
-        ref: o.showTarget !== false && slo ? { value: slo.errorRate, label: `goal ${pct(slo.errorRate)}` } : void 0
+      return timeChart(x, [{ label: "Failed requests", color: C.bad, values: b.map((k) => k.failedRate) }], pct2, {
+        ref: o.showTarget !== false && slo ? { value: slo.errorRate, label: `goal ${pct2(slo.errorRate)}` } : void 0
       });
     case "status":
       return timeChart(
@@ -51294,10 +51421,10 @@ function widgetBody(w, report, opts) {
           { label: "TCP connect", color: C.series[1], values: b.map((k) => k.connectMs ?? null) },
           { label: "TLS handshake", color: C.series[2], values: b.map((k) => k.tlsMs ?? null) }
         ],
-        ms
+        ms2
       );
     case "checksRate":
-      return timeChart(x, [{ label: "Checks passing", color: C.ok, values: b.map((k) => k.checksPassed != null && k.checksPassed + (k.checksFailed ?? 0) > 0 ? k.checksPassed / (k.checksPassed + (k.checksFailed ?? 0)) : null) }], pct);
+      return timeChart(x, [{ label: "Checks passing", color: C.ok, values: b.map((k) => k.checksPassed != null && k.checksPassed + (k.checksFailed ?? 0) > 0 ? k.checksPassed / (k.checksPassed + (k.checksFailed ?? 0)) : null) }], pct2);
     case "dropped":
       return timeChart(x, [{ label: "Requests not sent", color: C.warn, values: b.map((k) => k.dropped ?? null) }], (n) => String(Math.round(n)));
     case "histogram":
@@ -51307,12 +51434,12 @@ function widgetBody(w, report, opts) {
     case "percentiles": {
       const l = report.summary.latencyMs;
       return barList([
-        { label: "Fastest", value: l.min, color: C.mute, text: ms(l.min) },
-        { label: PERCENTILE_LABEL.p50, value: l.median, color: C.pct.p50, text: ms(l.median) },
-        { label: PERCENTILE_LABEL.p90, value: l.p90, color: C.pct.p90, text: ms(l.p90) },
-        { label: PERCENTILE_LABEL.p95, value: l.p95, color: C.pct.p95, text: ms(l.p95) },
-        { label: PERCENTILE_LABEL.p99, value: l.p99, color: C.pct.p99, text: ms(l.p99) },
-        { label: PERCENTILE_LABEL.max, value: l.max, color: C.ink, text: ms(l.max) }
+        { label: "Fastest", value: l.min, color: C.mute, text: ms2(l.min) },
+        { label: PERCENTILE_LABEL.p50, value: l.median, color: C.pct.p50, text: ms2(l.median) },
+        { label: PERCENTILE_LABEL.p90, value: l.p90, color: C.pct.p90, text: ms2(l.p90) },
+        { label: PERCENTILE_LABEL.p95, value: l.p95, color: C.pct.p95, text: ms2(l.p95) },
+        { label: PERCENTILE_LABEL.p99, value: l.p99, color: C.pct.p99, text: ms2(l.p99) },
+        { label: PERCENTILE_LABEL.max, value: l.max, color: C.ink, text: ms2(l.max) }
       ]);
     }
     case "phases": {
@@ -51327,7 +51454,7 @@ function widgetBody(w, report, opts) {
         { label: "Download", value: p.download.avg, color: C.series[6] }
       ];
       const total = rows2.reduce((n, r) => n + r.value, 0) || 1;
-      return `<div class="stack">${rows2.filter((r) => r.value > 0).map((r) => `<span style="width:${(r.value / total * 100).toFixed(2)}%;background:${r.color}" title="${esc3(r.label)} ${esc3(ms(r.value))}"></span>`).join("")}</div>${barList(rows2.map((r) => ({ ...r, text: `${ms(r.value)} \xB7 ${Math.round(r.value / total * 100)}%` })))}<p class="note">\u201CServer time\u201D is your API working on the answer; high connection times point to the network or the testing computer.</p>`;
+      return `<div class="stack">${rows2.filter((r) => r.value > 0).map((r) => `<span style="width:${(r.value / total * 100).toFixed(2)}%;background:${r.color}" title="${esc3(r.label)} ${esc3(ms2(r.value))}"></span>`).join("")}</div>${barList(rows2.map((r) => ({ ...r, text: `${ms2(r.value)} \xB7 ${Math.round(r.value / total * 100)}%` })))}<p class="note">\u201CServer time\u201D is your API working on the answer; high connection times point to the network or the testing computer.</p>`;
     }
     case "concurrency":
       return scatter(report);
@@ -51338,7 +51465,7 @@ function widgetBody(w, report, opts) {
     case "targets": {
       const t = report.summary.thresholds;
       const goals = t.length ? `<ul class="list">${t.map((g) => `<li><b class="${g.ok ? "pass" : "fail"}">${g.ok ? "\u2713" : "\u2715"}</b> ${esc3(g.name)}${g.actual ? ` <span class="note">measured ${esc3(g.actual)}</span>` : ""}</li>`).join("")}</ul>` : `<p class="note">No goals were set for this run.</p>`;
-      const checks = report.summary.checks.length ? `<h4>Checks on every response</h4><ul class="list">${report.summary.checks.map((c) => `<li><b class="${c.fails ? "fail" : "pass"}">${c.fails ? "\u2715" : "\u2713"}</b> <code>${esc3(c.name)}</code> <span class="note">${esc3(pct(c.passes / Math.max(1, c.passes + c.fails)))} \xB7 ${esc3(num2(c.fails))} failed of ${esc3(num2(c.passes + c.fails))}</span></li>`).join("")}</ul>` : "";
+      const checks = report.summary.checks.length ? `<h4>Checks on every response</h4><ul class="list">${report.summary.checks.map((c) => `<li><b class="${c.fails ? "fail" : "pass"}">${c.fails ? "\u2715" : "\u2713"}</b> <code>${esc3(c.name)}</code> <span class="note">${esc3(pct2(c.passes / Math.max(1, c.passes + c.fails)))} \xB7 ${esc3(num2(c.fails))} failed of ${esc3(num2(c.passes + c.fails))}</span></li>`).join("")}</ul>` : "";
       return `<h4>Goals</h4>${goals}${checks}`;
     }
     case "statusTable": {
@@ -51347,7 +51474,7 @@ function widgetBody(w, report, opts) {
       return `<table class="tbl"><thead><tr><th>Code</th><th>Meaning</th><th>Count</th><th>Share</th></tr></thead><tbody>${entries.map(([code, n]) => {
         const c = Number(code);
         const meaning = code === "0" ? "No answer (timeout or connection error)" : c < 300 ? "Success" : c < 400 ? "Redirect" : c < 500 ? "Client error" : "Server error";
-        return `<tr><td><code>${esc3(code)}</code></td><td>${esc3(meaning)}</td><td>${esc3(num2(n))}</td><td>${esc3(pct(n / total))}</td></tr>`;
+        return `<tr><td><code>${esc3(code)}</code></td><td>${esc3(meaning)}</td><td>${esc3(num2(n))}</td><td>${esc3(pct2(n / total))}</td></tr>`;
       }).join("")}</tbody></table>`;
     }
     case "config":
@@ -51404,21 +51531,21 @@ function runDebrief(report, opts = {}) {
   if (story.timingsUnreliable) {
     const ok = story.healthyP95Ms;
     findings.push(
-      `<b>Speed.</b> The response times of this run are not meaningful: ${esc3(pct(s.http.failed.rate))} of responses were errors, and errors come back almost instantly.${ok ? story.onset ? ` While requests were still succeeding (before ${esc3(secs(story.onset.elapsedS))}), 95% took about ${esc3(ms(ok))}.` : ` Successful requests alone: 95% took about ${esc3(ms(ok))}.` : ""}`
+      `<b>Speed.</b> The response times of this run are not meaningful: ${esc3(pct2(s.http.failed.rate))} of responses were errors, and errors come back almost instantly.${ok ? story.onset ? ` While requests were still succeeding (before ${esc3(secs(story.onset.elapsedS))}), 95% took about ${esc3(ms2(ok))}.` : ` Successful requests alone: 95% took about ${esc3(ms2(ok))}.` : ""}`
     );
   } else {
-    let speed = `<b>Speed.</b> A typical request took ${esc3(ms(s.latencyMs.median))}; 95% finished within ${esc3(ms(p95))}, and the slowest took ${esc3(ms(s.latencyMs.max))}.`;
-    if (slo?.p95Ms) speed += p95 <= slo.p95Ms ? ` That is within your ${esc3(ms(slo.p95Ms))} goal.` : ` That is over your ${esc3(ms(slo.p95Ms))} goal by ${esc3(ms(p95 - slo.p95Ms))}.`;
-    if (s.latencyMs.p99 > p95 * 3 && s.latencyMs.p99 > 100) speed += ` The slowest 1% (${esc3(ms(s.latencyMs.p99))}) is much slower than the rest \u2014 a few requests hit something slow, like a cold cache, a lock, or garbage collection.`;
+    let speed = `<b>Speed.</b> A typical request took ${esc3(ms2(s.latencyMs.median))}; 95% finished within ${esc3(ms2(p95))}, and the slowest took ${esc3(ms2(s.latencyMs.max))}.`;
+    if (slo?.p95Ms) speed += p95 <= slo.p95Ms ? ` That is within your ${esc3(ms2(slo.p95Ms))} goal.` : ` That is over your ${esc3(ms2(slo.p95Ms))} goal by ${esc3(ms2(p95 - slo.p95Ms))}.`;
+    if (s.latencyMs.p99 > p95 * 3 && s.latencyMs.p99 > 100) speed += ` The slowest 1% (${esc3(ms2(s.latencyMs.p99))}) is much slower than the rest \u2014 a few requests hit something slow, like a cold cache, a lock, or garbage collection.`;
     findings.push(speed);
   }
   if (b.length >= 6 && vi.earlyP95 > 0 && !story.onset && !story.timingsUnreliable) {
     const ratio = vi.lateP95 / vi.earlyP95;
     if (ratio > 1.5) {
-      findings.push(`<b>Over time.</b> It got slower as the test went on: 95% of requests took ${esc3(ms(vi.earlyP95))} early on and ${esc3(ms(vi.lateP95))} near the end (\xD7${ratio.toFixed(1)}). That often means work piling up \u2014 a queue, a connection pool, or memory that keeps growing.`);
+      findings.push(`<b>Over time.</b> It got slower as the test went on: 95% of requests took ${esc3(ms2(vi.earlyP95))} early on and ${esc3(ms2(vi.lateP95))} near the end (\xD7${ratio.toFixed(1)}). That often means work piling up \u2014 a queue, a connection pool, or memory that keeps growing.`);
       next.push("Run it longer (the Soak preset) to see whether the slowdown keeps growing.");
     } else if (ratio < 0.67) {
-      findings.push(`<b>Over time.</b> It got faster after the start (${esc3(ms(vi.earlyP95))} \u2192 ${esc3(ms(vi.lateP95))}) \u2014 typical of warm-up: caches filling, connections opening, code getting compiled.`);
+      findings.push(`<b>Over time.</b> It got faster after the start (${esc3(ms2(vi.earlyP95))} \u2192 ${esc3(ms2(vi.lateP95))}) \u2014 typical of warm-up: caches filling, connections opening, code getting compiled.`);
     } else {
       findings.push(`<b>Over time.</b> Response time stayed steady from start to finish.`);
     }
@@ -51430,7 +51557,7 @@ function runDebrief(report, opts = {}) {
     const codes = Object.entries(s.http.status).filter(([c]) => c === "0" || Number(c) >= 400).sort((a, z2) => z2[1] - a[1]).slice(0, 4).map(([c, n]) => `${c === "0" ? "no answer" : c} \xD7${num2(n)}`).join(", ");
     const firstBad = b.find((k) => k.failedRate > 0);
     const d = story.dominant;
-    let line = `<b>Errors.</b> ${esc3(num2(failed))} requests failed (${esc3(pct(s.http.failed.rate))})${codes ? `: ${esc3(codes)}` : ""}.`;
+    let line = `<b>Errors.</b> ${esc3(num2(failed))} requests failed (${esc3(pct2(s.http.failed.rate))})${codes ? `: ${esc3(codes)}` : ""}.`;
     if (d) line += ` ${esc3(d.code === "0" ? "No answer" : d.code)} means ${esc3(d.meaning)}.`;
     if (story.onset) {
       line += ` From ${esc3(secs(story.onset.elapsedS))} on \u2014 at about ${esc3(num2(story.onset.vus))} simultaneous users and ${esc3(rps(story.onset.rps))} requests per second \u2014 most requests failed.`;
@@ -51479,10 +51606,10 @@ function runDebrief(report, opts = {}) {
     if (key(high[0]) > key(low[low.length - 1]) && lowP95 > 0) {
       const k = highP95 / lowP95;
       if (k > 2) {
-        findings.push(`<b>Capacity.</b> Under the heaviest load, 95% of requests took ${esc3(ms(highP95))}, against ${esc3(ms(lowP95))} at light load (\xD7${k.toFixed(1)}). The API is near its comfortable limit at about ${esc3(rate ? `${rps(avg(high, key))} requests per second` : `${Math.round(avg(high, key))} simultaneous users`)}.`);
+        findings.push(`<b>Capacity.</b> Under the heaviest load, 95% of requests took ${esc3(ms2(highP95))}, against ${esc3(ms2(lowP95))} at light load (\xD7${k.toFixed(1)}). The API is near its comfortable limit at about ${esc3(rate ? `${rps(avg(high, key))} requests per second` : `${Math.round(avg(high, key))} simultaneous users`)}.`);
         next.push("Use the Load vs response time chart to find where the dots start climbing \u2014 that is the most this API can take comfortably.");
       } else {
-        findings.push(`<b>Capacity.</b> Response time barely changed between light and full load (${esc3(ms(lowP95))} \u2192 ${esc3(ms(highP95))}), so this load is comfortably within what the API can handle.`);
+        findings.push(`<b>Capacity.</b> Response time barely changed between light and full load (${esc3(ms2(lowP95))} \u2192 ${esc3(ms2(highP95))}), so this load is comfortably within what the API can handle.`);
         next.push("Raise the load (more users, or the Stress preset) to find where it starts to slow down.");
       }
     }
@@ -51501,21 +51628,79 @@ function runDebrief(report, opts = {}) {
   if (!slo) next.splice(story.blocked || story.dominant?.code === "503" ? 1 : 0, 0, "Set pass/fail goals (Goals tab) so the result reflects what \u201Cfast enough\u201D means for this API.");
   return { findings, next: next.slice(0, 5) };
 }
+function layoutBands(widgets) {
+  const bands = [];
+  let bottom = -1;
+  for (const w of readingOrder(widgets)) {
+    if (!bands.length || w.y >= bottom) bands.push([]);
+    bands[bands.length - 1].push(w);
+    bottom = Math.max(bottom, w.y + w.h);
+  }
+  return bands.map((band) => {
+    const lanes = [];
+    for (const w of [...band].sort((a, b) => a.x - b.x || a.y - b.y)) {
+      const lane = lanes.find((l) => w.x < l.end && w.x + w.w > l.x);
+      if (lane) {
+        lane.widgets.push(w);
+        lane.x = Math.min(lane.x, w.x);
+        lane.end = Math.max(lane.end, w.x + w.w);
+      } else lanes.push({ x: w.x, end: w.x + w.w, widgets: [w] });
+    }
+    for (let merged = true; merged; ) {
+      merged = false;
+      lanes.sort((a, b) => a.x - b.x);
+      for (let i = 1; i < lanes.length; i++) {
+        if (lanes[i].x < lanes[i - 1].end) {
+          lanes[i - 1].end = Math.max(lanes[i - 1].end, lanes[i].end);
+          lanes[i - 1].widgets.push(...lanes[i].widgets);
+          lanes.splice(i, 1);
+          merged = true;
+          break;
+        }
+      }
+    }
+    return lanes.map((l) => ({ x: l.x, w: l.end - l.x, widgets: l.widgets.sort((a, b) => a.y - b.y || a.x - b.x) }));
+  });
+}
+function beforeAfterSection(report, before) {
+  if (!before || before.id === report.id) return "";
+  const r = compareRuns(before, report);
+  const tone = r.level === "worse" ? "fail" : r.level === "better" ? "pass" : r.level === "same" ? "same" : "warn";
+  const fmt = (key, v) => v == null ? "\u2014" : key === "rps" ? `${rps(v)}/s` : key === "errorRate" || key === "checksRate" ? pct2(v) : ms2(v);
+  const change = (m) => {
+    if (m.direction === "n/a") return `<span class="sub">${esc3(m.note ?? "\u2014")}</span>`;
+    if (m.direction === "same") return `<span class="sub">= about the same</span>`;
+    const up = (m.absolute ?? 0) > 0;
+    const amount = m.key === "errorRate" || m.key === "checksRate" ? `${up ? "+" : "\u2212"}${(Math.abs(m.absolute ?? 0) * 100).toFixed(1)} points` : m.relative != null ? `${up ? "+" : "\u2212"}${Math.round(Math.abs(m.relative) * 100)}%` : "";
+    return `<span style="color:${m.direction === "better" ? C.ok : C.bad};font-weight:600">${up ? "\u2191" : "\u2193"} ${esc3(amount)} \xB7 ${m.direction}</span>`;
+  };
+  const rows2 = r.metrics.map((m) => `<tr><th>${esc3(m.label)} <span class="sub">${esc3(m.tech)}</span></th><td>${esc3(fmt(m.key, m.before))}</td><td>${esc3(fmt(m.key, m.after))}</td><td>${change(m)}</td></tr>`).join("");
+  return `  <section class="debrief">
+    <h2>Before / after</h2>
+    <p class="sub">This run compared with \u201C${esc3(before.testName)}\u201D (${esc3(new Date(before.startedAt).toLocaleString("en-GB"))}).</p>
+    <div class="verdict ${tone}" style="margin:10px 0">${esc3(r.headline)}</div>
+    <table class="kv-tbl"><tr><th>Measure</th><th>Before</th><th>After</th><th>Change</th></tr>${rows2}</table>
+    <p class="note">Changes under 5% (or under 10 ms) count as about the same \u2014 two runs of an unchanged API never match exactly.</p>
+  </section>`;
+}
 function exportRunHtml(report, opts = {}) {
   const generatedAt = opts.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
   const view = opts.view ?? defaultViewFor("run");
   const verdict = buildVerdict(report, { slo: opts.slo ?? null });
   const debrief = runDebrief(report, opts);
   const lv = verdict.overall;
-  const widgets = readingOrder(view.widgets).map((w) => {
+  const card = (w) => {
     const def = METRICS[w.metric];
     const title = widgetTitle(w);
     const tech = widgetTech(w);
+    W = Math.max(320, Math.round(w.w / 12 * 1080));
     const body = widgetBody(w, report, opts);
     const cls = def.bare ? "w head" : "w";
-    return `<section class="${cls}" style="--x:${w.x + 1};--w:${w.w}">${def.bare ? `<h2>${esc3(title)}</h2>` : `<h3>${esc3(title)}${tech ? ` <small>${esc3(tech)}</small>` : ""}</h3>`}${body}</section>`;
-  }).join("\n");
-  const seriesRows = report.buckets.map((k) => `<tr><td>${esc3(secs(k.elapsedS))}</td><td>${k.vus}</td><td>${esc3(rps(k.rps))}</td><td>${esc3(ms(k.p50Ms))}</td><td>${esc3(ms(k.p95Ms))}</td><td>${esc3(ms(k.p99Ms))}</td><td>${esc3(pct(k.failedRate))}</td><td>${k.http2xx}</td><td>${k.http4xx}</td><td>${k.http5xx}</td><td>${k.http0}</td></tr>`).join("");
+    return `<section class="${cls}">${def.bare ? `<h2>${esc3(title)}</h2>` : `<h3>${esc3(title)}${tech ? ` <small>${esc3(tech)}</small>` : ""}</h3>`}${body}</section>`;
+  };
+  const widgets = layoutBands(view.widgets).map((band) => `<div class="band">${band.map((lane) => `<div class="lane" style="--x:${lane.x + 1};--w:${lane.w}">${lane.widgets.map(card).join("")}</div>`).join("")}</div>`).join("\n");
+  W = 640;
+  const seriesRows = report.buckets.map((k) => `<tr><td>${esc3(secs(k.elapsedS))}</td><td>${k.vus}</td><td>${esc3(rps(k.rps))}</td><td>${esc3(ms2(k.p50Ms))}</td><td>${esc3(ms2(k.p95Ms))}</td><td>${esc3(ms2(k.p99Ms))}</td><td>${esc3(pct2(k.failedRate))}</td><td>${k.http2xx}</td><td>${k.http4xx}</td><td>${k.http5xx}</td><td>${k.http0}</td></tr>`).join("");
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -51539,14 +51724,16 @@ function exportRunHtml(report, opts = {}) {
   .debrief { background: ${C.panel}; border: 1px solid ${C.line}; border-radius: 12px; padding: 16px 20px; margin: 16px 0; }
   .debrief h2 { margin: 0 0 8px; font-size: 17px; }
   .debrief p { margin: 6px 0; } .debrief ol { margin: 6px 0 0; padding-left: 20px; } .debrief li { margin: 3px 0; }
-  .grid { display: grid; grid-template-columns: repeat(12, minmax(0, 1fr)); gap: 12px; align-items: start; }
-  .w { grid-column: var(--x) / span var(--w); background: ${C.panel}; border: 1px solid ${C.line}; border-radius: 12px; padding: 12px 14px; min-width: 0; break-inside: avoid; }
+  .grid { display: flex; flex-direction: column; gap: 12px; }
+  .band { display: grid; grid-template-columns: repeat(12, minmax(0, 1fr)); gap: 12px; align-items: start; }
+  .lane { grid-column: var(--x) / span var(--w); display: flex; flex-direction: column; gap: 12px; min-width: 0; }
+  .w { background: ${C.panel}; border: 1px solid ${C.line}; border-radius: 12px; padding: 12px 14px; min-width: 0; break-inside: avoid; }
   .w.head { background: none; border: 0; padding: 14px 2px 0; }
   .w.head h2 { margin: 0; padding-bottom: 4px; border-bottom: 1px solid ${C.line}; font-size: 18px; }
   .w h3 { margin: 0 0 8px; font-size: 14px; } .w h3 small { color: ${C.mute}; font-weight: 400; font-size: 12px; margin-left: 4px; }
   .w h4 { margin: 10px 0 4px; font-size: 12px; text-transform: uppercase; letter-spacing: .05em; color: ${C.mute}; }
   svg { width: 100%; height: auto; display: block; }
-  svg .g { stroke: ${C.line}; stroke-width: 1; } svg .t { fill: ${C.mute}; font: 10px ui-monospace, Consolas, monospace; }
+  svg .g { stroke: ${C.line}; stroke-width: 1; } svg .t { fill: ${C.mute}; font: 11px ui-monospace, Consolas, monospace; }
   .legend { display: flex; flex-wrap: wrap; gap: 12px; font-size: 12px; color: ${C.mute}; margin-top: 4px; }
   .legend i { display: inline-block; width: 10px; height: 10px; border-radius: 2px; margin-right: 5px; vertical-align: -1px; }
   .kpis { display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 10px; }
@@ -51570,7 +51757,7 @@ function exportRunHtml(report, opts = {}) {
   details.appendix summary { cursor: pointer; font-weight: 600; }
   .series-wrap { max-height: 420px; overflow: auto; margin-top: 10px; }
   footer { color: ${C.mute}; font-size: 12px; margin-top: 24px; }
-  @media (max-width: 900px) { .w { grid-column: 1 / -1; } }
+  @media (max-width: 900px) { .lane { grid-column: 1 / -1; } }
   @media print { body { background: #fff; } .series-wrap { max-height: none; } details.appendix { display: none; } .w, .debrief { box-shadow: none; } }
 </style>
 </head>
@@ -51588,6 +51775,7 @@ function exportRunHtml(report, opts = {}) {
     ${debrief.next.length ? `<h2 style="margin-top:14px">Suggested next steps</h2><ol>${debrief.next.map((n) => `<li>${esc3(n)}</li>`).join("")}</ol>` : ""}
     <p class="note">Written from the measured numbers by fixed rules. ${esc3(verdict.disclaimer)}</p>
   </section>
+${beforeAfterSection(report, opts.before ?? null)}
   <div class="grid">
 ${widgets}
   </div>
@@ -51613,6 +51801,11 @@ function isCompareExport(value) {
   const doc = value;
   return doc.kind === "compare" && Array.isArray(doc.apis) && doc.apis.length >= 1 && doc.apis.every((api) => api && typeof api === "object" && isRunReport(api.report));
 }
+function parseRunReportFile(raw) {
+  const parsed = parseExportFile(raw);
+  if (parsed.kind === "report") return parsed.report;
+  throw new Error("That file is a compare export. Open it on Preview as a compare document.");
+}
 function parseExportFile(raw) {
   if (!raw || typeof raw !== "object") {
     throw new Error("That file is not JSON we can open.");
@@ -52462,16 +52655,16 @@ var LatencyHistogram = class {
   max = 0;
   sum = 0;
   sumSq = 0;
-  add(ms2) {
-    if (!Number.isFinite(ms2) || ms2 < 0) return;
-    const v = Math.max(ms2, FLOOR_MS);
+  add(ms3) {
+    if (!Number.isFinite(ms3) || ms3 < 0) return;
+    const v = Math.max(ms3, FLOOR_MS);
     const bin = Math.floor(Math.log(v / FLOOR_MS) / GROWTH);
     this.bins.set(bin, (this.bins.get(bin) ?? 0) + 1);
     this.count += 1;
-    this.sum += ms2;
-    this.sumSq += ms2 * ms2;
-    if (ms2 < this.min) this.min = ms2;
-    if (ms2 > this.max) this.max = ms2;
+    this.sum += ms3;
+    this.sumSq += ms3 * ms3;
+    if (ms3 < this.min) this.min = ms3;
+    if (ms3 > this.max) this.max = ms3;
   }
   mean() {
     return this.count ? this.sum / this.count : 0;
@@ -52782,9 +52975,9 @@ function liveSummaryParts(run) {
   const checks = [...run.aggregator.checks].map(([name, [passes, fails]]) => ({ name, passes, fails }));
   return { checks, dropped: Math.round(run.aggregator.dropped) };
 }
-function fmtMs(ms2) {
-  if (ms2 < 1) return `${ms2.toFixed(2)} ms`;
-  return ms2 < 10 ? `${ms2.toFixed(1)} ms` : `${Math.round(ms2)} ms`;
+function fmtMs(ms3) {
+  if (ms3 < 1) return `${ms3.toFixed(2)} ms`;
+  return ms3 < 10 ? `${ms3.toFixed(1)} ms` : `${Math.round(ms3)} ms`;
 }
 function fmtPct(rate) {
   return `${(rate * 100).toFixed(rate < 0.01 ? 2 : 1)}%`;
@@ -53419,6 +53612,33 @@ var WorkspaceStore = class {
     requests.sort((a, b) => a.collection.localeCompare(b.collection) || a.name.localeCompare(b.name));
     return { requests, environments: await this.environments(), secretsPersistent: this.secrets.persistent, invalid };
   }
+  /**
+   * A collection's files exactly as they are on disk — secrets are never in them — for running
+   * in CI: its requests, any Run first requests they use from other collections, and
+   * environments.json. Paths are relative to the data folder. `secrets` lists requests whose
+   * saved secret will be missing, so people can switch them to {{variables}}.
+   */
+  async exportCollection(collection) {
+    const all = [];
+    for (const path of await this.files()) {
+      const file2 = await this.readRequest(path);
+      if (file2) all.push({ path, file: file2 });
+    }
+    const picked = new Map(all.filter((f) => f.file.collection === collection).map((f) => [f.file.id, f]));
+    for (const f of [...picked.values()]) {
+      const before = f.file.request.before;
+      const ref = typeof before?.requestId === "string" ? all.find((a) => a.file.id === before.requestId) : void 0;
+      if (ref) picked.set(ref.file.id, ref);
+    }
+    const files = [];
+    for (const f of picked.values()) files.push({ path: relative(this.dir, f.path).split(sep).join("/"), text: await readFile5(f.path, "utf8") });
+    try {
+      files.push({ path: "environments.json", text: await readFile5(this.envFile, "utf8") });
+    } catch {
+    }
+    const secrets = [...picked.values()].filter((f) => f.file.secretFields?.length).map((f) => `${f.file.name} (${f.file.secretFields.join(", ")})`);
+    return { files, secrets };
+  }
   async getRequest(id) {
     const found = await this.find(id);
     if (!found) return null;
@@ -53521,7 +53741,7 @@ var WorkspaceStore = class {
 // ../../apps/engine/src/cli.ts
 var repoRoot = resolve2(dirname2(fileURLToPath(import.meta.url)), "../../..");
 var EXIT = { passed: 0, failed: 1, error: 2 };
-var VERSION = "0.4.0";
+var VERSION = "0.5.0";
 var HELP = `APITestCenter CLI ${VERSION} \u2014 https://apitestcenter.com/docs/cli-and-ci.html
 
 Usage (apitestcenter, or the short name atc)
@@ -53552,6 +53772,12 @@ Collection runs (atc suite)
   --stop-on-fail      stop at the first request that fails
   --env, --var, --json, --html, --junit, --quiet work as for run
 
+Compare with a baseline (atc run)
+  --baseline <file>      a saved report (JSON export, or --save-baseline from an earlier run)
+  --max-slower <percent> fail when p95 is slower than the baseline by more than this (default 10)
+                         or when more requests fail; changes under 5% / 10 ms count as the same
+  --save-baseline <file> save this run as a baseline for later runs
+
 Output
   --json <file>  --html <file>  --junit <file>   --save   also keep the run in History
   --no-check     skip the single check request before load
@@ -53589,6 +53815,9 @@ async function main() {
       save: { type: "boolean" },
       "no-check": { type: "boolean" },
       quiet: { type: "boolean" },
+      baseline: { type: "string" },
+      "max-slower": { type: "string" },
+      "save-baseline": { type: "string" },
       "stop-on-fail": { type: "boolean" },
       help: { type: "boolean", short: "h" },
       version: { type: "boolean", short: "v" },
@@ -53673,9 +53902,24 @@ Environments (${index.environments.length})`);
   if (Object.keys(overrides).length) load = { ...load, ...overrides, stages: load.stages && !values.duration ? load.stages : null, preset: "custom" };
   const problem = loadProblem(load);
   if (problem) fail(problem);
-  const pct2 = (v) => v == null ? void 0 : (num3(v, "percent") ?? 0) / 100;
-  const targets = values.p95 || values.p99 || values.errors || values.checks ? { p95Ms: num3(values.p95, "--p95"), p99Ms: num3(values.p99, "--p99"), errorRate: pct2(values.errors), checksRate: pct2(values.checks), abortOnFail: values.abort === true } : void 0;
+  const pct3 = (v) => v == null ? void 0 : (num3(v, "percent") ?? 0) / 100;
+  const targets = values.p95 || values.p99 || values.errors || values.checks ? { p95Ms: num3(values.p95, "--p95"), p99Ms: num3(values.p99, "--p99"), errorRate: pct3(values.errors), checksRate: pct3(values.checks), abortOnFail: values.abort === true } : void 0;
   const slo = targets?.p95Ms && targets.errorRate != null ? { p95Ms: targets.p95Ms, errorRate: targets.errorRate, checksRate: targets.checksRate } : null;
+  let baseline = null;
+  if (values.baseline) {
+    try {
+      baseline = parseRunReportFile(JSON.parse(await readFile6(values.baseline, "utf8")));
+    } catch (err) {
+      fail(`can't read the baseline "${values.baseline}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const maxSlower = (() => {
+    const raw2 = values["max-slower"];
+    if (raw2 == null) return 0.1;
+    const n = Number(raw2.replace(/%$/, ""));
+    if (!Number.isFinite(n) || n < 0) fail("--max-slower must be a percentage, like 10");
+    return n / 100;
+  })();
   const payload = buildPayload(draft, toLoadConfig(load), `${name} \xB7 CLI`, targets);
   const log = (line) => !values.quiet && console.log(line);
   if (draft.before) {
@@ -53731,18 +53975,32 @@ Environments (${index.environments.length})`);
   const verdict = buildVerdict(report, { slo });
   const missed = report.summary.thresholds.filter((t) => !t.ok);
   const s = report.summary;
+  const compared = baseline ? compareRuns(baseline, report) : null;
+  const gate = compared ? slowerThanAllowed(compared, maxSlower) : null;
+  const failed = missed.length > 0 || verdict.overall === "fail" || gate?.failed === true;
   console.log(`
-${missed.length || verdict.overall === "fail" ? "FAIL" : "PASS"}  (verdict: ${verdict.overall}) ${verdict.headline}`);
+${failed ? "FAIL" : "PASS"}  (verdict: ${verdict.overall}) ${verdict.headline}`);
   console.log(`  requests ${s.http.requests} \xB7 ${s.http.rps.avg.toFixed(1)} req/s \xB7 p95 ${s.latencyMs.p95.toFixed(1)} ms \xB7 p99 ${s.latencyMs.p99.toFixed(1)} ms \xB7 errors ${(s.http.failed.rate * 100).toFixed(2)}%`);
   for (const t of s.thresholds) console.log(`  ${t.ok ? "\u2713" : "\u2715"} ${t.name}${t.actual ? ` (measured ${t.actual})` : ""}`);
   for (const c of s.checks) console.log(`  ${c.fails ? "\u2715" : "\u2713"} check ${c.name}: ${c.passes}/${c.passes + c.fails}`);
   if (report.endReason === "target-missed") console.log("  stopped early: a target was missed");
+  if (compared && gate && baseline) {
+    console.log(`
+compared with baseline \u201C${baseline.testName}\u201D (${baseline.startedAt.slice(0, 10)})`);
+    console.log(`  ${compared.headline}`);
+    console.log(`  ${gate.failed ? "\u2715" : "\u2713"} ${gate.reason}`);
+  }
   if (values.json) await writeFile6(values.json, exportRunJson(report), "utf8");
-  if (values.html) await writeFile6(values.html, exportRunHtml(report, { slo }), "utf8");
-  if (values.junit) await writeFile6(values.junit, exportRunJunit(report, verdict, targets?.checksRate ?? 0.99), "utf8");
+  if (values.html) await writeFile6(values.html, exportRunHtml(report, { slo, before: baseline }), "utf8");
+  const extra = gate ? [{ classname: "baseline", name: `no slower than the baseline by more than ${Math.round(maxSlower * 100)}%`, failure: gate.failed ? gate.reason : void 0 }] : [];
+  if (values.junit) await writeFile6(values.junit, exportRunJunit(report, verdict, targets?.checksRate ?? 0.99, extra), "utf8");
+  if (values["save-baseline"]) {
+    await writeFile6(values["save-baseline"], exportRunJson(report), "utf8");
+    log(`  saved this run as a baseline \u2192 ${values["save-baseline"]}`);
+  }
   for (const [flag, file2] of [["json", values.json], ["html", values.html], ["junit", values.junit]]) if (file2) log(`  wrote ${flag} \u2192 ${file2}`);
   if (history) log(`  saved to History in ${dataDir}`);
-  return missed.length || verdict.overall === "fail" ? EXIT.failed : EXIT.passed;
+  return failed ? EXIT.failed : EXIT.passed;
 }
 async function suite(collection, values, workspace, dataDir) {
   if (collection === void 0) fail('suite needs a collection name, or "" for requests outside any collection. Run "atc list".');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apitestcenter",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "APITestCenter on the command line: run API collections and load tests in CI, with JUnit reports and pass/fail exit codes.",
   "type": "module",
   "bin": {
@@ -16,6 +16,10 @@
     "node": ">=20"
   },
   "homepage": "https://apitestcenter.com/docs/cli-and-ci.html",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apitestcenter/app.git"
+  },
   "license": "SEE LICENSE IN LICENSE.txt",
   "author": "Ratul Roy",
   "keywords": [