brass-runtime 1.16.0 → 1.17.0

package/dist/chunk-7X3K5RMS.js

@@ -0,0 +1,2024 @@
+import {
+  makeFiberRef,
+  makeRuntimeRecorder
+} from "./chunk-5QC7LRZ3.js";
+import {
+  makeDefaultHttpClient
+} from "./chunk-74ZTY6CP.js";
+import {
+  makeHttp
+} from "./chunk-MIIYDLGM.js";
+import {
+  withHttpObservability
+} from "./chunk-VWIPB6I5.js";
+import {
+  makeObservability
+} from "./chunk-BKK77SBA.js";
+import {
+  EventBus
+} from "./chunk-RKGKFN2A.js";
+import {
+  Runtime,
+  Scheduler
+} from "./chunk-FH2X7BVP.js";
+import {
+  asyncFlatMap,
+  asyncSucceed,
+  asyncSync
+} from "./chunk-UB4B6OFY.js";
+
+// src/perf/recorder.ts
+var DEFAULT_MAX_EVENTS = 2048;
+function makePerfRecorder(options = {}) {
+  const capacity = normalizeCapacity(options.maxEvents);
+  const clock = options.clock ?? defaultClock;
+  const buffer = new Array(capacity);
+  let writeIndex = 0;
+  let size = 0;
+  let recorded = 0;
+  let dropped = 0;
+  const record = (input) => {
+    const event = freezeEvent({
+      ...input,
+      timestamp: input.timestamp ?? clock()
+    });
+    if (size === capacity) {
+      dropped++;
+    } else {
+      size++;
+    }
+    buffer[writeIndex] = event;
+    writeIndex = (writeIndex + 1) % capacity;
+    recorded++;
+    return event;
+  };
+  const snapshot = () => {
+    const out = new Array(size);
+    const start = size === capacity ? writeIndex : 0;
+    for (let i = 0; i < size; i++) {
+      out[i] = buffer[(start + i) % capacity];
+    }
+    return Object.freeze(out);
+  };
+  return {
+    record,
+    mark: (name, details, tags) => record({ type: "mark", name, details, tags }),
+    measure: (name, fn, details, tags) => {
+      const startedAt = clock();
+      try {
+        return fn();
+      } finally {
+        record({
+          type: "measure",
+          name,
+          timestamp: clock(),
+          durationMs: round(clock() - startedAt),
+          details,
+          tags
+        });
+      }
+    },
+    measureAsync: async (name, fn, details, tags) => {
+      const startedAt = clock();
+      try {
+        return await fn();
+      } finally {
+        record({
+          type: "measure",
+          name,
+          timestamp: clock(),
+          durationMs: round(clock() - startedAt),
+          details,
+          tags
+        });
+      }
+    },
+    counter: (name, value = 1, unit, tags) => record({ type: "counter", name, value, unit, tags }),
+    gauge: (name, value, unit, tags) => record({ type: "gauge", name, value, unit, tags }),
+    snapshot,
+    stats: () => Object.freeze({ capacity, size, recorded, dropped }),
+    explain: () => summarizePerfEvents(snapshot()),
+    clear: () => {
+      buffer.fill(void 0);
+      writeIndex = 0;
+      size = 0;
+      recorded = 0;
+      dropped = 0;
+    }
+  };
+}
+function summarizePerfEvents(events) {
+  const summaries = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const key = `${event.type}:${event.name}`;
+    const current = summaries.get(key) ?? {
+      name: event.name,
+      type: event.type,
+      count: 0,
+      totalDurationMs: 0,
+      maxDurationMs: 0,
+      lastTimestamp: event.timestamp
+    };
+    const durationMs = event.durationMs ?? 0;
+    current.count++;
+    current.totalDurationMs = round(current.totalDurationMs + durationMs);
+    current.maxDurationMs = Math.max(current.maxDurationMs, durationMs);
+    current.lastTimestamp = event.timestamp;
+    if (event.value !== void 0) current.lastValue = event.value;
+    if (event.unit !== void 0) current.unit = event.unit;
+    summaries.set(key, current);
+  }
+  return Object.freeze([...summaries.values()].map((summary) => Object.freeze({
+    ...summary,
+    totalDurationMs: round(summary.totalDurationMs),
+    maxDurationMs: round(summary.maxDurationMs)
+  })).sort((a, b) => a.name.localeCompare(b.name) || a.type.localeCompare(b.type)));
+}
+function freezeEvent(event) {
+  return Object.freeze({
+    ...event,
+    durationMs: event.durationMs === void 0 ? void 0 : round(event.durationMs),
+    tags: event.tags ? Object.freeze({ ...event.tags }) : void 0,
+    details: event.details ? Object.freeze({ ...event.details }) : void 0
+  });
+}
+function normalizeCapacity(value) {
+  if (value === void 0) return DEFAULT_MAX_EVENTS;
+  if (!Number.isFinite(value)) return DEFAULT_MAX_EVENTS;
+  return Math.max(1, Math.floor(value));
+}
+function defaultClock() {
+  return performance.now();
+}
+function round(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+
+// src/perf/memory.ts
+function hasGc() {
+  return typeof globalThis.gc === "function";
+}
+function forceGc(passes = 2) {
+  const gc = globalThis.gc;
+  if (typeof gc !== "function") return false;
+  const count = Math.max(1, Math.floor(passes));
+  for (let i = 0; i < count; i++) gc();
+  return true;
+}
+function captureMemorySnapshot(options = {}) {
+  if (options.forceGc) forceGc(options.gcPasses);
+  const usage = process.memoryUsage();
+  const clock = options.clock ?? Date.now;
+  return Object.freeze({
+    timestamp: clock(),
+    heapUsedMb: toMb(usage.heapUsed),
+    heapTotalMb: toMb(usage.heapTotal),
+    rssMb: toMb(usage.rss),
+    externalMb: toMb(usage.external),
+    arrayBuffersMb: toMb(usage.arrayBuffers),
+    gcAvailable: hasGc()
+  });
+}
+function diffMemorySnapshots(before, after) {
+  return Object.freeze({
+    heapUsedMb: round2(after.heapUsedMb - before.heapUsedMb),
+    heapTotalMb: round2(after.heapTotalMb - before.heapTotalMb),
+    rssMb: round2(after.rssMb - before.rssMb),
+    externalMb: round2(after.externalMb - before.externalMb),
+    arrayBuffersMb: round2(after.arrayBuffersMb - before.arrayBuffersMb)
+  });
+}
+async function profileMemoryRetention(fn, options = {}) {
+  const clock = options.clock ?? performance.now.bind(performance);
+  const before = captureMemorySnapshot(options);
+  const startedAt = clock();
+  const value = await fn();
+  const durationMs = round2(clock() - startedAt);
+  const after = captureMemorySnapshot(options);
+  const report = Object.freeze({
+    label: options.label ?? "memory-retention",
+    durationMs,
+    before,
+    after,
+    delta: diffMemorySnapshots(before, after)
+  });
+  return Object.freeze({ value, report });
+}
+function toMb(bytes) {
+  return round2(bytes / (1024 * 1024));
+}
+function round2(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+
+// src/perf/runtimeProfiler.ts
+async function profileRuntimePrimitives(options = {}) {
+  const iterations = positiveInt(options.iterations, 5e3);
+  const chainDepth = positiveInt(options.chainDepth, 1e3);
+  const variant = options.variant ?? "default";
+  const runtimeCase = makeRuntimeCase(variant, chainDepth);
+  const runtime = runtimeCase.runtime;
+  const runMode = variant === "fiber-only" ? "fiber" : "auto";
+  const results = [];
+  results.push(await measureEffect("async-succeed/top-level", iterations, "effect", runtime, runMode, "success", () => asyncSucceed(1)));
+  results.push(await measureEffect("async-fail/top-level", iterations, "effect", runtime, runMode, "failure", () => asyncFailProgram()));
+  results.push(await measureEffect("async-sync/top-level", iterations, "effect", runtime, runMode, "success", () => asyncSync(() => 1)));
+  const flatMapRounds = Math.max(1, Math.floor(iterations / Math.max(1, chainDepth)));
+  results.push(await measureEffect(
+    "flatMap-chain",
+    flatMapRounds * chainDepth,
+    "operation",
+    runtime,
+    runMode,
+    "success",
+    () => makeFlatMapChain(chainDepth)
+  ));
+  const fiberRefRounds = Math.max(1, Math.floor(iterations / Math.max(1, chainDepth)));
+  results.push(await measureEffect(
+    "fiberRef-update-get",
+    fiberRefRounds * chainDepth,
+    "operation",
+    runtime,
+    runMode,
+    "success",
+    () => makeFiberRefProgram(chainDepth)
+  ));
+  for (const result of results) {
+    options.recorder?.gauge("runtime.ops-per-sec", result.operationsPerSecond, "ops/s", { primitive: result.name });
+  }
+  await runtime.shutdown();
+  return Object.freeze({
+    variant,
+    label: runtimeCase.label,
+    iterations,
+    chainDepth,
+    hooksActive: runtime.hasActiveHooks(),
+    recorderEvents: runtimeCase.recorder?.stats().size,
+    scheduler: runtimeCase.scheduler,
+    results: Object.freeze(results)
+  });
+}
+async function measureEffect(name, units, unit, runtime, runMode, expected, makeEffect) {
+  const fibersBefore = startedFibers(runtime);
+  const startedAt = performance.now();
+  if (unit === "effect") {
+    for (let i = 0; i < units; i++) {
+      await runExpectedEffect(runtime, makeEffect(), runMode, expected);
+    }
+  } else {
+    await runExpectedEffect(runtime, makeEffect(), runMode, expected);
+  }
+  const durationMs = round3(performance.now() - startedAt);
+  const fibersStarted = Math.max(0, startedFibers(runtime) - fibersBefore);
+  return Object.freeze({
+    name,
+    units,
+    unit,
+    durationMs,
+    nsPerOperation: round3(durationMs * 1e6 / Math.max(units, 1)),
+    operationsPerSecond: round3(units / Math.max(durationMs / 1e3, 1e-3)),
+    fibersStarted,
+    fibersPerThousandOps: round3(fibersStarted / Math.max(units, 1) * 1e3)
+  });
+}
+async function runExpectedEffect(runtime, effect, runMode, expected) {
+  try {
+    await runMeasuredEffect(runtime, effect, runMode);
+    if (expected === "failure") throw new Error("Expected measured effect to fail");
+  } catch (error) {
+    if (expected === "success") throw error;
+  }
+}
+function makeRuntimeCase(variant, chainDepth) {
+  const schedulerConfig = variant === "wide-scheduler" ? {
+    laneMode: "single",
+    initialCapacity: Math.max(65536, chainDepth * 8),
+    maxCapacity: Math.max(65536, chainDepth * 8),
+    flushBudget: 16384
+  } : {
+    laneMode: "fair",
+    initialCapacity: 8192,
+    maxCapacity: 8192,
+    flushBudget: 2048
+  };
+  const scheduler = variant === "wide-scheduler" ? new Scheduler(schedulerConfig) : void 0;
+  const recorder = variant === "recorder" ? makeRuntimeRecorder({ maxEvents: 1e4 }) : void 0;
+  const hooks = recorder?.hooks ?? (variant === "active-hooks" ? new EventBus() : void 0);
+  const runtime = Runtime.makeWithEngine(hooks ? {} : {}, "ts", {
+    hooks,
+    ...scheduler ? { scheduler } : {},
+    inferLane: false
+  });
+  return {
+    runtime,
+    label: labelForVariant(variant),
+    scheduler: schedulerConfig,
+    recorder
+  };
+}
+function labelForVariant(variant) {
+  switch (variant) {
+    case "default":
+      return "default runtime with native top-level fast path";
+    case "fiber-only":
+      return "forced fiber execution for every measured effect";
+    case "active-hooks":
+      return "runtime with active EventBus hooks";
+    case "recorder":
+      return "runtime with bounded flight recorder hooks";
+    case "wide-scheduler":
+      return "runtime with larger single-lane scheduler queues";
+  }
+}
+async function runMeasuredEffect(runtime, effect, runMode) {
+  if (runMode === "auto") return runtime.toPromise(effect);
+  return new Promise((resolve2, reject) => {
+    const fiber = runtime.fork(effect);
+    fiber.join((exit) => {
+      if (exit._tag === "Success") resolve2(exit.value);
+      else reject(exit.cause);
+    });
+  });
+}
+function asyncFailProgram() {
+  return { _tag: "Fail", error: "expected-profile-failure" };
+}
+function makeFlatMapChain(depth) {
+  let effect = asyncSucceed(0);
+  for (let i = 0; i < depth; i++) {
+    effect = asyncFlatMap(effect, (n) => asyncSucceed(n + 1));
+  }
+  return effect;
+}
+function makeFiberRefProgram(depth) {
+  const ref = makeFiberRef(0);
+  let effect = ref.set(0);
+  for (let i = 0; i < depth; i++) {
+    effect = asyncFlatMap(effect, () => ref.update((n) => n + 1));
+  }
+  return asyncFlatMap(effect, () => ref.get());
+}
+function positiveInt(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(1, Math.floor(value));
+}
+function startedFibers(runtime) {
+  return runtime.stats().data.startedFibers ?? 0;
+}
+function round3(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+
+// src/perf/runtimeDiagnostics.ts
+function diagnoseRuntimeProfile(report) {
+  const diagnostics = report.results.map(toDiagnostic);
+  const sortedByNs = [...diagnostics].sort((a, b) => b.nsPerOperation - a.nsPerOperation);
+  const totalFibersStarted = diagnostics.reduce((sum2, item) => sum2 + item.fibersStarted, 0);
+  const totalMeasuredUnits = report.results.reduce((sum2, item) => sum2 + item.units, 0);
+  const notes = makeNotes(report, sortedByNs, totalFibersStarted, totalMeasuredUnits);
+  return Object.freeze({
+    variant: report.variant,
+    slowest: sortedByNs[0],
+    fastest: sortedByNs[sortedByNs.length - 1],
+    hotPrimitives: Object.freeze(sortedByNs.slice(0, 3)),
+    totalFibersStarted,
+    totalMeasuredUnits,
+    averageFibersPerThousandOps: round4(totalFibersStarted / Math.max(totalMeasuredUnits, 1) * 1e3),
+    hooksActive: report.hooksActive,
+    recorderEvents: report.recorderEvents,
+    notes: Object.freeze(notes)
+  });
+}
+function toDiagnostic(result) {
+  return Object.freeze({
+    name: result.name,
+    operationsPerSecond: result.operationsPerSecond,
+    nsPerOperation: result.nsPerOperation,
+    fibersStarted: result.fibersStarted,
+    fibersPerThousandOps: result.fibersPerThousandOps
+  });
+}
+function makeNotes(report, sortedByNs, totalFibersStarted, totalMeasuredUnits) {
+  const notes = [];
+  const topLevelPure = report.results.filter(
+    (item) => item.name === "async-succeed/top-level" || item.name === "async-fail/top-level" || item.name === "async-sync/top-level" || item.name === "flatMap-chain"
+  );
+  const pureStartedFibers = topLevelPure.reduce((sum2, item) => sum2 + item.fibersStarted, 0);
+  if (pureStartedFibers === 0 && report.variant === "default") {
+    notes.push("Native top-level fast path avoided root fibers for pure/sync runtime primitives.");
+  }
+  if (report.hooksActive) {
+    notes.push("Hooks are active, so top-level pure effects keep normal fiber/event semantics.");
+  }
+  if (report.recorderEvents && report.recorderEvents > 0) {
+    notes.push(`Runtime recorder retained ${report.recorderEvents} events during the profile.`);
+  }
+  if (totalFibersStarted > totalMeasuredUnits * 0.25) {
+    notes.push("Fiber allocation pressure is visible; compare with the fiber-only baseline to isolate scheduling overhead.");
+  }
+  if (sortedByNs[0]) {
+    notes.push(`${sortedByNs[0].name} is the hottest sampled primitive by ns/op.`);
+  }
+  return notes;
+}
+function round4(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+
+// src/perf/runtimeAb.ts
+async function profileRuntimeAb(options = {}) {
+  const baselineVariant = options.baseline ?? "fiber-only";
+  const candidateVariant = options.candidate ?? "default";
+  const thresholds = normalizeThresholds(options.thresholds);
+  const before = captureMemorySnapshot({ forceGc: options.forceGc });
+  const baseline = await profileRuntimePrimitives({
+    ...options.runtime ?? {},
+    variant: baselineVariant
+  });
+  const candidate = await profileRuntimePrimitives({
+    ...options.runtime ?? {},
+    variant: candidateVariant
+  });
+  const after = captureMemorySnapshot({ forceGc: options.forceGc });
+  const comparisons = compareRuntimeProfiles(baseline, candidate, thresholds);
+  const budgetViolations = comparisons.filter((comparison) => comparison.deltaPercent < -thresholds.maxRegressionPercent).map((comparison) => `${comparison.primitive} regressed ${Math.abs(comparison.deltaPercent).toFixed(1)}%`);
+  return Object.freeze({
+    baselineVariant,
+    candidateVariant,
+    baseline,
+    candidate,
+    comparisons,
+    diagnostics: Object.freeze({
+      baseline: diagnoseRuntimeProfile(baseline),
+      candidate: diagnoseRuntimeProfile(candidate)
+    }),
+    memory: Object.freeze({
+      delta: diffMemorySnapshots(before, after)
+    }),
+    passedBudget: budgetViolations.length === 0,
+    budgetViolations: Object.freeze(budgetViolations)
+  });
+}
+function compareRuntimeProfiles(baseline, candidate, thresholds = normalizeThresholds()) {
+  const candidateByName = new Map(candidate.results.map((result) => [result.name, result]));
+  return Object.freeze(baseline.results.flatMap((base) => {
+    const next = candidateByName.get(base.name);
+    if (!next) return [];
+    const deltaPercent = percentDelta(next.operationsPerSecond, base.operationsPerSecond);
+    const verdict = deltaPercent >= thresholds.minSignificantDeltaPercent ? "improved" : deltaPercent <= -thresholds.minSignificantDeltaPercent ? "regressed" : "same";
+    return [Object.freeze({
+      primitive: base.name,
+      baselineOpsPerSecond: base.operationsPerSecond,
+      candidateOpsPerSecond: next.operationsPerSecond,
+      deltaPercent: round5(deltaPercent),
+      baselineNsPerOperation: base.nsPerOperation,
+      candidateNsPerOperation: next.nsPerOperation,
+      fibersStartedDelta: next.fibersStarted - base.fibersStarted,
+      verdict
+    })];
+  }));
+}
+function formatRuntimeAbReport(report) {
+  const lines = [];
+  lines.push("Brass Runtime A/B Performance Lab");
+  lines.push(`baseline=${report.baselineVariant} candidate=${report.candidateVariant} budget=${report.passedBudget ? "pass" : "fail"}`);
+  lines.push("");
+  lines.push("Comparisons");
+  for (const comparison of report.comparisons) {
+    const sign = comparison.deltaPercent >= 0 ? "+" : "";
+    lines.push(`- ${comparison.primitive}: ${sign}${comparison.deltaPercent}% (${formatNumber(comparison.baselineOpsPerSecond)} -> ${formatNumber(comparison.candidateOpsPerSecond)} ops/s) ${comparison.verdict}`);
+  }
+  lines.push("");
+  lines.push(`Memory: heapDelta=${report.memory.delta.heapUsedMb}MB rssDelta=${report.memory.delta.rssMb}MB`);
+  lines.push("");
+  lines.push("Candidate diagnostics");
+  for (const note of report.diagnostics.candidate.notes) {
+    lines.push(`- ${note}`);
+  }
+  if (report.budgetViolations.length > 0) {
+    lines.push("");
+    lines.push("Budget violations");
+    for (const violation of report.budgetViolations) lines.push(`- ${violation}`);
+  }
+  return lines.join("\n");
+}
+function normalizeThresholds(thresholds = {}) {
+  return {
+    maxRegressionPercent: positiveNumber(thresholds.maxRegressionPercent, 50),
+    minSignificantDeltaPercent: positiveNumber(thresholds.minSignificantDeltaPercent, 5)
+  };
+}
+function percentDelta(candidate, baseline) {
+  if (baseline <= 0) return 0;
+  return (candidate - baseline) / baseline * 100;
+}
+function positiveNumber(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, value);
+}
+function formatNumber(value) {
+  return value >= 1e3 ? value.toLocaleString("en-US", { maximumFractionDigits: 0 }) : value.toFixed(3);
+}
+function round5(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+
+// src/perf/runtimeSoak.ts
+async function profileRuntimeSoak(options = {}) {
+  const rounds = positiveInt2(options.rounds, 5);
+  const variant = options.variant ?? options.runtime?.variant ?? "default";
+  const before = captureMemorySnapshot({ forceGc: options.forceGc });
+  const results = [];
+  for (let i = 0; i < rounds; i++) {
+    const roundBefore = captureMemorySnapshot({ forceGc: options.forceGc });
+    const report = await profileRuntimePrimitives({
+      ...options.runtime ?? {},
+      variant
+    });
+    const roundAfter = captureMemorySnapshot({ forceGc: options.forceGc });
+    const delta2 = diffMemorySnapshots(roundBefore, roundAfter);
+    results.push(Object.freeze({
+      round: i + 1,
+      report,
+      diagnostics: diagnoseRuntimeProfile(report),
+      heapDeltaMb: delta2.heapUsedMb,
+      rssDeltaMb: delta2.rssMb
+    }));
+  }
+  const after = captureMemorySnapshot({ forceGc: options.forceGc });
+  return Object.freeze({
+    variant,
+    rounds: Object.freeze(results),
+    memory: Object.freeze({
+      delta: diffMemorySnapshots(before, after)
+    }),
+    throughputTrendPercent: round6(throughputTrend(results)),
+    heapTrendMb: round6(results.reduce((sum2, item) => sum2 + item.heapDeltaMb, 0))
+  });
+}
+function formatRuntimeSoakReport(report) {
+  const lines = [];
+  lines.push("Brass Runtime Soak Profile");
+  lines.push(`variant=${report.variant} rounds=${report.rounds.length} throughputTrend=${signed(report.throughputTrendPercent)}% heapTrend=${report.heapTrendMb}MB`);
+  lines.push("");
+  for (const round10 of report.rounds) {
+    const aggregateOps = aggregateOpsPerSecond(round10.report);
+    lines.push(`- round ${round10.round}: aggregate=${formatNumber2(aggregateOps)} ops/s heapDelta=${round10.heapDeltaMb}MB rssDelta=${round10.rssDeltaMb}MB hot=${round10.diagnostics.slowest.name}`);
+  }
+  lines.push("");
+  lines.push(`Total memory: heapDelta=${report.memory.delta.heapUsedMb}MB rssDelta=${report.memory.delta.rssMb}MB`);
+  return lines.join("\n");
+}
+function throughputTrend(rounds) {
+  if (rounds.length < 2) return 0;
+  const first = aggregateOpsPerSecond(rounds[0].report);
+  const last = aggregateOpsPerSecond(rounds[rounds.length - 1].report);
+  if (first <= 0) return 0;
+  return (last - first) / first * 100;
+}
+function aggregateOpsPerSecond(report) {
+  const totalUnits = report.results.reduce((sum2, item) => sum2 + item.units, 0);
+  const totalDurationMs = report.results.reduce((sum2, item) => sum2 + item.durationMs, 0);
+  return totalUnits / Math.max(totalDurationMs / 1e3, 1e-3);
+}
+function positiveInt2(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(1, Math.floor(value));
+}
+function formatNumber2(value) {
+  return value >= 1e3 ? value.toLocaleString("en-US", { maximumFractionDigits: 0 }) : value.toFixed(3);
+}
+function signed(value) {
+  return value >= 0 ? `+${value}` : String(value);
+}
+function round6(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+
+// src/perf/httpProfiler.ts
+import {
+  Agent as HttpAgent,
+  createServer,
+  request as httpRequest
+} from "http";
+var HTTP_PROFILE_VARIANTS = [
+  "node-http-text",
+  "wire-raw",
+  "default-minimal-json",
+  "default-balanced-no-adaptive-json",
+  "default-balanced-json",
+  "default-json",
+  "default-json-observed"
+];
+async function profileHttpLayers(options = {}) {
+  const calls = positiveInt3(options.calls, 1e3);
+  const concurrency = positiveInt3(options.concurrency, 64);
+  const delayMs = nonNegativeInt(options.delayMs, 1);
+  const timeoutMs = positiveInt3(options.timeoutMs, 3e4);
+  const warmupCalls = nonNegativeInt(options.warmupCalls, Math.min(200, Math.floor(calls / 10)));
+  const statsSampleMs = positiveInt3(options.statsSampleMs, 10);
+  const variants = normalizeVariants(options.variants);
+  const results = [];
+  for (const variant of variants) {
+    const scenario = {
+      variant,
+      label: labelForVariant2(variant),
+      calls,
+      warmupCalls,
+      concurrency,
+      delayMs,
+      timeoutMs,
+      statsSampleMs,
+      forceGc: options.forceGc ?? false
+    };
+    const result = await options.recorder?.measureAsync(
+      `http.profile.${variant}`,
+      () => runScenario(scenario),
+      { calls, concurrency, delayMs },
+      { variant }
+    ) ?? await runScenario(scenario);
+    options.recorder?.gauge("http.profile.throughput", result.httpPerSec, "http/s", { variant });
+    options.recorder?.gauge("http.profile.heap-delta", result.memory.delta.heapUsedMb, "MB", { variant });
+    results.push(result);
+  }
+  return Object.freeze({
+    calls,
+    concurrency,
+    delayMs,
+    timeoutMs,
+    warmupCalls,
+    variants,
+    results: Object.freeze(results)
+  });
+}
+async function runScenario(scenario) {
+  const server = await startDummyServer(scenario.delayMs);
+  const observability = scenario.variant === "default-json-observed" ? makeObservability({
+    logs: false,
+    traces: { maxFinishedSpans: 1e4 },
+    autoStart: false
+  }) : void 0;
+  const runner = makeScenarioRunner(scenario, server, observability);
+  let warmupDurationMs = 0;
+  try {
+    if (scenario.warmupCalls > 0) {
+      const warmup = await runHttpLoad(
+        {
+          ...scenario,
+          calls: scenario.warmupCalls,
+          warmupCalls: 0,
+          idOffset: scenario.calls + 1e6
+        },
+        server,
+        runner.runOne,
+        runner.readClientStats,
+        observability
+      );
+      warmupDurationMs = warmup.durationMs;
+      flushObservability(observability);
+      dropFinishedSpans(observability);
+      await runner.reset?.();
+      server.resetStats();
+    }
+    const result = await runHttpLoad(
+      scenario,
+      server,
+      runner.runOne,
+      runner.readClientStats,
+      observability
+    );
+    return Object.freeze({ ...result, warmupDurationMs: round7(warmupDurationMs) });
+  } finally {
+    await runner.cleanup?.();
+    await observability?.shutdown();
+    await server.close();
+  }
+}
+function startDummyServer(delayMs) {
+  return new Promise((resolve2, reject) => {
+    let requests = 0;
+    let inFlight = 0;
+    let maxInFlight = 0;
+    const server = createServer((req, res) => {
+      const id = ++requests;
+      inFlight++;
+      if (inFlight > maxInFlight) maxInFlight = inFlight;
+      const finish = () => {
+        const payload = {
+          ok: true,
+          id,
+          delayMs,
+          path: req.url ?? "/"
+        };
+        const body = JSON.stringify(payload);
+        res.writeHead(200, {
+          "content-type": "application/json",
+          "content-length": Buffer.byteLength(body),
+          "cache-control": "no-store"
+        });
+        res.end(body, () => {
+          inFlight--;
+        });
+      };
+      if (delayMs > 0) setTimeout(finish, delayMs);
+      else finish();
+    });
+    server.keepAliveTimeout = 65e3;
+    server.headersTimeout = 66e3;
+    server.maxRequestsPerSocket = 0;
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject);
+      const address = server.address();
+      resolve2({
+        baseUrl: `http://127.0.0.1:${address.port}`,
+        stats: () => ({ requests, maxInFlight }),
+        resetStats: () => {
+          requests = 0;
+          maxInFlight = inFlight;
+        },
+        close: () => closeServer(server)
+      });
+    });
+  });
+}
+function closeServer(server) {
+  return new Promise((resolve2, reject) => {
+    server.close((err) => {
+      if (err) reject(err);
+      else resolve2();
+    });
+  });
+}
+function makeScenarioRunner(scenario, server, observability) {
+  switch (scenario.variant) {
+    case "node-http-text":
+      return makeNodeHttpRunner(server, scenario);
+    case "wire-raw":
+      return makeWireRawRunner(server, scenario);
+    case "default-minimal-json":
+      return makeDefaultJsonRunner(server, scenario, "minimal");
+    case "default-balanced-no-adaptive-json":
+      return makeDefaultJsonRunner(server, scenario, "balanced", true);
+    case "default-balanced-json":
+      return makeDefaultJsonRunner(server, scenario, "balanced");
+    case "default-json":
+      return makeDefaultJsonRunner(server, scenario, "default");
+    case "default-json-observed":
+      return makeDefaultJsonRunner(server, scenario, "default", false, observability);
+  }
+}
+function makeNodeHttpRunner(server, scenario) {
+  const agent = new HttpAgent({
+    keepAlive: true,
+    maxSockets: scenario.concurrency,
+    maxFreeSockets: scenario.concurrency
+  });
+  return {
+    runOne: (id, cb) => {
+      let done = false;
+      const finish = (result) => {
+        if (done) return;
+        done = true;
+        cb(result);
+      };
+      const url = `${server.baseUrl}/todos/${id % 100}?i=${id}`;
+      const req = httpRequest(url, { agent, method: "GET" }, (res) => {
+        let bytes = 0;
+        res.on("data", (chunk) => {
+          bytes += chunk.length;
+        });
+        res.on("end", () => {
+          finish({ ok: res.statusCode === 200 && bytes > 0 });
+        });
+      });
+      req.setTimeout(scenario.timeoutMs, () => {
+        req.destroy(new Error(`node:http request timed out after ${scenario.timeoutMs}ms`));
+      });
+      req.on("error", (error) => finish({ ok: false, error }));
+      req.end();
+    },
+    cleanup: () => agent.destroy()
+  };
+}
+function makeWireRawRunner(server, scenario) {
+  const rt = makeProfileRuntime(scenario.concurrency);
+  const client = makeWireClient(server.baseUrl, scenario);
+  return {
+    runOne: (id, cb) => {
+      const effect = client({ method: "GET", url: `/todos/${id % 100}?i=${id}` });
+      runRuntimeEffect(rt, effect, cb, (res) => res.status === 200 && res.bodyText.length > 0);
+    },
+    readClientStats: () => snapshotWireStats(client.stats()),
+    cleanup: async () => {
+      client.shutdown?.();
+      client.destroy?.();
+      await rt.shutdown();
+    }
+  };
+}
+function makeDefaultJsonRunner(server, scenario, preset, disableAdaptiveLimiter = false, observability) {
+  const rt = makeProfileRuntime(scenario.concurrency, observability);
+  const client = preset === "minimal" ? makeMinimalClient(server.baseUrl, scenario) : makeDefaultClient(server.baseUrl, scenario, preset, disableAdaptiveLimiter, observability);
+  return {
+    runOne: (id, cb) => {
+      const effect = client.getJson(`/todos/${id % 100}?i=${id}`);
+      runRuntimeEffect(
+        rt,
+        effect,
+        cb,
+        (res) => res.status === 200 && res.body.ok === true
+      );
+    },
+    readClientStats: () => snapshotLifecycleStats(client.stats()),
+    reset: () => client.cache.clear(),
+    cleanup: async () => {
+      await rt.toPromise(client.shutdown());
+      await rt.shutdown();
+    }
+  };
+}
+function makeProfileRuntime(concurrency, observability) {
+  const capacity = Math.max(65536, concurrency * 8);
+  return Runtime.makeWithEngine(observability?.env ?? {}, "ts", {
+    hooks: observability?.hooks,
+    scheduler: new Scheduler({
+      laneMode: "single",
+      initialCapacity: capacity,
+      maxCapacity: capacity,
+      flushBudget: 8192
+    }),
+    inferLane: false
+  }).withLane("perf/http");
+}
+function baseHttpConfig(baseUrl, scenario) {
+  return {
+    baseUrl,
+    timeoutMs: scenario.timeoutMs,
+    pool: {
+      concurrency: scenario.concurrency,
+      maxQueue: scenario.concurrency,
+      queueTimeoutMs: scenario.timeoutMs,
+      key: "origin"
+    }
+  };
+}
+function makeWireClient(baseUrl, scenario) {
+  return makeHttp(baseHttpConfig(baseUrl, scenario));
+}
+function makeMinimalClient(baseUrl, scenario) {
+  return makeDefaultHttpClient({
+    preset: "minimal",
+    compression: false,
+    ...baseHttpConfig(baseUrl, scenario)
+  });
+}
+function makeDefaultClient(baseUrl, scenario, preset, disableAdaptiveLimiter, observability) {
+  return makeDefaultHttpClient({
+    preset,
+    compression: false,
+    ...baseHttpConfig(baseUrl, scenario),
+    ...disableAdaptiveLimiter ? { adaptiveLimiter: false } : {},
+    ...observability ? {
+      middleware: [
+        withHttpObservability({
+          metrics: observability.metrics,
+          logs: false,
+          spans: {},
+          injectTraceHeaders: true,
+          route: "/todos/:id"
+        })
+      ]
+    } : {}
+  });
+}
+function runRuntimeEffect(rt, effect, cb, validate) {
+  rt.unsafeRunAsync(effect, (exit) => {
+    if (exit._tag === "Success") {
+      cb({ ok: validate(exit.value) });
+    } else {
+      cb({ ok: false, error: exit });
+    }
+  });
+}
+function runHttpLoad(scenario, server, runOne, readClientStats, observability) {
+  return new Promise((resolve2, reject) => {
+    let next = 0;
+    let inFlight = 0;
+    let maxClientInFlight = 0;
+    let completed = 0;
+    let successCount = 0;
+    let errorCount = 0;
+    let firstError;
+    let maxWireInFlight = 0;
+    let maxPoolRunning = 0;
+    let maxPoolQueued = 0;
+    let maxLifecycleQueueDepth = 0;
+    let sawPoolStats = false;
+    let minAdaptiveLimit = Number.POSITIVE_INFINITY;
+    let maxAdaptiveLimit = 0;
+    let maxAdaptiveInFlight = 0;
+    let maxAdaptiveQueueDepth = 0;
+    let sawAdaptiveStats = false;
+    let lastClientStats;
+    const initialClientStats = readClientStats?.();
+    let latencies = new Array(scenario.calls);
+    const memoryBefore = captureMemorySnapshot({ forceGc: scenario.forceGc });
+    const startedAt = performance.now();
+    const sampleClientStats = () => {
+      const stats = readClientStats?.();
+      if (!stats) return;
+      lastClientStats = stats;
+      maxWireInFlight = Math.max(maxWireInFlight, stats.wireInFlight ?? 0);
+      if (stats.poolRunning !== void 0 || stats.poolQueued !== void 0) {
+        sawPoolStats = true;
+        maxPoolRunning = Math.max(maxPoolRunning, stats.poolRunning ?? 0);
+        maxPoolQueued = Math.max(maxPoolQueued, stats.poolQueued ?? 0);
+      }
+      if (stats.adaptiveLimit !== void 0) {
+        sawAdaptiveStats = true;
+        minAdaptiveLimit = Math.min(minAdaptiveLimit, stats.adaptiveLimit);
+        maxAdaptiveLimit = Math.max(maxAdaptiveLimit, stats.adaptiveLimit);
+        maxAdaptiveInFlight = Math.max(maxAdaptiveInFlight, stats.adaptiveInFlight ?? 0);
+        maxAdaptiveQueueDepth = Math.max(maxAdaptiveQueueDepth, stats.adaptiveQueueDepth ?? 0);
+      }
+      maxLifecycleQueueDepth = Math.max(maxLifecycleQueueDepth, stats.lifecycleQueueDepth ?? 0);
+    };
+    const sampleTimer = readClientStats ? setInterval(sampleClientStats, scenario.statsSampleMs) : void 0;
+    const finish = () => {
+      if (sampleTimer) clearInterval(sampleTimer);
+      sampleClientStats();
+      const durationMs = performance.now() - startedAt;
+      const observabilityFlushMs = flushObservability(observability);
+      const latencyPercentiles = percentiles(latencies);
+      latencies = [];
+      const memoryAfter = captureMemorySnapshot({ forceGc: scenario.forceGc });
+      const serverStats = server.stats();
+      const tracerStats = observability?.tracer.stats();
+      resolve2(Object.freeze({
+        variant: scenario.variant,
+        label: scenario.label,
+        calls: scenario.calls,
+        warmupCalls: scenario.warmupCalls,
+        concurrency: scenario.concurrency,
+        delayMs: scenario.delayMs,
+        timeoutMs: scenario.timeoutMs,
+        successCount,
+        errorCount,
+        durationMs: round7(durationMs),
+        httpPerSec: round7(scenario.calls / Math.max(durationMs / 1e3, 1e-3)),
+        requestP50Ms: latencyPercentiles.p50,
+        requestP90Ms: latencyPercentiles.p90,
+        requestP95Ms: latencyPercentiles.p95,
+        requestP99Ms: latencyPercentiles.p99,
+        serverRequests: serverStats.requests,
+        serverMaxInFlight: serverStats.maxInFlight,
+        clientMaxInFlight: maxClientInFlight,
+        clientWireMaxInFlight: maxWireInFlight,
+        ...sawPoolStats ? {
+          clientPoolMaxRunning: maxPoolRunning,
+          clientPoolMaxQueued: maxPoolQueued
+        } : {},
+        ...sawAdaptiveStats ? {
+          adaptiveMinLimit: minAdaptiveLimit,
+          adaptiveMaxLimit: maxAdaptiveLimit,
+          adaptiveFinalLimit: lastClientStats?.adaptiveLimit ?? 0,
+          adaptiveMaxInFlight: maxAdaptiveInFlight,
+          adaptiveMaxQueueDepth: maxAdaptiveQueueDepth,
+          adaptiveFinalGradient: lastClientStats?.adaptiveGradient ?? 0,
+          adaptiveWindowSize: lastClientStats?.adaptiveWindowSize ?? 0
+        } : {},
+        lifecycleMaxQueueDepth: maxLifecycleQueueDepth,
+        clientStarted: delta(lastClientStats?.wireStarted, initialClientStats?.wireStarted),
+        clientSucceeded: delta(lastClientStats?.wireSucceeded, initialClientStats?.wireSucceeded),
+        clientFailed: delta(lastClientStats?.wireFailed, initialClientStats?.wireFailed),
+        clientTimedOut: delta(lastClientStats?.wireTimedOut, initialClientStats?.wireTimedOut),
+        lifecycleStarted: delta(lastClientStats?.lifecycleStarted, initialClientStats?.lifecycleStarted),
+        lifecycleCompleted: delta(lastClientStats?.lifecycleCompleted, initialClientStats?.lifecycleCompleted),
+        lifecycleFailed: delta(lastClientStats?.lifecycleFailed, initialClientStats?.lifecycleFailed),
+        observedFinishedSpans: tracerStats?.finishedSpans ?? 0,
+        observedPrunedSpans: tracerStats?.prunedFinishedSpans ?? 0,
+        observabilityFlushMs,
+        gcAvailable: memoryAfter.gcAvailable,
+        memory: {
+          before: memoryBefore,
+          after: memoryAfter,
+          delta: diffMemorySnapshots(memoryBefore, memoryAfter)
+        },
+        firstError: firstError ? String(firstError) : void 0
+      }));
+    };
+    const launch = () => {
+      while (inFlight < scenario.concurrency && next < scenario.calls) {
+        const id = next++;
+        const requestId = id + (scenario.idOffset ?? 0);
+        const requestStartedAt = performance.now();
+        inFlight++;
+        if (inFlight > maxClientInFlight) maxClientInFlight = inFlight;
+        sampleClientStats();
+        runOne(requestId, (result) => {
+          latencies[id] = performance.now() - requestStartedAt;
+          inFlight--;
+          completed++;
+          if (result.ok) {
+            successCount++;
+          } else {
+            errorCount++;
+            if (firstError === void 0) firstError = result.error ?? "unknown HTTP profiler error";
+          }
+          sampleClientStats();
+          if (completed === scenario.calls) {
+            finish();
+            return;
+          }
+          launch();
+        });
+      }
+    };
+    try {
+      launch();
+    } catch (error) {
+      if (sampleTimer) clearInterval(sampleTimer);
+      reject(error);
+    }
+  });
+}
+function snapshotWireStats(stats) {
+  return {
+    wireInFlight: stats.inFlight,
+    wireStarted: stats.started,
+    wireSucceeded: stats.succeeded,
+    wireFailed: stats.failed,
+    wireTimedOut: stats.timedOut,
+    poolRunning: stats.pool?.running,
+    poolQueued: stats.pool?.queued,
+    adaptiveLimit: stats.adaptiveLimiter?.limit,
+    adaptiveInFlight: stats.adaptiveLimiter?.inFlight,
+    adaptiveQueueDepth: stats.adaptiveLimiter?.queueDepth,
+    adaptiveGradient: stats.adaptiveLimiter?.gradient,
+    adaptiveWindowSize: stats.adaptiveLimiter?.windowSize
+  };
+}
+function snapshotLifecycleStats(stats) {
+  return {
+    ...snapshotWireStats(stats.wire),
+    lifecycleQueueDepth: stats.queueDepth,
+    lifecycleStarted: stats.requestsStarted,
+    lifecycleCompleted: stats.requestsCompleted,
+    lifecycleFailed: stats.requestsFailed
+  };
+}
+function flushObservability(observability) {
+  if (!observability) return 0;
+  const startedAt = performance.now();
+  observability.hooks.flush?.(Number.MAX_SAFE_INTEGER);
+  return round7(performance.now() - startedAt);
+}
+function dropFinishedSpans(observability) {
+  if (!observability) return;
+  const spanIds = observability.tracer.exportFinished().map((span) => span.spanId);
+  if (spanIds.length > 0) observability.tracer.pruneFinished(spanIds);
+}
+function percentiles(samples) {
+  const sorted = samples.filter((value) => Number.isFinite(value)).sort((a, b) => a - b);
+  return {
+    p50: round7(percentile(sorted, 0.5)),
+    p90: round7(percentile(sorted, 0.9)),
+    p95: round7(percentile(sorted, 0.95)),
+    p99: round7(percentile(sorted, 0.99))
+  };
+}
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const idx = Math.ceil(p * sorted.length) - 1;
+  return sorted[Math.max(0, idx)] ?? 0;
+}
+function labelForVariant2(variant) {
+  switch (variant) {
+    case "node-http-text":
+      return "node:http transport text";
+    case "wire-raw":
+      return "brass wire raw";
+    case "default-minimal-json":
+      return "default client minimal JSON";
+    case "default-balanced-no-adaptive-json":
+      return "default client balanced JSON without adaptive limiter";
+    case "default-balanced-json":
+      return "default client balanced JSON";
+    case "default-json":
+      return "default client JSON";
+    case "default-json-observed":
+      return "default client JSON + observability";
+  }
+}
+function normalizeVariants(value) {
+  if (!value || value.length === 0) return HTTP_PROFILE_VARIANTS;
+  const allowed = new Set(HTTP_PROFILE_VARIANTS);
+  const variants = value.filter((variant) => allowed.has(variant));
+  return Object.freeze(variants.length > 0 ? variants : [...HTTP_PROFILE_VARIANTS]);
+}
+function delta(current, baseline) {
+  return Math.max(0, (current ?? 0) - (baseline ?? 0));
+}
+function positiveInt3(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(1, Math.floor(value));
+}
+function nonNegativeInt(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+}
+function round7(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+
+// src/perf/httpMemoryLab.ts
+var DEFAULT_MEMORY_VARIANTS = [
+  "node-http-text",
+  "wire-raw",
+  "default-minimal-json",
+  "default-balanced-no-adaptive-json",
+  "default-balanced-json",
+  "default-json",
+  "default-json-observed"
+];
+async function profileHttpMemoryLab(options = {}) {
+  const calls = positiveInt4(options.calls, 2e4);
+  const concurrency = positiveInt4(options.concurrency, 512);
+  const delayMs = nonNegativeInt2(options.delayMs, 2);
+  const timeoutMs = positiveInt4(options.timeoutMs, 3e4);
+  const warmupCalls = nonNegativeInt2(options.warmupCalls, Math.min(2e3, Math.floor(calls / 10)));
+  const statsSampleMs = positiveInt4(options.statsSampleMs, 10);
+  const rounds = positiveInt4(options.rounds, 1);
+  const forceGc2 = options.forceGc ?? true;
+  const variants = options.variants && options.variants.length > 0 ? options.variants : DEFAULT_MEMORY_VARIANTS;
+  const roundsData = [];
+  for (let i = 0; i < rounds; i++) {
+    const report = await profileHttpLayers({
+      calls,
+      concurrency,
+      delayMs,
+      timeoutMs,
+      warmupCalls,
+      statsSampleMs,
+      forceGc: forceGc2,
+      variants
+    });
+    roundsData.push(Object.freeze({
+      round: i + 1,
+      results: report.results
+    }));
+  }
+  const summaries = summarizeByVariant(roundsData, {
+    calls,
+    heapWarnMb: options.heapWarnMb ?? 16,
+    heapCriticalMb: options.heapCriticalMb ?? 64,
+    heapPer10kWarnMb: options.heapPer10kWarnMb ?? 4
+  });
+  return Object.freeze({
+    calls,
+    concurrency,
+    delayMs,
+    warmupCalls,
+    rounds,
+    forceGc: forceGc2,
+    variants: Object.freeze([...variants]),
+    summaries,
+    roundsData: Object.freeze(roundsData),
+    recommendations: makeHttpMemoryRecommendations(summaries, forceGc2)
+  });
+}
+function formatHttpMemoryLabReport(report) {
+  const lines = [];
+  lines.push("Brass HTTP Long-Run Memory Lab");
+  lines.push(`calls=${report.calls} concurrency=${report.concurrency} delay=${report.delayMs}ms rounds=${report.rounds} forceGc=${report.forceGc}`);
+  lines.push("");
+  lines.push("Variants");
+  for (const summary of report.summaries) {
+    lines.push(`- ${summary.variant}: ${formatNumber3(summary.meanHttpPerSec)} http/s, maxP99=${summary.maxP99Ms}ms, heap=${summary.totalHeapDeltaMb}MB (${summary.heapDeltaPer10kRequestsMb}MB/10k), rss=${summary.totalRssDeltaMb}MB, errors=${summary.totalErrors}, verdict=${summary.verdict}`);
+    for (const note of summary.notes) lines.push(`  note: ${note}`);
+  }
+  lines.push("");
+  lines.push("Recommendations");
+  for (const recommendation of report.recommendations) lines.push(`- ${recommendation}`);
+  return lines.join("\n");
+}
+function summarizeByVariant(roundsData, thresholds) {
+  const byVariant = /* @__PURE__ */ new Map();
+  for (const round10 of roundsData) {
+    for (const result of round10.results) {
+      const items = byVariant.get(result.variant) ?? [];
+      items.push(result);
+      byVariant.set(result.variant, items);
+    }
+  }
+  return Object.freeze([...byVariant.entries()].map(([variant, results]) => {
+    const totalCalls = results.reduce((sum2, result) => sum2 + result.calls, 0);
+    const heapDeltas = results.map((result) => result.memory.delta.heapUsedMb);
+    const rssDeltas = results.map((result) => result.memory.delta.rssMb);
+    const totalHeapDeltaMb = round8(sum(heapDeltas));
+    const totalRssDeltaMb = round8(sum(rssDeltas));
+    const heapDeltaPer10kRequestsMb = round8(totalHeapDeltaMb / Math.max(totalCalls / 1e4, 1));
+    const gcAvailable = results.every((result) => result.gcAvailable);
+    const maxHeapDeltaMb = round8(Math.max(...heapDeltas));
+    const maxRssDeltaMb = round8(Math.max(...rssDeltas));
+    const verdict = memoryVerdict({
+      gcAvailable,
+      totalHeapDeltaMb,
+      heapDeltaPer10kRequestsMb,
+      heapWarnMb: thresholds.heapWarnMb,
+      heapCriticalMb: thresholds.heapCriticalMb,
+      heapPer10kWarnMb: thresholds.heapPer10kWarnMb
+    });
+    return Object.freeze({
+      variant,
+      label: results[0]?.label ?? variant,
+      rounds: results.length,
+      callsPerRound: thresholds.calls,
+      totalCalls,
+      meanHttpPerSec: round8(mean(results.map((result) => result.httpPerSec))),
+      minHttpPerSec: round8(Math.min(...results.map((result) => result.httpPerSec))),
+      maxHttpPerSec: round8(Math.max(...results.map((result) => result.httpPerSec))),
+      maxP99Ms: round8(Math.max(...results.map((result) => result.requestP99Ms))),
+      totalHeapDeltaMb,
+      maxHeapDeltaMb,
+      heapDeltaPer10kRequestsMb,
+      totalRssDeltaMb,
+      maxRssDeltaMb,
+      totalErrors: results.reduce((sum2, result) => sum2 + result.errorCount, 0),
+      gcAvailable,
+      observedFinishedSpans: results.reduce((sum2, result) => sum2 + (result.observedFinishedSpans ?? 0), 0),
+      adaptiveFinalLimit: lastDefined(results.map((result) => result.adaptiveFinalLimit)),
+      verdict,
+      notes: Object.freeze(notesForVariant(variant, verdict, gcAvailable, heapDeltaPer10kRequestsMb))
+    });
+  }));
+}
+function memoryVerdict(input) {
+  if (!input.gcAvailable) return "unknown-gc";
+  if (input.totalHeapDeltaMb >= input.heapCriticalMb) return "critical";
+  if (input.totalHeapDeltaMb >= input.heapWarnMb) return "watch";
+  if (input.heapDeltaPer10kRequestsMb >= input.heapPer10kWarnMb) return "watch";
+  return "ok";
+}
+function notesForVariant(variant, verdict, gcAvailable, heapDeltaPer10kRequestsMb) {
+  const notes = [];
+  if (!gcAvailable) notes.push("GC was unavailable; heap delta may be allocator churn rather than retained memory.");
+  if (verdict === "watch") notes.push(`Retained heap is worth watching at ${heapDeltaPer10kRequestsMb}MB per 10k requests.`);
+  if (verdict === "critical") notes.push("Retained heap crossed the critical threshold after GC.");
+  if (variant === "default-json-observed") notes.push("Includes client observability middleware and span retention pressure.");
+  if (variant === "default-json") notes.push("Default preset includes adaptive limiter and safe-method cache policy.");
+  if (variant === "default-balanced-no-adaptive-json") notes.push("Balanced preset without adaptive limiter isolates limiter overhead.");
+  return Object.freeze(notes);
+}
+function makeHttpMemoryRecommendations(summaries, forceGc2) {
+  const recommendations = [];
+  if (!summaries.every((summary) => summary.gcAvailable)) {
+    recommendations.push("Re-run with node --expose-gc to distinguish allocator churn from retained references.");
+  } else if (forceGc2) {
+    recommendations.push("GC was available; positive heap deltas are stronger retention signals than non-GC runs.");
+  }
+  const critical = summaries.filter((summary) => summary.verdict === "critical");
+  const watch = summaries.filter((summary) => summary.verdict === "watch");
+  if (critical.length > 0) {
+    recommendations.push(`Critical retained heap in: ${critical.map((summary) => summary.variant).join(", ")}.`);
+  } else if (watch.length > 0) {
+    recommendations.push(`Watch retained heap in: ${watch.map((summary) => summary.variant).join(", ")}.`);
+  } else if (summaries.every((summary) => summary.gcAvailable)) {
+    recommendations.push("No variant crossed retained-heap thresholds after GC.");
+  }
+  const observed = summaries.find((summary) => summary.variant === "default-json-observed");
+  const def = summaries.find((summary) => summary.variant === "default-json");
+  if (observed && def) {
+    const observedHeapOverDefault = round8(observed.heapDeltaPer10kRequestsMb - def.heapDeltaPer10kRequestsMb);
+    const throughputRatio = def.meanHttpPerSec > 0 ? round8(observed.meanHttpPerSec / def.meanHttpPerSec * 100) : 100;
+    recommendations.push(`Observability vs default: heapDeltaPer10k ${signed2(observedHeapOverDefault)}MB, throughput ${throughputRatio}% of default.`);
+  }
+  const lowestHeap = [...summaries].sort((a, b) => a.heapDeltaPer10kRequestsMb - b.heapDeltaPer10kRequestsMb)[0];
+  const fastest = [...summaries].sort((a, b) => b.meanHttpPerSec - a.meanHttpPerSec)[0];
+  if (lowestHeap) recommendations.push(`Lowest heap/10k variant: ${lowestHeap.variant} (${lowestHeap.heapDeltaPer10kRequestsMb}MB/10k).`);
+  if (fastest) recommendations.push(`Fastest variant: ${fastest.variant} (${formatNumber3(fastest.meanHttpPerSec)} http/s).`);
+  return Object.freeze(recommendations);
+}
+function positiveInt4(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(1, Math.floor(value));
+}
+function nonNegativeInt2(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, Math.floor(value));
+}
+function mean(values) {
+  return values.length === 0 ? 0 : sum(values) / values.length;
+}
+function sum(values) {
+  return values.reduce((acc, value) => acc + value, 0);
+}
+function lastDefined(values) {
+  for (let i = values.length - 1; i >= 0; i--) {
+    if (values[i] !== void 0) return values[i];
+  }
+  return void 0;
+}
+function signed2(value) {
+  return value >= 0 ? `+${value}` : String(value);
+}
+function formatNumber3(value) {
+  return value >= 1e3 ? value.toLocaleString("en-US", { maximumFractionDigits: 0 }) : value.toFixed(3);
+}
+function round8(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+
+// src/perf/history.ts
+import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
+import { join, resolve } from "path";
+var DEFAULT_HISTORY_DIR = ".brass/perf-history";
+var DEFAULT_HISTORY_FILE = "runs.jsonl";
+var DEFAULT_BASELINES_DIR = "baselines";
+function defaultPerfHistoryDirectory(cwd = process.cwd()) {
+  return join(cwd, DEFAULT_HISTORY_DIR);
+}
+function createPerfHistoryEntry(profile, report, options = {}) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const metrics = extractPerfMetrics(profile, report);
+  return Object.freeze({
+    id: makeEntryId(profile, timestamp),
+    timestamp,
+    profile,
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    metrics,
+    ...options.metadata ? { metadata: Object.freeze({ ...options.metadata }) } : {},
+    ...options.includeReport ? { report } : {}
+  });
+}
+async function recordPerfHistoryRun(profile, report, options = {}) {
+  const entry = createPerfHistoryEntry(profile, report, options);
+  const path = await writePerfHistoryEntry(entry, options);
+  return Object.freeze({ entry, path });
+}
+async function writePerfHistoryEntry(entry, options = {}) {
+  const paths = resolveStorePaths(options);
+  await mkdir(paths.directory, { recursive: true });
+  await appendFile(paths.historyFile, `${JSON.stringify(entry)}
+`, "utf8");
+  if (options.maxEntries && options.maxEntries > 0) {
+    await pruneHistoryFile(paths.historyFile, Math.floor(options.maxEntries));
+  }
+  return paths.historyFile;
+}
+async function readPerfHistory(options = {}) {
+  const paths = resolveStorePaths(options);
+  let raw = "";
+  try {
+    raw = await readFile(paths.historyFile, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return Object.freeze([]);
+    throw error;
+  }
+  const entries = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      entries.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return Object.freeze(entries);
+}
+async function savePerfBaseline(name, entry, options = {}) {
+  const paths = resolveStorePaths(options);
+  await mkdir(paths.baselinesDirectory, { recursive: true });
+  const baseline = Object.freeze({
+    name,
+    savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    entry
+  });
+  const path = baselinePath(paths, name);
+  await writeFile(path, `${JSON.stringify(baseline, null, 2)}
+`, "utf8");
+  return Object.freeze({ baseline, path });
+}
+async function loadPerfBaseline(name, options = {}) {
+  const paths = resolveStorePaths(options);
+  try {
+    return JSON.parse(await readFile(baselinePath(paths, name), "utf8"));
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function comparePerfToBaseline(current, baseline, thresholds = {}) {
+  const normalized = normalizeThresholds2(thresholds);
+  const currentByKey = new Map(current.metrics.map((metric) => [metricKey(metric), metric]));
+  const items = [];
+  const missingMetrics = [];
+  for (const baselineMetric of baseline.entry.metrics) {
+    if (baselineMetric.direction === "neutral") continue;
+    const currentMetric = currentByKey.get(metricKey(baselineMetric));
+    if (!currentMetric) {
+      missingMetrics.push(formatMetricName(baselineMetric));
+      continue;
+    }
+    const item = compareMetric(currentMetric, baselineMetric, normalized);
+    items.push(item);
+  }
+  const hasFailures = items.some((item) => item.status === "fail") || normalized.failOnMissingMetric && missingMetrics.length > 0;
+  const hasWarnings = items.some((item) => item.status === "warn") || !normalized.failOnMissingMetric && missingMetrics.length > 0;
+  const status = hasFailures ? "fail" : hasWarnings ? "warn" : "pass";
+  return Object.freeze({
+    baselineName: baseline.name,
+    baselineId: baseline.entry.id,
+    currentId: current.id,
+    comparedMetrics: items.length,
+    missingMetrics: Object.freeze(missingMetrics),
+    status,
+    passed: status !== "fail",
+    items: Object.freeze(items)
+  });
+}
+function formatPerfBaselineComparison(comparison) {
+  const lines = [];
+  lines.push(`Baseline comparison: ${comparison.baselineName} status=${comparison.status}`);
+  lines.push(`compared=${comparison.comparedMetrics} missing=${comparison.missingMetrics.length}`);
+  for (const item of comparison.items.filter((candidate) => candidate.status !== "pass")) {
+    const sign = item.deltaPercent >= 0 ? "+" : "";
+    lines.push(`- [${item.status}] ${formatMetricName(item.metric)} ${item.baselineValue} -> ${item.currentValue} (${sign}${item.deltaPercent}%)`);
+    lines.push(`  ${item.reason}`);
+  }
+  for (const missing of comparison.missingMetrics) {
+    lines.push(`- [warn] missing metric: ${missing}`);
+  }
+  if (comparison.items.every((item) => item.status === "pass") && comparison.missingMetrics.length === 0) {
+    lines.push("- all comparable metrics stayed within baseline thresholds");
+  }
+  return lines.join("\n");
+}
+function extractPerfMetrics(profile, report) {
+  const metrics = [];
+  if (isBrassPerformanceReport(report)) {
+    if (report.runtime) pushRuntimeMetrics(metrics, "runtime", report.runtime);
+    if (report.http) pushHttpMetrics(metrics, "http", report.http);
+    if (report.memory) {
+      pushMetric(metrics, "profile.heap_delta_mb", report.memory.delta.heapUsedMb, "MB", "lower-is-better", { profile });
+      pushMetric(metrics, "profile.rss_delta_mb", report.memory.delta.rssMb, "MB", "lower-is-better", { profile });
+    }
+    return Object.freeze(metrics);
+  }
+  if (isRuntimeAbReport(report)) {
+    pushRuntimeMetrics(metrics, "runtime_ab.baseline", report.baseline);
+    pushRuntimeMetrics(metrics, "runtime_ab.candidate", report.candidate);
+    for (const comparison of report.comparisons) {
+      pushMetric(metrics, "runtime_ab.delta_percent", comparison.deltaPercent, "%", "higher-is-better", {
+        primitive: comparison.primitive,
+        baseline: report.baselineVariant,
+        candidate: report.candidateVariant
+      });
+    }
+    pushMetric(metrics, "runtime_ab.heap_delta_mb", report.memory.delta.heapUsedMb, "MB", "lower-is-better", { profile });
+    pushMetric(metrics, "runtime_ab.rss_delta_mb", report.memory.delta.rssMb, "MB", "lower-is-better", { profile });
+    return Object.freeze(metrics);
+  }
+  if (isRuntimeSoakReport(report)) {
+    pushMetric(metrics, "runtime_soak.throughput_trend_percent", report.throughputTrendPercent, "%", "higher-is-better", { variant: report.variant });
+    pushMetric(metrics, "runtime_soak.heap_trend_mb", report.heapTrendMb, "MB", "lower-is-better", { variant: report.variant });
+    pushMetric(metrics, "runtime_soak.heap_delta_mb", report.memory.delta.heapUsedMb, "MB", "lower-is-better", { variant: report.variant });
+    for (const round10 of report.rounds) {
+      pushMetric(metrics, "runtime_soak.aggregate_ops_per_second", aggregateRuntimeOps(round10.report), "ops/s", "higher-is-better", {
+        variant: report.variant,
+        round: String(round10.round)
+      });
+    }
+    return Object.freeze(metrics);
+  }
+  if (isHttpMemoryLabReport(report)) {
+    for (const summary of report.summaries) pushHttpMemoryMetrics(metrics, summary);
+    return Object.freeze(metrics);
+  }
+  if (isHttpLayerProfileReport(report)) {
+    pushHttpMetrics(metrics, "http", report);
+    return Object.freeze(metrics);
+  }
+  if (isRuntimePrimitiveProfileReport(report)) {
+    pushRuntimeMetrics(metrics, "runtime", report);
+  }
+  return Object.freeze(metrics);
+}
+function pushRuntimeMetrics(metrics, prefix, report) {
+  for (const result of report.results) {
+    const tags = { variant: report.variant, primitive: result.name };
+    pushMetric(metrics, `${prefix}.ops_per_second`, result.operationsPerSecond, `${result.unit}/s`, "higher-is-better", tags);
+    pushMetric(metrics, `${prefix}.ns_per_operation`, result.nsPerOperation, "ns/op", "lower-is-better", tags);
+    pushMetric(metrics, `${prefix}.fibers_per_1000_ops`, result.fibersPerThousandOps, "fibers/1k", "lower-is-better", tags);
+  }
+}
+function pushHttpMetrics(metrics, prefix, report) {
+  for (const result of report.results) {
+    const tags = { variant: result.variant };
+    pushMetric(metrics, `${prefix}.requests_per_second`, result.httpPerSec, "http/s", "higher-is-better", tags);
+    pushMetric(metrics, `${prefix}.p99_ms`, result.requestP99Ms, "ms", "lower-is-better", tags);
+    pushMetric(metrics, `${prefix}.heap_delta_mb`, result.memory.delta.heapUsedMb, "MB", "lower-is-better", tags);
+    pushMetric(metrics, `${prefix}.rss_delta_mb`, result.memory.delta.rssMb, "MB", "lower-is-better", tags);
+    pushMetric(metrics, `${prefix}.errors`, result.errorCount, "count", "lower-is-better", tags);
+  }
+}
+function pushHttpMemoryMetrics(metrics, summary) {
+  const tags = { variant: summary.variant };
+  pushMetric(metrics, "http_memory.mean_requests_per_second", summary.meanHttpPerSec, "http/s", "higher-is-better", tags);
+  pushMetric(metrics, "http_memory.max_p99_ms", summary.maxP99Ms, "ms", "lower-is-better", tags);
+  pushMetric(metrics, "http_memory.heap_per_10k_mb", summary.heapDeltaPer10kRequestsMb, "MB/10k", "lower-is-better", tags);
+  pushMetric(metrics, "http_memory.total_heap_delta_mb", summary.totalHeapDeltaMb, "MB", "lower-is-better", tags);
+  pushMetric(metrics, "http_memory.total_rss_delta_mb", summary.totalRssDeltaMb, "MB", "lower-is-better", tags);
+  pushMetric(metrics, "http_memory.errors", summary.totalErrors, "count", "lower-is-better", tags);
+}
+function pushMetric(metrics, name, value, unit, direction, tags) {
+  if (!Number.isFinite(value)) return;
+  metrics.push(Object.freeze({
+    name,
+    value: round9(value),
+    unit,
+    direction,
+    ...tags ? { tags: Object.freeze({ ...tags }) } : {}
+  }));
+}
+function compareMetric(current, baseline, thresholds) {
+  const delta2 = round9(current.value - baseline.value);
+  const deltaPercent = round9(percentDelta2(current.value, baseline.value));
+  const regressionPercent = regressionFor(current, baseline);
+  const limit = isHeapLikeMetric(current) ? thresholds.maxHeapRegressionPercent : thresholds.maxRegressionPercent;
+  const warnLimit = limit * thresholds.warnAtRatio;
+  const status = regressionPercent > limit ? "fail" : regressionPercent > warnLimit ? "warn" : "pass";
+  return Object.freeze({
+    metric: current,
+    baselineValue: baseline.value,
+    currentValue: current.value,
+    delta: delta2,
+    deltaPercent,
+    status,
+    reason: reasonForMetric(current, regressionPercent, limit)
+  });
+}
+function regressionFor(current, baseline) {
+  if (current.direction === "higher-is-better") {
+    if (baseline.value <= 0) return current.value < baseline.value ? 100 : 0;
+    return Math.max(0, (baseline.value - current.value) / baseline.value * 100);
+  }
+  if (current.direction === "lower-is-better") {
+    if (baseline.value === 0) return current.value > 0 ? 100 : 0;
+    return Math.max(0, (current.value - baseline.value) / Math.abs(baseline.value) * 100);
+  }
+  return 0;
+}
+function reasonForMetric(metric, regressionPercent, limit) {
+  if (regressionPercent <= 0) return "no regression against baseline";
+  return `${formatMetricName(metric)} regressed ${round9(regressionPercent)}% (limit ${limit}%)`;
+}
+function resolveStorePaths(options) {
+  const directory = resolve(options.directory ?? defaultPerfHistoryDirectory());
+  return Object.freeze({
+    directory,
+    historyFile: join(directory, options.historyFileName ?? DEFAULT_HISTORY_FILE),
+    baselinesDirectory: join(directory, options.baselinesDirectoryName ?? DEFAULT_BASELINES_DIR)
+  });
+}
+function baselinePath(paths, name) {
+  return join(paths.baselinesDirectory, `${sanitizeBaselineName(name)}.json`);
+}
+function sanitizeBaselineName(name) {
+  let safe = "";
+  let lastWasReplacement = false;
+  for (const char of name.trim()) {
+    if (isSafeBaselineNameChar(char)) {
+      safe += char;
+      lastWasReplacement = false;
+      continue;
+    }
+    if (safe.length > 0 && !lastWasReplacement) {
+      safe += "-";
+      lastWasReplacement = true;
+    }
+  }
+  let start = 0;
+  let end = safe.length;
+  while (start < end && safe.charCodeAt(start) === HYPHEN_CODE) start += 1;
+  while (end > start && safe.charCodeAt(end - 1) === HYPHEN_CODE) end -= 1;
+  const normalized = safe.slice(start, end);
+  return normalized.length > 0 ? normalized : "baseline";
+}
+var HYPHEN_CODE = 45;
+var DOT_CODE = 46;
+var UNDERSCORE_CODE = 95;
+var ZERO_CODE = 48;
+var NINE_CODE = 57;
+var UPPER_A_CODE = 65;
+var UPPER_Z_CODE = 90;
+var LOWER_A_CODE = 97;
+var LOWER_Z_CODE = 122;
+function isSafeBaselineNameChar(char) {
+  if (char.length !== 1) return false;
+  const code = char.charCodeAt(0);
+  return code === HYPHEN_CODE || code === DOT_CODE || code === UNDERSCORE_CODE || code >= ZERO_CODE && code <= NINE_CODE || code >= UPPER_A_CODE && code <= UPPER_Z_CODE || code >= LOWER_A_CODE && code <= LOWER_Z_CODE;
+}
+async function pruneHistoryFile(historyFile, maxEntries) {
+  const raw = await readFile(historyFile, "utf8");
+  const lines = raw.split(/\r?\n/).filter((line) => line.trim().length > 0);
+  if (lines.length <= maxEntries) return;
+  await writeFile(historyFile, `${lines.slice(-maxEntries).join("\n")}
+`, "utf8");
+}
+function normalizeThresholds2(thresholds) {
+  return {
+    maxRegressionPercent: positiveNumber2(thresholds.maxRegressionPercent, 10),
+    maxHeapRegressionPercent: positiveNumber2(thresholds.maxHeapRegressionPercent, 25),
+    warnAtRatio: clamp(positiveNumber2(thresholds.warnAtRatio, 0.5), 0, 1),
+    failOnMissingMetric: thresholds.failOnMissingMetric ?? false
+  };
+}
+function aggregateRuntimeOps(report) {
+  const units = report.results.reduce((sum2, result) => sum2 + result.units, 0);
+  const durationMs = report.results.reduce((sum2, result) => sum2 + result.durationMs, 0);
+  return round9(units / Math.max(durationMs / 1e3, 1e-3));
+}
+function metricKey(metric) {
+  const tags = metric.tags ? Object.entries(metric.tags).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}=${value}`).join(",") : "";
+  return `${metric.name}|${tags}`;
+}
+function formatMetricName(metric) {
+  const tags = metric.tags ? Object.entries(metric.tags).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}=${value}`).join(",") : "";
+  return tags.length > 0 ? `${metric.name}{${tags}}` : metric.name;
+}
+function isHeapLikeMetric(metric) {
+  return metric.name.includes("heap") || metric.name.includes("rss");
+}
+function makeEntryId(profile, timestamp) {
+  return `${profile}-${timestamp.replace(/[^0-9A-Za-z]/g, "")}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function isBrassPerformanceReport(value) {
+  return isRecord(value) && ("recorder" in value || "recommendations" in value) && ("runtime" in value || "http" in value || "memory" in value);
+}
+function isRuntimePrimitiveProfileReport(value) {
+  return isRecord(value) && Array.isArray(value.results) && typeof value.variant === "string" && typeof value.chainDepth === "number";
+}
+function isHttpLayerProfileReport(value) {
+  return isRecord(value) && Array.isArray(value.results) && typeof value.calls === "number" && value.results.some((item) => isRecord(item) && "httpPerSec" in item);
+}
+function isRuntimeAbReport(value) {
+  return isRecord(value) && Array.isArray(value.comparisons) && isRuntimePrimitiveProfileReport(value.baseline) && isRuntimePrimitiveProfileReport(value.candidate);
+}
+function isRuntimeSoakReport(value) {
+  return isRecord(value) && Array.isArray(value.rounds) && typeof value.throughputTrendPercent === "number" && typeof value.variant === "string";
+}
+function isHttpMemoryLabReport(value) {
+  return isRecord(value) && Array.isArray(value.summaries) && Array.isArray(value.roundsData);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isNodeError(value) {
+  return value instanceof Error && "code" in value;
+}
+function positiveNumber2(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, value);
+}
+function percentDelta2(current, baseline) {
+  if (baseline === 0) return current === 0 ? 0 : 100;
+  return (current - baseline) / Math.abs(baseline) * 100;
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function round9(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+
+// src/perf/recommendations.ts
+function recommendPerformance(input) {
+  const thresholds = {
+    maxHeapDeltaMb: input.thresholds?.maxHeapDeltaMb ?? 16,
+    criticalHeapDeltaMb: input.thresholds?.criticalHeapDeltaMb ?? 64,
+    minDefaultVsNodeRatio: input.thresholds?.minDefaultVsNodeRatio ?? 0.7,
+    minObservedVsDefaultRatio: input.thresholds?.minObservedVsDefaultRatio ?? 0.7,
+    maxHttpP99Ms: input.thresholds?.maxHttpP99Ms ?? Math.max(250, (input.http?.delayMs ?? 1) * 80),
+    minRuntimeOpsPerSecond: input.thresholds?.minRuntimeOpsPerSecond ?? 25e3
+  };
+  const out = [];
+  addHttpRecommendations(out, input.http, thresholds);
+  addRuntimeRecommendations(out, input.runtime, thresholds);
+  addMemoryRecommendations(out, input.memoryDelta, thresholds);
+  if (out.length === 0) {
+    out.push({
+      severity: "info",
+      area: "benchmark",
+      title: "No obvious performance regression",
+      message: "The sampled runtime, HTTP, and memory signals are inside the default profiler thresholds.",
+      action: "Keep this report as a baseline and compare it after larger runtime or HTTP changes."
+    });
+  }
+  return Object.freeze(out.map((item) => Object.freeze(item)));
+}
+function addHttpRecommendations(out, report, thresholds) {
+  if (!report) return;
+  const node = findResult(report, "node-http-text");
+  const def = findResult(report, "default-json");
+  const observed = findResult(report, "default-json-observed");
+  for (const result of report.results) {
+    if (result.errorCount > 0) {
+      out.push({
+        severity: "critical",
+        area: "http",
+        title: `HTTP errors in ${result.variant}`,
+        message: `${result.errorCount} of ${result.calls} profiled requests failed.`,
+        evidence: {
+          variant: result.variant,
+          firstError: result.firstError,
+          successCount: result.successCount,
+          errorCount: result.errorCount
+        },
+        action: "Inspect timeout, pool, queue, retry, and server-side pressure before trusting throughput numbers."
+      });
+    }
+    if (result.memory.delta.heapUsedMb >= thresholds.criticalHeapDeltaMb) {
+      out.push(memoryRecommendation("critical", result));
+    } else if (result.memory.delta.heapUsedMb >= thresholds.maxHeapDeltaMb) {
+      out.push(memoryRecommendation("warn", result));
+    }
+    if (result.requestP99Ms > thresholds.maxHttpP99Ms) {
+      out.push({
+        severity: "warn",
+        area: "http",
+        title: `High p99 latency in ${result.variant}`,
+        message: `p99 was ${result.requestP99Ms}ms against a ${report.delayMs}ms local server delay.`,
+        evidence: {
+          variant: result.variant,
+          p50Ms: result.requestP50Ms,
+          p95Ms: result.requestP95Ms,
+          p99Ms: result.requestP99Ms,
+          thresholdMs: thresholds.maxHttpP99Ms
+        },
+        action: "Compare queue depth, adaptive limiter state, and observability overhead for this variant."
+      });
+    }
+    if ((result.lifecycleMaxQueueDepth ?? 0) > 0 || (result.clientPoolMaxQueued ?? 0) > 0) {
+      out.push({
+        severity: "info",
+        area: "http",
+        title: `Queueing observed in ${result.variant}`,
+        message: "The client queued work during the run, so throughput is bounded by a limiter or pool setting.",
+        evidence: {
+          variant: result.variant,
+          lifecycleMaxQueueDepth: result.lifecycleMaxQueueDepth,
+          clientPoolMaxQueued: result.clientPoolMaxQueued,
+          concurrency: result.concurrency
+        },
+        action: "Tune priority concurrency, pool concurrency, or adaptive limiter bounds for this workload."
+      });
+    }
+    if ((result.adaptiveMaxQueueDepth ?? 0) > 0 && (result.adaptiveFinalLimit ?? result.concurrency) < result.concurrency / 4) {
+      out.push({
+        severity: "warn",
+        area: "http",
+        title: `Adaptive limiter constrained ${result.variant}`,
+        message: "The adaptive limiter ended far below requested concurrency while requests queued.",
+        evidence: {
+          variant: result.variant,
+          adaptiveFinalLimit: result.adaptiveFinalLimit,
+          adaptiveMaxQueueDepth: result.adaptiveMaxQueueDepth,
+          concurrency: result.concurrency,
+          adaptiveFinalGradient: result.adaptiveFinalGradient
+        },
+        action: "Try a warmer initial limit, more warmup calls, or a more aggressive preset for short local workloads."
+      });
+    }
+  }
+  if (node && def) {
+    const ratio = ratioOf(def.httpPerSec, node.httpPerSec);
+    if (ratio < thresholds.minDefaultVsNodeRatio) {
+      out.push({
+        severity: "warn",
+        area: "http",
+        title: "Default HTTP overhead is visible",
+        message: `Default JSON throughput is ${(ratio * 100).toFixed(1)}% of the node:http baseline.`,
+        evidence: {
+          nodeHttpPerSec: node.httpPerSec,
+          defaultHttpPerSec: def.httpPerSec,
+          ratio
+        },
+        action: "Run the focused HTTP profile with GC enabled and compare minimal, balanced, default, and observed variants."
+      });
+    }
+  }
+  if (def && observed) {
+    const ratio = ratioOf(observed.httpPerSec, def.httpPerSec);
+    if (ratio < thresholds.minObservedVsDefaultRatio) {
+      out.push({
+        severity: "warn",
+        area: "observability",
+        title: "Observability overhead is visible",
+        message: `Observed default throughput is ${(ratio * 100).toFixed(1)}% of the unobserved default client.`,
+        evidence: {
+          defaultHttpPerSec: def.httpPerSec,
+          observedHttpPerSec: observed.httpPerSec,
+          ratio,
+          observedFinishedSpans: observed.observedFinishedSpans
+        },
+        action: "Check span retention, attribute cardinality, trace sampling, and exporter flush strategy."
+      });
+    }
+  }
+}
+function addRuntimeRecommendations(out, report, thresholds) {
+  if (!report) return;
+  for (const result of report.results) {
+    if (result.units >= 1e3 && result.operationsPerSecond < thresholds.minRuntimeOpsPerSecond) {
+      out.push({
+        severity: "info",
+        area: "runtime",
+        title: `Low sampled runtime throughput for ${result.name}`,
+        message: `${result.name} measured ${result.operationsPerSecond} ${result.unit}/s in this local profile.`,
+        evidence: {
+          primitive: result.name,
+          operationsPerSecond: result.operationsPerSecond,
+          threshold: thresholds.minRuntimeOpsPerSecond,
+          units: result.units,
+          durationMs: result.durationMs
+        },
+        action: "Use npm run benchmark:runtime for the stable regression budget before changing interpreter internals."
+      });
+    }
+  }
+}
+function addMemoryRecommendations(out, delta2, thresholds) {
+  if (!delta2) return;
+  if (delta2.heapUsedMb >= thresholds.criticalHeapDeltaMb) {
+    out.push({
+      severity: "critical",
+      area: "memory",
+      title: "Large retained heap in full profile",
+      message: `The whole profiler run retained ${delta2.heapUsedMb}MB of heap.`,
+      evidence: delta2,
+      action: "Re-run with node --expose-gc and isolate runtime-only vs HTTP-only profiles."
+    });
+  } else if (delta2.heapUsedMb >= thresholds.maxHeapDeltaMb) {
+    out.push({
+      severity: "warn",
+      area: "memory",
+      title: "Retained heap deserves a focused run",
+      message: `The whole profiler run retained ${delta2.heapUsedMb}MB of heap.`,
+      evidence: delta2,
+      action: "Compare forceGc=false and forceGc=true to separate allocator churn from retained references."
+    });
+  }
+}
+function memoryRecommendation(severity, result) {
+  return {
+    severity,
+    area: "memory",
+    title: `HTTP heap retention in ${result.variant}`,
+    message: `${result.variant} retained ${result.memory.delta.heapUsedMb}MB of heap during the sampled run.`,
+    evidence: {
+      variant: result.variant,
+      heapDeltaMb: result.memory.delta.heapUsedMb,
+      rssDeltaMb: result.memory.delta.rssMb,
+      gcAvailable: result.gcAvailable
+    },
+    action: "Run with node --expose-gc, increase calls, and compare with/without observability."
+  };
+}
+function findResult(report, variant) {
+  return report.results.find((result) => result.variant === variant);
+}
+function ratioOf(numerator, denominator) {
+  if (denominator <= 0) return 1;
+  return numerator / denominator;
+}
+
+// src/perf/report.ts
+async function runBrassPerformanceProfile(options = {}) {
+  const recorder = resolveRecorder(options.recorder);
+  const memoryOptions = options.memory === false ? void 0 : options.memory ?? {};
+  const before = memoryOptions ? captureMemorySnapshot(memoryOptions) : void 0;
+  const runtime = options.runtime === false ? void 0 : await recorder.measureAsync(
+    "perf.runtime",
+    () => profileRuntimePrimitives({ ...options.runtime ?? {}, recorder })
+  );
+  const http = options.http === false ? void 0 : await recorder.measureAsync(
+    "perf.http",
+    () => profileHttpLayers({ ...options.http ?? {}, recorder })
+  );
+  const after = memoryOptions ? captureMemorySnapshot(memoryOptions) : void 0;
+  const memory = before && after ? Object.freeze({
+    before,
+    after,
+    delta: diffMemorySnapshots(before, after)
+  }) : void 0;
+  const runtimeDiagnostics = runtime ? diagnoseRuntimeProfile(runtime) : void 0;
+  const recommendations = recommendPerformance({
+    runtime,
+    http,
+    memoryDelta: memory?.delta,
+    thresholds: options.thresholds
+  });
+  return Object.freeze({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    runtime,
+    runtimeDiagnostics,
+    http,
+    memory,
+    recorder: Object.freeze({
+      stats: recorder.stats(),
+      summary: recorder.explain()
+    }),
+    recommendations
+  });
+}
+function formatPerformanceReport(report) {
+  const lines = [];
+  lines.push("Brass Performance Profile");
+  lines.push(`timestamp=${report.timestamp} node=${report.nodeVersion} platform=${report.platform}/${report.arch}`);
+  if (report.runtime) {
+    lines.push("");
+    lines.push(`Runtime primitives (${report.runtime.variant})`);
+    for (const result of report.runtime.results) {
+      lines.push(`- ${result.name}: ${formatNumber4(result.operationsPerSecond)} ${result.unit}/s, ns/op=${result.nsPerOperation}, fibers=${result.fibersStarted}`);
+    }
+  }
+  if (report.runtimeDiagnostics) {
+    lines.push("");
+    lines.push("Runtime diagnostics");
+    lines.push(`- hottest: ${report.runtimeDiagnostics.slowest.name} (${report.runtimeDiagnostics.slowest.nsPerOperation} ns/op)`);
+    lines.push(`- fibers: ${report.runtimeDiagnostics.totalFibersStarted} total, ${report.runtimeDiagnostics.averageFibersPerThousandOps}/1k ops`);
+    for (const note of report.runtimeDiagnostics.notes) lines.push(`- ${note}`);
+  }
+  if (report.http) {
+    lines.push("");
+    lines.push(`HTTP layers (${report.http.calls} calls, concurrency=${report.http.concurrency}, delay=${report.http.delayMs}ms)`);
+    for (const result of report.http.results) {
+      const heap = result.memory.delta.heapUsedMb;
+      const p99 = result.requestP99Ms;
+      lines.push(`- ${result.variant}: ${formatNumber4(result.httpPerSec)} http/s, p99=${p99}ms, heapDelta=${heap}MB, errors=${result.errorCount}`);
+    }
+  }
+  if (report.memory) {
+    lines.push("");
+    lines.push(`Memory: heapDelta=${report.memory.delta.heapUsedMb}MB rssDelta=${report.memory.delta.rssMb}MB gc=${report.memory.after.gcAvailable ? "available" : "unavailable"}`);
+  }
+  lines.push("");
+  lines.push("Recommendations");
+  for (const item of report.recommendations) {
+    lines.push(`- [${item.severity}] ${item.area}: ${item.title}`);
+    lines.push(`  ${item.message}`);
+    if (item.action) lines.push(`  action: ${item.action}`);
+  }
+  return lines.join("\n");
+}
+function resolveRecorder(input) {
+  if (isPerfRecorder(input)) return input;
+  return makePerfRecorder(input);
+}
+function isPerfRecorder(input) {
+  return Boolean(input && "record" in input && typeof input.record === "function");
+}
+function formatNumber4(value) {
+  return value >= 1e3 ? value.toLocaleString("en-US", { maximumFractionDigits: 0 }) : value.toFixed(3);
+}
+
+export {
+  makePerfRecorder,
+  summarizePerfEvents,
+  hasGc,
+  forceGc,
+  captureMemorySnapshot,
+  diffMemorySnapshots,
+  profileMemoryRetention,
+  profileRuntimePrimitives,
+  diagnoseRuntimeProfile,
+  profileRuntimeAb,
+  compareRuntimeProfiles,
+  formatRuntimeAbReport,
+  profileRuntimeSoak,
+  formatRuntimeSoakReport,
+  HTTP_PROFILE_VARIANTS,
+  profileHttpLayers,
+  profileHttpMemoryLab,
+  formatHttpMemoryLabReport,
+  defaultPerfHistoryDirectory,
+  createPerfHistoryEntry,
+  recordPerfHistoryRun,
+  writePerfHistoryEntry,
+  readPerfHistory,
+  savePerfBaseline,
+  loadPerfBaseline,
+  comparePerfToBaseline,
+  formatPerfBaselineComparison,
+  extractPerfMetrics,
+  recommendPerformance,
+  runBrassPerformanceProfile,
+  formatPerformanceReport
+};