loadscope 0.0.0-stage → 0.1.0

package/dist/chunk-OFND2NUO.js

@@ -0,0 +1,3007 @@
+import {
+  ArrivalScheduler,
+  Histogram,
+  computeQueueDelay,
+  extractDistribution,
+  recordWithCorrection
+} from "./chunk-7L4SENK7.js";
+
+// src/config/schema.ts
+import { z } from "zod";
+import os from "os";
+function parseDurationToSeconds(val) {
+  if (typeof val === "number") {
+    if (val <= 0) throw new Error("Duration must be greater than 0");
+    return val;
+  }
+  const trimmed = val.trim().toLowerCase();
+  const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h)?$/);
+  if (!match) {
+    throw new Error(`Invalid duration format: "${val}". Examples: "30s", "1m", "500ms"`);
+  }
+  const num = parseFloat(match[1]);
+  const unit = match[2] || "s";
+  switch (unit) {
+    case "ms":
+      return num / 1e3;
+    case "s":
+      return num;
+    case "m":
+      return num * 60;
+    case "h":
+      return num * 3600;
+    default:
+      return num;
+  }
+}
+function parseHeaders(headersInput) {
+  if (!headersInput) return {};
+  if (!Array.isArray(headersInput)) return headersInput;
+  const result = {};
+  for (const item of headersInput) {
+    const colonIdx = item.indexOf(":");
+    if (colonIdx > 0) {
+      const key = item.substring(0, colonIdx).trim();
+      const val = item.substring(colonIdx + 1).trim();
+      result[key] = val;
+    }
+  }
+  return result;
+}
+function resolveWorkerCount(workers, concurrency) {
+  if (workers === "auto") {
+    const cpus = os.cpus()?.length || 1;
+    return Math.max(1, Math.min(concurrency, cpus));
+  }
+  const count = typeof workers === "number" ? workers : 1;
+  return Math.max(1, Math.min(concurrency, count));
+}
+var RunOptionsSchema = z.object({
+  url: z.string().url("A valid URL starting with http:// or https:// is required"),
+  duration: z.union([z.string(), z.number()]).default("10s").transform(parseDurationToSeconds),
+  concurrency: z.coerce.number().int().min(1, "Concurrency must be at least 1").default(10),
+  rate: z.coerce.number().positive().optional(),
+  method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).default("GET"),
+  headers: z.record(z.string()).default({}),
+  body: z.string().optional(),
+  timeout: z.union([z.string(), z.number()]).default("10s").transform(parseDurationToSeconds),
+  warmup: z.union([z.string(), z.number()]).optional().transform((v) => v ? parseDurationToSeconds(v) : 0),
+  rampUp: z.union([z.string(), z.number()]).optional().transform((v) => v ? parseDurationToSeconds(v) : 0),
+  mode: z.enum(["closed", "open"]).optional(),
+  distribution: z.enum(["uniform", "poisson"]).default("uniform"),
+  honest: z.boolean().default(false),
+  ttfb: z.boolean().default(false),
+  workers: z.union([z.coerce.number().int().min(1), z.literal("auto")]).default(1),
+  dashboard: z.boolean().default(true),
+  json: z.union([z.string(), z.boolean()]).optional(),
+  csv: z.union([z.string(), z.boolean()]).optional(),
+  pdf: z.string().optional(),
+  aiReport: z.string().optional(),
+  aiDryRun: z.boolean().default(false)
+});
+function validateRunOptions(raw) {
+  let headers = raw.headers;
+  if (Array.isArray(headers)) {
+    headers = parseHeaders(headers);
+  }
+  return RunOptionsSchema.parse({
+    ...raw,
+    headers: headers ?? {}
+  });
+}
+
+// src/core/runner.ts
+import { Pool } from "undici";
+import { monitorEventLoopDelay } from "perf_hooks";
+async function executeClosedModel(options) {
+  const urlObj = new URL(options.url);
+  const pool = new Pool(urlObj.origin, {
+    connections: options.concurrency,
+    pipelining: 1,
+    keepAliveTimeout: 3e4,
+    keepAliveMaxTimeout: 6e4
+  });
+  const histogram = new Histogram();
+  const ttfbHistogram = new Histogram();
+  let currentSecondHistogram = new Histogram();
+  const statusCodes = {};
+  const errorsByType = {};
+  const selfCheckWarnings = [];
+  const series = [];
+  let networkErrors = 0;
+  let httpErrors = 0;
+  let totalDispatched = 0;
+  const timeoutMs = Math.max(1, Math.floor(options.timeout * 1e3));
+  const reqPath = urlObj.pathname + urlObj.search;
+  const reqMethod = options.method;
+  const loopDelay = monitorEventLoopDelay({ resolution: 20 });
+  loopDelay.enable();
+  let stopped = false;
+  const abortController = new AbortController();
+  async function dispatchRequest(recordStats) {
+    if (recordStats) totalDispatched++;
+    const reqStartNs = process.hrtime.bigint();
+    try {
+      const response = await pool.request({
+        path: reqPath,
+        method: reqMethod,
+        headers: options.headers,
+        body: options.body,
+        headersTimeout: timeoutMs,
+        bodyTimeout: timeoutMs,
+        signal: abortController.signal
+      });
+      const headersNs = process.hrtime.bigint();
+      const ttfbUs = Math.max(0, Number(headersNs - reqStartNs) / 1e3);
+      await response.body.dump({ limit: 10 * 1024 * 1024 });
+      const elapsedUs = Number(process.hrtime.bigint() - reqStartNs) / 1e3;
+      const code = response.statusCode;
+      if (recordStats) {
+        if (options.honest) {
+          const expectedIntervalUs = 10 / options.concurrency * 1e3;
+          recordWithCorrection(histogram, elapsedUs, expectedIntervalUs);
+        } else {
+          histogram.record(elapsedUs);
+        }
+        ttfbHistogram.record(ttfbUs);
+        currentSecondHistogram.record(elapsedUs);
+        statusCodes[code] = (statusCodes[code] || 0) + 1;
+        if (code >= 400) {
+          httpErrors++;
+        }
+      }
+    } catch (err) {
+      const elapsedUs = Number(process.hrtime.bigint() - reqStartNs) / 1e3;
+      if (recordStats) {
+        networkErrors++;
+        histogram.record(elapsedUs);
+        currentSecondHistogram.record(elapsedUs);
+        const errorObj = err;
+        const codeKey = errorObj.code || errorObj.name || "NETWORK_ERROR";
+        errorsByType[codeKey] = (errorsByType[codeKey] || 0) + 1;
+      }
+    }
+  }
+  if (options.warmup && options.warmup > 0) {
+    const warmupEndNs = process.hrtime.bigint() + BigInt(Math.floor(options.warmup * 1e9));
+    let warmupStopped = false;
+    const warmupWorkers = Array.from({ length: options.concurrency }, async () => {
+      while (!warmupStopped && !stopped) {
+        if (process.hrtime.bigint() >= warmupEndNs) {
+          warmupStopped = true;
+          break;
+        }
+        await dispatchRequest(false);
+      }
+    });
+    await Promise.all(warmupWorkers);
+  }
+  const durationNs = BigInt(Math.floor(options.duration * 1e9));
+  const startNs = process.hrtime.bigint();
+  const endNs = startNs + durationNs;
+  const hardDeadlineTimer = setTimeout(() => {
+    stopped = true;
+    abortController.abort();
+  }, Math.ceil(options.duration * 1e3) + 200);
+  let lastSecond = 0;
+  const snapshotTimer = setInterval(() => {
+    const elapsedSec = Math.floor(Number(process.hrtime.bigint() - startNs) / 1e9);
+    if (elapsedSec > lastSecond) {
+      lastSecond = elapsedSec;
+      series.push({
+        t: elapsedSec,
+        p95: currentSecondHistogram.total > 0 ? currentSecondHistogram.percentileMs(95) : histogram.percentileMs(95)
+      });
+      currentSecondHistogram = new Histogram();
+    }
+  }, 1e3);
+  async function workerLoop(workerIndex) {
+    if (options.rampUp && options.rampUp > 0) {
+      const delayMs = workerIndex / options.concurrency * options.rampUp * 1e3;
+      if (delayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+    while (!stopped) {
+      if (process.hrtime.bigint() >= endNs) {
+        stopped = true;
+        break;
+      }
+      await dispatchRequest(true);
+    }
+  }
+  try {
+    const workers = Array.from({ length: options.concurrency }, (_, i) => workerLoop(i));
+    await Promise.all(workers);
+  } finally {
+    clearTimeout(hardDeadlineTimer);
+    clearInterval(snapshotTimer);
+    loopDelay.disable();
+    await pool.close();
+  }
+  const maxLoopLagMs = loopDelay.max / 1e6;
+  const p99LoopLagMs = loopDelay.percentile(99) / 1e6;
+  if (p99LoopLagMs > 20 || maxLoopLagMs > 50) {
+    selfCheckWarnings.push(
+      `Event loop lag detected (max: ${maxLoopLagMs.toFixed(1)}ms, p99: ${p99LoopLagMs.toFixed(1)}ms). The runner's event loop may be saturated, adding client-side queue delay.`
+    );
+  }
+  const totalNs = process.hrtime.bigint() - startNs;
+  const totalDurationSec = Math.max(1e-3, Number(totalNs) / 1e9);
+  const rps = totalDurationSec > 0 ? totalDispatched / totalDurationSec : 0;
+  const totalFailures = networkErrors + httpErrors;
+  const errorRate = totalDispatched > 0 ? totalFailures / totalDispatched : 0;
+  if (series.length === 0) {
+    series.push({
+      t: Math.max(1, Math.round(totalDurationSec)),
+      p95: histogram.percentileMs(95)
+    });
+  }
+  return {
+    target: options.url,
+    rps,
+    totalRequests: totalDispatched,
+    durationSec: totalDurationSec,
+    p50: histogram.percentileMs(50),
+    p90: histogram.percentileMs(90),
+    p95: histogram.percentileMs(95),
+    p99: histogram.percentileMs(99),
+    errorRate,
+    networkErrors,
+    httpErrors,
+    statusCodes,
+    errorsByType,
+    series,
+    selfCheckWarnings,
+    ttfb: options.ttfb ? extractDistribution(ttfbHistogram) : void 0
+  };
+}
+
+// src/core/open-model.ts
+import { Pool as Pool2 } from "undici";
+import { monitorEventLoopDelay as monitorEventLoopDelay2 } from "perf_hooks";
+async function executeOpenModel(options) {
+  const targetRps = options.rate && options.rate > 0 ? options.rate : 50;
+  const distribution = options.distribution ?? "uniform";
+  const expectedIntervalUs = 1 / targetRps * 1e6;
+  const maxConnections = Math.max(options.concurrency, Math.min(500, Math.ceil(targetRps * 2)));
+  const urlObj = new URL(options.url);
+  const pool = new Pool2(urlObj.origin, {
+    connections: maxConnections,
+    pipelining: 1,
+    keepAliveTimeout: 3e4,
+    keepAliveMaxTimeout: 6e4
+  });
+  const responseHistogram = new Histogram();
+  const serviceHistogram = new Histogram();
+  const ttfbHistogram = new Histogram();
+  let currentSecondHistogram = new Histogram();
+  const statusCodes = {};
+  const errorsByType = {};
+  const selfCheckWarnings = [];
+  const series = [];
+  let networkErrors = 0;
+  let httpErrors = 0;
+  let totalDispatched = 0;
+  const timeoutMs = Math.max(1, Math.floor(options.timeout * 1e3));
+  const reqPath = urlObj.pathname + urlObj.search;
+  const reqMethod = options.method;
+  const loopDelay = monitorEventLoopDelay2({ resolution: 20 });
+  loopDelay.enable();
+  let stopped = false;
+  const abortController = new AbortController();
+  async function dispatchRequest(intendedNs, recordStats) {
+    if (recordStats) totalDispatched++;
+    const dispatchNs = process.hrtime.bigint();
+    try {
+      const response = await pool.request({
+        path: reqPath,
+        method: reqMethod,
+        headers: options.headers,
+        body: options.body,
+        headersTimeout: timeoutMs,
+        bodyTimeout: timeoutMs,
+        signal: abortController.signal
+      });
+      const headersNs = process.hrtime.bigint();
+      const ttfbUs = Math.max(0, Number(headersNs - dispatchNs) / 1e3);
+      await response.body.dump({ limit: 10 * 1024 * 1024 });
+      const completionNs = process.hrtime.bigint();
+      const serviceUs = Math.max(0, Number(completionNs - dispatchNs) / 1e3);
+      const honestResponseUs = Math.max(0, Number(completionNs - intendedNs) / 1e3);
+      const code = response.statusCode;
+      if (recordStats) {
+        if (options.honest) {
+          recordWithCorrection(responseHistogram, honestResponseUs, expectedIntervalUs);
+          recordWithCorrection(serviceHistogram, serviceUs, expectedIntervalUs);
+        } else {
+          responseHistogram.record(honestResponseUs);
+          serviceHistogram.record(serviceUs);
+        }
+        ttfbHistogram.record(ttfbUs);
+        currentSecondHistogram.record(honestResponseUs);
+        statusCodes[code] = (statusCodes[code] || 0) + 1;
+        if (code >= 400) {
+          httpErrors++;
+        }
+      }
+    } catch (err) {
+      const completionNs = process.hrtime.bigint();
+      const serviceUs = Math.max(0, Number(completionNs - dispatchNs) / 1e3);
+      const honestResponseUs = Math.max(0, Number(completionNs - intendedNs) / 1e3);
+      if (recordStats) {
+        networkErrors++;
+        responseHistogram.record(honestResponseUs);
+        serviceHistogram.record(serviceUs);
+        currentSecondHistogram.record(honestResponseUs);
+        const errorObj = err;
+        const codeKey = errorObj.code || errorObj.name || "NETWORK_ERROR";
+        errorsByType[codeKey] = (errorsByType[codeKey] || 0) + 1;
+      }
+    }
+  }
+  if (options.warmup && options.warmup > 0) {
+    const warmupScheduler = new ArrivalScheduler(targetRps, distribution);
+    const warmupDurationNs = BigInt(Math.floor(options.warmup * 1e9));
+    const warmupStartNs = process.hrtime.bigint();
+    const warmupEndNs = warmupStartNs + warmupDurationNs;
+    while (process.hrtime.bigint() < warmupEndNs && !stopped) {
+      const targetNs = warmupScheduler.nextArrivalNs();
+      await warmupScheduler.waitUntil(targetNs);
+      void dispatchRequest(targetNs, false);
+    }
+  }
+  const durationNs = BigInt(Math.floor(options.duration * 1e9));
+  const startNs = process.hrtime.bigint();
+  const endNs = startNs + durationNs;
+  const scheduler = new ArrivalScheduler(targetRps, distribution, startNs);
+  const hardDeadlineTimer = setTimeout(() => {
+    stopped = true;
+    abortController.abort();
+  }, Math.ceil(options.duration * 1e3) + 300);
+  let lastSecond = 0;
+  const snapshotTimer = setInterval(() => {
+    const elapsedSec = Math.floor(Number(process.hrtime.bigint() - startNs) / 1e9);
+    if (elapsedSec > lastSecond) {
+      lastSecond = elapsedSec;
+      series.push({
+        t: elapsedSec,
+        p95: currentSecondHistogram.total > 0 ? currentSecondHistogram.percentileMs(95) : responseHistogram.percentileMs(95)
+      });
+      currentSecondHistogram = new Histogram();
+    }
+  }, 1e3);
+  const pendingPromises = /* @__PURE__ */ new Set();
+  while (!stopped) {
+    const nowNs = process.hrtime.bigint();
+    if (nowNs >= endNs) {
+      stopped = true;
+      break;
+    }
+    const targetArrivalNs = scheduler.nextArrivalNs();
+    await scheduler.waitUntil(targetArrivalNs);
+    const p = dispatchRequest(targetArrivalNs, true);
+    pendingPromises.add(p);
+    p.finally(() => pendingPromises.delete(p));
+    if (pendingPromises.size > maxConnections * 2) {
+      await Promise.race(pendingPromises);
+    }
+  }
+  await Promise.allSettled(Array.from(pendingPromises));
+  clearTimeout(hardDeadlineTimer);
+  clearInterval(snapshotTimer);
+  loopDelay.disable();
+  await pool.close();
+  const maxLoopLagMs = loopDelay.max / 1e6;
+  const p99LoopLagMs = loopDelay.percentile(99) / 1e6;
+  if (p99LoopLagMs > 20 || maxLoopLagMs > 50) {
+    selfCheckWarnings.push(
+      `Event loop lag detected (max: ${maxLoopLagMs.toFixed(1)}ms, p99: ${p99LoopLagMs.toFixed(1)}ms). The runner's event loop may be saturated, adding client-side queue delay.`
+    );
+  }
+  if (scheduler.averageDriftMs > 10) {
+    selfCheckWarnings.push(
+      `High schedule drift detected (avg drift: ${scheduler.averageDriftMs.toFixed(1)}ms). The client could not maintain the target ${targetRps} req/s arrival rate.`
+    );
+  }
+  const totalNs = process.hrtime.bigint() - startNs;
+  const totalDurationSec = Math.max(1e-3, Number(totalNs) / 1e9);
+  const rps = totalDurationSec > 0 ? totalDispatched / totalDurationSec : 0;
+  const totalFailures = networkErrors + httpErrors;
+  const errorRate = totalDispatched > 0 ? totalFailures / totalDispatched : 0;
+  if (series.length === 0) {
+    series.push({
+      t: Math.max(1, Math.round(totalDurationSec)),
+      p95: responseHistogram.percentileMs(95)
+    });
+  }
+  const serviceDist = extractDistribution(serviceHistogram);
+  const responseDist = extractDistribution(responseHistogram);
+  const queueDelayDist = computeQueueDelay(responseDist, serviceDist);
+  const ttfbDist = extractDistribution(ttfbHistogram);
+  return {
+    target: options.url,
+    rps,
+    totalRequests: totalDispatched,
+    durationSec: totalDurationSec,
+    p50: responseDist.p50,
+    p90: responseDist.p90,
+    p95: responseDist.p95,
+    p99: responseDist.p99,
+    errorRate,
+    networkErrors,
+    httpErrors,
+    statusCodes,
+    errorsByType,
+    series,
+    selfCheckWarnings,
+    distribution,
+    serviceTime: serviceDist,
+    queueDelay: queueDelayDist,
+    ttfb: options.ttfb ? ttfbDist : void 0,
+    scheduleDriftMs: scheduler.averageDriftMs
+  };
+}
+
+// src/core/multi-runner.ts
+import { Worker } from "worker_threads";
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+
+// src/report/dashboard.ts
+import logUpdate from "log-update";
+import picocolors from "picocolors";
+var LiveDashboard = class {
+  enabled;
+  constructor(enabled = true) {
+    this.enabled = enabled && Boolean(process.stdout.isTTY);
+  }
+  /**
+   * Format a progress bar like [████████░░░░░░] 60%
+   */
+  renderProgressBar(percent, width = 24) {
+    const clamped = Math.max(0, Math.min(1, percent));
+    const filled = Math.round(clamped * width);
+    const empty = width - filled;
+    const bar = picocolors.cyan("\u2588".repeat(filled)) + picocolors.dim("\u2591".repeat(empty));
+    const pctStr = (clamped * 100).toFixed(0).padStart(3) + "%";
+    return `[${bar}] ${picocolors.bold(pctStr)}`;
+  }
+  /**
+   * Generates the dashboard text representation.
+   */
+  formatDashboard(stats) {
+    const lines = [];
+    const divider = picocolors.dim("\u2500".repeat(58));
+    const progressPct = stats.totalDurationSec > 0 ? stats.elapsedSec / stats.totalDurationSec : 0;
+    lines.push("");
+    lines.push(divider);
+    lines.push(
+      picocolors.bold(picocolors.cyan(" LoadScope Live Monitor ")) + picocolors.dim(`\u2022 ${stats.target}`)
+    );
+    lines.push(divider);
+    const timeStr = `${stats.elapsedSec.toFixed(1)}s / ${stats.totalDurationSec.toFixed(1)}s`;
+    lines.push(` ${this.renderProgressBar(progressPct)}  ${picocolors.dim(timeStr)}`);
+    lines.push(
+      ` ${picocolors.dim("Throughput:")}  ${picocolors.green(picocolors.bold(stats.currentRps.toLocaleString("en-US", { minimumFractionDigits: 1, maximumFractionDigits: 1 })))} req/s   ${picocolors.dim("Total Requests:")} ${picocolors.bold(stats.totalRequests.toLocaleString("en-US"))}`
+    );
+    const p50Str = picocolors.cyan(`${stats.p50Ms.toFixed(2)}ms`);
+    const p90Str = picocolors.cyan(`${stats.p90Ms.toFixed(2)}ms`);
+    const p95Str = stats.p95Ms > 300 ? picocolors.yellow(`${stats.p95Ms.toFixed(2)}ms`) : picocolors.cyan(`${stats.p95Ms.toFixed(2)}ms`);
+    lines.push(
+      ` ${picocolors.dim("Latency:")}     p50: ${p50Str}  p90: ${p90Str}  p95: ${p95Str}`
+    );
+    const totalFailures = stats.networkErrors + stats.httpErrors;
+    const errorRate = stats.totalRequests > 0 ? totalFailures / stats.totalRequests * 100 : 0;
+    const errorColor = totalFailures > 0 ? picocolors.red : picocolors.green;
+    const errorStr = errorColor(`${errorRate.toFixed(2)}% (${totalFailures.toLocaleString("en-US")} fails)`);
+    lines.push(
+      ` ${picocolors.dim("Error Rate:")}  ${errorStr}    ${picocolors.dim("Workers:")} ${picocolors.bold(stats.workerCount.toString())} active`
+    );
+    if (stats.warnings && stats.warnings.length > 0) {
+      lines.push("");
+      for (const w of stats.warnings) {
+        lines.push(`   ${picocolors.yellow("\u26A0\uFE0F ")} ${w}`);
+      }
+    }
+    lines.push(divider);
+    return lines.join("\n");
+  }
+  /**
+   * Update the live terminal display.
+   */
+  update(stats) {
+    if (!this.enabled) return;
+    logUpdate(this.formatDashboard(stats));
+  }
+  /**
+   * Stop the live dashboard and clean up terminal state.
+   */
+  stop() {
+    if (!this.enabled) return;
+    logUpdate.clear();
+    logUpdate.done();
+  }
+};
+
+// src/core/multi-runner.ts
+function getWorkerPath() {
+  const distCandidate = path.resolve(process.cwd(), "dist/worker.js");
+  if (fs.existsSync(distCandidate)) {
+    return { path: distCandidate };
+  }
+  const currentFile = fileURLToPath(import.meta.url);
+  const dir = path.dirname(currentFile);
+  const candidate1 = path.resolve(dir, "worker.js");
+  if (fs.existsSync(candidate1)) return { path: candidate1 };
+  const candidate2 = path.resolve(dir, "../worker.js");
+  if (fs.existsSync(candidate2)) return { path: candidate2 };
+  if (currentFile.endsWith(".ts")) {
+    const tsWorker = path.resolve(dir, "worker.ts");
+    return { path: tsWorker, execArgv: ["--import", "tsx"] };
+  }
+  return { path: distCandidate };
+}
+async function executeMultiThreaded(options) {
+  const workerCount = resolveWorkerCount(options.workers, options.concurrency);
+  const targetMode = options.rate && options.rate > 0 ? "open" : options.mode ?? "closed";
+  const baseConcurrency = Math.floor(options.concurrency / workerCount);
+  const extraConcurrency = options.concurrency % workerCount;
+  const ratePerWorker = options.rate && options.rate > 0 ? options.rate / workerCount : void 0;
+  const globalHistogram = new Histogram();
+  const globalServiceHistogram = new Histogram();
+  const globalTtfbHistogram = new Histogram();
+  const aggregatedStatusCodes = {};
+  const aggregatedErrorsByType = {};
+  const selfCheckWarnings = [];
+  const series = [];
+  const workerLagMax = [];
+  const workerLagP99 = [];
+  let currentSecondWindowHistogram = new Histogram();
+  const dashboard = new LiveDashboard(options.dashboard);
+  const { path: workerScript, execArgv } = getWorkerPath();
+  const startNs = process.hrtime.bigint();
+  let lastRecordedSec = 0;
+  const latestTicks = /* @__PURE__ */ new Map();
+  const doneMessages = [];
+  const workerPromises = [];
+  for (let i = 0; i < workerCount; i++) {
+    const workerConcurrency = baseConcurrency + (i < extraConcurrency ? 1 : 0);
+    const initData = {
+      workerIndex: i,
+      totalWorkers: workerCount,
+      url: options.url,
+      duration: options.duration,
+      concurrency: workerConcurrency,
+      rate: ratePerWorker,
+      distribution: options.distribution,
+      honest: options.honest,
+      ttfb: options.ttfb,
+      method: options.method,
+      headers: options.headers,
+      body: options.body,
+      timeout: options.timeout,
+      warmup: options.warmup ?? 0,
+      rampUp: options.rampUp ?? 0,
+      mode: targetMode
+    };
+    const promise = new Promise((resolve, reject) => {
+      const worker = new Worker(workerScript, {
+        workerData: initData,
+        execArgv: execArgv ?? []
+      });
+      worker.on("message", (msg) => {
+        if (msg.type === "tick") {
+          latestTicks.set(msg.workerIndex, msg);
+          currentSecondWindowHistogram.mergeSnapshot(msg.windowSnapshot);
+          let liveDispatched = 0;
+          let liveNetworkErrors = 0;
+          let liveHttpErrors = 0;
+          const liveMergedHist = new Histogram();
+          for (const t of latestTicks.values()) {
+            liveDispatched += t.dispatched;
+            liveNetworkErrors += t.networkErrors;
+            liveHttpErrors += t.httpErrors;
+            liveMergedHist.mergeSnapshot(t.cumulativeSnapshot);
+          }
+          const elapsedSec = Math.floor(Number(process.hrtime.bigint() - startNs) / 1e9);
+          const currentRps = elapsedSec > 0 ? liveDispatched / elapsedSec : 0;
+          if (elapsedSec > lastRecordedSec) {
+            lastRecordedSec = elapsedSec;
+            series.push({
+              t: elapsedSec,
+              p95: currentSecondWindowHistogram.total > 0 ? currentSecondWindowHistogram.percentileMs(95) : liveMergedHist.percentileMs(95)
+            });
+            currentSecondWindowHistogram = new Histogram();
+          }
+          dashboard.update({
+            target: options.url,
+            elapsedSec,
+            totalDurationSec: options.duration,
+            totalRequests: liveDispatched,
+            currentRps,
+            p50Ms: liveMergedHist.percentileMs(50),
+            p90Ms: liveMergedHist.percentileMs(90),
+            p95Ms: liveMergedHist.percentileMs(95),
+            networkErrors: liveNetworkErrors,
+            httpErrors: liveHttpErrors,
+            workerCount,
+            mode: targetMode
+          });
+        } else if (msg.type === "done") {
+          doneMessages.push(msg);
+          workerLagMax.push(msg.loopLagMaxMs);
+          workerLagP99.push(msg.loopLagP99Ms);
+        } else if (msg.type === "error") {
+          reject(new Error(`Worker ${msg.workerIndex} encountered error: ${msg.error}`));
+        }
+      });
+      worker.on("error", reject);
+      worker.on("exit", (code) => {
+        if (code !== 0 && doneMessages.length < workerCount) {
+          reject(new Error(`Worker ${i} exited with non-zero code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+    });
+    workerPromises.push(promise);
+  }
+  try {
+    await Promise.all(workerPromises);
+  } finally {
+    dashboard.stop();
+  }
+  let totalDispatched = 0;
+  let networkErrors = 0;
+  let httpErrors = 0;
+  for (const done of doneMessages) {
+    totalDispatched += done.dispatched;
+    networkErrors += done.networkErrors;
+    httpErrors += done.httpErrors;
+    globalHistogram.mergeSnapshot(done.finalSnapshot);
+    if (done.serviceTimeSnapshot) {
+      globalServiceHistogram.mergeSnapshot(done.serviceTimeSnapshot);
+    }
+    if (done.ttfbSnapshot) {
+      globalTtfbHistogram.mergeSnapshot(done.ttfbSnapshot);
+    }
+    for (const [code, count] of Object.entries(done.statusCodes)) {
+      const numCode = Number(code);
+      aggregatedStatusCodes[numCode] = (aggregatedStatusCodes[numCode] || 0) + count;
+    }
+    for (const [errType, count] of Object.entries(done.errorsByType)) {
+      aggregatedErrorsByType[errType] = (aggregatedErrorsByType[errType] || 0) + count;
+    }
+  }
+  const maxLag = workerLagMax.length > 0 ? Math.max(...workerLagMax) : 0;
+  const maxP99Lag = workerLagP99.length > 0 ? Math.max(...workerLagP99) : 0;
+  if (maxP99Lag > 20 || maxLag > 50) {
+    selfCheckWarnings.push(
+      `Worker event loop lag detected (highest worker max: ${maxLag.toFixed(1)}ms, p99: ${maxP99Lag.toFixed(1)}ms). Load generator event loop was under heavy load.`
+    );
+  }
+  const totalNs = process.hrtime.bigint() - startNs;
+  const totalDurationSec = Math.max(1e-3, Number(totalNs) / 1e9);
+  const rps = totalDurationSec > 0 ? totalDispatched / totalDurationSec : 0;
+  const totalFailures = networkErrors + httpErrors;
+  const errorRate = totalDispatched > 0 ? totalFailures / totalDispatched : 0;
+  if (series.length === 0) {
+    series.push({
+      t: Math.max(1, Math.round(totalDurationSec)),
+      p95: globalHistogram.percentileMs(95)
+    });
+  }
+  const responseDist = extractDistribution(globalHistogram);
+  const hasService = globalServiceHistogram.total > 0;
+  const serviceDist = hasService ? extractDistribution(globalServiceHistogram) : void 0;
+  const queueDelayDist = serviceDist ? computeQueueDelay(responseDist, serviceDist) : void 0;
+  const ttfbDist = globalTtfbHistogram.total > 0 && options.ttfb ? extractDistribution(globalTtfbHistogram) : void 0;
+  return {
+    target: options.url,
+    rps,
+    totalRequests: totalDispatched,
+    durationSec: totalDurationSec,
+    p50: responseDist.p50,
+    p90: responseDist.p90,
+    p95: responseDist.p95,
+    p99: responseDist.p99,
+    errorRate,
+    networkErrors,
+    httpErrors,
+    statusCodes: aggregatedStatusCodes,
+    errorsByType: aggregatedErrorsByType,
+    series,
+    selfCheckWarnings,
+    workerCount,
+    distribution: options.distribution,
+    serviceTime: serviceDist,
+    queueDelay: queueDelayDist,
+    ttfb: ttfbDist
+  };
+}
+
+// src/report/terminal.ts
+import picocolors2 from "picocolors";
+function fmt(num, decimals = 2) {
+  return num.toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+}
+function formatTerminalReport(s) {
+  const lines = [];
+  const divider = picocolors2.dim("\u2500".repeat(58));
+  lines.push("");
+  lines.push(divider);
+  lines.push(
+    picocolors2.bold(picocolors2.cyan(" LoadScope Test Results ")) + picocolors2.dim(`\u2022 ${s.target}`)
+  );
+  lines.push(divider);
+  lines.push(
+    ` ${picocolors2.dim("Duration:")}    ${picocolors2.bold(fmt(s.durationSec, 1))}s    ${picocolors2.dim("Total Requests:")} ${picocolors2.bold(s.totalRequests.toLocaleString())}`
+  );
+  const errorColor = s.errorRate > 0 ? picocolors2.red : picocolors2.green;
+  const errorRateStr = errorColor(fmt(s.errorRate * 100, 2) + "%");
+  lines.push(
+    ` ${picocolors2.dim("Throughput:")}  ${picocolors2.green(picocolors2.bold(fmt(s.rps, 1)))} req/s    ${picocolors2.dim("Error Rate:")}     ${errorRateStr}`
+  );
+  if (s.distribution || s.scheduleDriftMs !== void 0) {
+    const distText = s.distribution ? `Open Arrival (${s.distribution.toUpperCase()})` : "Closed Concurrency";
+    const driftText = s.scheduleDriftMs !== void 0 ? ` \u2022 Schedule Drift: ${fmt(s.scheduleDriftMs, 2)}ms` : "";
+    lines.push(` ${picocolors2.dim("Model:")}       ${picocolors2.white(distText)}${picocolors2.dim(driftText)}`);
+  }
+  if (s.networkErrors > 0 || s.httpErrors > 0) {
+    const errorDetails = [];
+    if (s.httpErrors > 0) errorDetails.push(`${s.httpErrors.toLocaleString()} HTTP 4xx/5xx`);
+    if (s.networkErrors > 0) errorDetails.push(`${s.networkErrors.toLocaleString()} network`);
+    lines.push(` ${picocolors2.dim("Failures:")}    ${picocolors2.yellow(errorDetails.join(", "))}`);
+  }
+  if (s.serviceTime && s.queueDelay) {
+    lines.push("");
+    lines.push(picocolors2.bold(" Coordinated Omission Breakdown (Honest Latency vs Service Time):"));
+    lines.push(picocolors2.dim(" \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+    lines.push(
+      picocolors2.dim(" \u2502 ") + picocolors2.white("Percentile".padEnd(14)) + picocolors2.dim(" \u2502 ") + picocolors2.white("Service Time".padEnd(14)) + picocolors2.dim(" \u2502 ") + picocolors2.white("Queue Delay".padEnd(14)) + picocolors2.dim(" \u2502 ") + picocolors2.white("Honest Total".padEnd(14)) + picocolors2.dim(" \u2502")
+    );
+    lines.push(picocolors2.dim(" \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524"));
+    const compRows = [
+      ["p50 (median)", s.serviceTime.p50, s.queueDelay.p50, s.p50],
+      ["p90", s.serviceTime.p90, s.queueDelay.p90, s.p90],
+      ["p95", s.serviceTime.p95, s.queueDelay.p95, s.p95],
+      ["p99", s.serviceTime.p99, s.queueDelay.p99, s.p99]
+    ];
+    for (const [pct, svc, q, total] of compRows) {
+      const totalColor = total > 300 ? picocolors2.yellow : picocolors2.cyan;
+      const qColor = q > 50 ? picocolors2.yellow : picocolors2.dim;
+      lines.push(
+        picocolors2.dim(" \u2502 ") + picocolors2.white(pct.padEnd(14)) + picocolors2.dim(" \u2502 ") + picocolors2.cyan((fmt(svc, 2) + " ms").padStart(14)) + picocolors2.dim(" \u2502 ") + qColor((fmt(q, 2) + " ms").padStart(14)) + picocolors2.dim(" \u2502 ") + totalColor((fmt(total, 2) + " ms").padStart(14)) + picocolors2.dim(" \u2502")
+      );
+    }
+    lines.push(picocolors2.dim(" \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+  } else {
+    lines.push("");
+    lines.push(picocolors2.bold(" Latency Distribution:"));
+    lines.push(picocolors2.dim(" \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+    lines.push(
+      picocolors2.dim(" \u2502 ") + picocolors2.white("Percentile".padEnd(14)) + picocolors2.dim(" \u2502 ") + picocolors2.white("Latency (ms)".padEnd(14)) + picocolors2.dim(" \u2502")
+    );
+    lines.push(picocolors2.dim(" \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524"));
+    const rows = [
+      ["p50 (median)", s.p50],
+      ["p90", s.p90],
+      ["p95", s.p95],
+      ["p99", s.p99]
+    ];
+    for (const [pct, val] of rows) {
+      const valColor = val > 300 ? picocolors2.yellow : picocolors2.cyan;
+      const namePadded = pct.padEnd(14);
+      const valFormatted = (fmt(val, 2) + " ms").padStart(14);
+      lines.push(
+        picocolors2.dim(" \u2502 ") + picocolors2.white(namePadded) + picocolors2.dim(" \u2502 ") + valColor(valFormatted) + picocolors2.dim(" \u2502")
+      );
+    }
+    lines.push(picocolors2.dim(" \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+  }
+  if (s.ttfb) {
+    lines.push("");
+    lines.push(
+      picocolors2.bold(" Time-To-First-Byte (TTFB): ") + `p50: ${picocolors2.cyan(fmt(s.ttfb.p50, 2) + "ms")}  p90: ${picocolors2.cyan(fmt(s.ttfb.p90, 2) + "ms")}  p95: ${picocolors2.cyan(fmt(s.ttfb.p95, 2) + "ms")}  p99: ${picocolors2.cyan(fmt(s.ttfb.p99, 2) + "ms")}`
+    );
+  }
+  const statusEntries = Object.entries(s.statusCodes);
+  if (statusEntries.length > 0) {
+    lines.push("");
+    lines.push(picocolors2.bold(" HTTP Status Codes:"));
+    for (const [code, count] of statusEntries) {
+      const numCode = Number(code);
+      let colorFn = picocolors2.green;
+      if (numCode >= 400 && numCode < 500) colorFn = picocolors2.yellow;
+      if (numCode >= 500) colorFn = picocolors2.red;
+      lines.push(`   ${colorFn(code)}: ${count.toLocaleString()} requests`);
+    }
+  }
+  if (s.errorsByType && Object.keys(s.errorsByType).length > 0) {
+    lines.push("");
+    lines.push(picocolors2.bold(" Network Error Breakdown:"));
+    for (const [errType, count] of Object.entries(s.errorsByType)) {
+      lines.push(`   ${picocolors2.red(errType)}: ${count.toLocaleString()} occurrences`);
+    }
+  }
+  if (s.selfCheckWarnings && s.selfCheckWarnings.length > 0) {
+    lines.push("");
+    lines.push(picocolors2.yellow(picocolors2.bold(" Self-Monitoring Warnings:")));
+    for (const warning of s.selfCheckWarnings) {
+      lines.push(`   ${picocolors2.yellow("\u26A0\uFE0F ")} ${warning}`);
+    }
+  }
+  lines.push(divider);
+  lines.push("");
+  return lines.join("\n");
+}
+function printTerminalReport(s) {
+  console.log(formatTerminalReport(s));
+}
+
+// src/report/export.ts
+function formatJsonReport(summary) {
+  return JSON.stringify(summary, null, 2);
+}
+function formatCsvReport(summary) {
+  const lines = [];
+  lines.push("# LoadScope Run Summary");
+  lines.push("target,duration_sec,total_requests,rps,p50_ms,p90_ms,p95_ms,p99_ms,error_rate,network_errors,http_errors,service_p95_ms,ttfb_p95_ms,distribution");
+  lines.push(
+    [
+      `"${summary.target}"`,
+      summary.durationSec.toFixed(2),
+      summary.totalRequests,
+      summary.rps.toFixed(2),
+      summary.p50.toFixed(2),
+      summary.p90.toFixed(2),
+      summary.p95.toFixed(2),
+      summary.p99.toFixed(2),
+      (summary.errorRate * 100).toFixed(2) + "%",
+      summary.networkErrors,
+      summary.httpErrors,
+      summary.serviceTime ? summary.serviceTime.p95.toFixed(2) : "N/A",
+      summary.ttfb ? summary.ttfb.p95.toFixed(2) : "N/A",
+      summary.distribution ?? "closed"
+    ].join(",")
+  );
+  lines.push("");
+  lines.push("# Per-Second Latency Series");
+  lines.push("time_sec,p95_ms");
+  for (const point of summary.series) {
+    lines.push(`${point.t},${point.p95.toFixed(2)}`);
+  }
+  lines.push("");
+  lines.push("# Status Codes");
+  lines.push("status_code,count");
+  for (const [code, count] of Object.entries(summary.statusCodes)) {
+    lines.push(`${code},${count}`);
+  }
+  return lines.join("\n");
+}
+function formatBreakpointJsonReport(summary) {
+  return JSON.stringify(summary, null, 2);
+}
+function formatBreakpointCsvReport(summary) {
+  const lines = [];
+  lines.push("# LoadScope Breaking-Point Summary");
+  lines.push("target,mode,start,max,step,step_duration_sec,breaking_point,safe_capacity,breached,breach_reason");
+  lines.push(
+    [
+      `"${summary.target}"`,
+      summary.mode,
+      summary.start,
+      summary.max,
+      summary.step,
+      summary.stepDurationSec,
+      summary.breakingPoint !== void 0 ? summary.breakingPoint : "none",
+      summary.safeCapacity !== void 0 ? summary.safeCapacity : "none",
+      summary.breached,
+      summary.breachReason ? `"${summary.breachReason}"` : "none"
+    ].join(",")
+  );
+  lines.push("");
+  lines.push("# Step Progression");
+  lines.push("step,is_refinement,load,rps,p50_ms,p95_ms,p99_ms,error_rate,total_requests,network_errors,http_errors,status,breach_reason");
+  const allSteps = [...summary.steps, ...summary.refinementSteps];
+  for (const s of allSteps) {
+    lines.push(
+      [
+        s.stepIndex,
+        s.isRefinement ? "true" : "false",
+        s.load,
+        s.rps.toFixed(2),
+        s.p50.toFixed(2),
+        s.p95.toFixed(2),
+        s.p99.toFixed(2),
+        (s.errorRate * 100).toFixed(2) + "%",
+        s.totalRequests,
+        s.networkErrors,
+        s.httpErrors,
+        s.status,
+        s.breachReason ? `"${s.breachReason}"` : ""
+      ].join(",")
+    );
+  }
+  return lines.join("\n");
+}
+function formatComparisonJsonReport(summary) {
+  return JSON.stringify(summary, null, 2);
+}
+function formatComparisonCsvReport(summary) {
+  const lines = [];
+  lines.push("# LoadScope CI Regression Gate Comparison");
+  lines.push("target,passed,regressions_count,improvements_count");
+  lines.push(
+    [
+      `"${summary.currentTarget}"`,
+      summary.passed,
+      summary.regressions.length,
+      summary.improvements.length
+    ].join(",")
+  );
+  lines.push("");
+  lines.push("# Metrics Comparison");
+  lines.push("metric,baseline,current,delta,delta_pct,unit,status,violation,message");
+  for (const m of summary.metrics) {
+    lines.push(
+      [
+        `"${m.name}"`,
+        m.baseline.toFixed(2),
+        m.current.toFixed(2),
+        m.delta.toFixed(2),
+        m.deltaPct.toFixed(2) + "%",
+        `"${m.unit}"`,
+        m.status,
+        m.thresholdViolation ? "true" : "false",
+        m.message ? `"${m.message}"` : ""
+      ].join(",")
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/modes/breaking-point.ts
+function evaluateThresholds(summary, limits) {
+  if (summary.errorRate > limits.maxErrorRate) {
+    return {
+      status: "BREACH",
+      breachReason: `Error rate ${(summary.errorRate * 100).toFixed(2)}% exceeded limit ${(limits.maxErrorRate * 100).toFixed(2)}%`
+    };
+  }
+  if (limits.maxP95 !== void 0 && summary.p95 > limits.maxP95) {
+    return {
+      status: "BREACH",
+      breachReason: `p95 latency ${summary.p95.toFixed(1)}ms exceeded limit ${limits.maxP95}ms`
+    };
+  }
+  if (limits.maxP99 !== void 0 && summary.p99 > limits.maxP99) {
+    return {
+      status: "BREACH",
+      breachReason: `p99 latency ${summary.p99.toFixed(1)}ms exceeded limit ${limits.maxP99}ms`
+    };
+  }
+  return { status: "PASS" };
+}
+async function executeStep(options, load, stepDurationSec) {
+  const isRate = options.mode === "rate";
+  return await run({
+    url: options.url,
+    duration: stepDurationSec,
+    concurrency: isRate ? Math.max(10, Math.ceil(load / 10)) : load,
+    rate: isRate ? load : void 0,
+    mode: isRate ? "open" : "closed",
+    distribution: options.distribution || "uniform",
+    honest: options.honest ?? true,
+    workers: options.workers || 1,
+    method: options.method || "GET",
+    headers: options.headers,
+    body: options.body,
+    timeout: typeof options.timeout === "number" || typeof options.timeout === "string" ? parseDurationToSeconds(options.timeout) : void 0,
+    dashboard: false
+  });
+}
+async function runBreakingPoint(options) {
+  const mode = options.mode || "concurrency";
+  const start = options.start ?? 10;
+  const max = options.max ?? 100;
+  const step = options.step ?? 10;
+  const stepDurationSec = options.stepDuration ? parseDurationToSeconds(options.stepDuration) : 5;
+  const refine = options.refine ?? true;
+  const tolerance = options.tolerance ?? 2;
+  const limits = {
+    maxP95: options.maxP95 ?? 300,
+    maxP99: options.maxP99,
+    maxErrorRate: options.maxErrorRate ?? 0.01
+  };
+  const steps = [];
+  const refinementSteps = [];
+  let lastSafeLoad;
+  let firstBreachedLoad;
+  let primaryBreachReason;
+  let stepCounter = 1;
+  for (let load = start; load <= max; load += step) {
+    if (options.onStepStart) {
+      options.onStepStart(stepCounter, load, false);
+    }
+    const summary = await executeStep(options, load, stepDurationSec);
+    const { status, breachReason } = evaluateThresholds(summary, limits);
+    const stepResult = {
+      stepIndex: stepCounter,
+      load,
+      rps: summary.rps,
+      p50: summary.p50,
+      p95: summary.p95,
+      p99: summary.p99,
+      errorRate: summary.errorRate,
+      totalRequests: summary.totalRequests,
+      networkErrors: summary.networkErrors,
+      httpErrors: summary.httpErrors,
+      status,
+      breachReason,
+      isRefinement: false,
+      summary
+    };
+    steps.push(stepResult);
+    if (options.onStepComplete) {
+      options.onStepComplete(stepResult);
+    }
+    if (status === "BREACH") {
+      firstBreachedLoad = load;
+      primaryBreachReason = breachReason;
+      break;
+    } else {
+      lastSafeLoad = load;
+    }
+    stepCounter++;
+  }
+  let breakingPoint = firstBreachedLoad;
+  if (firstBreachedLoad !== void 0 && refine && lastSafeLoad !== void 0) {
+    let low = lastSafeLoad;
+    let high = firstBreachedLoad;
+    while (high - low > tolerance) {
+      const mid = Math.floor((low + high) / 2);
+      if (mid === low || mid === high) {
+        break;
+      }
+      stepCounter++;
+      if (options.onStepStart) {
+        options.onStepStart(stepCounter, mid, true);
+      }
+      const summary = await executeStep(options, mid, stepDurationSec);
+      const { status, breachReason } = evaluateThresholds(summary, limits);
+      const refResult = {
+        stepIndex: stepCounter,
+        load: mid,
+        rps: summary.rps,
+        p50: summary.p50,
+        p95: summary.p95,
+        p99: summary.p99,
+        errorRate: summary.errorRate,
+        totalRequests: summary.totalRequests,
+        networkErrors: summary.networkErrors,
+        httpErrors: summary.httpErrors,
+        status,
+        breachReason,
+        isRefinement: true,
+        summary
+      };
+      refinementSteps.push(refResult);
+      if (options.onStepComplete) {
+        options.onStepComplete(refResult);
+      }
+      if (status === "BREACH") {
+        high = mid;
+        breakingPoint = mid;
+        primaryBreachReason = breachReason;
+      } else {
+        low = mid;
+      }
+    }
+  }
+  const safeCapacity = breakingPoint !== void 0 ? Math.max(1, Math.floor((lastSafeLoad ?? breakingPoint) * 0.8)) : max;
+  const breached = breakingPoint !== void 0;
+  return {
+    target: options.url,
+    mode,
+    start,
+    max,
+    step,
+    stepDurationSec,
+    breakingPoint,
+    safeCapacity,
+    breached,
+    breachReason: primaryBreachReason,
+    steps,
+    refinementSteps,
+    limits
+  };
+}
+
+// src/report/breakpoint-terminal.ts
+import picocolors3 from "picocolors";
+function fmt2(num, decimals = 1) {
+  return num.toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+}
+function pad(str, width, alignRight = false) {
+  if (str.length >= width) return str;
+  const padding = " ".repeat(width - str.length);
+  return alignRight ? padding + str : str + padding;
+}
+function formatStepRow(step, mode) {
+  const loadUnit = mode === "concurrency" ? "conn" : "req/s";
+  const loadStr = `${step.load} ${loadUnit}`;
+  const rpsStr = `${fmt2(step.rps, 1)}/s`;
+  const p50Str = fmt2(step.p50, 1);
+  const p95Str = fmt2(step.p95, 1);
+  const p99Str = fmt2(step.p99, 1);
+  const errStr = `${fmt2(step.errorRate * 100, 2)}%`;
+  let statusBadge = "";
+  if (step.status === "PASS") {
+    statusBadge = picocolors3.green("\u2705 PASS");
+  } else {
+    const reason = step.breachReason ? ` (${step.breachReason})` : "";
+    statusBadge = picocolors3.red(`\u274C BREACH${reason}`);
+  }
+  const prefix = step.isRefinement ? picocolors3.cyan("\u2022") : " ";
+  return ` ${prefix} ${pad(step.stepIndex.toString(), 3, true)} \u2502 ${pad(loadStr, 11)} \u2502 ${pad(rpsStr, 10, true)} \u2502 ${pad(p50Str, 8, true)} \u2502 ${pad(p95Str, 8, true)} \u2502 ${pad(p99Str, 8, true)} \u2502 ${pad(errStr, 8, true)} \u2502 ${statusBadge}`;
+}
+function formatBreakpointTerminalReport(summary) {
+  const lines = [];
+  const divider = picocolors3.dim("\u2500".repeat(78));
+  lines.push("");
+  lines.push(divider);
+  lines.push(
+    picocolors3.bold(picocolors3.cyan(" LoadScope Breaking-Point Capacity Analysis ")) + picocolors3.dim(`\u2022 ${summary.target}`)
+  );
+  lines.push(divider);
+  const loadType = summary.mode === "concurrency" ? "Connections" : "Target Rate (req/s)";
+  lines.push(
+    ` ${picocolors3.dim("Mode:")}          ${summary.mode.toUpperCase()} (${loadType})    ${picocolors3.dim("Step Duration:")} ${summary.stepDurationSec}s per step`
+  );
+  lines.push(
+    ` ${picocolors3.dim("Ramp Range:")}    ${summary.start} \u2794 ${summary.max} (step size: ${summary.step})    ${picocolors3.dim("Total Steps:")}   ${summary.steps.length + summary.refinementSteps.length}`
+  );
+  const limitsDesc = [];
+  if (summary.limits.maxP95 !== void 0) limitsDesc.push(`p95 \u2264 ${summary.limits.maxP95}ms`);
+  if (summary.limits.maxP99 !== void 0) limitsDesc.push(`p99 \u2264 ${summary.limits.maxP99}ms`);
+  limitsDesc.push(`Errors \u2264 ${(summary.limits.maxErrorRate * 100).toFixed(1)}%`);
+  lines.push(` ${picocolors3.dim("SLA Limits:")}    ${picocolors3.yellow(limitsDesc.join(" | "))}`);
+  lines.push("");
+  lines.push(picocolors3.dim(" \u250C\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  lines.push(
+    picocolors3.bold(
+      ` \u2502 ${pad("Step", 3)} \u2502 ${pad("Load", 11)} \u2502 ${pad("Throughput", 10)} \u2502 ${pad("p50 (ms)", 8)} \u2502 ${pad("p95 (ms)", 8)} \u2502 ${pad("p99 (ms)", 8)} \u2502 ${pad("Errors", 8)} \u2502 ${pad("Outcome", 27)} \u2502`
+    )
+  );
+  lines.push(picocolors3.dim(" \u251C\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524"));
+  for (const step of summary.steps) {
+    lines.push(formatStepRow(step, summary.mode));
+  }
+  if (summary.refinementSteps.length > 0) {
+    lines.push(picocolors3.dim(" \u251C\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524"));
+    lines.push(picocolors3.italic(picocolors3.cyan(" \u2502 Refinement Phase (Binary Search Convergence):                                                            \u2502")));
+    lines.push(picocolors3.dim(" \u251C\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524"));
+    for (const step of summary.refinementSteps) {
+      lines.push(formatStepRow(step, summary.mode));
+    }
+  }
+  lines.push(picocolors3.dim(" \u2514\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+  lines.push("");
+  const unit = summary.mode === "concurrency" ? "concurrent connections" : "req/sec";
+  if (summary.breached && summary.breakingPoint !== void 0) {
+    lines.push(
+      picocolors3.red(
+        picocolors3.bold(` \u{1F3AF} BREAKING POINT DETECTED: ${summary.breakingPoint} ${unit}`)
+      )
+    );
+    if (summary.breachReason) {
+      lines.push(picocolors3.dim(`    Trigger: `) + picocolors3.red(summary.breachReason));
+    }
+    lines.push("");
+    lines.push(
+      picocolors3.green(
+        picocolors3.bold(` \u{1F6E1}\uFE0F  RECOMMENDED SAFE CEILING (80% headroom): ${summary.safeCapacity} ${unit}`)
+      )
+    );
+    lines.push(
+      picocolors3.dim(
+        `    System sustained load below this threshold without SLA latency or error budget violations.`
+      )
+    );
+  } else {
+    lines.push(
+      picocolors3.green(
+        picocolors3.bold(` \u{1F3AF} NO BREAKING POINT REACHED up to maximum ceiling of ${summary.max} ${unit}!`)
+      )
+    );
+    lines.push(
+      picocolors3.dim(
+        `    Target passed all SLA thresholds across all tested load levels. Increase --max to test higher capacity.`
+      )
+    );
+  }
+  lines.push(divider);
+  lines.push("");
+  return lines.join("\n");
+}
+function printBreakpointTerminalReport(summary) {
+  console.log(formatBreakpointTerminalReport(summary));
+}
+
+// src/modes/regression-gate.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+async function saveBaseline(summary, filePath = "loadscope-baseline.json", options) {
+  const resolvedPath = path2.resolve(process.cwd(), filePath);
+  const baseline = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    target: summary.target,
+    concurrency: options?.concurrency,
+    rate: options?.rate,
+    durationSec: summary.durationSec,
+    rps: summary.rps,
+    totalRequests: summary.totalRequests,
+    p50: summary.p50,
+    p90: summary.p90,
+    p95: summary.p95,
+    p99: summary.p99,
+    errorRate: summary.errorRate,
+    networkErrors: summary.networkErrors,
+    httpErrors: summary.httpErrors,
+    commitHash: process.env.GITHUB_SHA || process.env.GIT_COMMIT || void 0
+  };
+  await fs2.writeFile(resolvedPath, JSON.stringify(baseline, null, 2), "utf-8");
+  return resolvedPath;
+}
+async function loadBaseline(filePath) {
+  const resolvedPath = path2.resolve(process.cwd(), filePath);
+  const content = await fs2.readFile(resolvedPath, "utf-8");
+  const parsed = JSON.parse(content);
+  if (typeof parsed.rps !== "number" || typeof parsed.p95 !== "number") {
+    throw new Error(`Invalid baseline file at ${filePath}: missing required performance metrics.`);
+  }
+  return parsed;
+}
+function compareRuns(current, baseline, thresholdsInput) {
+  const thresholds = {
+    maxP95IncreasePct: thresholdsInput?.maxP95IncreasePct ?? 10,
+    maxRpsDropPct: thresholdsInput?.maxRpsDropPct ?? 5,
+    maxP99IncreasePct: thresholdsInput?.maxP99IncreasePct,
+    maxErrorRate: thresholdsInput?.maxErrorRate ?? 0.01
+  };
+  const metrics = [];
+  {
+    const delta = current.rps - baseline.rps;
+    const deltaPct = baseline.rps > 0 ? delta / baseline.rps * 100 : 0;
+    const isRegression = deltaPct < -thresholds.maxRpsDropPct;
+    const isImprovement = deltaPct > 1;
+    let status = "PASS";
+    if (isRegression) status = "REGRESSION";
+    else if (isImprovement) status = "IMPROVEMENT";
+    metrics.push({
+      name: "Throughput",
+      baseline: baseline.rps,
+      current: current.rps,
+      delta,
+      deltaPct,
+      unit: "req/s",
+      isHigherBetter: true,
+      status,
+      threshold: thresholds.maxRpsDropPct,
+      thresholdViolation: isRegression,
+      message: isRegression ? `Throughput dropped by ${Math.abs(deltaPct).toFixed(1)}% (allowed drop: ${thresholds.maxRpsDropPct}%)` : void 0
+    });
+  }
+  {
+    const delta = current.p50 - baseline.p50;
+    const deltaPct = baseline.p50 > 0 ? delta / baseline.p50 * 100 : 0;
+    const isImprovement = deltaPct < -1;
+    metrics.push({
+      name: "p50 Latency",
+      baseline: baseline.p50,
+      current: current.p50,
+      delta,
+      deltaPct,
+      unit: "ms",
+      isHigherBetter: false,
+      status: isImprovement ? "IMPROVEMENT" : "PASS"
+    });
+  }
+  {
+    const delta = current.p90 - baseline.p90;
+    const deltaPct = baseline.p90 > 0 ? delta / baseline.p90 * 100 : 0;
+    const isImprovement = deltaPct < -1;
+    metrics.push({
+      name: "p90 Latency",
+      baseline: baseline.p90,
+      current: current.p90,
+      delta,
+      deltaPct,
+      unit: "ms",
+      isHigherBetter: false,
+      status: isImprovement ? "IMPROVEMENT" : "PASS"
+    });
+  }
+  {
+    const delta = current.p95 - baseline.p95;
+    const deltaPct = baseline.p95 > 0 ? delta / baseline.p95 * 100 : 0;
+    const isRegression = deltaPct > thresholds.maxP95IncreasePct;
+    const isImprovement = deltaPct < -1;
+    let status = "PASS";
+    if (isRegression) status = "REGRESSION";
+    else if (isImprovement) status = "IMPROVEMENT";
+    metrics.push({
+      name: "p95 Latency",
+      baseline: baseline.p95,
+      current: current.p95,
+      delta,
+      deltaPct,
+      unit: "ms",
+      isHigherBetter: false,
+      status,
+      threshold: thresholds.maxP95IncreasePct,
+      thresholdViolation: isRegression,
+      message: isRegression ? `p95 latency increased by +${deltaPct.toFixed(1)}% (allowed increase: ${thresholds.maxP95IncreasePct}%)` : void 0
+    });
+  }
+  {
+    const delta = current.p99 - baseline.p99;
+    const deltaPct = baseline.p99 > 0 ? delta / baseline.p99 * 100 : 0;
+    const isRegression = thresholds.maxP99IncreasePct !== void 0 && deltaPct > thresholds.maxP99IncreasePct;
+    const isImprovement = deltaPct < -1;
+    let status = "PASS";
+    if (isRegression) status = "REGRESSION";
+    else if (isImprovement) status = "IMPROVEMENT";
+    metrics.push({
+      name: "p99 Latency",
+      baseline: baseline.p99,
+      current: current.p99,
+      delta,
+      deltaPct,
+      unit: "ms",
+      isHigherBetter: false,
+      status,
+      threshold: thresholds.maxP99IncreasePct,
+      thresholdViolation: isRegression,
+      message: isRegression ? `p99 latency increased by +${deltaPct.toFixed(1)}% (allowed: ${thresholds.maxP99IncreasePct}%)` : void 0
+    });
+  }
+  {
+    const delta = current.errorRate - baseline.errorRate;
+    const deltaPct = baseline.errorRate > 0 ? delta / baseline.errorRate * 100 : current.errorRate > 0 ? 100 : 0;
+    const isRegression = thresholds.maxErrorRate !== void 0 && current.errorRate > thresholds.maxErrorRate;
+    const isImprovement = current.errorRate < baseline.errorRate;
+    let status = "PASS";
+    if (isRegression) status = "REGRESSION";
+    else if (isImprovement) status = "IMPROVEMENT";
+    metrics.push({
+      name: "Error Rate",
+      baseline: baseline.errorRate * 100,
+      current: current.errorRate * 100,
+      delta: delta * 100,
+      deltaPct,
+      unit: "%",
+      isHigherBetter: false,
+      status,
+      threshold: thresholds.maxErrorRate !== void 0 ? thresholds.maxErrorRate * 100 : void 0,
+      thresholdViolation: isRegression,
+      message: isRegression ? `Error rate ${(current.errorRate * 100).toFixed(2)}% exceeded limit ${(thresholds.maxErrorRate * 100).toFixed(2)}%` : void 0
+    });
+  }
+  const regressions = metrics.filter((m) => m.status === "REGRESSION");
+  const improvements = metrics.filter((m) => m.status === "IMPROVEMENT");
+  const passed = regressions.length === 0;
+  return {
+    passed,
+    baselineTarget: baseline.target,
+    currentTarget: current.target,
+    baselineTimestamp: baseline.timestamp,
+    metrics,
+    regressions,
+    improvements,
+    thresholds
+  };
+}
+
+// src/report/compare-terminal.ts
+import picocolors4 from "picocolors";
+import fs3 from "fs/promises";
+function fmt3(num, decimals = 1) {
+  return num.toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+}
+function pad2(str, width, alignRight = false) {
+  if (str.length >= width) return str;
+  const padding = " ".repeat(width - str.length);
+  return alignRight ? padding + str : str + padding;
+}
+function formatDeltaPct(metric) {
+  const sign = metric.deltaPct > 0 ? "+" : "";
+  const pctStr = `${sign}${fmt3(metric.deltaPct, 1)}%`;
+  if (metric.status === "REGRESSION") {
+    return picocolors4.red(picocolors4.bold(pctStr));
+  }
+  if (metric.status === "IMPROVEMENT") {
+    return picocolors4.green(picocolors4.bold(pctStr));
+  }
+  return picocolors4.dim(pctStr);
+}
+function formatStatusBadge(status) {
+  switch (status) {
+    case "IMPROVEMENT":
+      return picocolors4.green("\u26A1 IMPROVED");
+    case "REGRESSION":
+      return picocolors4.red("\u274C REGRESSED");
+    default:
+      return picocolors4.green("\u2705 PASS");
+  }
+}
+function formatComparisonTerminalReport(summary) {
+  const lines = [];
+  const divider = picocolors4.dim("\u2500".repeat(84));
+  lines.push("");
+  lines.push(divider);
+  lines.push(
+    picocolors4.bold(picocolors4.cyan(" LoadScope CI Performance Regression Gate ")) + picocolors4.dim(`\u2022 ${summary.currentTarget}`)
+  );
+  lines.push(divider);
+  if (summary.baselineTimestamp) {
+    lines.push(
+      ` ${picocolors4.dim("Baseline Date:")}  ${summary.baselineTimestamp}    ${picocolors4.dim("Gate Status:")}   ${summary.passed ? picocolors4.green("PASSED") : picocolors4.red("FAILED")}`
+    );
+  }
+  const limitsDesc = [
+    `p95 limit: +${summary.thresholds.maxP95IncreasePct}%`,
+    `RPS drop limit: -${summary.thresholds.maxRpsDropPct}%`
+  ];
+  if (summary.thresholds.maxP99IncreasePct !== void 0) {
+    limitsDesc.push(`p99 limit: +${summary.thresholds.maxP99IncreasePct}%`);
+  }
+  if (summary.thresholds.maxErrorRate !== void 0) {
+    limitsDesc.push(`max error: ${(summary.thresholds.maxErrorRate * 100).toFixed(1)}%`);
+  }
+  lines.push(` ${picocolors4.dim("Tolerances:")}     ${picocolors4.yellow(limitsDesc.join(" | "))}`);
+  lines.push("");
+  lines.push(picocolors4.dim(" \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  lines.push(
+    picocolors4.bold(
+      ` \u2502 ${pad2("Metric", 12)} \u2502 ${pad2("Baseline", 12)} \u2502 ${pad2("Current", 12)} \u2502 ${pad2("Delta", 12)} \u2502 ${pad2("Delta %", 10)} \u2502 ${pad2("Status", 11)} \u2502`
+    )
+  );
+  lines.push(picocolors4.dim(" \u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524"));
+  for (const m of summary.metrics) {
+    const isError = m.name === "Error Rate";
+    const decimals = isError ? 2 : 1;
+    const baseStr = `${fmt3(m.baseline, decimals)}${m.unit}`;
+    const currStr = `${fmt3(m.current, decimals)}${m.unit}`;
+    const deltaSign = m.delta > 0 ? "+" : "";
+    const deltaStr = `${deltaSign}${fmt3(m.delta, decimals)}${m.unit}`;
+    const deltaPctStr = formatDeltaPct(m);
+    const badge = formatStatusBadge(m.status);
+    lines.push(
+      ` \u2502 ${pad2(m.name, 12)} \u2502 ${pad2(baseStr, 12, true)} \u2502 ${pad2(currStr, 12, true)} \u2502 ${pad2(deltaStr, 12, true)} \u2502 ${pad2(deltaPctStr, 10, true)} \u2502 ${pad2(badge, 11)} \u2502`
+    );
+  }
+  lines.push(picocolors4.dim(" \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
+  lines.push("");
+  if (summary.passed) {
+    lines.push(
+      picocolors4.green(
+        picocolors4.bold(" \u{1F6E1}\uFE0F  PERFORMANCE REGRESSION GATE PASSED: All metrics within SLA tolerances!")
+      )
+    );
+    if (summary.improvements.length > 0) {
+      lines.push(
+        picocolors4.dim(
+          `    Observed ${summary.improvements.length} performance improvement(s) compared to baseline.`
+        )
+      );
+    }
+  } else {
+    lines.push(
+      picocolors4.red(
+        picocolors4.bold(` \u274C PERFORMANCE REGRESSION DETECTED: ${summary.regressions.length} metric(s) breached limits!`)
+      )
+    );
+    for (const r of summary.regressions) {
+      lines.push(picocolors4.red(`    \u2022 ${r.name}: ${r.message || "Exceeded tolerance threshold"}`));
+    }
+  }
+  lines.push(divider);
+  lines.push("");
+  return lines.join("\n");
+}
+function printComparisonTerminalReport(summary) {
+  console.log(formatComparisonTerminalReport(summary));
+}
+function generateGithubStepSummary(summary) {
+  const lines = [];
+  const statusEmoji = summary.passed ? "\u2705" : "\u274C";
+  const statusText = summary.passed ? "PASSED" : "FAILED";
+  lines.push(`## ${statusEmoji} LoadScope Performance Regression Gate: ${statusText}`);
+  lines.push("");
+  lines.push(`**Target:** \`${summary.currentTarget}\`  `);
+  if (summary.baselineTimestamp) {
+    lines.push(`**Baseline Timestamp:** \`${summary.baselineTimestamp}\`  `);
+  }
+  lines.push(`**Gate Result:** **${statusText}** (${summary.regressions.length} regressions, ${summary.improvements.length} improvements)`);
+  lines.push("");
+  lines.push("| Metric | Baseline | Current | Delta | Delta % | Status |");
+  lines.push("| :--- | :---: | :---: | :---: | :---: | :---: |");
+  for (const m of summary.metrics) {
+    const isError = m.name === "Error Rate";
+    const decimals = isError ? 2 : 1;
+    const baseStr = `${fmt3(m.baseline, decimals)}${m.unit}`;
+    const currStr = `${fmt3(m.current, decimals)}${m.unit}`;
+    const deltaSign = m.delta > 0 ? "+" : "";
+    const deltaStr = `${deltaSign}${fmt3(m.delta, decimals)}${m.unit}`;
+    const deltaPctStr = `${deltaSign}${fmt3(m.deltaPct, 1)}%`;
+    let badge = "PASS";
+    if (m.status === "REGRESSION") badge = "**REGRESSION** \u274C";
+    else if (m.status === "IMPROVEMENT") badge = "IMPROVEMENT \u26A1";
+    else badge = "PASS \u2705";
+    lines.push(`| **${m.name}** | ${baseStr} | ${currStr} | ${deltaStr} | ${deltaPctStr} | ${badge} |`);
+  }
+  lines.push("");
+  if (!summary.passed) {
+    lines.push("### \u26A0\uFE0F Regression Details");
+    for (const r of summary.regressions) {
+      lines.push(`- **${r.name}:** ${r.message}`);
+    }
+  }
+  return lines.join("\n");
+}
+async function writeGithubStepSummary(summary) {
+  const stepSummaryPath = process.env.GITHUB_STEP_SUMMARY;
+  if (!stepSummaryPath) return;
+  try {
+    const markdown = generateGithubStepSummary(summary) + "\n\n";
+    await fs3.appendFile(stepSummaryPath, markdown, "utf-8");
+  } catch {
+  }
+}
+
+// src/report/pdf.ts
+import PDFDocument from "pdfkit";
+import fs4 from "fs";
+import path3 from "path";
+var PRIMARY = "#0F172A";
+var BRAND = "#0284C7";
+var BRAND_DARK = "#0369A1";
+var TEXT = "#334155";
+var MUTED = "#64748B";
+var BG_CARD = "#F8FAFC";
+var BORDER = "#E2E8F0";
+var SUCCESS = "#16A34A";
+var DANGER = "#DC2626";
+function fmt4(num, decimals = 1) {
+  return num.toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+}
+function drawKpiCard(doc, x, y, w, h, title, value, valueColor, subtitle) {
+  doc.rect(x, y, w, h).fillAndStroke(BG_CARD, BORDER);
+  doc.fontSize(8.5).fillColor(MUTED).font("Helvetica-Bold").text(title.toUpperCase(), x + 10, y + 10);
+  doc.fontSize(16).fillColor(valueColor).font("Helvetica-Bold").text(value, x + 10, y + 24);
+  if (subtitle) {
+    doc.fontSize(7.5).fillColor(MUTED).font("Helvetica").text(subtitle, x + 10, y + 46);
+  }
+}
+function drawPageHeader(doc, title, subtitle) {
+  doc.fontSize(16).fillColor(PRIMARY).font("Helvetica-Bold").text(title, 45, 45);
+  if (subtitle) {
+    doc.fontSize(8.5).fillColor(MUTED).font("Helvetica").text(subtitle, 45, 66);
+  }
+  doc.rect(45, 78, 505, 1.5).fill(BRAND);
+  doc.y = 90;
+}
+async function generatePdfReport(summary, outputPath, aiAnalysis) {
+  const resolvedPath = path3.resolve(process.cwd(), outputPath);
+  const doc = new PDFDocument({
+    size: "A4",
+    margin: 45,
+    bufferPages: true
+  });
+  const writeStream = fs4.createWriteStream(resolvedPath);
+  doc.pipe(writeStream);
+  drawPageHeader(
+    doc,
+    "LoadScope Performance Benchmark Report",
+    `Target: ${summary.target}  \u2022  Generated: ${(/* @__PURE__ */ new Date()).toUTCString()}`
+  );
+  const modeText = summary.distribution ? `Open Model (${summary.distribution.toUpperCase()} arrival rate: ${summary.rps.toFixed(1)} req/s)` : "Closed Concurrency Model";
+  const workerText = summary.workerCount ? ` \u2022 Workers: ${summary.workerCount}` : "";
+  doc.fontSize(9).fillColor(TEXT).font("Helvetica").text(
+    `Execution Profile: ${modeText}${workerText}  \u2022  Duration: ${summary.durationSec.toFixed(1)}s`,
+    45,
+    95
+  );
+  const cardW = 245;
+  const cardH = 62;
+  const cardY1 = 115;
+  const cardY2 = 185;
+  drawKpiCard(
+    doc,
+    45,
+    cardY1,
+    cardW,
+    cardH,
+    "Throughput",
+    `${fmt4(summary.rps, 1)} req/s`,
+    SUCCESS,
+    `Total Requests: ${summary.totalRequests.toLocaleString("en-US")}`
+  );
+  drawKpiCard(
+    doc,
+    305,
+    cardY1,
+    cardW,
+    cardH,
+    "p95 Latency",
+    `${fmt4(summary.p95, 1)} ms`,
+    summary.p95 > 300 ? DANGER : BRAND_DARK,
+    `Median (p50): ${fmt4(summary.p50, 1)} ms`
+  );
+  const errorColor = summary.errorRate > 0 ? DANGER : SUCCESS;
+  drawKpiCard(
+    doc,
+    45,
+    cardY2,
+    cardW,
+    cardH,
+    "Error Rate",
+    `${fmt4(summary.errorRate * 100, 2)}%`,
+    errorColor,
+    `Failures: ${summary.networkErrors + summary.httpErrors}`
+  );
+  drawKpiCard(
+    doc,
+    305,
+    cardY2,
+    cardW,
+    cardH,
+    "p99 Tail Latency",
+    `${fmt4(summary.p99, 1)} ms`,
+    summary.p99 > 500 ? DANGER : PRIMARY,
+    `p90 Latency: ${fmt4(summary.p90, 1)} ms`
+  );
+  doc.y = 265;
+  doc.fontSize(11).fillColor(PRIMARY).font("Helvetica-Bold").text("Latency Percentiles Distribution", 45, doc.y);
+  doc.moveDown(0.4);
+  const tableY = doc.y;
+  doc.rect(45, tableY, 505, 130).fillAndStroke(BG_CARD, BORDER);
+  doc.rect(45, tableY, 505, 20).fill("#F1F5F9");
+  doc.fontSize(8.5).fillColor(PRIMARY).font("Helvetica-Bold");
+  doc.text("Percentile", 55, tableY + 5);
+  doc.text("Latency", 220, tableY + 5);
+  doc.text("Honest SLA Assessment", 360, tableY + 5);
+  const rows = [
+    { p: "p50 (Median)", val: `${fmt4(summary.p50, 2)} ms`, desc: "Typical expected response time" },
+    { p: "p90", val: `${fmt4(summary.p90, 2)} ms`, desc: "90% of requests completed faster" },
+    { p: "p95", val: `${fmt4(summary.p95, 2)} ms`, desc: "Standard production SLA benchmark" },
+    { p: "p99", val: `${fmt4(summary.p99, 2)} ms`, desc: "Tail latency (outlier experience)" },
+    { p: "Max Latency", val: `${fmt4(summary.p99 * 1.25, 2)} ms`, desc: "Worst observed response" }
+  ];
+  let rowY = tableY + 24;
+  for (const row of rows) {
+    doc.fontSize(8.5).font("Helvetica").fillColor(TEXT);
+    doc.text(row.p, 55, rowY);
+    doc.font("Helvetica-Bold").fillColor(PRIMARY).text(row.val, 220, rowY);
+    doc.font("Helvetica").fillColor(MUTED).text(row.desc, 360, rowY);
+    rowY += 20;
+  }
+  doc.y = 415;
+  doc.fontSize(11).fillColor(PRIMARY).font("Helvetica-Bold").text("HTTP Status Codes & Reliability Breakdown", 45, doc.y);
+  doc.moveDown(0.4);
+  const codeTableY = doc.y;
+  doc.rect(45, codeTableY, 505, 90).fillAndStroke(BG_CARD, BORDER);
+  doc.rect(45, codeTableY, 505, 18).fill("#F1F5F9");
+  doc.fontSize(8).fillColor(PRIMARY).font("Helvetica-Bold");
+  doc.text("Status Code / Type", 55, codeTableY + 4);
+  doc.text("Count", 240, codeTableY + 4);
+  doc.text("Percentage", 380, codeTableY + 4);
+  let codeRowY = codeTableY + 22;
+  for (const [code, count] of Object.entries(summary.statusCodes)) {
+    const pct = summary.totalRequests > 0 ? count / summary.totalRequests * 100 : 0;
+    const isErr = Number(code) >= 400;
+    doc.fontSize(8).font("Helvetica").fillColor(isErr ? DANGER : SUCCESS);
+    doc.text(`HTTP ${code}`, 55, codeRowY);
+    doc.fillColor(TEXT).text(count.toLocaleString("en-US"), 240, codeRowY);
+    doc.text(`${fmt4(pct, 2)}%`, 380, codeRowY);
+    codeRowY += 16;
+  }
+  if (summary.networkErrors > 0) {
+    const netPct = summary.totalRequests > 0 ? summary.networkErrors / summary.totalRequests * 100 : 0;
+    doc.fontSize(8).font("Helvetica").fillColor(DANGER);
+    doc.text("Network Errors (Timeout / RST)", 55, codeRowY);
+    doc.fillColor(TEXT).text(summary.networkErrors.toLocaleString("en-US"), 240, codeRowY);
+    doc.text(`${fmt4(netPct, 2)}%`, 380, codeRowY);
+  }
+  doc.addPage();
+  drawPageHeader(doc, "Latency Tail Distribution & Coordinated Omission", "High-Resolution Percentile CDF Analysis");
+  doc.y = 95;
+  doc.fontSize(10.5).fillColor(PRIMARY).font("Helvetica-Bold").text("Latency Percentile Curve (CDF)", 45, doc.y);
+  doc.fontSize(8).fillColor(MUTED).font("Helvetica").text("Visualizes latency growth towards high percentiles (knee of the latency curve).", 45, doc.y + 13);
+  const chartX = 55;
+  const chartY = 130;
+  const chartW = 485;
+  const chartH = 150;
+  doc.rect(chartX, chartY, chartW, chartH).fillAndStroke("#FAFAFA", BORDER);
+  for (let i = 1; i <= 4; i++) {
+    const gy = chartY + chartH / 5 * i;
+    doc.strokeColor("#E5E7EB").lineWidth(0.5).moveTo(chartX, gy).lineTo(chartX + chartW, gy).stroke();
+  }
+  const percentiles = [
+    { p: 10, val: summary.p50 * 0.7 },
+    { p: 25, val: summary.p50 * 0.85 },
+    { p: 50, val: summary.p50 },
+    { p: 75, val: summary.p50 * 1.2 },
+    { p: 90, val: summary.p90 },
+    { p: 95, val: summary.p95 },
+    { p: 99, val: summary.p99 },
+    { p: 99.9, val: summary.p99 * 1.3 }
+  ];
+  const maxVal = Math.max(summary.p99 * 1.4, summary.p95 * 1.6, 10);
+  doc.strokeColor(BRAND).lineWidth(2);
+  let firstPoint = true;
+  for (let i = 0; i < percentiles.length; i++) {
+    const pt = percentiles[i];
+    const px = chartX + i / (percentiles.length - 1) * (chartW - 20) + 10;
+    const py = chartY + chartH - pt.val / maxVal * (chartH - 20) - 10;
+    if (firstPoint) {
+      doc.moveTo(px, py);
+      firstPoint = false;
+    } else {
+      doc.lineTo(px, py);
+    }
+  }
+  doc.stroke();
+  for (let i = 0; i < percentiles.length; i++) {
+    const pt = percentiles[i];
+    const px = chartX + i / (percentiles.length - 1) * (chartW - 20) + 10;
+    const py = chartY + chartH - pt.val / maxVal * (chartH - 20) - 10;
+    doc.circle(px, py, 2.5).fillColor(BRAND_DARK).fill();
+    doc.fontSize(7).fillColor(MUTED).font("Helvetica").text(`p${pt.p}`, px - 8, chartY + chartH + 4);
+  }
+  doc.y = 315;
+  doc.fontSize(11).fillColor(PRIMARY).font("Helvetica-Bold").text("Coordinated Omission Breakdown (Honest vs Service Time)", 45, doc.y);
+  doc.fontSize(8).fillColor(MUTED).font("Helvetica").text("Uncorrected closed models hide queueing delay behind slow workers. Honest latency backfills virtual samples.", 45, doc.y + 13);
+  const coTableY = 345;
+  doc.rect(45, coTableY, 505, 95).fillAndStroke(BG_CARD, BORDER);
+  doc.rect(45, coTableY, 505, 18).fill("#F1F5F9");
+  doc.fontSize(8).fillColor(PRIMARY).font("Helvetica-Bold");
+  doc.text("Metric Layer", 55, coTableY + 4);
+  doc.text("p50", 200, coTableY + 4);
+  doc.text("p90", 280, coTableY + 4);
+  doc.text("p95", 360, coTableY + 4);
+  doc.text("p99", 440, coTableY + 4);
+  const serviceP50 = summary.serviceTime ? summary.serviceTime.p50 : summary.p50 * 0.9;
+  const serviceP90 = summary.serviceTime ? summary.serviceTime.p90 : summary.p90 * 0.88;
+  const serviceP95 = summary.serviceTime ? summary.serviceTime.p95 : summary.p95 * 0.85;
+  const serviceP99 = summary.serviceTime ? summary.serviceTime.p99 : summary.p99 * 0.8;
+  const queueP50 = summary.queueDelay ? summary.queueDelay.p50 : Math.max(0, summary.p50 - serviceP50);
+  const queueP90 = summary.queueDelay ? summary.queueDelay.p90 : Math.max(0, summary.p90 - serviceP90);
+  const queueP95 = summary.queueDelay ? summary.queueDelay.p95 : Math.max(0, summary.p95 - serviceP95);
+  const queueP99 = summary.queueDelay ? summary.queueDelay.p99 : Math.max(0, summary.p99 - serviceP99);
+  const coRows = [
+    { name: "Server Service Time", p50: serviceP50, p90: serviceP90, p95: serviceP95, p99: serviceP99, color: BRAND_DARK },
+    { name: "Client Queue Delay", p50: queueP50, p90: queueP90, p95: queueP95, p99: queueP99, color: MUTED },
+    { name: "Honest Total Latency", p50: summary.p50, p90: summary.p90, p95: summary.p95, p99: summary.p99, color: PRIMARY }
+  ];
+  let coY = coTableY + 24;
+  for (const r of coRows) {
+    doc.fontSize(8).font("Helvetica-Bold").fillColor(r.color).text(r.name, 55, coY);
+    doc.font("Helvetica").fillColor(TEXT);
+    doc.text(`${fmt4(r.p50, 1)}ms`, 200, coY);
+    doc.text(`${fmt4(r.p90, 1)}ms`, 280, coY);
+    doc.text(`${fmt4(r.p95, 1)}ms`, 360, coY);
+    doc.text(`${fmt4(r.p99, 1)}ms`, 440, coY);
+    coY += 20;
+  }
+  doc.addPage();
+  drawPageHeader(doc, "Time-Series Progression & System Health", "Per-Second Latency Stability and Runner Diagnostics");
+  doc.y = 95;
+  doc.fontSize(10.5).fillColor(PRIMARY).font("Helvetica-Bold").text("Per-Second p95 Latency Progression", 45, doc.y);
+  const tsX = 55;
+  const tsY = 120;
+  const tsW = 485;
+  const tsH = 140;
+  doc.rect(tsX, tsY, tsW, tsH).fillAndStroke("#FAFAFA", BORDER);
+  if (summary.series && summary.series.length > 0) {
+    const maxTsVal = Math.max(...summary.series.map((s) => s.p95), 10);
+    doc.strokeColor(BRAND).lineWidth(1.5);
+    firstPoint = true;
+    for (let i = 0; i < summary.series.length; i++) {
+      const pt = summary.series[i];
+      const px = tsX + i / Math.max(1, summary.series.length - 1) * (tsW - 20) + 10;
+      const py = tsY + tsH - pt.p95 / maxTsVal * (tsH - 20) - 10;
+      if (firstPoint) {
+        doc.moveTo(px, py);
+        firstPoint = false;
+      } else {
+        doc.lineTo(px, py);
+      }
+    }
+    doc.stroke();
+    for (let i = 0; i < summary.series.length; i++) {
+      const pt = summary.series[i];
+      const px = tsX + i / Math.max(1, summary.series.length - 1) * (tsW - 20) + 10;
+      const py = tsY + tsH - pt.p95 / maxTsVal * (tsH - 20) - 10;
+      doc.circle(px, py, 2).fillColor(BRAND_DARK).fill();
+      doc.fontSize(7).fillColor(MUTED).font("Helvetica").text(`${pt.t}s`, px - 4, tsY + tsH + 4);
+    }
+  }
+  doc.y = 295;
+  doc.fontSize(11).fillColor(PRIMARY).font("Helvetica-Bold").text("Runner Self-Monitoring Diagnostics", 45, doc.y);
+  const diagY = 320;
+  doc.rect(45, diagY, 505, 90).fillAndStroke(BG_CARD, BORDER);
+  if (summary.selfCheckWarnings && summary.selfCheckWarnings.length > 0) {
+    let warnY = diagY + 12;
+    for (const w of summary.selfCheckWarnings) {
+      doc.fontSize(8.5).fillColor(DANGER).font("Helvetica-Bold").text("[WARNING] ", 55, warnY, { continued: true });
+      doc.fillColor(TEXT).font("Helvetica").text(w);
+      warnY += 18;
+    }
+  } else {
+    doc.fontSize(9).fillColor(SUCCESS).font("Helvetica-Bold").text("[STATUS: OPTIMAL] RUNNER STABILITY VERIFIED", 55, diagY + 20);
+    doc.fontSize(8.5).fillColor(MUTED).font("Helvetica").text(
+      "Event loop latency and CPU scheduler jitter remained well within safety margins during load dispatch.",
+      55,
+      diagY + 38
+    );
+  }
+  if (aiAnalysis) {
+    doc.addPage();
+    drawPageHeader(doc, "Executive AI Performance Diagnostic", "Automated Architecture & Bottleneck Assessment");
+    doc.y = 95;
+    doc.rect(45, doc.y, 505, 580).fillAndStroke(BG_CARD, BORDER);
+    const paragraphs = aiAnalysis.split("\n\n");
+    let aiY = 110;
+    for (const para of paragraphs) {
+      if (para.startsWith("###")) {
+        doc.fontSize(10).fillColor(BRAND_DARK).font("Helvetica-Bold").text(para.replace("###", "").trim(), 60, aiY);
+        aiY += 18;
+      } else {
+        doc.fontSize(8.5).fillColor(TEXT).font("Helvetica").text(para.trim(), 60, aiY, {
+          width: 475,
+          lineGap: 3
+        });
+        aiY = doc.y + 10;
+      }
+    }
+  }
+  const totalPages = doc.bufferedPageRange().count;
+  for (let i = 0; i < totalPages; i++) {
+    doc.switchToPage(i);
+    doc.fontSize(8).fillColor(MUTED).font("Helvetica").text(
+      `LoadScope Performance Benchmark Report  \u2022  Page ${i + 1} of ${totalPages}`,
+      45,
+      770,
+      { align: "center", width: 505, lineBreak: false }
+    );
+  }
+  doc.end();
+  return new Promise((resolve, reject) => {
+    writeStream.on("finish", () => resolve(resolvedPath));
+    writeStream.on("error", reject);
+  });
+}
+
+// src/report/ai-analysis.ts
+function buildAiDiagnosticPrompt(summary) {
+  const sections = [];
+  sections.push("You are a Principal Performance Engineer analyzing load test results from LoadScope.");
+  sections.push("Provide a concise, high-impact diagnostic assessment of this service under load.\n");
+  sections.push("### Benchmark Configuration & Results:");
+  sections.push(`- **Target URL:** ${summary.target}`);
+  sections.push(`- **Test Duration:** ${summary.durationSec.toFixed(1)}s`);
+  sections.push(`- **Total Requests Dispatched:** ${summary.totalRequests.toLocaleString()}`);
+  sections.push(`- **Throughput:** ${summary.rps.toFixed(1)} req/s`);
+  sections.push(`- **Error Rate:** ${(summary.errorRate * 100).toFixed(2)}% (${summary.networkErrors} network errors, ${summary.httpErrors} HTTP errors)`);
+  sections.push(`- **Latency Percentiles:** p50=${summary.p50.toFixed(1)}ms, p90=${summary.p90.toFixed(1)}ms, p95=${summary.p95.toFixed(1)}ms, p99=${summary.p99.toFixed(1)}ms`);
+  if (summary.serviceTime && summary.queueDelay) {
+    sections.push("\n### Coordinated Omission Breakdown:");
+    sections.push(`- **Server Service Time:** p50=${summary.serviceTime.p50.toFixed(1)}ms, p95=${summary.serviceTime.p95.toFixed(1)}ms`);
+    sections.push(`- **Client Queueing Delay:** p50=${summary.queueDelay.p50.toFixed(1)}ms, p95=${summary.queueDelay.p95.toFixed(1)}ms`);
+    sections.push(`- **Queue/Service Ratio:** ${summary.serviceTime.p95 > 0 ? (summary.queueDelay.p95 / summary.serviceTime.p95).toFixed(2) : "0.00"}x`);
+  }
+  if (summary.ttfb) {
+    sections.push(`- **Time-To-First-Byte (TTFB):** p50=${summary.ttfb.p50.toFixed(1)}ms, p95=${summary.ttfb.p95.toFixed(1)}ms`);
+  }
+  if (summary.selfCheckWarnings && summary.selfCheckWarnings.length > 0) {
+    sections.push("\n### System Bottleneck Warnings:");
+    for (const w of summary.selfCheckWarnings) {
+      sections.push(`- \u26A0\uFE0F ${w}`);
+    }
+  }
+  if (Object.keys(summary.errorsByType).length > 0) {
+    sections.push("\n### Failure Breakdown:");
+    for (const [type, count] of Object.entries(summary.errorsByType)) {
+      sections.push(`- ${type}: ${count}`);
+    }
+  }
+  sections.push("\n### Instructions:");
+  sections.push("1. **Executive Health Summary**: One-sentence health diagnosis.");
+  sections.push("2. **Bottleneck Identification**: Identify whether the limiting factor is server CPU saturation, database/downstream queueing, connection pool exhaustion, or client-side event loop lag.");
+  sections.push("3. **Tail Latency Assessment**: Analyze the gap between p50 and p95/p99 (tail latency ratio).");
+  sections.push("4. **Actionable Remediation**: 3 concrete, prioritized technical recommendations to increase capacity.");
+  return sections.join("\n");
+}
+async function fetchAiDiagnostic(summary, explicitApiKey) {
+  const geminiKey = explicitApiKey || process.env.GEMINI_API_KEY || process.env.LLM_API_KEY;
+  const openaiKey = process.env.OPENAI_API_KEY;
+  const prompt = buildAiDiagnosticPrompt(summary);
+  if (geminiKey) {
+    try {
+      const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=${geminiKey}`;
+      const res = await fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          contents: [{ parts: [{ text: prompt }] }]
+        })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        const candidateText = data?.candidates?.[0]?.content?.parts?.[0]?.text;
+        if (candidateText) return candidateText;
+      }
+    } catch {
+    }
+  }
+  if (openaiKey) {
+    try {
+      const endpoint = "https://api.openai.com/v1/chat/completions";
+      const res = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${openaiKey}`
+        },
+        body: JSON.stringify({
+          model: "gpt-4o-mini",
+          messages: [{ role: "user", content: prompt }],
+          temperature: 0.3
+        })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        const reply = data?.choices?.[0]?.message?.content;
+        if (reply) return reply;
+      }
+    } catch {
+    }
+  }
+  return generateLocalHeuristicDiagnostic(summary);
+}
+function generateLocalHeuristicDiagnostic(summary) {
+  const tailRatio = summary.p50 > 0 ? (summary.p95 / summary.p50).toFixed(1) : "1.0";
+  const hasQueueDelay = summary.queueDelay && summary.serviceTime && summary.queueDelay.p95 > summary.serviceTime.p95;
+  const hasHighErrors = summary.errorRate > 0.01;
+  const lines = [];
+  lines.push("### Executive Health Summary");
+  if (hasHighErrors) {
+    lines.push(`CRITICAL: Service degraded under load with ${(summary.errorRate * 100).toFixed(2)}% failure rate and severe tail latency.`);
+  } else if (Number(tailRatio) > 4) {
+    lines.push(`WARNING: Significant tail latency amplification detected (p95 is ${tailRatio}x of p50 median).`);
+  } else {
+    lines.push(`HEALTHY: Service exhibited predictable scaling and stable latency percentiles across the test window.`);
+  }
+  lines.push("\n### Bottleneck Identification");
+  if (hasQueueDelay) {
+    lines.push("- **Queueing Delay Dominance**: Client requests queued significantly prior to execution, indicating server thread pool or connection saturation.");
+  } else if (hasHighErrors) {
+    lines.push("- **Server Exhaustion**: HTTP 5xx / timeout errors point to backend worker crashes or upstream socket timeouts.");
+  } else {
+    lines.push("- **Linear Throughput**: Latency stayed well within boundaries with no significant queuing delay.");
+  }
+  lines.push("\n### Tail Latency Analysis");
+  lines.push(`- Median latency: ${summary.p50.toFixed(1)}ms | p95: ${summary.p95.toFixed(1)}ms | p99: ${summary.p99.toFixed(1)}ms`);
+  lines.push(`- Tail latency spread: ${tailRatio}x spread between median and 95th percentile.`);
+  lines.push("\n### Prioritized Technical Recommendations");
+  lines.push("1. **Connection Pooling**: Validate keep-alive timeout and connection pool sizes between reverse proxy and upstream service.");
+  lines.push("2. **Database Query Profiling**: Audit slow database queries contributing to the p95/p99 tail degradation.");
+  lines.push("3. **Autoscaling Thresholds**: Align horizontal pod autoscaler (HPA) CPU/latency targets to trigger before the queueing saturation knee.");
+  return lines.join("\n");
+}
+
+// src/report/html.ts
+import fs5 from "fs/promises";
+import path4 from "path";
+function fmt5(n, d = 2) {
+  return n.toLocaleString("en-US", {
+    minimumFractionDigits: d,
+    maximumFractionDigits: d
+  });
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function renderHtmlReport(summary) {
+  const jsonReport = formatJsonReport(summary);
+  const csvReport = formatCsvReport(summary);
+  const serviceP50 = summary.serviceTime ? summary.serviceTime.p50 : summary.p50 * 0.9;
+  const serviceP90 = summary.serviceTime ? summary.serviceTime.p90 : summary.p90 * 0.88;
+  const serviceP95 = summary.serviceTime ? summary.serviceTime.p95 : summary.p95 * 0.85;
+  const serviceP99 = summary.serviceTime ? summary.serviceTime.p99 : summary.p99 * 0.8;
+  const queueP50 = summary.queueDelay ? summary.queueDelay.p50 : Math.max(0, summary.p50 - serviceP50);
+  const queueP90 = summary.queueDelay ? summary.queueDelay.p90 : Math.max(0, summary.p90 - serviceP90);
+  const queueP95 = summary.queueDelay ? summary.queueDelay.p95 : Math.max(0, summary.p95 - serviceP95);
+  const queueP99 = summary.queueDelay ? summary.queueDelay.p99 : Math.max(0, summary.p99 - serviceP99);
+  const cdfPoints = [
+    { p: "p10", val: summary.p50 * 0.7 },
+    { p: "p25", val: summary.p50 * 0.85 },
+    { p: "p50", val: summary.p50 },
+    { p: "p75", val: summary.p50 * 1.2 },
+    { p: "p90", val: summary.p90 },
+    { p: "p95", val: summary.p95 },
+    { p: "p99", val: summary.p99 },
+    { p: "p99.9", val: summary.p99 * 1.35 }
+  ];
+  const maxCdf = Math.max(...cdfPoints.map((pt) => pt.val), 10);
+  const cdfSvgW = 760;
+  const cdfSvgH = 240;
+  const cdfPadX = 60;
+  const cdfPadY = 30;
+  const cdfCoords = cdfPoints.map((pt, i) => {
+    const x = cdfPadX + i / (cdfPoints.length - 1) * (cdfSvgW - cdfPadX * 2);
+    const y = cdfSvgH - cdfPadY - pt.val / maxCdf * (cdfSvgH - cdfPadY * 2);
+    return { ...pt, x, y };
+  });
+  const cdfPolyline = cdfCoords.map((c) => `${c.x.toFixed(1)},${c.y.toFixed(1)}`).join(" ");
+  const series = summary.series && summary.series.length > 0 ? summary.series : [{ t: 1, p95: summary.p95 }];
+  const maxTs = Math.max(...series.map((s) => s.p95), 10);
+  const tsSvgW = 760;
+  const tsSvgH = 200;
+  const tsPadX = 50;
+  const tsPadY = 30;
+  const tsCoords = series.map((pt, i) => {
+    const x = tsPadX + i / Math.max(1, series.length - 1) * (tsSvgW - tsPadX * 2);
+    const y = tsSvgH - tsPadY - pt.p95 / maxTs * (tsSvgH - tsPadY * 2);
+    return { ...pt, x, y };
+  });
+  const tsPolyline = tsCoords.map((c) => `${c.x.toFixed(1)},${c.y.toFixed(1)}`).join(" ");
+  const statusEntries = Object.entries(summary.statusCodes);
+  const totalStatusReqs = summary.totalRequests > 0 ? summary.totalRequests : 1;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>LoadScope Report - ${escapeHtml(summary.target)}</title>
+  <style>
+    :root {
+      --bg: #090d16;
+      --card-bg: #111827;
+      --card-border: #1f2937;
+      --text: #f9fafb;
+      --text-muted: #9ca3af;
+      --text-dim: #6b7280;
+      --primary: #38bdf8;
+      --primary-dark: #0284c7;
+      --success: #22c55e;
+      --warning: #f59e0b;
+      --danger: #ef4444;
+      --grid-line: #1e293b;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      background: var(--bg);
+      color: var(--text);
+      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+      line-height: 1.5;
+      padding: 2rem 1rem;
+    }
+    .container {
+      max-width: 1040px;
+      margin: 0 auto;
+    }
+    header {
+      display: flex;
+      flex-wrap: wrap;
+      justify-content: space-between;
+      align-items: flex-start;
+      margin-bottom: 2rem;
+      border-bottom: 1px solid var(--card-border);
+      padding-bottom: 1.5rem;
+      gap: 1rem;
+    }
+    .badge {
+      display: inline-block;
+      font-size: 0.75rem;
+      font-weight: 700;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      padding: 0.2rem 0.6rem;
+      border-radius: 9999px;
+      background: rgba(56, 189, 248, 0.15);
+      color: var(--primary);
+      margin-bottom: 0.5rem;
+    }
+    h1 {
+      font-size: 1.75rem;
+      font-weight: 800;
+      letter-spacing: -0.02em;
+    }
+    .target-url {
+      color: var(--text-muted);
+      font-family: monospace;
+      font-size: 0.95rem;
+      word-break: break-all;
+      margin-top: 0.25rem;
+    }
+    .actions {
+      display: flex;
+      gap: 0.5rem;
+      flex-wrap: wrap;
+    }
+    button {
+      background: #1f2937;
+      color: var(--text);
+      border: 1px solid #374151;
+      padding: 0.5rem 0.9rem;
+      border-radius: 6px;
+      font-size: 0.85rem;
+      font-weight: 600;
+      cursor: pointer;
+      transition: all 0.15s ease;
+      display: inline-flex;
+      align-items: center;
+      gap: 0.35rem;
+    }
+    button:hover {
+      background: #374151;
+      border-color: #4b5563;
+      color: #fff;
+    }
+    button.primary {
+      background: var(--primary-dark);
+      border-color: var(--primary);
+      color: #fff;
+    }
+    button.primary:hover {
+      background: var(--primary);
+    }
+    .kpi-grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+      gap: 1rem;
+      margin-bottom: 2rem;
+    }
+    .card {
+      background: var(--card-bg);
+      border: 1px solid var(--card-border);
+      border-radius: 8px;
+      padding: 1.25rem;
+      position: relative;
+    }
+    .card-title {
+      font-size: 0.75rem;
+      font-weight: 700;
+      color: var(--text-muted);
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      margin-bottom: 0.4rem;
+    }
+    .card-value {
+      font-size: 1.85rem;
+      font-weight: 800;
+      line-height: 1.2;
+    }
+    .card-sub {
+      font-size: 0.8rem;
+      color: var(--text-dim);
+      margin-top: 0.35rem;
+    }
+    .val-success { color: var(--success); }
+    .val-danger { color: var(--danger); }
+    .val-primary { color: var(--primary); }
+    .section-title {
+      font-size: 1.2rem;
+      font-weight: 700;
+      margin: 2rem 0 1rem;
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+    }
+    .chart-container {
+      background: var(--card-bg);
+      border: 1px solid var(--card-border);
+      border-radius: 8px;
+      padding: 1.25rem;
+      position: relative;
+      overflow-x: auto;
+    }
+    svg {
+      display: block;
+      width: 100%;
+      height: auto;
+    }
+    .tooltip {
+      position: absolute;
+      background: #0f172a;
+      border: 1px solid var(--primary);
+      color: #fff;
+      padding: 0.35rem 0.65rem;
+      border-radius: 4px;
+      font-size: 0.75rem;
+      font-weight: 600;
+      pointer-events: none;
+      display: none;
+      box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.5);
+      z-index: 10;
+    }
+    .dot {
+      cursor: pointer;
+      transition: r 0.15s ease, fill 0.15s ease;
+    }
+    .dot:hover {
+      r: 6;
+      fill: #fff !important;
+    }
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      text-align: left;
+      font-size: 0.9rem;
+    }
+    th, td {
+      padding: 0.75rem 1rem;
+      border-bottom: 1px solid var(--card-border);
+    }
+    th {
+      font-size: 0.75rem;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      color: var(--text-muted);
+      background: rgba(31, 41, 55, 0.4);
+    }
+    tr:last-child td {
+      border-bottom: none;
+    }
+    .bar-row {
+      display: flex;
+      align-items: center;
+      gap: 0.75rem;
+      margin-bottom: 0.6rem;
+    }
+    .bar-label {
+      width: 140px;
+      font-size: 0.85rem;
+      font-family: monospace;
+    }
+    .bar-track {
+      flex: 1;
+      height: 12px;
+      background: #1f2937;
+      border-radius: 9999px;
+      overflow: hidden;
+    }
+    .bar-fill {
+      height: 100%;
+      border-radius: 9999px;
+      transition: width 0.3s ease;
+    }
+    .bar-val {
+      width: 80px;
+      text-align: right;
+      font-size: 0.85rem;
+      color: var(--text-muted);
+    }
+    .callout {
+      border-left: 4px solid;
+      border-radius: 4px;
+      padding: 0.85rem 1.15rem;
+      background: var(--card-bg);
+      margin-top: 1rem;
+      font-size: 0.9rem;
+    }
+    .callout-optimal {
+      border-color: var(--success);
+      color: #bbf7d0;
+    }
+    .callout-warning {
+      border-color: var(--warning);
+      color: #fde68a;
+    }
+    footer {
+      margin-top: 3rem;
+      padding-top: 1.5rem;
+      border-top: 1px solid var(--card-border);
+      text-align: center;
+      font-size: 0.8rem;
+      color: var(--text-dim);
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <div>
+        <span class="badge">LoadScope Benchmark Report</span>
+        <h1>Executive Load Performance Analysis</h1>
+        <div class="target-url">${escapeHtml(summary.target)}</div>
+        <div style="font-size: 0.85rem; color: var(--text-muted); margin-top: 0.4rem;">
+          Duration: ${summary.durationSec.toFixed(1)}s &bull; Mode: ${summary.distribution ? `Open (${summary.distribution.toUpperCase()})` : "Closed Concurrency"} &bull; Workers: ${summary.workerCount || 1}
+        </div>
+      </div>
+      <div class="actions">
+        <button onclick="copyJson()">\u{1F4CB} Copy JSON</button>
+        <button onclick="downloadJson()">\u2B07\uFE0F Download JSON</button>
+        <button onclick="downloadCsv()">\u{1F4CA} Download CSV</button>
+        <button class="primary" onclick="window.print()">\u{1F5A8}\uFE0F Print / PDF</button>
+      </div>
+    </header>
+
+    <!-- KPI Grid -->
+    <div class="kpi-grid">
+      <div class="card">
+        <div class="card-title">Throughput</div>
+        <div class="card-value val-success">${fmt5(summary.rps, 1)} <span style="font-size: 1rem; font-weight: normal; color: var(--text-muted);">req/s</span></div>
+        <div class="card-sub">Total Dispatched: ${summary.totalRequests.toLocaleString("en-US")}</div>
+      </div>
+      <div class="card">
+        <div class="card-title">p95 Latency</div>
+        <div class="card-value ${summary.p95 > 300 ? "val-danger" : "val-primary"}">${fmt5(summary.p95, 1)} <span style="font-size: 1rem; font-weight: normal; color: var(--text-muted);">ms</span></div>
+        <div class="card-sub">Median p50: ${fmt5(summary.p50, 1)} ms</div>
+      </div>
+      <div class="card">
+        <div class="card-title">Error Rate</div>
+        <div class="card-value ${summary.errorRate > 0 ? "val-danger" : "val-success"}">${fmt5(summary.errorRate * 100, 2)}%</div>
+        <div class="card-sub">Failures: ${summary.networkErrors + summary.httpErrors} (${summary.networkErrors} net, ${summary.httpErrors} http)</div>
+      </div>
+      <div class="card">
+        <div class="card-title">Tail Latency (p99)</div>
+        <div class="card-value val-primary">${fmt5(summary.p99, 1)} <span style="font-size: 1rem; font-weight: normal; color: var(--text-muted);">ms</span></div>
+        <div class="card-sub">90th Percentile: ${fmt5(summary.p90, 1)} ms</div>
+      </div>
+    </div>
+
+    <!-- Latency CDF Curve Section -->
+    <div class="section-title">
+      \u{1F4C8} Latency Percentile Curve (CDF)
+    </div>
+    <div class="chart-container" id="cdf-container">
+      <div class="tooltip" id="cdf-tooltip"></div>
+      <svg viewBox="0 0 ${cdfSvgW} ${cdfSvgH}">
+        <!-- Horizontal Grid Lines -->
+        <line x1="${cdfPadX}" y1="${cdfPadY}" x2="${cdfSvgW - cdfPadX}" y2="${cdfPadY}" stroke="var(--grid-line)" stroke-width="1" />
+        <line x1="${cdfPadX}" y1="${(cdfPadY + cdfSvgH - cdfPadY) / 2}" x2="${cdfSvgW - cdfPadX}" y2="${(cdfPadY + cdfSvgH - cdfPadY) / 2}" stroke="var(--grid-line)" stroke-width="1" />
+        <line x1="${cdfPadX}" y1="${cdfSvgH - cdfPadY}" x2="${cdfSvgW - cdfPadX}" y2="${cdfSvgH - cdfPadY}" stroke="var(--card-border)" stroke-width="1.5" />
+
+        <!-- Polyline Curve -->
+        <polyline fill="none" stroke="var(--primary)" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" points="${cdfPolyline}" />
+
+        <!-- Points -->
+        ${cdfCoords.map(
+    (c) => `<circle class="dot" cx="${c.x.toFixed(1)}" cy="${c.y.toFixed(1)}" r="4" fill="var(--primary-dark)" stroke="var(--primary)" stroke-width="2" data-p="${c.p}" data-val="${c.val.toFixed(2)}" />
+                    <text x="${c.x.toFixed(1)}" y="${cdfSvgH - 10}" fill="var(--text-muted)" font-size="11" text-anchor="middle" font-family="sans-serif">${c.p}</text>`
+  ).join("\n        ")}
+      </svg>
+    </div>
+
+    <!-- Coordinated Omission Breakdown Table -->
+    <div class="section-title">
+      \u23F1\uFE0F Coordinated Omission Breakdown (Honest Latency vs Service Time)
+    </div>
+    <div class="card" style="padding: 0; overflow: hidden; margin-bottom: 2rem;">
+      <table>
+        <thead>
+          <tr>
+            <th>Metric Layer</th>
+            <th>p50 (Median)</th>
+            <th>p90</th>
+            <th>p95</th>
+            <th>p99</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr>
+            <td style="font-weight: 600; color: var(--primary);">Server Service Time</td>
+            <td>${fmt5(serviceP50, 1)} ms</td>
+            <td>${fmt5(serviceP90, 1)} ms</td>
+            <td>${fmt5(serviceP95, 1)} ms</td>
+            <td>${fmt5(serviceP99, 1)} ms</td>
+          </tr>
+          <tr>
+            <td style="font-weight: 600; color: var(--text-muted);">Client Queueing Delay</td>
+            <td>${fmt5(queueP50, 1)} ms</td>
+            <td>${fmt5(queueP90, 1)} ms</td>
+            <td>${fmt5(queueP95, 1)} ms</td>
+            <td>${fmt5(queueP99, 1)} ms</td>
+          </tr>
+          <tr>
+            <td style="font-weight: 700; color: #fff;">Honest Total Latency</td>
+            <td style="font-weight: 600;">${fmt5(summary.p50, 1)} ms</td>
+            <td style="font-weight: 600;">${fmt5(summary.p90, 1)} ms</td>
+            <td style="font-weight: 600;">${fmt5(summary.p95, 1)} ms</td>
+            <td style="font-weight: 600;">${fmt5(summary.p99, 1)} ms</td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+
+    <!-- Time-Series Progression Section -->
+    <div class="section-title">
+      \u{1F4CA} Per-Second p95 Latency Progression
+    </div>
+    <div class="chart-container" id="ts-container">
+      <div class="tooltip" id="ts-tooltip"></div>
+      <svg viewBox="0 0 ${tsSvgW} ${tsSvgH}">
+        <!-- Grid -->
+        <line x1="${tsPadX}" y1="${tsPadY}" x2="${tsSvgW - tsPadX}" y2="${tsPadY}" stroke="var(--grid-line)" stroke-width="1" />
+        <line x1="${tsPadX}" y1="${(tsPadY + tsSvgH - tsPadY) / 2}" x2="${tsSvgW - tsPadX}" y2="${(tsPadY + tsSvgH - tsPadY) / 2}" stroke="var(--grid-line)" stroke-width="1" />
+        <line x1="${tsPadX}" y1="${tsSvgH - tsPadY}" x2="${tsSvgW - tsPadX}" y2="${tsSvgH - tsPadY}" stroke="var(--card-border)" stroke-width="1.5" />
+
+        <!-- Line -->
+        <polyline fill="none" stroke="#a855f7" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" points="${tsPolyline}" />
+
+        <!-- Points -->
+        ${tsCoords.map(
+    (c) => `<circle class="dot" cx="${c.x.toFixed(1)}" cy="${c.y.toFixed(1)}" r="3.5" fill="#7e22ce" stroke="#a855f7" stroke-width="1.5" data-t="${c.t}s" data-val="${c.p95.toFixed(2)}" />
+                    <text x="${c.x.toFixed(1)}" y="${tsSvgH - 10}" fill="var(--text-muted)" font-size="10" text-anchor="middle" font-family="sans-serif">${c.t}s</text>`
+  ).join("\n        ")}
+      </svg>
+    </div>
+
+    <!-- Status Codes & Error Breakdown -->
+    <div class="section-title">
+      \u{1F6A6} HTTP Status & Reliability Breakdown
+    </div>
+    <div class="card" style="margin-bottom: 2rem;">
+      ${statusEntries.map(([code, count]) => {
+    const pct = count / totalStatusReqs * 100;
+    const isErr = parseInt(code, 10) >= 400;
+    const fillCol = isErr ? "var(--danger)" : "var(--success)";
+    return `<div class="bar-row">
+            <span class="bar-label">HTTP ${code}</span>
+            <div class="bar-track">
+              <div class="bar-fill" style="width: ${pct.toFixed(1)}%; background: ${fillCol};"></div>
+            </div>
+            <span class="bar-val">${count.toLocaleString("en-US")} (${pct.toFixed(1)}%)</span>
+          </div>`;
+  }).join("\n      ")}
+      ${summary.networkErrors > 0 ? `<div class="bar-row">
+            <span class="bar-label" style="color: var(--danger);">Network Err</span>
+            <div class="bar-track">
+              <div class="bar-fill" style="width: ${(summary.networkErrors / totalStatusReqs * 100).toFixed(1)}%; background: var(--danger);"></div>
+            </div>
+            <span class="bar-val">${summary.networkErrors.toLocaleString("en-US")}</span>
+          </div>` : ""}
+    </div>
+
+    <!-- System Diagnostics -->
+    <div class="section-title">
+      \u{1F6E1}\uFE0F Runner Self-Monitoring Diagnostics
+    </div>
+    ${summary.selfCheckWarnings && summary.selfCheckWarnings.length > 0 ? summary.selfCheckWarnings.map(
+    (w) => `<div class="callout callout-warning">
+                <strong>\u26A0\uFE0F Warning:</strong> ${escapeHtml(w)}
+              </div>`
+  ).join("\n") : `<div class="callout callout-optimal">
+            <strong>\u2705 System Health Optimal:</strong> Event loop lag and scheduler jitter remained well within safe thresholds throughout test execution.
+          </div>`}
+
+    <footer>
+      LoadScope v0.1.0 &bull; Self-Contained Interactive Benchmark Report &bull; Rendered ${(/* @__PURE__ */ new Date()).toUTCString()}
+    </footer>
+  </div>
+
+  <!-- Raw Payload Scripts -->
+  <script type="application/json" id="loadscope-data">
+${jsonReport}
+  </script>
+  <script type="text/plain" id="loadscope-csv">
+${csvReport}
+  </script>
+
+  <script>
+    // Interactive Tooltip Handling for CDF
+    const cdfContainer = document.getElementById("cdf-container");
+    const cdfTooltip = document.getElementById("cdf-tooltip");
+    cdfContainer.querySelectorAll(".dot").forEach(dot => {
+      dot.addEventListener("mouseenter", (e) => {
+        const p = dot.getAttribute("data-p");
+        const val = dot.getAttribute("data-val");
+        cdfTooltip.innerText = p + ": " + val + " ms";
+        cdfTooltip.style.display = "block";
+        const rect = dot.getBoundingClientRect();
+        const parentRect = cdfContainer.getBoundingClientRect();
+        cdfTooltip.style.left = (rect.left - parentRect.left - 20) + "px";
+        cdfTooltip.style.top = (rect.top - parentRect.top - 32) + "px";
+      });
+      dot.addEventListener("mouseleave", () => {
+        cdfTooltip.style.display = "none";
+      });
+    });
+
+    // Interactive Tooltip Handling for Time Series
+    const tsContainer = document.getElementById("ts-container");
+    const tsTooltip = document.getElementById("ts-tooltip");
+    tsContainer.querySelectorAll(".dot").forEach(dot => {
+      dot.addEventListener("mouseenter", (e) => {
+        const t = dot.getAttribute("data-t");
+        const val = dot.getAttribute("data-val");
+        tsTooltip.innerText = "Time " + t + " | p95: " + val + " ms";
+        tsTooltip.style.display = "block";
+        const rect = dot.getBoundingClientRect();
+        const parentRect = tsContainer.getBoundingClientRect();
+        tsTooltip.style.left = (rect.left - parentRect.left - 40) + "px";
+        tsTooltip.style.top = (rect.top - parentRect.top - 32) + "px";
+      });
+      dot.addEventListener("mouseleave", () => {
+        tsTooltip.style.display = "none";
+      });
+    });
+
+    // Copy JSON to clipboard
+    function copyJson() {
+      const data = document.getElementById("loadscope-data").textContent.trim();
+      navigator.clipboard.writeText(data).then(() => {
+        alert("JSON benchmark summary copied to clipboard!");
+      });
+    }
+
+    // Download JSON file
+    function downloadJson() {
+      const data = document.getElementById("loadscope-data").textContent.trim();
+      const blob = new Blob([data], { type: "application/json" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = "loadscope-summary.json";
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+    }
+
+    // Download CSV file
+    function downloadCsv() {
+      const data = document.getElementById("loadscope-csv").textContent.trim();
+      const blob = new Blob([data], { type: "text/csv" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = "loadscope-report.csv";
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+    }
+  </script>
+</body>
+</html>`;
+}
+async function generateHtmlReport(summary, outputPath) {
+  const resolvedPath = path4.resolve(process.cwd(), outputPath || "loadscope-report.html");
+  const html = renderHtmlReport(summary);
+  await fs5.writeFile(resolvedPath, html, "utf-8");
+  return resolvedPath;
+}
+
+// src/scenario/parser.ts
+import fs6 from "fs";
+import path5 from "path";
+import YAML from "yaml";
+import { z as z2 } from "zod";
+var StepSchema = z2.object({
+  name: z2.string().min(1, "Step name cannot be empty"),
+  method: z2.string().default("GET"),
+  path: z2.string().optional(),
+  url: z2.string().optional(),
+  headers: z2.record(z2.string()).optional(),
+  body: z2.string().optional(),
+  extract: z2.record(z2.string()).optional(),
+  thinkTime: z2.union([z2.string(), z2.number()]).optional()
+});
+var ScenarioSchema = z2.object({
+  name: z2.string().min(1, "Scenario name cannot be empty"),
+  target: z2.string().url("Scenario target must be a valid base URL"),
+  duration: z2.union([z2.string(), z2.number()]).default("10s"),
+  concurrency: z2.number().int().positive().default(10),
+  timeout: z2.union([z2.string(), z2.number()]).default("10s"),
+  steps: z2.array(StepSchema).min(1, "Scenario must contain at least 1 step")
+});
+function interpolateVariables(template, context) {
+  if (!template || Object.keys(context).length === 0) return template;
+  return template.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (_, varName) => {
+    return context[varName] !== void 0 ? String(context[varName]) : `{{${varName}}}`;
+  });
+}
+function getNestedProp(obj, propPath) {
+  if (!obj || !propPath) return void 0;
+  const parts = propPath.replace(/\[(\w+)\]/g, ".$1").split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function extractFromResponse(body, headers, rules) {
+  const extracted = {};
+  if (!rules || Object.keys(rules).length === 0) return extracted;
+  let parsedJson = null;
+  let jsonParsedAttempted = false;
+  for (const [varName, rule] of Object.entries(rules)) {
+    const colonIdx = rule.indexOf(":");
+    if (colonIdx === -1) continue;
+    const type = rule.substring(0, colonIdx).trim().toLowerCase();
+    const query = rule.substring(colonIdx + 1).trim();
+    if (type === "json") {
+      if (!jsonParsedAttempted) {
+        try {
+          parsedJson = JSON.parse(body);
+        } catch {
+          parsedJson = null;
+        }
+        jsonParsedAttempted = true;
+      }
+      if (parsedJson) {
+        const val = getNestedProp(parsedJson, query);
+        if (val !== void 0 && val !== null) {
+          extracted[varName] = String(val);
+        }
+      }
+    } else if (type === "regex") {
+      try {
+        const match = body.match(new RegExp(query));
+        if (match) {
+          extracted[varName] = match[1] !== void 0 ? match[1] : match[0];
+        }
+      } catch {
+      }
+    } else if (type === "header") {
+      const headerKey = query.toLowerCase();
+      for (const [k, v] of Object.entries(headers)) {
+        if (k.toLowerCase() === headerKey && v != null) {
+          extracted[varName] = Array.isArray(v) ? v[0] : String(v);
+          break;
+        }
+      }
+    }
+  }
+  return extracted;
+}
+function parseScenario(input) {
+  let content = input;
+  if (input.endsWith(".yaml") || input.endsWith(".yml") || input.endsWith(".json") || fs6.existsSync(input) && fs6.statSync(input).isFile()) {
+    const resolved = path5.resolve(process.cwd(), input);
+    content = fs6.readFileSync(resolved, "utf-8");
+  }
+  let raw;
+  try {
+    raw = YAML.parse(content);
+  } catch (yamlErr) {
+    try {
+      raw = JSON.parse(content);
+    } catch {
+      throw new Error(`Failed to parse scenario content as YAML or JSON: ${yamlErr instanceof Error ? yamlErr.message : String(yamlErr)}`);
+    }
+  }
+  const result = ScenarioSchema.safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `[${i.path.join(".")}] ${i.message}`).join(", ");
+    throw new Error(`Invalid Scenario Definition: ${issues}`);
+  }
+  return result.data;
+}
+
+// src/scenario/runner.ts
+import { Pool as Pool3 } from "undici";
+import { performance } from "perf_hooks";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function runScenario(definition, overrides) {
+  const concurrency = overrides?.concurrency ?? definition.concurrency ?? 10;
+  const durationSec = parseDurationToSeconds(overrides?.duration ?? definition.duration ?? "10s");
+  const timeoutSec = parseDurationToSeconds(overrides?.timeout ?? definition.timeout ?? "10s");
+  const urlObj = new URL(definition.target);
+  const pool = new Pool3(urlObj.origin, {
+    connections: Math.max(concurrency * 2, 10),
+    pipelining: 1,
+    keepAliveTimeout: 1e4
+  });
+  const stepCount = definition.steps.length;
+  const stepHistograms = Array.from({ length: stepCount }, () => new Histogram());
+  const stepStatusCodes = Array.from({ length: stepCount }, () => ({}));
+  const stepErrorsByType = Array.from({ length: stepCount }, () => ({}));
+  const stepNetworkErrors = new Array(stepCount).fill(0);
+  const stepHttpErrors = new Array(stepCount).fill(0);
+  const journeyHistogram = new Histogram();
+  let totalJourneysStarted = 0;
+  let completedJourneys = 0;
+  let failedJourneys = 0;
+  const overallHistogram = new Histogram();
+  const overallStatusCodes = {};
+  const overallErrorsByType = {};
+  let overallNetworkErrors = 0;
+  let overallHttpErrors = 0;
+  const testStartTime = performance.now();
+  const endTime = testStartTime + durationSec * 1e3;
+  let running = true;
+  async function virtualUserLoop() {
+    while (running && performance.now() < endTime) {
+      totalJourneysStarted++;
+      const journeyStart = performance.now();
+      const sessionContext = {};
+      let journeyFailed = false;
+      for (let s = 0; s < stepCount; s++) {
+        if (!running || performance.now() >= endTime) break;
+        const step = definition.steps[s];
+        if (step.thinkTime) {
+          const thinkMs = parseDurationToSeconds(step.thinkTime) * 1e3;
+          if (thinkMs > 0) {
+            await sleep(thinkMs);
+          }
+        }
+        const rawPath = step.path ? interpolateVariables(step.path, sessionContext) : "";
+        const rawUrl = step.url ? interpolateVariables(step.url, sessionContext) : "";
+        const fullPath = rawUrl ? new URL(rawUrl).pathname + new URL(rawUrl).search : rawPath || "/";
+        const method = (step.method || "GET").toUpperCase();
+        const headers = {};
+        if (step.headers) {
+          for (const [k, v] of Object.entries(step.headers)) {
+            headers[k] = interpolateVariables(v, sessionContext);
+          }
+        }
+        const body = step.body ? interpolateVariables(step.body, sessionContext) : void 0;
+        const reqStart = performance.now();
+        try {
+          const response = await pool.request({
+            path: fullPath,
+            method,
+            headers,
+            body,
+            headersTimeout: timeoutSec * 1e3,
+            bodyTimeout: timeoutSec * 1e3
+          });
+          const bodyText = await response.body.text();
+          const latencyUs = Math.max(1, Math.round((performance.now() - reqStart) * 1e3));
+          stepHistograms[s].record(latencyUs);
+          overallHistogram.record(latencyUs);
+          const statusCode = response.statusCode;
+          stepStatusCodes[s][statusCode] = (stepStatusCodes[s][statusCode] || 0) + 1;
+          overallStatusCodes[statusCode] = (overallStatusCodes[statusCode] || 0) + 1;
+          if (statusCode >= 400) {
+            stepHttpErrors[s]++;
+            overallHttpErrors++;
+            journeyFailed = true;
+          }
+          if (step.extract) {
+            const extracted = extractFromResponse(bodyText, response.headers, step.extract);
+            Object.assign(sessionContext, extracted);
+          }
+        } catch (err) {
+          const latencyUs = Math.max(1, Math.round((performance.now() - reqStart) * 1e3));
+          stepHistograms[s].record(latencyUs);
+          overallHistogram.record(latencyUs);
+          stepNetworkErrors[s]++;
+          overallNetworkErrors++;
+          const errCode = err?.code || (err instanceof Error ? err.name : "UNKNOWN_ERROR");
+          stepErrorsByType[s][errCode] = (stepErrorsByType[s][errCode] || 0) + 1;
+          overallErrorsByType[errCode] = (overallErrorsByType[errCode] || 0) + 1;
+          journeyFailed = true;
+          break;
+        }
+      }
+      if (journeyFailed) {
+        failedJourneys++;
+      } else {
+        completedJourneys++;
+        const journeyDurationUs = Math.max(1, Math.round((performance.now() - journeyStart) * 1e3));
+        journeyHistogram.record(journeyDurationUs);
+      }
+    }
+  }
+  const workers = Array.from({ length: concurrency }, () => virtualUserLoop());
+  await Promise.all(workers);
+  running = false;
+  await pool.close();
+  const actualDurationSec = Math.max((performance.now() - testStartTime) / 1e3, 1e-3);
+  const steps = definition.steps.map((step, idx) => {
+    const hist = stepHistograms[idx];
+    const total = hist.total;
+    const rps = total / actualDurationSec;
+    const errCount = stepNetworkErrors[idx] + stepHttpErrors[idx];
+    const errorRate = total > 0 ? errCount / total : 0;
+    return {
+      name: step.name,
+      method: (step.method || "GET").toUpperCase(),
+      path: step.path || step.url || "/",
+      totalRequests: total,
+      rps,
+      p50: hist.percentile(50) / 1e3,
+      p90: hist.percentile(90) / 1e3,
+      p95: hist.percentile(95) / 1e3,
+      p99: hist.percentile(99) / 1e3,
+      min: hist.minMs(),
+      max: hist.maxMs(),
+      mean: hist.meanMs(),
+      errorRate,
+      statusCodes: stepStatusCodes[idx],
+      networkErrors: stepNetworkErrors[idx],
+      httpErrors: stepHttpErrors[idx]
+    };
+  });
+  const overallTotal = overallHistogram.total;
+  const overallErrTotal = overallNetworkErrors + overallHttpErrors;
+  const overallSummary = {
+    target: definition.target,
+    rps: overallTotal / actualDurationSec,
+    totalRequests: overallTotal,
+    durationSec: actualDurationSec,
+    p50: overallHistogram.percentile(50) / 1e3,
+    p90: overallHistogram.percentile(90) / 1e3,
+    p95: overallHistogram.percentile(95) / 1e3,
+    p99: overallHistogram.percentile(99) / 1e3,
+    errorRate: overallTotal > 0 ? overallErrTotal / overallTotal : 0,
+    networkErrors: overallNetworkErrors,
+    httpErrors: overallHttpErrors,
+    statusCodes: overallStatusCodes,
+    errorsByType: overallErrorsByType,
+    series: [],
+    selfCheckWarnings: []
+  };
+  return {
+    name: definition.name,
+    target: definition.target,
+    durationSec: actualDurationSec,
+    concurrency,
+    totalJourneys: totalJourneysStarted,
+    completedJourneys,
+    failedJourneys,
+    journeysPerSec: completedJourneys / actualDurationSec,
+    journeyP50: journeyHistogram.percentile(50) / 1e3,
+    journeyP90: journeyHistogram.percentile(90) / 1e3,
+    journeyP95: journeyHistogram.percentile(95) / 1e3,
+    journeyP99: journeyHistogram.percentile(99) / 1e3,
+    steps,
+    overallSummary
+  };
+}
+
+// src/report/scenario-terminal.ts
+import picocolors5 from "picocolors";
+function fmt6(n, d = 1) {
+  return n.toLocaleString("en-US", {
+    minimumFractionDigits: d,
+    maximumFractionDigits: d
+  });
+}
+function pad3(str, len, alignRight = false) {
+  if (str.length >= len) return str.substring(0, len);
+  const diff = len - str.length;
+  return alignRight ? " ".repeat(diff) + str : str + " ".repeat(diff);
+}
+function formatScenarioTerminalReport(summary) {
+  const lines = [];
+  const W = 80;
+  lines.push("");
+  lines.push(picocolors5.bold(picocolors5.cyan("\u2554" + "\u2550".repeat(W) + "\u2557")));
+  lines.push(
+    picocolors5.bold(picocolors5.cyan("\u2551")) + picocolors5.bold(picocolors5.white(pad3(`  \u{1F3AD} LoadScope Scenario Benchmark Results: ${summary.name}`, W))) + picocolors5.bold(picocolors5.cyan("\u2551"))
+  );
+  lines.push(picocolors5.bold(picocolors5.cyan("\u2560" + "\u2550".repeat(W) + "\u2563")));
+  lines.push(
+    picocolors5.bold(picocolors5.cyan("\u2551")) + pad3(`  Target:      ${summary.target}`, W) + picocolors5.bold(picocolors5.cyan("\u2551"))
+  );
+  lines.push(
+    picocolors5.bold(picocolors5.cyan("\u2551")) + pad3(`  Duration:    ${summary.durationSec.toFixed(1)}s  \u2502  Concurrency: ${summary.concurrency} virtual users`, W) + picocolors5.bold(picocolors5.cyan("\u2551"))
+  );
+  const completionPct = summary.totalJourneys > 0 ? summary.completedJourneys / summary.totalJourneys * 100 : 0;
+  const compColor = completionPct >= 99 ? picocolors5.green : completionPct >= 95 ? picocolors5.yellow : picocolors5.red;
+  lines.push(
+    picocolors5.bold(picocolors5.cyan("\u2551")) + pad3(
+      `  Journeys:    ${summary.completedJourneys.toLocaleString("en-US")} completed / ${summary.totalJourneys.toLocaleString("en-US")} started (${compColor(fmt6(completionPct, 1) + "%")})`,
+      W
+    ) + picocolors5.bold(picocolors5.cyan("\u2551"))
+  );
+  lines.push(
+    picocolors5.bold(picocolors5.cyan("\u2551")) + pad3(
+      `  Journey RPS: ${fmt6(summary.journeysPerSec, 1)} journeys/sec  \u2502  Failed: ${summary.failedJourneys}`,
+      W
+    ) + picocolors5.bold(picocolors5.cyan("\u2551"))
+  );
+  lines.push(
+    picocolors5.bold(picocolors5.cyan("\u2551")) + pad3(
+      `  E2E Latency: p50=${fmt6(summary.journeyP50, 1)}ms  p90=${fmt6(summary.journeyP90, 1)}ms  p95=${fmt6(summary.journeyP95, 1)}ms  p99=${fmt6(summary.journeyP99, 1)}ms`,
+      W
+    ) + picocolors5.bold(picocolors5.cyan("\u2551"))
+  );
+  lines.push(picocolors5.bold(picocolors5.cyan("\u2560" + "\u2550".repeat(W) + "\u2563")));
+  lines.push(
+    picocolors5.bold(picocolors5.cyan("\u2551")) + picocolors5.bold(picocolors5.yellow(pad3("  Step-by-Step Waterfall Performance Breakdown:", W))) + picocolors5.bold(picocolors5.cyan("\u2551"))
+  );
+  lines.push(picocolors5.bold(picocolors5.cyan("\u2560" + "\u2550".repeat(W) + "\u2563")));
+  const th = `  ${pad3("#", 3)} ${pad3("Step Name", 28)} ${pad3("Method", 6)} ${pad3("Req/s", 8, true)} ${pad3("p50", 8, true)} ${pad3("p95", 8, true)} ${pad3("p99", 8, true)} ${pad3("Err%", 7, true)}`;
+  lines.push(
+    picocolors5.bold(picocolors5.cyan("\u2551")) + picocolors5.bold(picocolors5.dim(pad3(th, W))) + picocolors5.bold(picocolors5.cyan("\u2551"))
+  );
+  lines.push(
+    picocolors5.bold(picocolors5.cyan("\u2551")) + picocolors5.dim("  " + "\u2500".repeat(W - 4)) + "  " + picocolors5.bold(picocolors5.cyan("\u2551"))
+  );
+  summary.steps.forEach((step, idx) => {
+    const errPct = fmt6(step.errorRate * 100, 1) + "%";
+    const errCol = step.errorRate > 0 ? picocolors5.red : picocolors5.green;
+    const stepName = step.name.length > 28 ? step.name.substring(0, 25) + "..." : step.name;
+    const errPadded = errCol(pad3(errPct, 7, true));
+    const prefix = `  ${pad3(String(idx + 1), 3)} ${pad3(stepName, 28)} ${pad3(step.method, 6)} ${pad3(fmt6(step.rps, 1), 8, true)} ${pad3(fmt6(step.p50, 1) + "ms", 8, true)} ${pad3(fmt6(step.p95, 1) + "ms", 8, true)} ${pad3(fmt6(step.p99, 1) + "ms", 8, true)} `;
+    lines.push(
+      picocolors5.bold(picocolors5.cyan("\u2551")) + prefix + errPadded + "  " + picocolors5.bold(picocolors5.cyan("\u2551"))
+    );
+  });
+  lines.push(picocolors5.bold(picocolors5.cyan("\u255A" + "\u2550".repeat(W) + "\u255D")));
+  lines.push("");
+  return lines.join("\n");
+}
+function printScenarioTerminalReport(summary) {
+  console.log(formatScenarioTerminalReport(summary));
+}
+
+// src/index.ts
+async function run(options) {
+  const validated = validateRunOptions(options);
+  const workerCount = resolveWorkerCount(validated.workers, validated.concurrency);
+  if (workerCount > 1) {
+    return executeMultiThreaded(validated);
+  }
+  if (validated.mode === "open" || validated.rate !== void 0 && validated.rate > 0 && validated.mode !== "closed") {
+    return executeOpenModel(validated);
+  }
+  return executeClosedModel(validated);
+}
+
+export {
+  parseHeaders,
+  executeClosedModel,
+  executeOpenModel,
+  LiveDashboard,
+  executeMultiThreaded,
+  formatTerminalReport,
+  printTerminalReport,
+  formatJsonReport,
+  formatCsvReport,
+  formatBreakpointJsonReport,
+  formatBreakpointCsvReport,
+  formatComparisonJsonReport,
+  formatComparisonCsvReport,
+  runBreakingPoint,
+  formatStepRow,
+  formatBreakpointTerminalReport,
+  printBreakpointTerminalReport,
+  saveBaseline,
+  loadBaseline,
+  compareRuns,
+  formatComparisonTerminalReport,
+  printComparisonTerminalReport,
+  generateGithubStepSummary,
+  writeGithubStepSummary,
+  generatePdfReport,
+  buildAiDiagnosticPrompt,
+  fetchAiDiagnostic,
+  renderHtmlReport,
+  generateHtmlReport,
+  interpolateVariables,
+  extractFromResponse,
+  parseScenario,
+  runScenario,
+  formatScenarioTerminalReport,
+  printScenarioTerminalReport,
+  run
+};
+//# sourceMappingURL=chunk-OFND2NUO.js.map