@cellajs/cli 0.6.2 → 0.6.5

package/dist/bench.js

@@ -0,0 +1,1480 @@
+// src/tools/bench/run.ts
+import { appendFileSync, mkdirSync as mkdirSync2, readdirSync, rmSync } from "fs";
+import { join as join2 } from "path";
+import { monitorEventLoopDelay, performance as performance4 } from "perf_hooks";
+import process5 from "process";
+import { setTimeout as delay } from "timers/promises";
+
+// src/utils/colors.ts
+import process2 from "process";
+import { styleText } from "util";
+
+// src/utils/env.ts
+import process from "process";
+function getEnv(name) {
+  return process.env[name];
+}
+function hasEnv(name) {
+  return name in process.env;
+}
+
+// src/utils/colors.ts
+function colorsEnabled() {
+  if (hasEnv("NO_COLOR")) return false;
+  if (hasEnv("FORCE_COLOR")) return true;
+  return !!process2.stdout.isTTY;
+}
+function applyStyle(style, text) {
+  if (!colorsEnabled()) return text;
+  return styleText(style, text, { validateStream: false });
+}
+var pc = {
+  blue: (text) => applyStyle("blue", text),
+  bold: (text) => applyStyle("bold", text),
+  cyan: (text) => applyStyle("cyan", text),
+  dim: (text) => applyStyle("dim", text),
+  gray: (text) => applyStyle("gray", text),
+  green: (text) => applyStyle("green", text),
+  magenta: (text) => applyStyle("magenta", text),
+  red: (text) => applyStyle("red", text),
+  white: (text) => applyStyle("white", text),
+  yellow: (text) => applyStyle("yellow", text)
+};
+var colors_default = pc;
+
+// src/tools/bench/baseline.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+var RUNNER_EPOCH = "cella-bench@1";
+var isComparable = (entry) => entry?.runner === RUNNER_EPOCH;
+function readEntries(file) {
+  if (!existsSync(file)) return [];
+  try {
+    const data = JSON.parse(readFileSync(file, "utf8"));
+    return Array.isArray(data) ? data : [data];
+  } catch {
+    return [];
+  }
+}
+var baselineFile = (dir, scenario) => join(dir, "baselines", `${scenario}.json`);
+function loadBaseline(dir, scenario) {
+  const entries = readEntries(baselineFile(dir, scenario));
+  const comparable = entries.filter(isComparable);
+  return { baseline: comparable.at(-1) ?? null, older: entries.length - comparable.length };
+}
+function saveBaseline(dir, entry) {
+  const file = baselineFile(dir, entry.scenario);
+  const entries = readEntries(file);
+  entries.push(entry);
+  mkdirSync(join(dir, "baselines"), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(entries, null, 2)}
+`);
+  return entries.length;
+}
+function compareBaseline(current, baseline) {
+  const delta = (label, now, before, lowerIsBetter = true) => ({
+    label,
+    current: now,
+    baseline: before,
+    pct: before === 0 ? null : (now - before) / before * 100,
+    lowerIsBetter
+  });
+  const deltas = [];
+  if (current.primary.metric === baseline.primary.metric)
+    deltas.push(delta(current.primary.metric, current.primary.value, baseline.primary.value));
+  if (current.requests > 0) {
+    if (current.primary.metric !== "http.response_time.p50") deltas.push(delta("p50", current.p50, baseline.p50));
+    if (current.primary.metric !== "http.response_time.p95") deltas.push(delta("p95", current.p95, baseline.p95));
+    deltas.push(
+      delta("p99", current.p99, baseline.p99),
+      delta("req/s", current.requestRate, baseline.requestRate, false)
+    );
+  }
+  return deltas;
+}
+
+// src/tools/bench/report.ts
+import process4 from "process";
+import { stripVTControlCharacters as stripVTControlCharacters2 } from "util";
+
+// src/utils/layout.ts
+import process3 from "process";
+import { stripVTControlCharacters } from "util";
+function visibleWidth(text) {
+  return stripVTControlCharacters(text).length;
+}
+function padVisible(text, width, align = "start") {
+  const padding = " ".repeat(Math.max(0, width - visibleWidth(text)));
+  return align === "start" ? `${text}${padding}` : `${padding}${text}`;
+}
+var AGE_STEPS = [
+  [90 * 60, 60, "m"],
+  [36 * 3600, 3600, "h"],
+  [14 * 86400, 86400, "d"],
+  [70 * 86400, 7 * 86400, "w"],
+  [365 * 86400, 30 * 86400, "mo"]
+];
+
+// src/tools/bench/report.ts
+var visible = (text) => stripVTControlCharacters2(text).length;
+var count = (n) => Math.round(n).toLocaleString("en-US");
+var ms = (n) => n < 10 ? `${n.toFixed(1)}ms` : `${Math.round(n)}ms`;
+var seconds = (n) => `${Math.round(n)}s`;
+var LiveDisplay = class {
+  constructor(tty, out = process4.stdout) {
+    this.tty = tty;
+    this.out = out;
+  }
+  tty;
+  out;
+  rows = 0;
+  lines = [];
+  render(lines) {
+    this.lines = lines;
+    if (!this.tty) {
+      for (const line of lines) this.out.write(`${line}
+`);
+      return;
+    }
+    this.clear();
+    this.draw();
+  }
+  log(text) {
+    if (!this.tty) {
+      this.out.write(`${text}
+`);
+      return;
+    }
+    this.clear();
+    this.out.write(`${text}
+`);
+    this.draw();
+  }
+  /** Removes the block from a terminal; piped output keeps what it printed. */
+  clear() {
+    if (this.rows > 0) this.out.write(`\x1B[${this.rows}F\x1B[J`);
+    this.rows = 0;
+  }
+  draw() {
+    const columns = this.out.columns || 80;
+    for (const line of this.lines) this.out.write(`${line}
+`);
+    this.rows = this.lines.reduce((sum, line) => sum + Math.max(1, Math.ceil(visible(line) / columns)), 0);
+  }
+};
+function liveLines(state) {
+  const { vus, counters } = state;
+  const time = state.plannedS === null ? seconds(state.elapsedS) : `${seconds(state.elapsedS)}/${seconds(state.plannedS)}`;
+  const head = `${colors_default.bold(state.scenario)} ${colors_default.dim(`\xB7 ${state.phase} \xB7 ${time}`)}`;
+  const parts = [
+    `vus +${count(vus.started)} \u25B8${count(vus.active)} \u2713${count(vus.completed)} ${vus.failed > 0 ? colors_default.red(`\u2717${count(vus.failed)}`) : "\u27170"}`
+  ];
+  const requests = counters["http.requests"] ?? 0;
+  if (requests > 0 || state.http) {
+    parts.push(`${count(requests / state.intervalS)} req/s`);
+    if (state.http) parts.push(`p50 ${ms(state.http.p50)} p95 ${ms(state.http.p95)} p99 ${ms(state.http.p99)}`);
+    const classes = /* @__PURE__ */ new Map();
+    for (const [name, n] of Object.entries(counters)) {
+      const status = /^http\.codes\.(\d)\d\d$/.exec(name)?.[1];
+      if (status) classes.set(`${status}xx`, (classes.get(`${status}xx`) ?? 0) + n);
+    }
+    const codes = [...classes].sort().map(([cls, n]) => cls === "2xx" ? `${cls} ${count(n)}` : colors_default.yellow(`${cls} ${count(n)}`));
+    if (codes.length) parts.push(codes.join(" "));
+  }
+  const errors = Object.entries(counters).filter(([name]) => name.startsWith("errors."));
+  if (errors.length) parts.push(colors_default.red(errors.map(([name, n]) => `${name.slice(7)} ${count(n)}`).join(" ")));
+  if (state.primary) {
+    const d = state.primary.distribution;
+    parts.push(`${state.primary.name} p50 ${ms(d.p50)} p95 ${ms(d.p95)}`);
+  }
+  for (const [name, n] of state.custom) parts.push(`${name} +${count(n)}`);
+  parts.push(colors_default.dim(`gen lag ${ms(state.lagP99)}`));
+  return [head, `  ${parts.join(colors_default.dim(" \xB7 "))}`];
+}
+var pad = (text, width, left = false) => left ? text.padEnd(width) : text.padStart(width);
+function deltaText(pct2, lowerIsBetter) {
+  if (pct2 === null) return colors_default.dim("n/a");
+  if (Math.abs(pct2) < 1) return colors_default.dim("~0%");
+  const label = `${pct2 > 0 ? "+" : "\u2212"}${Math.abs(pct2).toFixed(0)}%`;
+  return (lowerIsBetter ? pct2 < 0 : pct2 > 0) ? colors_default.green(label) : colors_default.red(label);
+}
+function summaryLines(view) {
+  const lines = [];
+  const vus = `${count(view.vus.created)} VUs (\u2713${count(view.vus.completed)} \u2717${count(view.vus.failed)})`;
+  const reqs = view.requests > 0 ? ` \xB7 ${count(view.requests)} requests \xB7 ${count(view.requestRate)} req/s` : "";
+  lines.push(
+    `${colors_default.bold(view.scenario)}${view.short ? colors_default.dim(" (short)") : ""} \xB7 ${view.durationS.toFixed(1)} s \xB7 ${vus}${reqs}`
+  );
+  const labels = Object.keys(view.endpoints);
+  if (labels.length) {
+    const width = Math.max(8, ...labels.map((label) => label.length));
+    lines.push(
+      colors_default.dim(
+        `  ${pad("endpoint", width, true)} ${pad("req", 8)} ${pad("p50", 8)} ${pad("p95", 8)} ${pad("p99", 8)} ${pad("max", 8)} ${pad("non-2xx", 8)} ${pad("timeouts", 9)}`
+      )
+    );
+    for (const [label, e] of Object.entries(view.endpoints)) {
+      const d = e.ttfb;
+      const nonOk = e.nonOk > 0 ? colors_default.yellow(pad(count(e.nonOk), 8)) : pad("0", 8);
+      const timeouts = e.timeouts > 0 ? colors_default.red(pad(count(e.timeouts), 9)) : pad("0", 9);
+      lines.push(
+        `  ${pad(label, width, true)} ${pad(count(e.requests), 8)} ${pad(ms(d.p50), 8)} ${pad(ms(d.p95), 8)} ${pad(ms(d.p99), 8)} ${pad(ms(d.max), 8)} ${nonOk} ${timeouts}`
+      );
+      const rejected = Object.entries(e.codes).filter(([code]) => !code.startsWith("2"));
+      if (rejected.length)
+        lines.push(colors_default.dim(`  ${" ".repeat(width)} ${rejected.map(([code, n]) => `${code} \xD7${count(n)}`).join(", ")}`));
+    }
+  }
+  const histograms = Object.entries(view.histograms);
+  if (histograms.length) {
+    const width = Math.max(9, ...histograms.map(([name]) => name.length));
+    lines.push(
+      colors_default.dim(
+        `  ${pad("histogram", width, true)} ${pad("count", 8)} ${pad("p50", 8)} ${pad("p95", 8)} ${pad("p99", 8)} ${pad("max", 8)}`
+      )
+    );
+    for (const [name, d] of histograms) {
+      lines.push(
+        `  ${pad(name, width, true)} ${pad(count(d.count), 8)} ${pad(ms(d.p50), 8)} ${pad(ms(d.p95), 8)} ${pad(ms(d.p99), 8)} ${pad(ms(d.max), 8)}`
+      );
+    }
+  }
+  if (view.counters.length)
+    lines.push(`  ${view.counters.map(([name, n]) => `${name} ${colors_default.bold(count(n))}`).join(colors_default.dim(" \xB7 "))}`);
+  for (const [code, { count: n, message }] of Object.entries(view.errors)) {
+    lines.push(colors_default.red(`  errors.${code} ${count(n)}${message ? `: ${message}` : ""}`));
+  }
+  if (view.lagWarning) lines.push(colors_default.yellow(`  \u26A0 ${view.lagWarning}`));
+  for (const check of view.checks) lines.push(`  ${check.ok ? colors_default.green("\u2713") : colors_default.red("\u2717")} ${check.text}`);
+  if (view.compared) {
+    if (view.baseline) {
+      const deltas = compareBaseline(view.current, view.baseline).map(
+        (d) => `${d.label} ${deltaText(d.pct, d.lowerIsBetter)}`
+      );
+      lines.push(
+        `  baseline ${view.baseline.timestamp.slice(0, 16).replace("T", " ")} (${RUNNER_EPOCH}): ${deltas.join(", ")}`
+      );
+    } else {
+      const older = view.olderBaselines > 0 ? `, ${view.olderBaselines} older-runner entries kept` : "";
+      lines.push(colors_default.dim(`  no comparable baseline: first ${RUNNER_EPOCH} run${older}`));
+    }
+    if (view.saved !== null) lines.push(colors_default.dim(`  baseline saved (${view.saved} run${view.saved === 1 ? "" : "s"})`));
+  }
+  lines.push(colors_default.dim(`  log ${view.logFile}`));
+  return lines;
+}
+function compactLine(view) {
+  const failed = view.checks.filter((check) => !check.ok);
+  const mark = failed.length ? colors_default.red("\u2717") : colors_default.green("\u2713");
+  const reqs = view.requests > 0 ? ` \xB7 ${count(view.requests)} req \xB7 p95 ${ms(view.http?.p95 ?? 0)}` : "";
+  const primary = view.current.primary.metric.startsWith("http.") ? "" : ` \xB7 ${view.current.primary.metric} ${ms(view.current.primary.value)}`;
+  const reasons = failed.length ? colors_default.red(` \xB7 ${failed.map((check) => check.text).join("; ")}`) : "";
+  return `${mark} ${view.scenario}${colors_default.dim(`${reqs}${primary}`)}${reasons}`;
+}
+function suiteLines(rows) {
+  const extra = [...new Set(rows.flatMap((row) => Object.keys(row.columns)))];
+  const heads = ["Req/s", "p50", "p95", "p99", "Errors", ...extra];
+  const num = (n) => n === 0 ? "-" : n < 10 ? n.toFixed(1) : String(Math.round(n));
+  const lines = ["", `${colors_default.bold("Summary")} ${colors_default.dim("\xB7 all scenarios")}`, ""];
+  lines.push(
+    `  ${colors_default.bold(pad("Scenario", 22, true))} ${heads.map((head) => colors_default.bold(pad(head, 8))).join(" ")} ${colors_default.bold(pad("Primary \u0394", 10))}`
+  );
+  lines.push(`  ${"\u2500".repeat(22 + heads.length * 9 + 11)}`);
+  for (const row of rows) {
+    const { current, baseline } = row;
+    const delta = baseline ? deltaText(
+      baseline.primary.value === 0 ? null : (current.primary.value - baseline.primary.value) / baseline.primary.value * 100,
+      true
+    ) : colors_default.dim(row.ok ? "new" : "-");
+    const cells = [current.requestRate, current.p50, current.p95, current.p99].map(num);
+    cells.push(String(current.errors), ...extra.map((column) => row.columns[column] ?? "-"));
+    lines.push(
+      `  ${pad(row.name, 22, true)} ${cells.map((cell) => pad(cell, 8)).join(" ")} ${padVisible(delta, 10, "end")}${row.ok ? "" : colors_default.red("  \u2717")}`
+    );
+  }
+  lines.push("");
+  return lines;
+}
+
+// src/tools/bench/types.ts
+var stats = ["p50", "p95", "p99", "max", "min", "mean"];
+function splitMetricKey(key) {
+  const dot = key.lastIndexOf(".");
+  const tail = key.slice(dot + 1);
+  return { name: key.slice(0, dot), stat: stats.find((stat) => stat === tail) ?? null };
+}
+
+// src/tools/bench/checks.ts
+var DEFAULT_MAX_REJECTED_SHARE = 1;
+var pct = (n) => `${n.toFixed(1)}%`;
+function statusCounts(counters) {
+  return Object.entries(counters).flatMap(([name, n]) => {
+    const status = /^http\.codes\.(\d{3})$/.exec(name)?.[1];
+    return status ? [[status, n]] : [];
+  }).sort(([a], [b]) => a.localeCompare(b));
+}
+function evaluateChecks(checks, { counters, distributions, short }) {
+  const results = [];
+  const byStatus = statusCounts(counters);
+  const responses = byStatus.reduce((sum, [, n]) => sum + n, 0);
+  const rejected = byStatus.filter(([status]) => !status.startsWith("2"));
+  const rejectedCount = rejected.reduce((sum, [, n]) => sum + n, 0);
+  const maxRejected = checks.maxRejectedShare ?? DEFAULT_MAX_REJECTED_SHARE;
+  if (responses > 0) {
+    const ok = rejectedCount <= responses * maxRejected / 100;
+    const detail = rejected.length ? ` (${rejected.map(([status, n]) => `${status} \xD7${n}`).join(", ")})` : "";
+    results.push({
+      id: "responses",
+      ok,
+      text: `${count(rejectedCount)} of ${count(responses)} responses not 2xx, ${pct(rejectedCount / responses * 100)} ${ok ? "\u2264" : ">"} ${maxRejected}%${detail}`
+    });
+  }
+  if (checks.maxErrorRate !== void 0) {
+    const created = counters["vusers.created"] ?? 0;
+    const completed = counters["vusers.completed"] ?? 0;
+    const rate = created === 0 ? 0 : (created - completed) / created * 100;
+    const ok = rate <= checks.maxErrorRate;
+    results.push({
+      id: "errorRate",
+      ok,
+      text: `VU failures ${pct(rate)} ${ok ? "\u2264" : ">"} ${checks.maxErrorRate}% (${count(created - completed)} of ${count(created)})`
+    });
+  }
+  if (!short) {
+    for (const [key, limit] of Object.entries(checks.thresholds ?? {})) {
+      if (limit === void 0) continue;
+      const { name, stat } = splitMetricKey(key);
+      const value = stat ? distributions[name]?.[stat] : void 0;
+      if (value === void 0) {
+        results.push({ id: "threshold", ok: false, text: `${key}: nothing recorded` });
+        continue;
+      }
+      const ok = value <= limit;
+      results.push({ id: "threshold", ok, text: `${key} ${ms(value)} ${ok ? "\u2264" : ">"} ${ms(limit)}` });
+    }
+    for (const name of checks.expect ?? []) {
+      const n = counters[name] ?? 0;
+      results.push({ id: "expect", ok: n > 0, text: n > 0 ? `${name} counted ${count(n)}` : `${name} stayed at 0` });
+    }
+  }
+  for (const name of checks.forbid ?? []) {
+    const n = counters[name] ?? 0;
+    results.push({ id: "forbid", ok: n === 0, text: n === 0 ? `${name} stayed at 0` : `${name} counted ${count(n)}` });
+  }
+  return results;
+}
+
+// src/tools/bench/http.ts
+import http from "http";
+import https from "https";
+import { performance } from "perf_hooks";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var COUNTED = /* @__PURE__ */ Symbol("counted");
+function errorCode(error) {
+  if (error instanceof Error) return error.code ?? error.name;
+  return "unknown";
+}
+function codedError(code, message) {
+  return Object.assign(new Error(message), { code });
+}
+function defaultLabel(method, url) {
+  return `${method} ${url.pathname}`;
+}
+function createHttpClient(target, metrics, signal) {
+  const agents = /* @__PURE__ */ new Map();
+  const agentFor = (url) => {
+    let agent = agents.get(url.protocol);
+    if (!agent) {
+      agent = url.protocol === "https:" ? new https.Agent({ keepAlive: true, maxSockets: 1 }) : new http.Agent({ keepAlive: true, maxSockets: 1 });
+      agents.set(url.protocol, agent);
+    }
+    return agent;
+  };
+  const inFlight = /* @__PURE__ */ new Set();
+  const send = (method, path, options = {}) => {
+    const url = new URL(/^https?:\/\//.test(path) ? path : `${target}${path}`);
+    const label = options.name ?? defaultLabel(method, url);
+    const stats2 = metrics.endpoint(label);
+    const headers = { ...options.headers };
+    let body = options.body;
+    if (options.json !== void 0) {
+      body = JSON.stringify(options.json);
+      headers["content-type"] ??= "application/json";
+    }
+    if (body !== void 0) headers["content-length"] = String(Buffer.byteLength(body));
+    return new Promise((resolve3, reject) => {
+      if (signal.aborted) return reject(codedError("EABORTED", "the run stopped"));
+      const started = performance.now();
+      let connectedAt = 0;
+      let sentAt = 0;
+      let settled = false;
+      const lib = url.protocol === "https:" ? https : http;
+      const req = lib.request(url, { method, headers, agent: agentFor(url) });
+      const fail = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        signal.removeEventListener("abort", onAbort);
+        if (!signal.aborted) {
+          const code = errorCode(error);
+          if (code === "ETIMEDOUT") {
+            stats2.timeouts++;
+            metrics.counter("http.timeouts");
+          } else stats2.errors++;
+          metrics.counter(`errors.${code}`);
+          Object.assign(error, { [COUNTED]: true });
+        }
+        reject(error);
+      };
+      const timeoutMs = options.timeout ?? DEFAULT_TIMEOUT_MS;
+      const timer = setTimeout(
+        () => req.destroy(codedError("ETIMEDOUT", `${label} took longer than ${timeoutMs} ms`)),
+        timeoutMs
+      );
+      const onAbort = () => req.destroy(codedError("EABORTED", "the run stopped"));
+      signal.addEventListener("abort", onAbort, { once: true });
+      req.on("socket", (socket) => {
+        if (socket.connecting) socket.once("connect", () => connectedAt = performance.now());
+      });
+      req.on("finish", () => sentAt = performance.now());
+      req.on("error", fail);
+      req.on("response", (res) => {
+        const firstByteAt = performance.now();
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("error", fail);
+        res.on("end", () => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          signal.removeEventListener("abort", onAbort);
+          const status = res.statusCode ?? 0;
+          const ttfb = firstByteAt - Math.max(sentAt || started, connectedAt);
+          metrics.response(label, status, ttfb, performance.now() - started);
+          const buffer = Buffer.concat(chunks);
+          resolve3({
+            status,
+            ok: status >= 200 && status < 300,
+            headers: res.headers,
+            body: buffer,
+            text: () => buffer.toString("utf8"),
+            json: () => JSON.parse(buffer.toString("utf8"))
+          });
+        });
+      });
+      stats2.requests++;
+      metrics.counter("http.requests");
+      req.end(body);
+    });
+  };
+  const request = (method, path, options) => {
+    const pending = send(method, path, options);
+    const settled = pending.then(
+      () => void inFlight.delete(settled),
+      () => void inFlight.delete(settled)
+    );
+    inFlight.add(settled);
+    return pending;
+  };
+  return {
+    request,
+    get: (url, options) => request("GET", url, options),
+    post: (url, options) => request("POST", url, options),
+    put: (url, options) => request("PUT", url, options),
+    patch: (url, options) => request("PATCH", url, options),
+    delete: (url, options) => request("DELETE", url, options),
+    /** Closes the connections once every request has settled: destroying a socket would reset a request still on it. */
+    close: async () => {
+      await Promise.all(inFlight);
+      for (const agent of agents.values()) agent.destroy();
+    }
+  };
+}
+
+// src/tools/bench/metrics.ts
+import { createHistogram } from "perf_hooks";
+var toMicros = (ms2) => Math.max(1, Math.round(ms2 * 1e3));
+function distribution(histogram) {
+  if (histogram.count === 0) return { count: 0, min: 0, mean: 0, p50: 0, p95: 0, p99: 0, max: 0 };
+  const ms2 = (micros) => micros / 1e3;
+  return {
+    count: histogram.count,
+    min: ms2(histogram.min),
+    mean: ms2(histogram.mean),
+    p50: ms2(histogram.percentile(50)),
+    p95: ms2(histogram.percentile(95)),
+    p99: ms2(histogram.percentile(99)),
+    max: ms2(histogram.max)
+  };
+}
+var Metrics = class {
+  counters = /* @__PURE__ */ new Map();
+  intervalCounters = /* @__PURE__ */ new Map();
+  histograms = /* @__PURE__ */ new Map();
+  endpoints = /* @__PURE__ */ new Map();
+  counter(name, n = 1) {
+    this.counters.set(name, (this.counters.get(name) ?? 0) + n);
+    this.intervalCounters.set(name, (this.intervalCounters.get(name) ?? 0) + n);
+  }
+  histogram(name, ms2) {
+    let pair = this.histograms.get(name);
+    if (!pair) {
+      pair = { total: createHistogram(), interval: createHistogram() };
+      this.histograms.set(name, pair);
+    }
+    const value = toMicros(ms2);
+    pair.total.record(value);
+    pair.interval.record(value);
+  }
+  endpoint(label) {
+    let stats2 = this.endpoints.get(label);
+    if (!stats2) {
+      stats2 = {
+        requests: 0,
+        ttfb: createHistogram(),
+        total: createHistogram(),
+        codes: /* @__PURE__ */ new Map(),
+        timeouts: 0,
+        errors: 0
+      };
+      this.endpoints.set(label, stats2);
+    }
+    return stats2;
+  }
+  /** Records a response: `http.codes.<status>`, `http.response_time` (first byte) and, when the body was read, `http.total_time`. */
+  response(label, status, ttfbMs, totalMs) {
+    const stats2 = this.endpoint(label);
+    stats2.codes.set(status, (stats2.codes.get(status) ?? 0) + 1);
+    stats2.ttfb.record(toMicros(ttfbMs));
+    this.counter("http.responses");
+    this.counter(`http.codes.${status}`);
+    this.histogram("http.response_time", ttfbMs);
+    if (totalMs !== void 0) {
+      stats2.total.record(toMicros(totalMs));
+      this.histogram("http.total_time", totalMs);
+    }
+  }
+  get(name) {
+    return this.counters.get(name) ?? 0;
+  }
+  /** Whole-run distribution of a histogram; undefined for a name nothing recorded. */
+  distribution(name) {
+    const pair = this.histograms.get(name);
+    return pair && distribution(pair.total);
+  }
+  histogramNames() {
+    return [...this.histograms.keys()];
+  }
+  /** The interval's counters and histograms, then a fresh interval. */
+  tick() {
+    const counters = Object.fromEntries(this.intervalCounters);
+    this.intervalCounters.clear();
+    const histograms = {};
+    for (const [name, pair] of this.histograms) {
+      if (pair.interval.count > 0) histograms[name] = distribution(pair.interval);
+      pair.interval.reset();
+    }
+    return { counters, histograms };
+  }
+  endpointSummaries() {
+    const result = {};
+    for (const [label, stats2] of this.endpoints) {
+      const codes = Object.fromEntries(
+        [...stats2.codes].sort(([a], [b]) => a - b).map(([code, n]) => [String(code), n])
+      );
+      const nonOk = [...stats2.codes].filter(([code]) => code < 200 || code > 299).reduce((sum, [, n]) => sum + n, 0);
+      result[label] = {
+        requests: stats2.requests,
+        ttfb: distribution(stats2.ttfb),
+        total: distribution(stats2.total),
+        codes,
+        nonOk,
+        timeouts: stats2.timeouts,
+        errors: stats2.errors
+      };
+    }
+    return result;
+  }
+};
+
+// src/tools/bench/scheduler.ts
+import { performance as performance2 } from "perf_hooks";
+function rampedAt(i, from, to, duration) {
+  const slope = (to - from) / (2 * duration);
+  if (slope === 0) return i / from;
+  return (-from + Math.sqrt(from * from + 4 * slope * i)) / (2 * slope);
+}
+function phaseArrivals(phase) {
+  if (phase.arrivalCount !== void 0) return phase.arrivalCount;
+  const rate = phase.arrivalRate ?? 0;
+  return Math.round((rate + (phase.rampTo ?? rate)) / 2 * phase.duration);
+}
+function* schedule(phases) {
+  let offset = 0;
+  for (const [index, phase] of phases.entries()) {
+    yield { kind: "phase", at: offset, phase: index };
+    const count2 = phaseArrivals(phase);
+    const rate = phase.arrivalRate ?? 0;
+    for (let i = 0; i < count2; i++) {
+      let seconds2;
+      if (phase.arrivalCount !== void 0) seconds2 = i * phase.duration / count2;
+      else if (phase.rampTo !== void 0 && phase.rampTo !== rate)
+        seconds2 = rampedAt(i, rate, phase.rampTo, phase.duration);
+      else seconds2 = i / rate;
+      yield { kind: "arrival", at: offset + Math.min(seconds2, phase.duration) * 1e3, phase: index };
+    }
+    offset += phase.duration * 1e3;
+  }
+}
+function roleSequencer(roles) {
+  const total = roles.reduce((sum, role) => sum + role.weight, 0);
+  const current = roles.map(() => 0);
+  return () => {
+    let best = 0;
+    for (let i = 0; i < roles.length; i++) {
+      current[i] += roles[i].weight;
+      if (current[i] > current[best]) best = i;
+    }
+    current[best] -= total;
+    return roles[best];
+  };
+}
+function play(events, onEvent, signal) {
+  const iterator = events[Symbol.iterator]();
+  const start = performance2.now();
+  let next = iterator.next();
+  return new Promise((resolve3) => {
+    let timer;
+    const stop = () => {
+      clearTimeout(timer);
+      resolve3();
+    };
+    signal.addEventListener("abort", stop, { once: true });
+    const tick = () => {
+      const now = performance2.now() - start;
+      while (!next.done && next.value.at <= now && !signal.aborted) {
+        onEvent(next.value);
+        next = iterator.next();
+      }
+      if (next.done || signal.aborted) {
+        signal.removeEventListener("abort", stop);
+        return resolve3();
+      }
+      timer = setTimeout(tick, Math.max(0, next.value.at - (performance2.now() - start)));
+    };
+    tick();
+  });
+}
+
+// src/tools/bench/sse.ts
+import { performance as performance3 } from "perf_hooks";
+var CONNECT_TIMEOUT_MS = 1e4;
+function createSseParser(onEvent) {
+  let buffer = "";
+  let event = "";
+  let data = [];
+  let id;
+  const line = (text) => {
+    if (text === "") {
+      if (data.length > 0)
+        onEvent({ event: event || "message", data: data.join("\n"), ...id !== void 0 && { id } });
+      event = "";
+      data = [];
+      return;
+    }
+    if (text.startsWith(":")) return;
+    const colon = text.indexOf(":");
+    const field = colon === -1 ? text : text.slice(0, colon);
+    const value = colon === -1 ? "" : text.slice(colon + 1).replace(/^ /, "");
+    if (field === "event") event = value;
+    else if (field === "data") data.push(value);
+    else if (field === "id") id = value;
+  };
+  return (chunk) => {
+    buffer += chunk;
+    let start = 0;
+    for (let i = 0; i < buffer.length; i++) {
+      const char = buffer[i];
+      if (char !== "\n" && char !== "\r") continue;
+      if (char === "\r" && i === buffer.length - 1) break;
+      line(buffer.slice(start, i));
+      if (char === "\r" && buffer[i + 1] === "\n") i++;
+      start = i + 1;
+    }
+    buffer = buffer.slice(start);
+  };
+}
+async function readSse(url, onEvent, options, metrics, vuSignal) {
+  const label = options.name ?? `SSE ${new URL(url).pathname}`;
+  const stats2 = metrics.endpoint(label);
+  const connect = new AbortController();
+  const signal = AbortSignal.any([vuSignal, connect.signal, ...options.signal ? [options.signal] : []]);
+  const timer = setTimeout(
+    () => connect.abort(
+      Object.assign(new Error(`${label} sent no headers in ${CONNECT_TIMEOUT_MS} ms`), { code: "ETIMEDOUT" })
+    ),
+    CONNECT_TIMEOUT_MS
+  );
+  const started = performance3.now();
+  stats2.requests++;
+  metrics.counter("http.requests");
+  let res;
+  try {
+    res = await fetch(url, { headers: { accept: "text/event-stream", ...options.headers }, signal });
+  } catch (error) {
+    clearTimeout(timer);
+    if (options.signal?.aborted || vuSignal.aborted) return 0;
+    const cause = connect.signal.aborted ? connect.signal.reason : error;
+    const code = errorCode(cause);
+    if (code === "ETIMEDOUT") {
+      stats2.timeouts++;
+      metrics.counter("http.timeouts");
+    } else stats2.errors++;
+    metrics.counter(`errors.${code}`);
+    throw Object.assign(cause instanceof Error ? cause : new Error(String(cause)), { [COUNTED]: true });
+  }
+  clearTimeout(timer);
+  metrics.response(label, res.status, performance3.now() - started);
+  if (!res.ok || !res.body) {
+    await res.body?.cancel();
+    return res.status;
+  }
+  const push = createSseParser(onEvent);
+  const decoder = new TextDecoder();
+  try {
+    for await (const chunk of res.body) push(decoder.decode(chunk, { stream: true }));
+  } catch (error) {
+    if (!signal.aborted) throw error;
+  }
+  return res.status;
+}
+
+// src/tools/bench/run.ts
+var DEFAULT_INTERVAL_MS = 5e3;
+var LAG_WARN_MS = 50;
+var LAG_RESOLUTION_MS = 10;
+var DEFAULT_DRAIN_TIMEOUT_S = 300;
+var ABORT_GRACE_S = 5;
+var LOGS_KEPT = 30;
+function defineScenario(scenario) {
+  return scenario;
+}
+function plan(scenario, short) {
+  if (scenario.run) {
+    const fn = scenario.run;
+    return {
+      events: [
+        { kind: "phase", at: 0, phase: 0 },
+        { kind: "arrival", at: 0, phase: 0 }
+      ],
+      phases: [{ name: "run", duration: 0 }],
+      plannedS: null,
+      pick: () => ({ role: null, fn })
+    };
+  }
+  const roles = scenario.roles ?? [{ name: "", weight: 1, vu: scenario.vu }];
+  if (roles.some((role) => !(role.weight > 0))) throw new Error("every role needs a weight above 0");
+  const next = roleSequencer(roles);
+  const pick = () => {
+    const role = next();
+    return { role: scenario.roles ? role.name : null, fn: role.vu };
+  };
+  if (short) {
+    let i = 0;
+    const events = [
+      { kind: "phase", at: 0, phase: 0 },
+      ...roles.map(() => ({ kind: "arrival", at: 0, phase: 0 }))
+    ];
+    const pickEach = () => {
+      const role = roles[i++ % roles.length];
+      return { role: scenario.roles ? role.name : null, fn: role.vu };
+    };
+    return { events, phases: [{ name: "smoke", duration: 1 }], plannedS: 1, pick: pickEach };
+  }
+  const plannedS = scenario.phases.reduce((sum, phase) => sum + phase.duration, 0);
+  return { events: schedule(scenario.phases), phases: scenario.phases, plannedS, pick };
+}
+function logFileFor(dataDir, name, startedAt) {
+  const dir = join2(dataDir, "logs");
+  mkdirSync2(dir, { recursive: true });
+  const old = readdirSync(dir).filter((file) => file.startsWith(`${name}-`) && file.endsWith(".jsonl")).sort();
+  for (const file of old.slice(0, Math.max(0, old.length - LOGS_KEPT + 1))) rmSync(join2(dir, file), { force: true });
+  return join2(dir, `${name}-${startedAt.toISOString().slice(0, 19).replaceAll(":", "-")}.jsonl`);
+}
+function phaseText(phase) {
+  if (phase.arrivalCount !== void 0) return `${phase.arrivalCount} VUs over ${phase.duration}s`;
+  const rate = phase.arrivalRate ?? 0;
+  if (phase.rampTo !== void 0 && phase.rampTo !== rate) return `${rate} \u2192 ${phase.rampTo}/s over ${phase.duration}s`;
+  return `${rate}/s for ${phase.duration}s`;
+}
+async function runScenario(scenario, options) {
+  const { name, target, dataDir, short = false, quiet = false } = options;
+  const metrics = new Metrics();
+  const output = options.output ?? process5.stdout;
+  const display = new LiveDisplay(Boolean(output.isTTY), output);
+  const startedAt = /* @__PURE__ */ new Date();
+  const logFile = logFileFor(dataDir, name, startedAt);
+  const log = (entry) => appendFileSync(logFile, `${JSON.stringify(entry)}
+`);
+  const { events, phases, plannedS, pick } = plan(scenario, short);
+  const declared = new Set(scenario.counters ?? []);
+  const primaryKey = scenario.primary ?? "http.response_time.p95";
+  const { name: primaryName, stat: primaryStat } = splitMetricKey(primaryKey);
+  const attachments = {};
+  const errors = {};
+  const showPhases = !(quiet && output.isTTY);
+  const stop = new AbortController();
+  const lag = monitorEventLoopDelay({ resolution: LAG_RESOLUTION_MS });
+  lag.enable();
+  let lagP99Max = 0;
+  let lagWarning = null;
+  let phaseName = phases[0]?.name ?? "";
+  let active = 0;
+  let index = 0;
+  let onIdle = null;
+  const started = performance4.now();
+  let lastTick = started;
+  const launch = () => {
+    const { role, fn } = pick();
+    const client = createHttpClient(target, metrics, stop.signal);
+    const sockets = [];
+    const resolveUrl = (url) => /^[a-z]+:\/\//.test(url) ? url : `${target}${url}`;
+    const vu = {
+      index: index++,
+      role,
+      short,
+      signal: stop.signal,
+      http: client,
+      sse: (url, onEvent, sseOptions = {}) => readSse(resolveUrl(url), onEvent, sseOptions, metrics, stop.signal),
+      ws: (url, protocols) => new Promise((resolve3, reject) => {
+        const socket = new WebSocket(resolveUrl(url).replace(/^http/, "ws"), protocols);
+        sockets.push(socket);
+        socket.addEventListener("open", () => resolve3(socket), { once: true });
+        socket.addEventListener(
+          "error",
+          () => reject(Object.assign(new Error(`WebSocket ${url} did not open`), { code: "EWEBSOCKET" })),
+          {
+            once: true
+          }
+        );
+      }),
+      think: (thinkMs) => delay(thinkMs, void 0, { signal: stop.signal }),
+      counter: (counter, n) => metrics.counter(counter, n),
+      histogram: (histogram, value) => metrics.histogram(histogram, value),
+      log: (text) => display.log(text),
+      attach: (key, data) => {
+        attachments[key] = data;
+      }
+    };
+    metrics.counter("vusers.created");
+    active++;
+    Promise.resolve().then(() => fn(vu)).then(
+      () => metrics.counter("vusers.completed"),
+      (error) => {
+        metrics.counter("vusers.failed");
+        const code = stop.signal.aborted ? "aborted" : errorCode(error);
+        if (!error?.[COUNTED] || stop.signal.aborted) metrics.counter(`errors.${code}`);
+        errors[code] ??= { message: error instanceof Error ? error.message : String(error) };
+      }
+    ).finally(async () => {
+      await client.close();
+      for (const socket of sockets) socket.close();
+      active--;
+      if (active === 0) onIdle?.();
+    });
+  };
+  const tick = () => {
+    const now = performance4.now();
+    const intervalS = (now - lastTick) / 1e3;
+    lastTick = now;
+    const { counters: counters2, histograms } = metrics.tick();
+    const lagP99 = Math.max(0, lag.percentile(99) / 1e6 - LAG_RESOLUTION_MS);
+    lag.reset();
+    lagP99Max = Math.max(lagP99Max, lagP99);
+    const elapsedS = (now - started) / 1e3;
+    if (lagP99 > LAG_WARN_MS && !lagWarning) {
+      lagWarning = `generator event-loop lag p99 ${Math.round(lagP99)} ms (over ${LAG_WARN_MS} ms): the load generator is saturated, latencies include its own queueing`;
+      display.log(`  \u26A0 ${lagWarning}`);
+    }
+    const custom = Object.entries(counters2).filter(([counter, n]) => declared.has(counter) && n > 0);
+    const primary = primaryName.startsWith("http.") ? void 0 : histograms[primaryName];
+    const vus = {
+      started: counters2["vusers.created"] ?? 0,
+      active,
+      completed: metrics.get("vusers.completed"),
+      failed: metrics.get("vusers.failed")
+    };
+    log({
+      type: "interval",
+      t: Math.round(elapsedS * 10) / 10,
+      phase: phaseName,
+      vus,
+      counters: counters2,
+      histograms,
+      lagP99Ms: lagP99
+    });
+    display.render(
+      liveLines({
+        scenario: name,
+        phase: phaseName,
+        elapsedS,
+        plannedS,
+        vus,
+        intervalS: Math.max(intervalS, 1e-3),
+        counters: counters2,
+        http: histograms["http.response_time"],
+        primary: primary && { name: primaryName, distribution: primary },
+        custom,
+        lagP99
+      })
+    );
+  };
+  if (!quiet) display.log(`${colors_default.dim("\u25B8")} running ${name}${short ? " (short)" : ""}: ${scenario.description}`);
+  const ticker = setInterval(tick, DEFAULT_INTERVAL_MS);
+  await play(
+    events,
+    (event) => {
+      if (event.kind === "arrival") return launch();
+      phaseName = phases[event.phase].name;
+      if (showPhases && !scenario.run && !short)
+        display.log(`  ${colors_default.dim("phase")} ${phaseName} \xB7 ${phaseText(phases[event.phase])}`);
+    },
+    stop.signal
+  );
+  if (active > 0) {
+    if (!scenario.run) phaseName = "drain";
+    const drainS = scenario.drainTimeout ?? (scenario.run ? Number.POSITIVE_INFINITY : DEFAULT_DRAIN_TIMEOUT_S);
+    const idle = new Promise((resolve3) => {
+      onIdle = resolve3;
+    });
+    const timers = new AbortController();
+    const wait = (seconds2) => delay(seconds2 * 1e3, "timeout", { signal: timers.signal }).catch(() => null);
+    const timedOut = Number.isFinite(drainS) ? wait(drainS) : new Promise(() => {
+    });
+    if (await Promise.race([idle, timedOut]) === "timeout") {
+      display.log(`  \u26A0 ${active} VUs still running after ${drainS} s: aborted`);
+      stop.abort();
+      await Promise.race([idle, wait(ABORT_GRACE_S)]);
+    }
+    timers.abort();
+  }
+  clearInterval(ticker);
+  tick();
+  lag.disable();
+  const durationS = (performance4.now() - started) / 1e3;
+  const counters = Object.fromEntries(metrics.counters);
+  const distributions = Object.fromEntries(
+    metrics.histogramNames().flatMap((histogram) => {
+      const d = metrics.distribution(histogram);
+      return d ? [[histogram, d]] : [];
+    })
+  );
+  const checks = evaluateChecks(scenario.checks ?? {}, { counters, distributions, short });
+  if (options.afterRun) {
+    display.render([`${name} ${colors_default.dim("\xB7 checking what the app recorded")}`]);
+    checks.push(...await options.afterRun({ counters, checks: [...checks], short }));
+  }
+  display.clear();
+  const ok = checks.every((check) => check.ok);
+  const requests = metrics.get("http.requests");
+  const http2 = distributions["http.response_time"] ?? null;
+  const endpoints = metrics.endpointSummaries();
+  const current = {
+    runner: RUNNER_EPOCH,
+    timestamp: startedAt.toISOString(),
+    scenario: name,
+    requests,
+    requestRate: Math.round(requests / durationS * 10) / 10,
+    mean: http2?.mean ?? 0,
+    p50: http2?.p50 ?? 0,
+    p95: http2?.p95 ?? 0,
+    p99: http2?.p99 ?? 0,
+    errors: Object.entries(counters).reduce((sum, [counter, n]) => counter.startsWith("errors.") ? sum + n : sum, 0),
+    vusersCreated: metrics.get("vusers.created"),
+    vusersFailed: metrics.get("vusers.failed"),
+    primary: { metric: primaryKey, value: primaryStat ? distributions[primaryName]?.[primaryStat] ?? 0 : 0 },
+    endpoints: Object.fromEntries(
+      Object.entries(endpoints).map(([label, e]) => [
+        label,
+        {
+          requests: e.requests,
+          p50: e.ttfb.p50,
+          p95: e.ttfb.p95,
+          p99: e.ttfb.p99,
+          nonOk: e.nonOk,
+          timeouts: e.timeouts
+        }
+      ])
+    )
+  };
+  const { baseline, older } = short ? { baseline: null, older: 0 } : loadBaseline(dataDir, name);
+  const saved = !short && ok ? saveBaseline(dataDir, current) : null;
+  const builtin = /^(vusers|http|errors)\./;
+  const summary = {
+    type: "summary",
+    runner: RUNNER_EPOCH,
+    scenario: name,
+    startedAt: startedAt.toISOString(),
+    durationS,
+    short,
+    vus: { created: current.vusersCreated, completed: metrics.get("vusers.completed"), failed: current.vusersFailed },
+    requests,
+    requestRate: current.requestRate,
+    http: http2,
+    endpoints,
+    histograms: Object.fromEntries(
+      Object.entries(distributions).filter(([histogram]) => !histogram.startsWith("http."))
+    ),
+    counters,
+    errors: Object.fromEntries(
+      Object.entries(counters).flatMap(
+        ([counter, n]) => counter.startsWith("errors.") ? [[counter.slice(7), { count: n, message: errors[counter.slice(7)]?.message ?? "" }]] : []
+      )
+    ),
+    checks,
+    generatorLagP99MaxMs: lagP99Max,
+    attachments
+  };
+  log(summary);
+  const view = {
+    ...summary,
+    counters: Object.entries(counters).filter(([counter]) => !builtin.test(counter)),
+    compared: !short && ok,
+    baseline,
+    olderBaselines: older,
+    current,
+    saved,
+    logFile,
+    lagWarning
+  };
+  if (quiet) display.log(compactLine(view));
+  else for (const line of ["", ...summaryLines(view), ""]) display.log(line);
+  return { ok, summary, current, baseline: ok ? baseline : null, logFile };
+}
+
+// src/tools/bench/suite.ts
+import { readdirSync as readdirSync3 } from "fs";
+import { basename, join as join6 } from "path";
+import process8 from "process";
+import { setTimeout as sleep } from "timers/promises";
+import { pathToFileURL } from "url";
+import { select } from "@inquirer/prompts";
+
+// src/utils/display.ts
+import { resolve as resolve2 } from "path";
+import process6 from "process";
+
+// package.json
+var package_default = {
+  name: "@cellajs/cli",
+  version: "0.6.5",
+  private: false,
+  license: "MIT",
+  description: "CLI for managing your monorepo and upgrading it with upstream Cella.",
+  repository: {
+    type: "git",
+    url: "https://github.com/cellajs/cella-cli"
+  },
+  homepage: "https://cellajs.com",
+  author: "CellaJS <info@cellajs.com>",
+  engines: {
+    node: "26.x"
+  },
+  type: "module",
+  main: "./dist/index.js",
+  exports: {
+    ".": "./dist/index.js",
+    "./config": {
+      types: "./dist/config.d.ts",
+      import: "./dist/config.js"
+    },
+    "./bench": {
+      types: "./dist/bench.d.ts",
+      import: "./dist/bench.js"
+    },
+    "./style": {
+      types: "./dist/style.d.ts",
+      import: "./dist/style.js"
+    },
+    "./drive": {
+      types: "./dist/drive.d.ts",
+      import: "./dist/drive.js"
+    },
+    "./a11y": {
+      types: "./dist/a11y.d.ts",
+      import: "./dist/a11y.js"
+    },
+    "./screenshots": {
+      types: "./dist/screenshots.d.ts",
+      import: "./dist/screenshots.js"
+    },
+    "./pentest": {
+      types: "./dist/pentest.d.ts",
+      import: "./dist/pentest.js"
+    },
+    "./package.json": "./package.json"
+  },
+  files: [
+    "dist",
+    "index.js",
+    "README.md"
+  ],
+  bin: {
+    cella: "index.js"
+  },
+  imports: {
+    "#/*": "./src/*"
+  },
+  scripts: {
+    start: "tsx index.ts",
+    clean: "rimraf ./dist",
+    build: "tsup",
+    "test-build": "pnpm run build && node index.js --help",
+    prepublishOnly: "pnpm run test:release",
+    check: "pnpm ts && pnpm biome check --write .",
+    ts: "tsgo --pretty",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    test: "vitest run",
+    "test:release": "pnpm run build && vitest run --config vitest.release.config.ts",
+    "test:watch": "vitest",
+    prepare: "lefthook install"
+  },
+  dependencies: {
+    "@inquirer/core": "^12.0.3",
+    "@inquirer/prompts": "^8.7.2",
+    "@pierre/diffs": "^1.5.1",
+    "axe-core": "^4.14.0",
+    commander: "^15.0.0",
+    "ts-morph": "^28.0.0",
+    yaml: "^2.9.1",
+    zod: "^4.6.5"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^2.5.15",
+    "@commitlint/cli": "^21.2.3",
+    "@commitlint/config-conventional": "^21.2.3",
+    "@evilmartians/lefthook": "^2.1.15",
+    "@tailwindcss/node": "^4.3.3",
+    "@types/node": "26.6.3",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    playwright: "^1.64.1",
+    rimraf: "^6.1.3",
+    tailwindcss: "^4.3.3",
+    tsup: "^8.5.1",
+    tsx: "^4.23.15",
+    typescript: "6.0.3",
+    vitest: "^5.0.3"
+  },
+  publishConfig: {
+    access: "public"
+  },
+  keywords: [
+    "cella",
+    "cellajs",
+    "cli",
+    "sync",
+    "template"
+  ],
+  packageManager: "pnpm@11.28.7",
+  commitlint: {
+    extends: [
+      "@commitlint/config-conventional"
+    ],
+    rules: {
+      "type-enum": [
+        2,
+        "always",
+        [
+          "feat",
+          "fix",
+          "perf",
+          "refactor",
+          "revert",
+          "docs",
+          "chore",
+          "build",
+          "ci",
+          "style",
+          "test"
+        ]
+      ],
+      "header-max-length": [
+        2,
+        "always",
+        120
+      ],
+      "body-max-line-length": [
+        0,
+        "always",
+        200
+      ],
+      "footer-max-line-length": [
+        0,
+        "always",
+        200
+      ]
+    }
+  }
+};
+
+// src/utils/git.ts
+import { execFile } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir2, readdir, rmdir, unlink } from "fs/promises";
+import { dirname as dirname2, join as join4, resolve } from "path";
+import { promisify } from "util";
+
+// src/utils/manifest.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join as join3 } from "path";
+
+// src/utils/git.ts
+var execFileAsync = promisify(execFile);
+var MAX_BUFFER = 50 * 1024 * 1024;
+
+// src/utils/display.ts
+var VERSION = package_default.version;
+var DIVIDER = "\u2500".repeat(60);
+var MENU_DIVIDER = "\u2500".repeat(40);
+var STEP_LABEL_WIDTH = 9;
+var STEP_INDENT = 2 + STEP_LABEL_WIDTH + 2;
+var warningMark = colors_default.yellow("\u26A0");
+var checkMark = colors_default.green("\u2713");
+var activeSpinner = null;
+var jsonMode = false;
+function createSpinner(text) {
+  stopSpinner();
+  const enabled = !jsonMode && !getEnv("VITEST") && getEnv("NODE_ENV") !== "test" && !!process6.stdout.isTTY;
+  const frames = ["-", "\\", "|", "/"];
+  let frame = 0;
+  let timer;
+  const spinner = {
+    text,
+    stop() {
+      clearInterval(timer);
+      if (enabled) process6.stdout.write("\r\x1B[2K");
+    }
+  };
+  const render = () => process6.stdout.write(`\r${colors_default.cyan(frames[frame++ % frames.length])} ${spinner.text}`);
+  if (enabled) {
+    render();
+    timer = setInterval(render, 80);
+  }
+  activeSpinner = spinner;
+  return spinner;
+}
+function printStep(label, detail, mark = checkMark) {
+  stopSpinner();
+  const [first = "", ...rest] = (detail ?? "").split("\n");
+  console.info(`${mark} ${colors_default.bold(label.padEnd(STEP_LABEL_WIDTH))}  ${first}`.trimEnd());
+  for (const line of rest) console.info(line ? `${" ".repeat(STEP_INDENT)}${line}` : "");
+}
+function spinnerFail(message) {
+  stopSpinner();
+  console.info(`${colors_default.red("\u2717")} ${message}`);
+}
+function stopSpinner() {
+  if (activeSpinner) {
+    activeSpinner.stop();
+    activeSpinner = null;
+  }
+}
+var statusConfig = {
+  behind: { icon: colors_default.cyan("\u2193"), label: "behind", color: colors_default.cyan, description: "upstream changed, will update" },
+  diverged: { icon: colors_default.magenta("\u21C5"), label: "diverged", color: colors_default.magenta, description: "both changed, will merge" },
+  drifted: { icon: colors_default.yellow("!"), label: "drifted", color: colors_default.yellow, description: "fork changed (at risk)" },
+  ahead: { icon: colors_default.blue("\u2191"), label: "ahead", color: colors_default.blue, description: "fork changed (protected)" },
+  local: { icon: colors_default.green("+"), label: "local", color: colors_default.green, description: "local file in cella folders" },
+  pinned: { icon: colors_default.green("\u2A00"), label: "pinned", color: colors_default.green, description: "both changed, fork wins" },
+  ignored: { icon: colors_default.gray("\u2A02"), label: "ignored", color: colors_default.gray },
+  identical: { icon: colors_default.gray("\u2713"), label: "identical", color: colors_default.gray, description: "no changes" },
+  deleted: { icon: colors_default.red("\u2717"), label: "deleted", color: colors_default.red },
+  renamed: { icon: colors_default.blue("\u2192"), label: "renamed", color: colors_default.blue }
+};
+var summaryStatusConfig = {
+  ...statusConfig,
+  managed: {
+    icon: colors_default.cyan("\u25C7"),
+    label: "managed",
+    color: colors_default.cyan,
+    description: "package.jsons & cella/cella.config.ts handled separately"
+  },
+  ignored: { ...statusConfig.ignored, description: "protected by ignored config" }
+};
+
+// src/utils/errors.ts
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/tools/bench/lock.ts
+import { mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
+import process7 from "process";
+var isAlive = (pid) => {
+  try {
+    process7.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+var readLock = (file) => {
+  try {
+    return JSON.parse(readFileSync2(file, "utf8"));
+  } catch {
+    return null;
+  }
+};
+function acquireLock(dataDir, target, scenario) {
+  const dir = join5(dataDir, "locks");
+  mkdirSync3(dir, { recursive: true });
+  const { host } = new URL(target);
+  const file = join5(dir, `${host.replace(/[^a-z0-9.-]/gi, "_")}.json`);
+  const info = { pid: process7.pid, scenario, startedAt: (/* @__PURE__ */ new Date()).toISOString(), target };
+  for (let attempt = 0; ; attempt++) {
+    try {
+      writeFileSync2(file, JSON.stringify(info), { flag: "wx" });
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST" || attempt > 2) throw error;
+      const holder = readLock(file);
+      if (holder && isAlive(holder.pid)) return { holder };
+      try {
+        unlinkSync(file);
+      } catch {
+      }
+    }
+  }
+  const release = () => {
+    if (readLock(file)?.pid !== process7.pid) return;
+    try {
+      unlinkSync(file);
+    } catch {
+    }
+  };
+  process7.once("exit", release);
+  const others = readdirSync2(dir).map((name) => join5(dir, name)).filter((path) => path !== file).flatMap((path) => readLock(path) ?? []).filter((other) => isAlive(other.pid));
+  return {
+    lock: {
+      update: (name) => writeFileSync2(file, JSON.stringify({ ...info, scenario: name })),
+      release,
+      others
+    }
+  };
+}
+
+// src/tools/bench/request.ts
+var BENCH_REQUEST_ENV = "CELLA_BENCH";
+
+// src/tools/bench/suite.ts
+var DEFAULT_COOLDOWN_S = 15;
+function readRequest() {
+  const raw = getEnv(BENCH_REQUEST_ENV);
+  if (!raw) throw new Error("this is the app side of `pnpm cella bench`: run that instead");
+  return JSON.parse(raw);
+}
+var isScenario = (value) => typeof value === "object" && value !== null && "description" in value && typeof value.description === "string";
+async function loadScenario(dir, name) {
+  const { default: scenario } = await import(pathToFileURL(join6(dir, `${name}.ts`)).href);
+  if (!isScenario(scenario)) throw new Error(`scenarios/${name}.ts has no \`export default defineScenario(...)\``);
+  return scenario;
+}
+async function pickScenario(dir) {
+  const names = readdirSync3(dir).filter((file) => file.endsWith(".ts")).map((file) => basename(file, ".ts")).sort();
+  const choices = [];
+  for (const name of names) {
+    const { description } = await loadScenario(dir, name);
+    choices.push({ value: name, name: `${name.padEnd(22)}${colors_default.dim(description)}` });
+  }
+  const picked = await select({
+    message: "select a scenario",
+    choices: [
+      ...choices,
+      { type: "separator", separator: MENU_DIVIDER },
+      { value: "", name: colors_default.red(`${"exit".padEnd(22)}${colors_default.dim("quit without running")}`) }
+    ],
+    loop: false
+  });
+  return picked || void 0;
+}
+async function runRequest(bench, request) {
+  const picked = request.scenarios.length > 0 ? void 0 : await pickScenario(request.scenariosDir);
+  const names = picked ? [picked] : request.scenarios;
+  if (names.length === 0) return 0;
+  const scenarios = [];
+  for (const name of names) scenarios.push([name, await loadScenario(request.scenariosDir, name)]);
+  if (bench.preflight) {
+    createSpinner(`checking the stack at ${bench.target}`);
+    await bench.preflight();
+  }
+  printStep("stack", bench.target);
+  const claimed = acquireLock(request.dataDir, bench.target, request.all ? "--all" : names[0]);
+  if ("holder" in claimed) {
+    const { pid, scenario, startedAt } = claimed.holder;
+    const message = `another bench run holds ${bench.target}: pid ${pid} runs ${scenario} since ${new Date(startedAt).toLocaleTimeString("en-GB")}`;
+    throw new Error(message);
+  }
+  const { lock } = claimed;
+  for (const other of lock.others) {
+    console.info(
+      `${warningMark} bench pid ${other.pid} runs ${other.scenario} on ${other.target}: it shares this machine, numbers will be skewed`
+    );
+  }
+  if (bench.seed && !request.skipSeed) {
+    createSpinner("seeding the bench data");
+    await bench.seed();
+    printStep("seeded", colors_default.dim("bench data written again"));
+  }
+  await bench.beforeAll?.({ skipSeed: request.skipSeed });
+  const cooldownS = request.all && !request.short ? bench.cooldownSeconds ?? DEFAULT_COOLDOWN_S : 0;
+  const rows = [];
+  for (const [index, [name, scenario]] of scenarios.entries()) {
+    lock.update(name);
+    const state = await bench.beforeEach?.(name);
+    let columns = {};
+    const result = await runScenario(scenario, {
+      name,
+      target: bench.target,
+      dataDir: request.dataDir,
+      short: request.short,
+      quiet: request.all,
+      afterRun: async (outcome) => {
+        if (!bench.afterEach) return [];
+        const app = await bench.afterEach(outcome, state);
+        columns = app.columns ?? {};
+        return app.checks;
+      }
+    });
+    rows.push({ name, ok: result.ok, current: result.current, baseline: result.baseline, columns });
+    if (cooldownS > 0 && index < scenarios.length - 1) {
+      const spinner = createSpinner(`cooling down ${cooldownS} s`);
+      await sleep(cooldownS * 1e3);
+      spinner.stop();
+    }
+  }
+  lock.release();
+  const failed = rows.filter((row) => !row.ok).map((row) => row.name);
+  if (request.all && !request.short) for (const line of suiteLines(rows)) console.info(line);
+  else if (request.all && failed.length === 0) console.info(`
+${colors_default.green("\u2713")} every scenario passed its short run`);
+  else if (request.all) console.info(`
+${colors_default.red("\u2717")} the short run failed for ${failed.join(", ")}`);
+  return failed.length > 0 ? 1 : 0;
+}
+async function runBench(bench) {
+  process8.once("SIGINT", () => process8.exit(130));
+  process8.once("SIGTERM", () => process8.exit(143));
+  try {
+    process8.exitCode = await runRequest(bench, readRequest());
+  } catch (error) {
+    spinnerFail(errorMessage(error));
+    process8.exitCode = 1;
+  }
+}
+export {
+  defineScenario,
+  runBench
+};
+//# sourceMappingURL=bench.js.map