@flotorch/loadtest 0.1.0

package/dist/index.js

@@ -0,0 +1,2163 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/.pnpm/tsup@8.5.1_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/.pnpm/tsup@8.5.1_tsx@4.21.0_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/generator/tokenizer.ts
+import { encode } from "gpt-tokenizer";
+function countTokens(text) {
+  return encode(text).length;
+}
+var init_tokenizer = __esm({
+  "src/generator/tokenizer.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/generator/file.ts
+var file_exports = {};
+__export(file_exports, {
+  FileGenerator: () => FileGenerator
+});
+import { readFileSync as readFileSync3 } from "fs";
+var FileGenerator;
+var init_file = __esm({
+  "src/generator/file.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_tokenizer();
+    FileGenerator = class {
+      records;
+      constructor(filePath) {
+        const content = readFileSync3(filePath, "utf-8");
+        this.records = content.split("\n").filter((line) => line.trim().length > 0).map((line) => {
+          const parsed = JSON.parse(line);
+          const text = parsed.text ?? parsed.prompt ?? "";
+          return {
+            text,
+            tokenCount: parsed.tokenCount ?? countTokens(text),
+            outputTokenTarget: parsed.outputTokenTarget ?? parsed.max_tokens ?? 256
+          };
+        });
+      }
+      generate(count) {
+        const results = [];
+        for (let i = 0; i < count; i++) {
+          results.push(this.records[i % this.records.length]);
+        }
+        return results;
+      }
+      generateOne(_targetInputTokens, targetOutputTokens) {
+        const record = this.records[Math.floor(Math.random() * this.records.length)];
+        return { ...record, outputTokenTarget: targetOutputTokens };
+      }
+    };
+  }
+});
+
+// src/cli/ui/components/header.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Header({ modelName, maxConcurrency, streaming, totalTarget }) {
+  const targetStr = totalTarget === Infinity ? "\u221E" : String(totalTarget);
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "FLOTorch Load Tester" }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Model: " }),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: modelName }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  Concurrency: " }),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: maxConcurrency }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  Streaming: " }),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: streaming ? "yes" : "no" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  Requests: " }),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: targetStr })
+    ] })
+  ] });
+}
+var init_header = __esm({
+  "src/cli/ui/components/header.tsx"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/ui/components/phase-bar.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function PhaseBar({ phase, activeSlots, allowedConcurrency }) {
+  const color = phaseColors[phase];
+  const barWidth = 20;
+  const filled = allowedConcurrency > 0 ? Math.round(activeSlots / allowedConcurrency * barWidth) : 0;
+  const empty = barWidth - filled;
+  return /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { children: [
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "Phase: " }),
+    /* @__PURE__ */ jsx2(Text2, { color, bold: true, children: "\u25CF " }),
+    /* @__PURE__ */ jsx2(Text2, { color, children: phaseLabels[phase] }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "   Slots: " }),
+    /* @__PURE__ */ jsx2(Text2, { color: "cyan", children: "\u2588".repeat(filled) }),
+    /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: "\u2591".repeat(empty) }),
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      " ",
+      activeSlots,
+      "/",
+      allowedConcurrency
+    ] })
+  ] }) });
+}
+var phaseColors, phaseLabels;
+var init_phase_bar = __esm({
+  "src/cli/ui/components/phase-bar.tsx"() {
+    "use strict";
+    init_esm_shims();
+    phaseColors = {
+      "ramp-up": "yellow",
+      steady: "green",
+      "ramp-down": "magenta"
+    };
+    phaseLabels = {
+      "ramp-up": "Ramp Up",
+      steady: "Steady State",
+      "ramp-down": "Ramp Down"
+    };
+  }
+});
+
+// src/cli/ui/components/progress-bar.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function formatDuration2(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = Math.floor(seconds % 60);
+  return m > 0 ? `${m}m${s.toString().padStart(2, "0")}s` : `${s}s`;
+}
+function ProgressBar({ completed, totalTarget, elapsedMs, rps }) {
+  const barWidth = 30;
+  const isInfinite = totalTarget === Infinity || totalTarget <= 0;
+  const pct = isInfinite ? 0 : Math.min(1, completed / totalTarget);
+  const filled = Math.round(pct * barWidth);
+  const empty = barWidth - filled;
+  const elapsedSec = elapsedMs / 1e3;
+  let eta = "";
+  if (!isInfinite && rps > 0) {
+    const remaining = (totalTarget - completed) / rps;
+    eta = `ETA: ${formatDuration2(remaining)}`;
+  }
+  const targetStr = isInfinite ? "?" : String(totalTarget);
+  const pctStr = isInfinite ? "" : ` (${(pct * 100).toFixed(1)}%)`;
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Progress " }),
+      /* @__PURE__ */ jsx3(Text3, { color: "green", children: "\u2588".repeat(filled) }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2591".repeat(empty) }),
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        " ",
+        completed,
+        "/",
+        targetStr,
+        pctStr
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "Elapsed: ",
+      formatDuration2(elapsedSec),
+      "   ",
+      rps.toFixed(1),
+      " req/s",
+      "   ",
+      eta
+    ] })
+  ] });
+}
+var init_progress_bar = __esm({
+  "src/cli/ui/components/progress-bar.tsx"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/ui/components/stats-panel.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, idx)];
+}
+function mean2(arr) {
+  if (arr.length === 0) return 0;
+  let sum = 0;
+  for (const v of arr) sum += v;
+  return sum / arr.length;
+}
+function fmtMs(ms) {
+  if (ms >= 1e3) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${Math.round(ms)}ms`;
+}
+function StatsPanel({
+  rps,
+  outputTps,
+  inputTps,
+  recentTtft,
+  recentE2eLatency,
+  errors,
+  completed
+}) {
+  const sortedTtft = [...recentTtft].sort((a, b) => a - b);
+  const sortedE2e = [...recentE2eLatency].sort((a, b) => a - b);
+  const errRate = completed > 0 ? (errors / completed * 100).toFixed(1) : "0.0";
+  const labelW = 14;
+  const valW = 10;
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, dimColor: true, children: "Live Stats" }),
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Box4, { width: labelW, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Requests/s" }) }),
+      /* @__PURE__ */ jsx4(Box4, { width: valW, children: /* @__PURE__ */ jsx4(Text4, { bold: true, children: rps.toFixed(1) }) }),
+      /* @__PURE__ */ jsx4(Box4, { width: labelW, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Out tok/s" }) }),
+      /* @__PURE__ */ jsx4(Box4, { width: valW, children: /* @__PURE__ */ jsx4(Text4, { bold: true, children: outputTps.toFixed(0) }) }),
+      /* @__PURE__ */ jsx4(Box4, { width: labelW, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "In tok/s" }) }),
+      /* @__PURE__ */ jsx4(Box4, { width: valW, children: /* @__PURE__ */ jsx4(Text4, { bold: true, children: inputTps.toFixed(0) }) })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Box4, { width: labelW, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "TTFT" }) }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "mean=" }),
+        /* @__PURE__ */ jsx4(Text4, { children: fmtMs(mean2(sortedTtft)) }),
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  p50=" }),
+        /* @__PURE__ */ jsx4(Text4, { children: fmtMs(percentile(sortedTtft, 50)) }),
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  p95=" }),
+        /* @__PURE__ */ jsx4(Text4, { children: fmtMs(percentile(sortedTtft, 95)) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Box4, { width: labelW, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "E2E" }) }),
+      /* @__PURE__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "mean=" }),
+        /* @__PURE__ */ jsx4(Text4, { children: fmtMs(mean2(sortedE2e)) }),
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  p50=" }),
+        /* @__PURE__ */ jsx4(Text4, { children: fmtMs(percentile(sortedE2e, 50)) }),
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "  p95=" }),
+        /* @__PURE__ */ jsx4(Text4, { children: fmtMs(percentile(sortedE2e, 95)) })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Box4, { width: labelW, children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Errors" }) }),
+      /* @__PURE__ */ jsxs4(Text4, { color: errors > 0 ? "red" : void 0, bold: errors > 0, children: [
+        errors,
+        " (",
+        errRate,
+        "%)"
+      ] })
+    ] })
+  ] });
+}
+var init_stats_panel = __esm({
+  "src/cli/ui/components/stats-panel.tsx"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/ui/components/error-panel.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function ErrorPanel({ recentErrors }) {
+  if (recentErrors.length === 0) return null;
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { color: "red", bold: true, children: "Recent Errors:" }),
+    recentErrors.map((err, i) => /* @__PURE__ */ jsxs5(Text5, { color: "red", dimColor: true, children: [
+      "  ",
+      " ",
+      err.length > 80 ? err.slice(0, 77) + "..." : err
+    ] }, i))
+  ] });
+}
+var init_error_panel = __esm({
+  "src/cli/ui/components/error-panel.tsx"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/cli/ui/app.tsx
+var app_exports = {};
+__export(app_exports, {
+  App: () => App
+});
+import { useState, useEffect } from "react";
+import { Box as Box6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function App({ store }) {
+  const [snap, setSnap] = useState(() => store.snapshot());
+  useEffect(() => {
+    const id = setInterval(() => {
+      setSnap(store.snapshot());
+    }, 200);
+    return () => clearInterval(id);
+  }, [store]);
+  const elapsedMs = snap.startTime > 0 ? performance.now() - snap.startTime : 0;
+  const elapsedSec = elapsedMs / 1e3;
+  const rps = elapsedSec > 0 ? snap.completed / elapsedSec : 0;
+  const outputTps = elapsedSec > 0 ? snap.totalOutputTokens / elapsedSec : 0;
+  const inputTps = elapsedSec > 0 ? snap.totalInputTokens / elapsedSec : 0;
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingLeft: 2, children: [
+    /* @__PURE__ */ jsx6(
+      Header,
+      {
+        modelName: snap.modelName,
+        maxConcurrency: snap.maxConcurrency,
+        streaming: snap.streaming,
+        totalTarget: snap.totalTarget
+      }
+    ),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(
+      PhaseBar,
+      {
+        phase: snap.phase,
+        activeSlots: snap.activeSlots,
+        allowedConcurrency: snap.allowedConcurrency
+      }
+    ) }),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, flexDirection: "column", children: /* @__PURE__ */ jsx6(
+      ProgressBar,
+      {
+        completed: snap.completed,
+        totalTarget: snap.totalTarget,
+        elapsedMs,
+        rps
+      }
+    ) }),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(
+      StatsPanel,
+      {
+        rps,
+        outputTps,
+        inputTps,
+        recentTtft: snap.recentTtft,
+        recentE2eLatency: snap.recentE2eLatency,
+        errors: snap.errors,
+        completed: snap.completed
+      }
+    ) }),
+    /* @__PURE__ */ jsx6(ErrorPanel, { recentErrors: snap.recentErrors })
+  ] });
+}
+var init_app = __esm({
+  "src/cli/ui/app.tsx"() {
+    "use strict";
+    init_esm_shims();
+    init_header();
+    init_phase_bar();
+    init_progress_bar();
+    init_stats_panel();
+    init_error_panel();
+  }
+});
+
+// index.ts
+init_esm_shims();
+
+// src/cli/args.ts
+init_esm_shims();
+import { parseArgs } from "util";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+
+// src/schemas/config.zod.ts
+init_esm_shims();
+import { z } from "zod";
+var rampSchema = z.object({
+  requests: z.number().optional(),
+  duration: z.number().optional()
+}).refine((d) => d.requests || d.duration, {
+  message: "At least one of requests or duration required"
+});
+var ConfigSchema = z.object({
+  generator: z.object({
+    enabled: z.boolean().default(false),
+    prompt: z.string().optional(),
+    corpus: z.string().optional()
+  }).default(() => ({ enabled: false })),
+  benchmark: z.object({
+    inputFile: z.string().optional(),
+    outputDir: z.string().default("./results"),
+    inputTokens: z.object({
+      mean: z.number(),
+      stddev: z.number().optional()
+    }),
+    outputTokens: z.object({
+      mean: z.number(),
+      stddev: z.number().optional()
+    }),
+    maxRequests: z.number().optional(),
+    maxDuration: z.number().optional(),
+    timeout: z.number().default(600),
+    concurrency: z.number(),
+    rampUp: rampSchema.optional(),
+    rampDown: rampSchema.optional(),
+    cachePercentage: z.number().min(0).max(100).default(0),
+    streaming: z.boolean().default(true)
+  }).refine((d) => d.maxRequests || d.maxDuration, {
+    message: "At least one of maxRequests or maxDuration required"
+  }),
+  provider: z.object({
+    adapter: z.enum(["openai", "sagemaker"]).default("openai"),
+    model: z.string(),
+    baseURL: z.string().optional(),
+    systemPrompt: z.string().optional(),
+    config: z.record(z.string(), z.any()).optional()
+  }),
+  reporter: z.object({
+    adapters: z.array(z.enum(["json", "csv"])).default(["json"])
+  }).default(() => ({ adapters: ["json"] }))
+});
+function validateEnv(schema, adapterName) {
+  const result = schema.safeParse(process.env);
+  if (!result.success) {
+    const errors = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`Missing/invalid env vars for "${adapterName}" backend:
+${errors}`);
+  }
+  return result.data;
+}
+
+// src/cli/ansi.ts
+init_esm_shims();
+var enabled = process.env.NO_COLOR === void 0 && process.env.TERM !== "dumb" && (process.stdout.isTTY ?? false);
+var wrap = (code, close) => enabled ? (s) => `\x1B[${code}m${s}\x1B[${close}m` : (s) => s;
+var bold = wrap("1", "22");
+var dim = wrap("2", "22");
+var red = wrap("31", "39");
+var green = wrap("32", "39");
+var yellow = wrap("33", "39");
+var cyan = wrap("36", "39");
+var magenta = wrap("35", "39");
+
+// src/cli/args.ts
+var VALID_COMMANDS = /* @__PURE__ */ new Set(["run", "generate", "bench", "report", "init"]);
+var HELP_TEXT = `
+${bold("FLOTorch Load Tester")}
+
+${yellow("USAGE")}
+  flotorch ${dim("<command>")} ${dim("[options]")}
+
+${yellow("COMMANDS")}
+  ${cyan("run")}          ${dim("Run full pipeline: generate \u2192 bench \u2192 report (default)")}
+  ${cyan("generate")}     ${dim("Generate prompts only")}
+  ${cyan("bench")}        ${dim("Run benchmark using existing prompts")}
+  ${cyan("report")}       ${dim("Generate report from existing results")}
+  ${cyan("init")} ${dim("[path]")}  ${dim("Interactively create a config file (default: config.json)")}
+
+${yellow("OPTIONS")}
+  ${cyan("-c, --config")} ${dim("<path>")}   Path to config JSON ${dim("(required for run/generate/bench/report)")}
+  ${cyan("--run-id")} ${dim("<id>")}         Custom run ID ${dim("(default: ISO timestamp)")}
+  ${cyan("-m, --model")} ${dim("<name>")}    Override provider.model
+  ${cyan("-n, --concurrency")} ${dim("<n>")} Override benchmark.concurrency
+  ${cyan("--max-requests")} ${dim("<n>")}    Override benchmark.maxRequests
+  ${cyan("--max-duration")} ${dim("<n>")}    Override benchmark.maxDuration ${dim("(seconds)")}
+  ${cyan("-o, --output-dir")} ${dim("<p>")}  Override benchmark.outputDir
+  ${cyan("--base-url")} ${dim("<url>")}      Override provider.baseURL
+  ${cyan("--streaming")}           Enable streaming
+  ${cyan("--no-streaming")}        Disable streaming
+  ${cyan("-h, --help")}            Show this help message
+`.trimStart();
+function parseCliArgs(argv) {
+  const args = argv.slice(2);
+  let command = "run";
+  if (args.length > 0 && VALID_COMMANDS.has(args[0])) {
+    command = args.shift();
+  }
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      config: { type: "string", short: "c" },
+      "run-id": { type: "string" },
+      model: { type: "string", short: "m" },
+      concurrency: { type: "string", short: "n" },
+      "max-requests": { type: "string" },
+      "max-duration": { type: "string" },
+      "output-dir": { type: "string", short: "o" },
+      "base-url": { type: "string" },
+      streaming: { type: "boolean" },
+      "no-streaming": { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    },
+    allowPositionals: true
+  });
+  if (values.help) {
+    console.log(HELP_TEXT);
+    process.exit(0);
+  }
+  if (command === "init") {
+    const initOutputPath = positionals[0] ?? "config.json";
+    return { command, configPath: "", runId: "", overrides: {}, initOutputPath };
+  }
+  const configPath = values.config;
+  if (!configPath) {
+    throw new Error("--config / -c is required");
+  }
+  const runId = values["run-id"] ?? (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const overrides = collectOverrides(values);
+  return { command, configPath, runId, overrides };
+}
+function resolveConfig(configPath, runId, cliOverrides) {
+  if (!existsSync(configPath)) {
+    throw new Error(`Config file not found: ${configPath}`);
+  }
+  const rawConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+  const benchRaw = rawConfig.benchmark ?? {};
+  const baseOutputDir = benchRaw.outputDir ?? "./results";
+  const outputDir = join(baseOutputDir, runId);
+  const savedOverrides = loadSavedOverrides(outputDir);
+  const merged = deepMerge(rawConfig, savedOverrides, cliOverrides);
+  const combinedOverrides = deepMerge(savedOverrides, cliOverrides);
+  mkdirSync(outputDir, { recursive: true });
+  saveOverrides(outputDir, combinedOverrides);
+  const result = ConfigSchema.safeParse(merged);
+  if (!result.success) {
+    const errors = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
+    throw new Error(`Invalid configuration:
+${errors}`);
+  }
+  writeFileSync(
+    join(outputDir, "config.resolved.json"),
+    JSON.stringify(result.data, null, 2) + "\n"
+  );
+  return { config: result.data, outputDir };
+}
+function collectOverrides(values) {
+  const overrides = {};
+  const benchmark = {};
+  const provider = {};
+  if (values.model) provider.model = values.model;
+  if (values["base-url"]) provider.baseURL = values["base-url"];
+  if (values.concurrency) benchmark.concurrency = Number(values.concurrency);
+  if (values["max-requests"]) benchmark.maxRequests = Number(values["max-requests"]);
+  if (values["max-duration"]) benchmark.maxDuration = Number(values["max-duration"]);
+  if (values["output-dir"]) benchmark.outputDir = values["output-dir"];
+  if (values.streaming === true) benchmark.streaming = true;
+  if (values["no-streaming"] === true) benchmark.streaming = false;
+  if (Object.keys(provider).length > 0) overrides.provider = provider;
+  if (Object.keys(benchmark).length > 0) overrides.benchmark = benchmark;
+  return overrides;
+}
+function loadSavedOverrides(outputDir) {
+  const path2 = join(outputDir, "overrides.json");
+  if (!existsSync(path2)) return {};
+  return JSON.parse(readFileSync(path2, "utf-8"));
+}
+function saveOverrides(outputDir, overrides) {
+  if (Object.keys(overrides).length === 0) return;
+  writeFileSync(join(outputDir, "overrides.json"), JSON.stringify(overrides, null, 2) + "\n");
+}
+function isPlainObject(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+function deepMerge(...sources) {
+  const result = {};
+  for (const source of sources) {
+    for (const key of Object.keys(source)) {
+      if (isPlainObject(result[key]) && isPlainObject(source[key])) {
+        result[key] = deepMerge(
+          result[key],
+          source[key]
+        );
+      } else {
+        result[key] = source[key];
+      }
+    }
+  }
+  return result;
+}
+
+// src/cli/init.ts
+init_esm_shims();
+import { createInterface } from "readline/promises";
+import { writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
+async function prompt(rl, question, defaultValue) {
+  const suffix = defaultValue != null ? ` (${defaultValue})` : "";
+  const answer = (await rl.question(`${question}${suffix}: `)).trim();
+  return answer || defaultValue || "";
+}
+async function runInit(outputPath) {
+  if (existsSync2(outputPath)) {
+    const rl2 = createInterface({ input: process.stdin, output: process.stdout });
+    const overwrite = await prompt(rl2, `${outputPath} already exists. Overwrite? [y/N]`, "n");
+    if (overwrite.toLowerCase() !== "y") {
+      rl2.close();
+      console.log("Aborted.");
+      return;
+    }
+    rl2.close();
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  console.log("\nFLOTorch Load Tester \u2014 Config Generator\n");
+  const adapter = await prompt(rl, "Provider adapter [openai/sagemaker]", "openai");
+  const model = await prompt(rl, "Model name (required)");
+  if (!model) {
+    rl.close();
+    throw new Error("Model name is required");
+  }
+  let baseURL;
+  if (adapter === "openai") {
+    const url = await prompt(rl, "Base URL", "https://api.openai.com/v1");
+    if (url !== "https://api.openai.com/v1") {
+      baseURL = url;
+    }
+  }
+  const concurrency = Number(await prompt(rl, "Concurrency", "10"));
+  const inputMean = Number(await prompt(rl, "Input tokens mean", "512"));
+  const outputMean = Number(await prompt(rl, "Output tokens mean", "256"));
+  const maxRequests = Number(await prompt(rl, "Max requests", "100"));
+  const streamingAnswer = await prompt(rl, "Streaming? [y/n]", "y");
+  const streaming = streamingAnswer.toLowerCase() === "y";
+  rl.close();
+  const config = {
+    provider: {
+      adapter,
+      model,
+      ...baseURL && { baseURL }
+    },
+    benchmark: {
+      concurrency,
+      inputTokens: { mean: inputMean },
+      outputTokens: { mean: outputMean },
+      maxRequests,
+      streaming,
+      outputDir: "./results",
+      timeout: 600,
+      cachePercentage: 0
+    },
+    generator: {
+      enabled: false
+    },
+    reporter: {
+      adapters: ["json"]
+    }
+  };
+  writeFileSync2(outputPath, JSON.stringify(config, null, 2) + "\n");
+  console.log(`
+Config written to ${outputPath}`);
+}
+
+// src/generator/generator.ts
+init_esm_shims();
+
+// src/generator/synthetic.ts
+init_esm_shims();
+init_tokenizer();
+
+// src/utils/random.ts
+init_esm_shims();
+function gaussianRandom(mean3, stddev2) {
+  let u1 = Math.random();
+  const u2 = Math.random();
+  while (u1 === 0) u1 = Math.random();
+  const z4 = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+  return mean3 + z4 * stddev2;
+}
+function clampedGaussian(mean3, stddev2, min, max) {
+  const value = gaussianRandom(mean3, stddev2);
+  return Math.max(min, Math.min(max, Math.round(value)));
+}
+
+// src/generator/synthetic.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/generator/corpus/default.ts
+init_esm_shims();
+var default_default = `Shall I compare thee to a summer's day?
+Thou art more lovely and more temperate:
+Rough winds do shake the darling buds of May,
+And summer's lease hath all too short a date:
+Sometime too hot the eye of heaven shines,
+And often is his gold complexion dimm'd;
+And every fair from fair sometime declines,
+By chance or nature's changing course untrimm'd;
+But thy eternal summer shall not fade
+Nor lose possession of that fair thou owest;
+Nor shall Death brag thou wander'st in his shade,
+When in eternal lines to time thou growest:
+So long as men can breathe or eyes can see,
+So long lives this and this gives life to thee.
+Then let not winter's ragged hand deface
+In thee thy summer, ere thou be distill'd:
+Make sweet some vial; treasure thou some place
+With beauty's treasure, ere it be self-kill'd.
+That use is not forbidden usury,
+Which happies those that pay the willing loan;
+That's for thyself to breed another thee,
+Or ten times happier, be it ten for one;
+Ten times thyself were happier than thou art,
+If ten of thine ten times refigured thee:
+Then what could death do, if thou shouldst depart,
+Leaving thee living in posterity?
+Be not self-will'd, for thou art much too fair
+To be death's conquest and make worms thine heir.
+Where art thou, Muse, that thou forget'st so long
+To speak of that which gives thee all thy might?
+Spend'st thou thy fury on some worthless song,
+Darkening thy power to lend base subjects light?
+Return, forgetful Muse, and straight redeem
+In gentle numbers time so idly spent;
+Sing to the ear that doth thy lays esteem
+And gives thy pen both skill and argument.
+Rise, resty Muse, my love's sweet face survey,
+If Time have any wrinkle graven there;
+If any, be a satire to decay,
+And make Time's spoils despised every where.
+Give my love fame faster than Time wastes life;
+So thou prevent'st his scythe and crooked knife.
+My glass shall not persuade me I am old,
+So long as youth and thou are of one date;
+But when in thee time's furrows I behold,
+Then look I death my days should expiate.
+For all that beauty that doth cover thee
+Is but the seemly raiment of my heart,
+Which in thy breast doth live, as thine in me:
+How can I then be elder than thou art?
+O, therefore, love, be of thyself so wary
+As I, not for myself, but for thee will;
+Bearing thy heart, which I will keep so chary
+As tender nurse her babe from faring ill.
+Presume not on thy heart when mine is slain;
+Thou gavest me thine, not to give back again.
+So am I as the rich, whose blessed key
+Can bring him to his sweet up-locked treasure,
+The which he will not every hour survey,
+For blunting the fine point of seldom pleasure.
+Therefore are feasts so solemn and so rare,
+Since, seldom coming, in the long year set,
+Like stones of worth they thinly placed are,
+Or captain jewels in the carcanet.
+So is the time that keeps you as my chest,
+Or as the wardrobe which the robe doth hide,
+To make some special instant special blest,
+By new unfolding his imprison'd pride.
+Blessed are you, whose worthiness gives scope,
+Being had, to triumph, being lack'd, to hope.
+If there be nothing new, but that which is
+Hath been before, how are our brains beguiled,
+Which, labouring for invention, bear amiss
+The second burden of a former child!
+O, that record could with a backward look,
+Even of five hundred courses of the sun,
+Show me your image in some antique book,
+Since mind at first in character was done!
+That I might see what the old world could say
+To this composed wonder of your frame;
+Whether we are mended, or whether better they,
+Or whether revolution be the same.
+O, sure I am, the wits of former days
+To subjects worse have given admiring praise.`;
+
+// src/generator/synthetic.ts
+var SyntheticGenerator = class {
+  lines;
+  config;
+  constructor(config) {
+    this.config = config;
+    const corpus = config.generator.corpus ? readFileSync2(config.generator.corpus, "utf-8") : default_default;
+    this.lines = corpus.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+  }
+  generate(count) {
+    const records = [];
+    const inputMean = this.config.benchmark.inputTokens.mean;
+    const inputStddev = this.config.benchmark.inputTokens.stddev ?? inputMean * 0.1;
+    const outputMean = this.config.benchmark.outputTokens.mean;
+    const outputStddev = this.config.benchmark.outputTokens.stddev ?? outputMean * 0.1;
+    for (let i = 0; i < count; i++) {
+      const targetInput = clampedGaussian(inputMean, inputStddev, 1, inputMean * 3);
+      const targetOutput = clampedGaussian(outputMean, outputStddev, 1, outputMean * 3);
+      records.push(this.generateOne(targetInput, targetOutput));
+    }
+    return records;
+  }
+  generateOne(targetInputTokens, targetOutputTokens) {
+    const shuffled = [...this.lines].sort(() => Math.random() - 0.5);
+    let text = "";
+    let tokens = 0;
+    let lineIdx = 0;
+    while (tokens < targetInputTokens && lineIdx < shuffled.length) {
+      const candidate = text ? `${text}
+${shuffled[lineIdx]}` : shuffled[lineIdx];
+      const candidateTokens = countTokens(candidate);
+      if (candidateTokens > targetInputTokens && text.length > 0) break;
+      text = candidate;
+      tokens = candidateTokens;
+      lineIdx++;
+    }
+    while (tokens < targetInputTokens) {
+      const line = shuffled[lineIdx % shuffled.length];
+      const candidate = `${text}
+${line}`;
+      const candidateTokens = countTokens(candidate);
+      if (candidateTokens > targetInputTokens * 1.1) break;
+      text = candidate;
+      tokens = candidateTokens;
+      lineIdx++;
+    }
+    const suffix = this.config.generator.prompt ?? "";
+    const header = `Randomly stream lines from the following text with ${targetOutputTokens} output tokens. Don't generate eos tokens:
+
+`;
+    const fullText = header + text + (suffix ? `
+${suffix}` : "");
+    const finalTokens = countTokens(fullText);
+    return {
+      text: fullText,
+      tokenCount: finalTokens,
+      outputTokenTarget: targetOutputTokens
+    };
+  }
+};
+
+// src/generator/generator.ts
+init_file();
+function createGenerator(config) {
+  if (config.generator.enabled) {
+    return new SyntheticGenerator(config);
+  }
+  if (config.benchmark.inputFile) {
+    return new FileGenerator(config.benchmark.inputFile);
+  }
+  return new SyntheticGenerator(config);
+}
+
+// src/runner/backend.ts
+init_esm_shims();
+
+// src/runner/backends/openai.ts
+init_esm_shims();
+init_tokenizer();
+import { z as z2 } from "zod";
+var EnvSchema = z2.object({
+  OPENAI_API_KEY: z2.string().min(1, "OPENAI_API_KEY is required")
+});
+var OpenAIBackend = class _OpenAIBackend {
+  name = "openai";
+  url;
+  apiKey;
+  static create(baseURL) {
+    const env = validateEnv(EnvSchema, "openai");
+    const url = baseURL ?? "https://api.openai.com/v1";
+    return new _OpenAIBackend(url, env.OPENAI_API_KEY);
+  }
+  constructor(baseURL, apiKey) {
+    this.url = baseURL.endsWith("/chat/completions") ? baseURL : `${baseURL.replace(/\/+$/, "")}/chat/completions`;
+    this.apiKey = apiKey;
+  }
+  async request(prompt2, model, maxTokens, systemPrompt, params, streaming, signal) {
+    const messages = [];
+    if (systemPrompt) {
+      messages.push({ role: "system", content: systemPrompt });
+    }
+    messages.push({ role: "user", content: prompt2 });
+    const body = {
+      model,
+      messages,
+      stream: streaming,
+      ...params
+    };
+    if (body.max_tokens && this.isOpenAIHost()) {
+      body.max_completion_tokens = body.max_tokens;
+      delete body.max_tokens;
+    }
+    const response = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      const error = new Error(`HTTP ${response.status}: ${text}`);
+      error.code = String(response.status);
+      throw error;
+    }
+    if (streaming) {
+      return this.parseStream(response);
+    }
+    return this.parseResponse(response);
+  }
+  isOpenAIHost() {
+    return this.url.includes("api.openai.com");
+  }
+  async parseStream(response) {
+    const body = response.body;
+    if (!body) throw new Error("No response body");
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let generatedText = "";
+    let ttftMs = 0;
+    const requestStart = performance.now();
+    let lastChunkTime = requestStart;
+    const interTokenLatencies = [];
+    let firstToken = true;
+    let outputTokens = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop();
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (data === "[DONE]") continue;
+          let chunk;
+          try {
+            chunk = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          const content = chunk.choices?.[0]?.delta?.content;
+          if (content) {
+            const now = performance.now();
+            if (firstToken) {
+              ttftMs = now - requestStart;
+              firstToken = false;
+            } else {
+              interTokenLatencies.push(now - lastChunkTime);
+            }
+            lastChunkTime = now;
+            generatedText += content;
+          }
+          if (chunk.usage?.completion_tokens) {
+            outputTokens = chunk.usage.completion_tokens;
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (outputTokens === 0) {
+      outputTokens = countTokens(generatedText);
+    }
+    return { generatedText, outputTokens, ttftMs, interTokenLatencies };
+  }
+  async parseResponse(response) {
+    const requestStart = performance.now();
+    const json = await response.json();
+    const ttftMs = performance.now() - requestStart;
+    const generatedText = json.choices?.[0]?.message?.content ?? "";
+    const outputTokens = json.usage?.completion_tokens ?? countTokens(generatedText);
+    return { generatedText, outputTokens, ttftMs, interTokenLatencies: [] };
+  }
+};
+
+// src/runner/backends/sagemaker.ts
+init_esm_shims();
+init_tokenizer();
+import { z as z3 } from "zod";
+import { SignatureV4 } from "@smithy/signature-v4";
+import { Hash } from "@smithy/hash-node";
+import { HttpRequest } from "@smithy/protocol-http";
+var EnvSchema2 = z3.object({
+  AWS_REGION: z3.string().default("us-east-1"),
+  AWS_ACCESS_KEY_ID: z3.string().min(1, "AWS_ACCESS_KEY_ID is required"),
+  AWS_SECRET_ACCESS_KEY: z3.string().min(1, "AWS_SECRET_ACCESS_KEY is required"),
+  AWS_SESSION_TOKEN: z3.string().optional()
+});
+var Sha256Hash = class extends Hash {
+  constructor(secret) {
+    super("sha256", secret);
+  }
+};
+var SageMakerBackend = class _SageMakerBackend {
+  name = "sagemaker";
+  signer;
+  baseURL;
+  requestFormat;
+  static create(baseURL, requestFormat) {
+    const env = validateEnv(EnvSchema2, "sagemaker");
+    const region = env.AWS_REGION;
+    return new _SageMakerBackend({
+      region,
+      accessKeyId: env.AWS_ACCESS_KEY_ID,
+      secretAccessKey: env.AWS_SECRET_ACCESS_KEY,
+      sessionToken: env.AWS_SESSION_TOKEN,
+      baseURL,
+      requestFormat
+    });
+  }
+  constructor(config) {
+    this.baseURL = config.baseURL ?? `https://runtime.sagemaker.${config.region}.amazonaws.com`;
+    this.requestFormat = config.requestFormat ?? "sagemaker" /* Sagemaker */;
+    this.signer = new SignatureV4({
+      service: "sagemaker",
+      region: config.region,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+        sessionToken: config.sessionToken
+      },
+      sha256: Sha256Hash
+    });
+  }
+  async request(prompt2, model, maxTokens, systemPrompt, params, streaming, signal) {
+    const path2 = streaming ? `/endpoints/${model}/invocations-response-stream` : `/endpoints/${model}/invocations`;
+    const body = this.buildRequestBody(prompt2, maxTokens, systemPrompt, params, streaming);
+    const bodyStr = JSON.stringify(body);
+    const url = new URL(path2, this.baseURL);
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (streaming) {
+      headers["X-Amzn-SageMaker-InferenceComponent-Inference-Code-Accepts"] = "application/jsonlines";
+    }
+    const httpRequest = new HttpRequest({
+      method: "POST",
+      protocol: url.protocol,
+      hostname: url.hostname,
+      port: url.port ? Number(url.port) : void 0,
+      path: url.pathname,
+      headers,
+      body: bodyStr
+    });
+    const signed = await this.signer.sign(httpRequest);
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: signed.headers,
+      body: bodyStr,
+      signal
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      const error = new Error(`HTTP ${response.status}: ${text}`);
+      error.code = String(response.status);
+      throw error;
+    }
+    if (streaming) {
+      return this.parseEventStream(response);
+    }
+    return this.parseResponse(response);
+  }
+  buildRequestBody(prompt2, maxTokens, systemPrompt, params, streaming) {
+    const messages = [];
+    if (systemPrompt) messages.push({ role: "system", content: systemPrompt });
+    messages.push({ role: "user", content: prompt2 });
+    if (this.requestFormat === "openai" /* OpenAI */) {
+      return {
+        messages,
+        max_tokens: maxTokens,
+        stream: streaming,
+        ...params
+      };
+    }
+    return {
+      inputs: [messages],
+      parameters: {
+        max_new_tokens: maxTokens,
+        ...params
+      }
+    };
+  }
+  // ---- Streaming: eventstream binary parser ----
+  async parseEventStream(response) {
+    const body = response.body;
+    if (!body) throw new Error("No response body");
+    const reader = body.getReader();
+    let buffer = new Uint8Array(0);
+    let generatedText = "";
+    let ttftMs = 0;
+    const requestStart = performance.now();
+    let lastChunkTime = requestStart;
+    const interTokenLatencies = [];
+    let firstToken = true;
+    let outputTokens = 0;
+    let sseBuffer = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer = concatBytes(buffer, value);
+        while (true) {
+          const parsed = readEventStreamMessage(buffer);
+          if (!parsed) break;
+          const { message, bytesConsumed } = parsed;
+          buffer = buffer.slice(bytesConsumed);
+          if (message.headers[":message-type"] === "exception") {
+            const errText = new TextDecoder().decode(message.payload);
+            throw new Error(
+              `SageMaker stream exception (${message.headers[":event-type"]}): ${errText}`
+            );
+          }
+          if (message.headers[":event-type"] !== "PayloadPart") continue;
+          const payloadText = new TextDecoder().decode(message.payload);
+          const now = performance.now();
+          if (this.requestFormat === "openai" /* OpenAI */) {
+            sseBuffer += payloadText;
+            const lines = sseBuffer.split("\n");
+            sseBuffer = lines.pop();
+            for (const line of lines) {
+              const trimmed = line.trim();
+              if (!trimmed.startsWith("data: ")) continue;
+              const data = trimmed.slice(6);
+              if (data === "[DONE]") continue;
+              let chunk;
+              try {
+                chunk = JSON.parse(data);
+              } catch {
+                continue;
+              }
+              const content = chunk.choices?.[0]?.delta?.content;
+              if (content) {
+                if (firstToken) {
+                  ttftMs = now - requestStart;
+                  firstToken = false;
+                } else {
+                  interTokenLatencies.push(now - lastChunkTime);
+                }
+                lastChunkTime = now;
+                generatedText += content;
+              }
+              if (chunk.usage?.completion_tokens) {
+                outputTokens = chunk.usage.completion_tokens;
+              }
+            }
+          } else {
+            const jsonLines = payloadText.split("\n").filter((l) => l.trim());
+            for (const jsonLine of jsonLines) {
+              let chunk;
+              try {
+                chunk = JSON.parse(jsonLine);
+              } catch {
+                continue;
+              }
+              const tokenText = chunk.token?.text;
+              if (tokenText) {
+                if (firstToken) {
+                  ttftMs = now - requestStart;
+                  firstToken = false;
+                } else {
+                  interTokenLatencies.push(now - lastChunkTime);
+                }
+                lastChunkTime = now;
+                generatedText += tokenText;
+              } else if (typeof chunk.generated_text === "string" && !generatedText) {
+                generatedText = chunk.generated_text;
+              }
+              const details = chunk.details;
+              if (details?.generated_tokens) {
+                outputTokens = details.generated_tokens;
+              }
+            }
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (outputTokens === 0) {
+      outputTokens = countTokens(generatedText);
+    }
+    return { generatedText, outputTokens, ttftMs, interTokenLatencies };
+  }
+  // ---- Non-streaming ----
+  async parseResponse(response) {
+    const requestStart = performance.now();
+    const json = await response.json();
+    const ttftMs = performance.now() - requestStart;
+    let generatedText = "";
+    let outputTokens = 0;
+    if (this.requestFormat === "openai" /* OpenAI */) {
+      const data = json;
+      generatedText = data.choices?.[0]?.message?.content ?? "";
+      outputTokens = data.usage?.completion_tokens ?? 0;
+    } else {
+      if (Array.isArray(json)) {
+        generatedText = json[0]?.generated_text ?? "";
+      } else {
+        const data = json;
+        generatedText = data.generated_text ?? "";
+      }
+    }
+    if (outputTokens === 0) {
+      outputTokens = countTokens(generatedText);
+    }
+    return {
+      generatedText,
+      outputTokens,
+      ttftMs,
+      interTokenLatencies: []
+    };
+  }
+};
+function concatBytes(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a, 0);
+  out.set(b, a.length);
+  return out;
+}
+function readEventStreamMessage(buf) {
+  if (buf.length < 16) return null;
+  const view = new DataView(buf.buffer, buf.byteOffset);
+  const totalLength = view.getUint32(0);
+  const headersLength = view.getUint32(4);
+  if (buf.length < totalLength) return null;
+  const headers = {};
+  let offset = 12;
+  const headersEnd = 12 + headersLength;
+  while (offset < headersEnd) {
+    const nameLen = buf[offset];
+    offset++;
+    const name = new TextDecoder().decode(buf.slice(offset, offset + nameLen));
+    offset += nameLen;
+    const valueType = buf[offset];
+    offset++;
+    if (valueType === 7) {
+      const valueLen = new DataView(buf.buffer, buf.byteOffset + offset).getUint16(0);
+      offset += 2;
+      headers[name] = new TextDecoder().decode(buf.slice(offset, offset + valueLen));
+      offset += valueLen;
+    } else {
+      break;
+    }
+  }
+  const payloadLength = totalLength - headersLength - 16;
+  const payloadOffset = 12 + headersLength;
+  const payload = buf.slice(payloadOffset, payloadOffset + payloadLength);
+  return { message: { headers, payload }, bytesConsumed: totalLength };
+}
+
+// src/runner/backend.ts
+function createBackend(config) {
+  const { adapter, baseURL } = config.provider;
+  switch (adapter) {
+    case "openai":
+      return OpenAIBackend.create(baseURL);
+    case "sagemaker": {
+      const requestFormat = config.provider.config?.["requestFormat"] ?? "sagemaker" /* Sagemaker */;
+      return SageMakerBackend.create(baseURL, requestFormat);
+    }
+    default:
+      throw new Error(`Unknown backend adapter: ${adapter}`);
+  }
+}
+
+// src/runner/orchestrator.ts
+init_esm_shims();
+
+// src/runner/phase.ts
+init_esm_shims();
+var PhaseController = class {
+  maxConcurrency;
+  rampUpRequests;
+  rampUpDuration;
+  rampDownRequests;
+  rampDownDuration;
+  startTime = 0;
+  completedRequests = 0;
+  totalRequests;
+  maxDuration;
+  constructor(config) {
+    this.maxConcurrency = config.benchmark.concurrency;
+    this.rampUpRequests = config.benchmark.rampUp?.requests ?? 0;
+    this.rampUpDuration = (config.benchmark.rampUp?.duration ?? 0) * 1e3;
+    this.rampDownRequests = config.benchmark.rampDown?.requests ?? 0;
+    this.rampDownDuration = (config.benchmark.rampDown?.duration ?? 0) * 1e3;
+    this.totalRequests = config.benchmark.maxRequests ?? Infinity;
+    this.maxDuration = (config.benchmark.maxDuration ?? Infinity) * 1e3;
+  }
+  start() {
+    this.startTime = performance.now();
+  }
+  recordCompletion() {
+    this.completedRequests++;
+  }
+  get phase() {
+    const elapsed = performance.now() - this.startTime;
+    const remaining = this.totalRequests - this.completedRequests;
+    if (this.rampUpDuration > 0 && elapsed < this.rampUpDuration) {
+      return "ramp-up";
+    }
+    if (this.rampUpRequests > 0 && this.completedRequests < this.rampUpRequests) {
+      return "ramp-up";
+    }
+    if (this.rampDownDuration > 0) {
+      const timeUntilEnd = this.maxDuration - elapsed;
+      if (timeUntilEnd <= this.rampDownDuration) return "ramp-down";
+    }
+    if (this.rampDownRequests > 0 && remaining <= this.rampDownRequests) {
+      return "ramp-down";
+    }
+    return "steady";
+  }
+  get allowedConcurrency() {
+    const currentPhase = this.phase;
+    const elapsed = performance.now() - this.startTime;
+    if (currentPhase === "ramp-up") {
+      let progress;
+      if (this.rampUpDuration > 0) {
+        progress = Math.min(1, elapsed / this.rampUpDuration);
+      } else {
+        progress = Math.min(1, this.completedRequests / this.rampUpRequests);
+      }
+      return Math.max(1, Math.ceil(progress * this.maxConcurrency));
+    }
+    if (currentPhase === "ramp-down") {
+      let progress;
+      if (this.rampDownDuration > 0) {
+        const timeUntilEnd = this.maxDuration - elapsed;
+        progress = Math.max(0, timeUntilEnd / this.rampDownDuration);
+      } else {
+        const remaining = this.totalRequests - this.completedRequests;
+        progress = Math.max(0, remaining / this.rampDownRequests);
+      }
+      return Math.max(1, Math.ceil(progress * this.maxConcurrency));
+    }
+    return this.maxConcurrency;
+  }
+  shouldStop(aborted) {
+    if (aborted) return true;
+    if (this.completedRequests >= this.totalRequests) return true;
+    const elapsed = performance.now() - this.startTime;
+    if (elapsed >= this.maxDuration) return true;
+    return false;
+  }
+};
+
+// src/runner/wal.ts
+init_esm_shims();
+import { appendFileSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join2 } from "path";
+var WAL = class {
+  logPath;
+  responsesDir;
+  constructor(outputDir) {
+    this.logPath = join2(outputDir, "run_log.jsonl");
+    this.responsesDir = join2(outputDir, "individual_responses");
+    mkdirSync2(this.responsesDir, { recursive: true });
+  }
+  write(metrics) {
+    appendFileSync(this.logPath, JSON.stringify(metrics) + "\n");
+    writeFileSync3(
+      join2(this.responsesDir, `${metrics.requestId}.json`),
+      JSON.stringify(metrics, null, 2)
+    );
+  }
+  static readLog(outputDir) {
+    const logPath = join2(outputDir, "run_log.jsonl");
+    const content = __require("fs").readFileSync(logPath, "utf-8");
+    return content.split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+  }
+};
+
+// src/runner/request.ts
+init_esm_shims();
+async function executeRequest(backend, prompt2, config, requestId, phase, cacheHit, signal) {
+  const startTime = performance.now();
+  try {
+    const timeoutMs = config.benchmark.timeout * 1e3;
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const combinedSignal = AbortSignal.any([signal, timeoutSignal]);
+    const response = await backend.request(
+      prompt2.text,
+      config.provider.model,
+      prompt2.outputTokenTarget,
+      config.provider.systemPrompt,
+      config.provider.config,
+      config.benchmark.streaming,
+      combinedSignal
+    );
+    const endTime = performance.now();
+    const e2eLatencyMs = endTime - startTime;
+    return {
+      requestId,
+      startTime,
+      endTime,
+      ttftMs: response.ttftMs,
+      e2eLatencyMs,
+      interTokenLatencies: response.interTokenLatencies,
+      inputText: prompt2.text,
+      inputTokens: prompt2.tokenCount,
+      outputTokens: response.outputTokens,
+      outputThroughputTps: e2eLatencyMs > 0 ? response.outputTokens / (e2eLatencyMs / 1e3) : 0,
+      generatedText: response.generatedText,
+      phase,
+      cacheHit
+    };
+  } catch (error) {
+    const endTime = performance.now();
+    return {
+      requestId,
+      startTime,
+      endTime,
+      ttftMs: 0,
+      e2eLatencyMs: endTime - startTime,
+      interTokenLatencies: [],
+      inputText: prompt2.text,
+      inputTokens: prompt2.tokenCount,
+      outputTokens: 0,
+      outputThroughputTps: 0,
+      generatedText: "",
+      error: error instanceof Error ? error.message : String(error),
+      errorCode: error instanceof Error && "code" in error ? String(error.code) : void 0,
+      phase,
+      cacheHit
+    };
+  }
+}
+
+// src/runner/orchestrator.ts
+var ConcurrencyOrchestrator = class {
+  config;
+  backend;
+  prompts;
+  wal;
+  phaseController;
+  promptIndex = 0;
+  completedRequests = 0;
+  activeSlots = 0;
+  results = [];
+  aborted = false;
+  onProgress;
+  constructor(config, backend, prompts, outputDir, onProgress) {
+    this.config = config;
+    this.backend = backend;
+    this.prompts = prompts;
+    this.wal = new WAL(outputDir);
+    this.phaseController = new PhaseController(config);
+    this.onProgress = onProgress;
+  }
+  abort() {
+    this.aborted = true;
+  }
+  async run(signal) {
+    this.phaseController.start();
+    const maxConcurrency = this.config.benchmark.concurrency;
+    const workers = Array.from({ length: maxConcurrency }, (_, i) => this.workerLoop(i, signal));
+    await Promise.allSettled(workers);
+    return this.results;
+  }
+  async workerLoop(slotId, signal) {
+    while (!this.phaseController.shouldStop(this.aborted || signal.aborted)) {
+      if (slotId >= this.phaseController.allowedConcurrency) {
+        await sleep(50);
+        continue;
+      }
+      const prompt2 = this.getNextPrompt();
+      if (!prompt2) break;
+      this.activeSlots++;
+      const requestId = crypto.randomUUID();
+      const phase = this.phaseController.phase;
+      const cacheHit = this.isCacheHit();
+      const metrics = await executeRequest(
+        this.backend,
+        prompt2,
+        this.config,
+        requestId,
+        phase,
+        cacheHit,
+        signal
+      );
+      this.results.push(metrics);
+      this.wal.write(metrics);
+      this.completedRequests++;
+      this.phaseController.recordCompletion();
+      this.onProgress?.(
+        metrics,
+        this.activeSlots,
+        this.completedRequests,
+        this.phaseController.phase,
+        this.phaseController.allowedConcurrency
+      );
+      this.activeSlots--;
+    }
+  }
+  getNextPrompt() {
+    if (this.prompts.length === 0) return null;
+    const maxReqs = this.config.benchmark.maxRequests ?? Infinity;
+    if (this.promptIndex >= maxReqs) return null;
+    const prompt2 = this.prompts[this.promptIndex % this.prompts.length];
+    this.promptIndex++;
+    return prompt2;
+  }
+  isCacheHit() {
+    const pct = this.config.benchmark.cachePercentage;
+    if (pct <= 0) return false;
+    return Math.random() * 100 < pct;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/reporter/aggregator.ts
+init_esm_shims();
+
+// src/reporter/statistics.ts
+init_esm_shims();
+function mean(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+function stddev(values) {
+  if (values.length < 2) return 0;
+  const m = mean(values);
+  const variance = values.reduce((acc, v) => acc + (v - m) ** 2, 0) / (values.length - 1);
+  return Math.sqrt(variance);
+}
+function quantile(sorted, q) {
+  if (sorted.length === 0) return 0;
+  const pos = (sorted.length - 1) * q;
+  const lower = Math.floor(pos);
+  const upper = Math.ceil(pos);
+  if (lower === upper) return sorted[lower];
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (pos - lower);
+}
+function aggregate(values) {
+  const sorted = [...values].sort((a, b) => a - b);
+  return {
+    mean: mean(values),
+    min: sorted[0] ?? 0,
+    max: sorted[sorted.length - 1] ?? 0,
+    stddev: stddev(values),
+    p25: quantile(sorted, 0.25),
+    p50: quantile(sorted, 0.5),
+    p75: quantile(sorted, 0.75),
+    p90: quantile(sorted, 0.9),
+    p95: quantile(sorted, 0.95),
+    p99: quantile(sorted, 0.99)
+  };
+}
+
+// src/reporter/aggregator.ts
+function computeSummary(requests) {
+  const successful = requests.filter((r) => !r.error);
+  const failed = requests.filter((r) => !!r.error);
+  const startTime = Math.min(...requests.map((r) => r.startTime));
+  const endTime = Math.max(...requests.map((r) => r.endTime));
+  const durationMs = endTime - startTime;
+  const durationMin = durationMs / 6e4;
+  const totalOutputTokens = successful.reduce((sum, r) => sum + r.outputTokens, 0);
+  const errorCodeFrequency = {};
+  for (const r of failed) {
+    const code = r.errorCode ?? "unknown";
+    errorCodeFrequency[code] = (errorCodeFrequency[code] ?? 0) + 1;
+  }
+  const cacheHits = requests.filter((r) => r.cacheHit).length;
+  const phases = ["ramp-up", "steady", "ramp-down"];
+  const phaseBreakdown = {};
+  for (const phase of phases) {
+    const phaseReqs = requests.filter((r) => r.phase === phase);
+    if (phaseReqs.length > 0) {
+      const phaseErrors = phaseReqs.filter((r) => !!r.error).length;
+      phaseBreakdown[phase] = {
+        requests: phaseReqs.length,
+        errorRate: phaseErrors / phaseReqs.length
+      };
+    }
+  }
+  const ttfntValues = successful.map((r) => r.ttfntMs).filter((v) => v !== void 0 && v > 0);
+  const itlValues = successful.flatMap((r) => r.interTokenLatencies);
+  return {
+    startTime,
+    endTime,
+    totalRequests: requests.length,
+    successfulRequests: successful.length,
+    failedRequests: failed.length,
+    errorRate: requests.length > 0 ? failed.length / requests.length : 0,
+    rpm: durationMin > 0 ? requests.length / durationMin : 0,
+    overallTps: durationMs > 0 ? totalOutputTokens / (durationMs / 1e3) : 0,
+    ttft: aggregate(successful.map((r) => r.ttftMs)),
+    ttfnt: ttfntValues.length > 0 ? aggregate(ttfntValues) : void 0,
+    e2eLatency: aggregate(successful.map((r) => r.e2eLatencyMs)),
+    outputThroughput: aggregate(successful.map((r) => r.outputThroughputTps)),
+    interTokenLatency: aggregate(itlValues),
+    inputTokens: aggregate(successful.map((r) => r.inputTokens)),
+    outputTokens: aggregate(successful.map((r) => r.outputTokens)),
+    errorCodeFrequency,
+    cacheHitRate: requests.length > 0 ? cacheHits / requests.length : 0,
+    phaseBreakdown
+  };
+}
+
+// src/reporter/exporter.ts
+init_esm_shims();
+
+// src/reporter/exporters/json.ts
+init_esm_shims();
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join3 } from "path";
+var JsonExporter = class {
+  name = "json";
+  async export(summary, _requests, outputDir) {
+    mkdirSync3(outputDir, { recursive: true });
+    writeFileSync4(join3(outputDir, "summary.json"), JSON.stringify(summary, null, 2));
+  }
+};
+
+// src/reporter/exporters/csv.ts
+init_esm_shims();
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4 } from "fs";
+import { join as join4 } from "path";
+var CsvExporter = class {
+  name = "csv";
+  async export(summary, requests, outputDir) {
+    mkdirSync4(outputDir, { recursive: true });
+    this.writeSummary(summary, outputDir);
+    this.writeRequests(requests, outputDir);
+  }
+  writeSummary(summary, outputDir) {
+    const metricFields = [
+      "ttft",
+      "e2eLatency",
+      "outputThroughput",
+      "interTokenLatency",
+      "inputTokens",
+      "outputTokens"
+    ];
+    const statFields = [
+      "mean",
+      "min",
+      "max",
+      "stddev",
+      "p25",
+      "p50",
+      "p75",
+      "p90",
+      "p95",
+      "p99"
+    ];
+    const headers = [
+      "totalRequests",
+      "successfulRequests",
+      "failedRequests",
+      "errorRate",
+      "rpm",
+      "overallTps",
+      "cacheHitRate"
+    ];
+    const values = [
+      summary.totalRequests,
+      summary.successfulRequests,
+      summary.failedRequests,
+      summary.errorRate,
+      summary.rpm,
+      summary.overallTps,
+      summary.cacheHitRate
+    ];
+    for (const metric of metricFields) {
+      const agg = summary[metric];
+      for (const stat of statFields) {
+        headers.push(`${metric}_${stat}`);
+        values.push(agg[stat]);
+      }
+    }
+    const csv = [headers.join(","), values.join(",")].join("\n");
+    writeFileSync5(join4(outputDir, "summary.csv"), csv);
+  }
+  writeRequests(requests, outputDir) {
+    if (requests.length === 0) return;
+    const headers = [
+      "requestId",
+      "startTime",
+      "endTime",
+      "ttftMs",
+      "e2eLatencyMs",
+      "inputTokens",
+      "outputTokens",
+      "outputThroughputTps",
+      "phase",
+      "cacheHit",
+      "error",
+      "errorCode"
+    ];
+    const rows = requests.map(
+      (r) => [
+        r.requestId,
+        r.startTime,
+        r.endTime,
+        r.ttftMs,
+        r.e2eLatencyMs,
+        r.inputTokens,
+        r.outputTokens,
+        r.outputThroughputTps,
+        r.phase,
+        r.cacheHit,
+        r.error ?? "",
+        r.errorCode ?? ""
+      ].join(",")
+    );
+    const csv = [headers.join(","), ...rows].join("\n");
+    writeFileSync5(join4(outputDir, "requests.csv"), csv);
+  }
+};
+
+// src/reporter/exporter.ts
+function createExporters(config) {
+  const adapters = config.reporter.adapters;
+  const exporters = [];
+  for (const adapter of adapters) {
+    switch (adapter) {
+      case "json":
+        exporters.push(new JsonExporter());
+        break;
+      case "csv":
+        exporters.push(new CsvExporter());
+        break;
+    }
+  }
+  return exporters;
+}
+
+// src/utils/signal.ts
+init_esm_shims();
+function createAbortController() {
+  const controller = new AbortController();
+  const shutdownCallbacks = [];
+  let shutdownCount = 0;
+  const handler = () => {
+    shutdownCount++;
+    if (shutdownCount === 1) {
+      console.log("\nGraceful shutdown initiated... (press Ctrl+C again to force)");
+      controller.abort();
+      for (const cb of shutdownCallbacks) cb();
+    } else {
+      process.exit(1);
+    }
+  };
+  process.on("SIGINT", handler);
+  process.on("SIGTERM", handler);
+  return {
+    controller,
+    onShutdown: (fn) => shutdownCallbacks.push(fn)
+  };
+}
+
+// src/cli/progress.ts
+init_esm_shims();
+
+// src/cli/ui/store.ts
+init_esm_shims();
+var ROLLING_CAP = 50;
+var BenchmarkStore = class {
+  phase = "steady";
+  stage = "idle";
+  activeSlots = 0;
+  allowedConcurrency = 0;
+  maxConcurrency;
+  completed = 0;
+  totalTarget;
+  errors = 0;
+  totalOutputTokens = 0;
+  totalInputTokens = 0;
+  startTime = 0;
+  recentTtft = [];
+  recentE2eLatency = [];
+  recentErrors = [];
+  modelName;
+  streaming;
+  constructor(opts) {
+    this.totalTarget = opts.totalTarget;
+    this.maxConcurrency = opts.maxConcurrency;
+    this.modelName = opts.modelName;
+    this.streaming = opts.streaming;
+  }
+  update(metrics, activeSlots, completed, phase, allowedConcurrency) {
+    this.activeSlots = activeSlots;
+    this.completed = completed;
+    this.phase = phase;
+    this.allowedConcurrency = allowedConcurrency;
+    this.totalOutputTokens += metrics.outputTokens;
+    this.totalInputTokens += metrics.inputTokens;
+    if (metrics.error) {
+      this.errors++;
+      if (this.recentErrors.length >= 5) this.recentErrors.shift();
+      this.recentErrors.push(metrics.error);
+    }
+    if (!metrics.error) {
+      if (this.recentTtft.length >= ROLLING_CAP) this.recentTtft.shift();
+      this.recentTtft.push(metrics.ttftMs);
+      if (this.recentE2eLatency.length >= ROLLING_CAP) this.recentE2eLatency.shift();
+      this.recentE2eLatency.push(metrics.e2eLatencyMs);
+    }
+  }
+  setStage(stage) {
+    this.stage = stage;
+  }
+  setStartTime(t) {
+    this.startTime = t;
+  }
+  snapshot() {
+    return {
+      phase: this.phase,
+      stage: this.stage,
+      activeSlots: this.activeSlots,
+      allowedConcurrency: this.allowedConcurrency,
+      maxConcurrency: this.maxConcurrency,
+      completed: this.completed,
+      totalTarget: this.totalTarget,
+      errors: this.errors,
+      totalOutputTokens: this.totalOutputTokens,
+      totalInputTokens: this.totalInputTokens,
+      startTime: this.startTime,
+      recentTtft: [...this.recentTtft],
+      recentE2eLatency: [...this.recentE2eLatency],
+      recentErrors: [...this.recentErrors],
+      modelName: this.modelName,
+      streaming: this.streaming
+    };
+  }
+};
+
+// src/cli/ui/fallback.ts
+init_esm_shims();
+function formatDuration(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = Math.floor(seconds % 60);
+  return m > 0 ? `${m}m${s.toString().padStart(2, "0")}s` : `${s}s`;
+}
+var FallbackDisplay = class {
+  store;
+  intervalId = null;
+  constructor(store) {
+    this.store = store;
+  }
+  start() {
+    this.intervalId = setInterval(() => this.print(), 2e3);
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.print();
+  }
+  print() {
+    const s = this.store;
+    const elapsed = s.startTime > 0 ? (performance.now() - s.startTime) / 1e3 : 0;
+    const rps = elapsed > 0 ? s.completed / elapsed : 0;
+    const tps = elapsed > 0 ? s.totalOutputTokens / elapsed : 0;
+    const isInfinite = s.totalTarget === Infinity;
+    const totalStr = isInfinite ? "?" : String(s.totalTarget);
+    const pct = isInfinite ? 0 : Math.min(1, s.completed / s.totalTarget);
+    const pctStr = isInfinite ? "" : ` (${(pct * 100).toFixed(1)}%)`;
+    const barWidth = 20;
+    const filled = Math.round(pct * barWidth);
+    const bar = "=".repeat(filled) + ".".repeat(barWidth - filled);
+    process.stderr.write(
+      `  [${bar}] ${s.completed}/${totalStr}${pctStr}
+  ${formatDuration(elapsed)} | ${rps.toFixed(1)} req/s | ${tps.toFixed(0)} tok/s | ${s.errors} err
+`
+    );
+  }
+};
+
+// src/cli/progress.ts
+var ProgressDisplay = class {
+  store;
+  inkInstance = null;
+  fallback = null;
+  constructor(opts) {
+    this.store = new BenchmarkStore(opts);
+  }
+  async start() {
+    this.store.setStartTime(performance.now());
+    if (process.stderr.isTTY) {
+      const { render } = await import("ink");
+      const { createElement } = await import("react");
+      const { App: App2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+      this.inkInstance = render(createElement(App2, { store: this.store }), {
+        stdout: process.stderr,
+        patchConsole: false,
+        exitOnCtrlC: false
+      });
+    } else {
+      this.fallback = new FallbackDisplay(this.store);
+      this.fallback.start();
+    }
+  }
+  update(metrics, activeSlots, completed, phase, allowedConcurrency) {
+    this.store.update(metrics, activeSlots, completed, phase, allowedConcurrency);
+  }
+  setStage(stage) {
+    this.store.setStage(stage);
+  }
+  stop() {
+    if (this.inkInstance) {
+      this.inkInstance.unmount();
+      this.inkInstance = null;
+    }
+    if (this.fallback) {
+      this.fallback.stop();
+      this.fallback = null;
+    }
+  }
+};
+
+// index.ts
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
+import { join as join5 } from "path";
+async function main() {
+  const cliArgs = parseCliArgs(process.argv);
+  if (cliArgs.command === "init") {
+    await runInit(cliArgs.initOutputPath);
+    return;
+  }
+  const { command, configPath, runId, overrides } = cliArgs;
+  const { config, outputDir } = resolveConfig(configPath, runId, overrides);
+  switch (command) {
+    case "run":
+      await runFullPipeline(config, outputDir);
+      break;
+    case "generate":
+      await runGenerate(config, outputDir);
+      break;
+    case "bench":
+      await runBench(config, outputDir);
+      break;
+    case "report":
+      await runReport(config);
+      break;
+  }
+}
+var BOX_W = 56;
+function printBox(title, lines) {
+  const inner = BOX_W - 2;
+  const titleStr = `\u2500\u2500 ${title} `;
+  const topPad = "\u2500".repeat(Math.max(0, inner - titleStr.length));
+  console.log(`  ${dim("\u256D")}${dim(titleStr)}${dim(topPad)}${dim("\u256E")}`);
+  for (const line of lines) {
+    const stripped = stripAnsi(line);
+    const pad = Math.max(0, inner - stripped.length - 2);
+    console.log(`  ${dim("\u2502")}  ${line}${" ".repeat(pad)}${dim("\u2502")}`);
+  }
+  console.log(`  ${dim("\u2570")}${dim("\u2500".repeat(inner))}${dim("\u256F")}`);
+}
+function stripAnsi(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function printBanner(config, outputDir) {
+  const inner = BOX_W - 2;
+  const title = "FLOTorch Load Tester";
+  const titlePad = Math.floor((inner - title.length) / 2);
+  console.log();
+  console.log(`  ${dim("\u256D")}${dim("\u2500".repeat(inner))}${dim("\u256E")}`);
+  console.log(`  ${dim("\u2502")}${" ".repeat(titlePad)}${bold(title)}${" ".repeat(inner - titlePad - title.length)}${dim("\u2502")}`);
+  console.log(`  ${dim("\u2570")}${dim("\u2500".repeat(inner))}${dim("\u256F")}`);
+  const maxReqs = config.benchmark.maxRequests;
+  const maxDur = config.benchmark.maxDuration;
+  const rows = [
+    [dim("Model"), bold(config.provider.model)],
+    [dim("Concurrency"), bold(String(config.benchmark.concurrency))],
+    [dim("Streaming"), bold(config.benchmark.streaming ? "yes" : "no")]
+  ];
+  if (maxReqs) rows.push([dim("Requests"), bold(String(maxReqs))]);
+  if (maxDur) rows.push([dim("Duration"), bold(`${maxDur}s`)]);
+  rows.push([dim("Output"), cyan(outputDir)]);
+  const labelW = 14;
+  for (const [label, value] of rows) {
+    const stripped = stripAnsi(label);
+    const pad = " ".repeat(Math.max(0, labelW - stripped.length));
+    console.log(`   ${label}${pad}${value}`);
+  }
+  console.log();
+}
+function stageOk(msg, detail) {
+  const suffix = detail ? `    ${dim(detail)}` : "";
+  console.log(`  ${green("\u2714")} ${msg}${suffix}`);
+}
+function stageRun(msg) {
+  console.log(`  ${bold("\u25B8")} ${msg}`);
+}
+function fmtNum(n, w) {
+  const s = n >= 100 ? n.toFixed(0) : n >= 10 ? n.toFixed(1) : n.toFixed(1);
+  return s.padStart(w);
+}
+function fmtMetricTable(label, agg, labelW, colW) {
+  const l = label.padEnd(labelW);
+  return `${bold(l)}${fmtNum(agg.mean, colW)}${fmtNum(agg.p50, colW)}${fmtNum(agg.p95, colW)}${fmtNum(agg.p99, colW)}${fmtNum(agg.max, colW)}`;
+}
+function printSummary(summary) {
+  const durationSec = (summary.endTime - summary.startTime) / 1e3;
+  const errColor = summary.failedRequests > 0 ? red : green;
+  console.log();
+  printBox("Summary", [
+    `${dim("Duration")}       ${bold(durationSec.toFixed(1) + "s")}`,
+    `${dim("Requests")}       ${bold(String(summary.successfulRequests))}/${summary.totalRequests} ${errColor(`(${summary.failedRequests} errors)`)}`,
+    `${dim("Throughput")}     ${bold(summary.rpm.toFixed(1))} ${dim("req/min")}   ${bold(summary.overallTps.toFixed(1))} ${dim("tok/s")}`
+  ]);
+  const labelW = 6;
+  const colW = 9;
+  const header = dim(" ".repeat(labelW)) + dim("mean".padStart(colW)) + dim("p50".padStart(colW)) + dim("p95".padStart(colW)) + dim("p99".padStart(colW)) + dim("max".padStart(colW));
+  const latencyLines = [
+    header,
+    fmtMetricTable("TTFT", summary.ttft, labelW, colW),
+    fmtMetricTable("E2E", summary.e2eLatency, labelW, colW),
+    fmtMetricTable("ITL", summary.interTokenLatency, labelW, colW)
+  ];
+  console.log();
+  printBox("Latency (ms)", latencyLines);
+  if (Object.keys(summary.errorCodeFrequency).length > 0) {
+    console.log();
+    const errLines = [];
+    for (const [code, count] of Object.entries(summary.errorCodeFrequency)) {
+      errLines.push(`${red(code)}  ${bold(String(count))}`);
+    }
+    printBox("Errors", errLines);
+  }
+  if (Object.keys(summary.phaseBreakdown).length > 1) {
+    console.log();
+    const phaseLines = [];
+    for (const [phase, data] of Object.entries(summary.phaseBreakdown)) {
+      phaseLines.push(
+        `${bold(phase.padEnd(12))} ${String(data.requests).padStart(4)} reqs   ${(data.errorRate * 100).toFixed(1)}% err`
+      );
+    }
+    printBox("Phases", phaseLines);
+  }
+}
+async function runFullPipeline(config, outputDir) {
+  printBanner(config, outputDir);
+  stageRun("Generating prompts...");
+  const prompts = generatePrompts(config);
+  process.stdout.write("\x1B[1A\x1B[2K");
+  stageOk("Generating prompts", `${prompts.length} prompts`);
+  mkdirSync5(outputDir, { recursive: true });
+  writeFileSync6(
+    join5(outputDir, "prompts.jsonl"),
+    prompts.map((p) => JSON.stringify(p)).join("\n") + "\n"
+  );
+  stageRun("Running benchmark...");
+  const { controller, onShutdown } = createAbortController();
+  const totalTarget = config.benchmark.maxRequests ?? Infinity;
+  const progress = new ProgressDisplay({
+    totalTarget,
+    maxConcurrency: config.benchmark.concurrency,
+    modelName: config.provider.model,
+    streaming: config.benchmark.streaming
+  });
+  progress.setStage("benchmarking");
+  const backend = createBackend(config);
+  const orchestrator = new ConcurrencyOrchestrator(
+    config,
+    backend,
+    prompts,
+    outputDir,
+    (metrics, active, completed, phase, allowedConcurrency) => progress.update(metrics, active, completed, phase, allowedConcurrency)
+  );
+  onShutdown(() => orchestrator.abort());
+  await progress.start();
+  const results = await orchestrator.run(controller.signal);
+  progress.stop();
+  stageOk("Running benchmark", `${results.length} requests`);
+  stageRun("Generating report...");
+  const summary = computeSummary(results);
+  const exporters = createExporters(config);
+  for (const exporter of exporters) {
+    await exporter.export(summary, results, outputDir);
+  }
+  process.stdout.write("\x1B[1A\x1B[2K");
+  stageOk("Generating report");
+  printSummary(summary);
+  console.log(`
+  ${dim("Results saved to:")} ${cyan(outputDir)}
+`);
+}
+async function runGenerate(config, outputDir) {
+  printBanner(config, outputDir);
+  stageRun("Generating prompts...");
+  const prompts = generatePrompts(config);
+  mkdirSync5(outputDir, { recursive: true });
+  const outPath = join5(outputDir, "prompts.jsonl");
+  writeFileSync6(outPath, prompts.map((p) => JSON.stringify(p)).join("\n") + "\n");
+  process.stdout.write("\x1B[1A\x1B[2K");
+  stageOk("Generating prompts", `${prompts.length} \u2192 ${cyan(outPath)}`);
+}
+async function runBench(config, outputDir) {
+  const inputFile = config.benchmark.inputFile;
+  if (!inputFile) {
+    throw new Error("bench command requires benchmark.inputFile (path to prompts.jsonl)");
+  }
+  printBanner(config, outputDir);
+  stageRun(`Loading prompts from ${cyan(inputFile)}...`);
+  const { FileGenerator: FileGenerator2 } = await Promise.resolve().then(() => (init_file(), file_exports));
+  const gen = new FileGenerator2(inputFile);
+  const count = config.benchmark.maxRequests ?? 100;
+  const prompts = gen.generate(count);
+  process.stdout.write("\x1B[1A\x1B[2K");
+  stageOk("Loading prompts", `${prompts.length} prompts`);
+  stageRun("Running benchmark...");
+  const { controller, onShutdown } = createAbortController();
+  const progress = new ProgressDisplay({
+    totalTarget: count,
+    maxConcurrency: config.benchmark.concurrency,
+    modelName: config.provider.model,
+    streaming: config.benchmark.streaming
+  });
+  progress.setStage("benchmarking");
+  const backend = createBackend(config);
+  const orchestrator = new ConcurrencyOrchestrator(
+    config,
+    backend,
+    prompts,
+    outputDir,
+    (metrics, active, completed, phase, allowedConcurrency) => progress.update(metrics, active, completed, phase, allowedConcurrency)
+  );
+  mkdirSync5(outputDir, { recursive: true });
+  onShutdown(() => orchestrator.abort());
+  await progress.start();
+  const results = await orchestrator.run(controller.signal);
+  progress.stop();
+  stageOk("Running benchmark", `${results.length} requests \u2192 ${cyan(outputDir)}`);
+}
+async function runReport(config) {
+  const inputDir = config.benchmark.inputFile;
+  if (!inputDir) {
+    throw new Error(
+      "report command requires benchmark.inputFile (path to run output dir containing run_log.jsonl)"
+    );
+  }
+  stageRun(`Reading results from ${cyan(inputDir)}...`);
+  const results = WAL.readLog(inputDir);
+  process.stdout.write("\x1B[1A\x1B[2K");
+  stageOk("Reading results", `${results.length} entries`);
+  stageRun("Computing report...");
+  const summary = computeSummary(results);
+  const exporters = createExporters(config);
+  for (const exporter of exporters) {
+    await exporter.export(summary, results, inputDir);
+  }
+  process.stdout.write("\x1B[1A\x1B[2K");
+  stageOk("Computing report");
+  printSummary(summary);
+}
+function generatePrompts(config) {
+  const generator = createGenerator(config);
+  const count = config.benchmark.maxRequests ?? 100;
+  return generator.generate(count);
+}
+main().catch((err) => {
+  console.error(red(err instanceof Error ? err.message : String(err)));
+  process.exit(1);
+});