brass-runtime 1.15.0 → 1.16.1

package/dist/perf/index.d.ts

@@ -0,0 +1,483 @@
+type PerfTagValue = string | number | boolean;
+type PerfEventType = "mark" | "measure" | "counter" | "gauge";
+type PerfEvent = {
+    readonly type: PerfEventType;
+    readonly name: string;
+    readonly timestamp: number;
+    readonly durationMs?: number;
+    readonly value?: number;
+    readonly unit?: string;
+    readonly tags?: Readonly<Record<string, PerfTagValue>>;
+    readonly details?: Readonly<Record<string, unknown>>;
+};
+type PerfRecorderOptions = {
+    readonly maxEvents?: number;
+    readonly clock?: () => number;
+};
+type PerfRecorderStats = {
+    readonly capacity: number;
+    readonly size: number;
+    readonly recorded: number;
+    readonly dropped: number;
+};
+type PerfEventSummary = {
+    readonly name: string;
+    readonly type: PerfEventType;
+    readonly count: number;
+    readonly totalDurationMs: number;
+    readonly maxDurationMs: number;
+    readonly lastTimestamp: number;
+    readonly lastValue?: number;
+    readonly unit?: string;
+};
+type PerfRecorder = {
+    readonly record: (event: Omit<PerfEvent, "timestamp"> & {
+        readonly timestamp?: number;
+    }) => PerfEvent;
+    readonly mark: (name: string, details?: Readonly<Record<string, unknown>>, tags?: Readonly<Record<string, PerfTagValue>>) => PerfEvent;
+    readonly measure: <A>(name: string, fn: () => A, details?: Readonly<Record<string, unknown>>, tags?: Readonly<Record<string, PerfTagValue>>) => A;
+    readonly measureAsync: <A>(name: string, fn: () => Promise<A>, details?: Readonly<Record<string, unknown>>, tags?: Readonly<Record<string, PerfTagValue>>) => Promise<A>;
+    readonly counter: (name: string, value?: number, unit?: string, tags?: Readonly<Record<string, PerfTagValue>>) => PerfEvent;
+    readonly gauge: (name: string, value: number, unit?: string, tags?: Readonly<Record<string, PerfTagValue>>) => PerfEvent;
+    readonly snapshot: () => readonly PerfEvent[];
+    readonly stats: () => PerfRecorderStats;
+    readonly explain: () => readonly PerfEventSummary[];
+    readonly clear: () => void;
+};
+declare function makePerfRecorder(options?: PerfRecorderOptions): PerfRecorder;
+declare function summarizePerfEvents(events: readonly PerfEvent[]): readonly PerfEventSummary[];
+
+type PerfMemorySnapshot = {
+    readonly timestamp: number;
+    readonly heapUsedMb: number;
+    readonly heapTotalMb: number;
+    readonly rssMb: number;
+    readonly externalMb: number;
+    readonly arrayBuffersMb: number;
+    readonly gcAvailable: boolean;
+};
+type PerfMemoryDelta = {
+    readonly heapUsedMb: number;
+    readonly heapTotalMb: number;
+    readonly rssMb: number;
+    readonly externalMb: number;
+    readonly arrayBuffersMb: number;
+};
+type PerfMemorySnapshotOptions = {
+    readonly forceGc?: boolean;
+    readonly gcPasses?: number;
+    readonly clock?: () => number;
+};
+type MemoryRetentionReport = {
+    readonly label: string;
+    readonly durationMs: number;
+    readonly before: PerfMemorySnapshot;
+    readonly after: PerfMemorySnapshot;
+    readonly delta: PerfMemoryDelta;
+};
+type MemoryRetentionOptions = PerfMemorySnapshotOptions & {
+    readonly label?: string;
+};
+type MemoryRetentionResult<A> = {
+    readonly value: A;
+    readonly report: MemoryRetentionReport;
+};
+declare function hasGc(): boolean;
+declare function forceGc(passes?: number): boolean;
+declare function captureMemorySnapshot(options?: PerfMemorySnapshotOptions): PerfMemorySnapshot;
+declare function diffMemorySnapshots(before: PerfMemorySnapshot, after: PerfMemorySnapshot): PerfMemoryDelta;
+declare function profileMemoryRetention<A>(fn: () => A | Promise<A>, options?: MemoryRetentionOptions): Promise<MemoryRetentionResult<A>>;
+
+type RuntimeProfileVariant = "default" | "fiber-only" | "active-hooks" | "recorder" | "wide-scheduler";
+type RuntimePrimitiveProfile = {
+    readonly name: string;
+    readonly units: number;
+    readonly unit: "effect" | "operation";
+    readonly durationMs: number;
+    readonly nsPerOperation: number;
+    readonly operationsPerSecond: number;
+    readonly fibersStarted: number;
+    readonly fibersPerThousandOps: number;
+};
+type RuntimePrimitiveProfileReport = {
+    readonly variant: RuntimeProfileVariant;
+    readonly label: string;
+    readonly iterations: number;
+    readonly chainDepth: number;
+    readonly hooksActive: boolean;
+    readonly recorderEvents?: number;
+    readonly scheduler: {
+        readonly laneMode: "single" | "fair";
+        readonly initialCapacity: number;
+        readonly maxCapacity: number;
+        readonly flushBudget: number;
+    };
+    readonly results: readonly RuntimePrimitiveProfile[];
+};
+type RuntimePrimitiveProfileOptions = {
+    readonly iterations?: number;
+    readonly chainDepth?: number;
+    readonly variant?: RuntimeProfileVariant;
+    readonly recorder?: PerfRecorder;
+};
+declare function profileRuntimePrimitives(options?: RuntimePrimitiveProfileOptions): Promise<RuntimePrimitiveProfileReport>;
+
+type RuntimePrimitiveDiagnostic = {
+    readonly name: string;
+    readonly operationsPerSecond: number;
+    readonly nsPerOperation: number;
+    readonly fibersStarted: number;
+    readonly fibersPerThousandOps: number;
+};
+type RuntimeDiagnosticsReport = {
+    readonly variant: string;
+    readonly slowest: RuntimePrimitiveDiagnostic;
+    readonly fastest: RuntimePrimitiveDiagnostic;
+    readonly hotPrimitives: readonly RuntimePrimitiveDiagnostic[];
+    readonly totalFibersStarted: number;
+    readonly totalMeasuredUnits: number;
+    readonly averageFibersPerThousandOps: number;
+    readonly hooksActive: boolean;
+    readonly recorderEvents?: number;
+    readonly notes: readonly string[];
+};
+declare function diagnoseRuntimeProfile(report: RuntimePrimitiveProfileReport): RuntimeDiagnosticsReport;
+
+type RuntimeAbThresholds = {
+    readonly maxRegressionPercent?: number;
+    readonly minSignificantDeltaPercent?: number;
+};
+type RuntimeAbOptions = {
+    readonly baseline?: RuntimeProfileVariant;
+    readonly candidate?: RuntimeProfileVariant;
+    readonly runtime?: RuntimePrimitiveProfileOptions;
+    readonly thresholds?: RuntimeAbThresholds;
+    readonly forceGc?: boolean;
+};
+type RuntimeAbVerdict = "improved" | "regressed" | "same";
+type RuntimeAbComparison = {
+    readonly primitive: string;
+    readonly baselineOpsPerSecond: number;
+    readonly candidateOpsPerSecond: number;
+    readonly deltaPercent: number;
+    readonly baselineNsPerOperation: number;
+    readonly candidateNsPerOperation: number;
+    readonly fibersStartedDelta: number;
+    readonly verdict: RuntimeAbVerdict;
+};
+type RuntimeAbReport = {
+    readonly baselineVariant: RuntimeProfileVariant;
+    readonly candidateVariant: RuntimeProfileVariant;
+    readonly baseline: RuntimePrimitiveProfileReport;
+    readonly candidate: RuntimePrimitiveProfileReport;
+    readonly comparisons: readonly RuntimeAbComparison[];
+    readonly diagnostics: {
+        readonly baseline: RuntimeDiagnosticsReport;
+        readonly candidate: RuntimeDiagnosticsReport;
+    };
+    readonly memory: {
+        readonly delta: PerfMemoryDelta;
+    };
+    readonly passedBudget: boolean;
+    readonly budgetViolations: readonly string[];
+};
+declare function profileRuntimeAb(options?: RuntimeAbOptions): Promise<RuntimeAbReport>;
+declare function compareRuntimeProfiles(baseline: RuntimePrimitiveProfileReport, candidate: RuntimePrimitiveProfileReport, thresholds?: Required<RuntimeAbThresholds>): readonly RuntimeAbComparison[];
+declare function formatRuntimeAbReport(report: RuntimeAbReport): string;
+
+type RuntimeSoakOptions = {
+    readonly rounds?: number;
+    readonly runtime?: RuntimePrimitiveProfileOptions;
+    readonly variant?: RuntimeProfileVariant;
+    readonly forceGc?: boolean;
+};
+type RuntimeSoakRound = {
+    readonly round: number;
+    readonly report: RuntimePrimitiveProfileReport;
+    readonly diagnostics: RuntimeDiagnosticsReport;
+    readonly heapDeltaMb: number;
+    readonly rssDeltaMb: number;
+};
+type RuntimeSoakReport = {
+    readonly variant: RuntimeProfileVariant;
+    readonly rounds: readonly RuntimeSoakRound[];
+    readonly memory: {
+        readonly delta: PerfMemoryDelta;
+    };
+    readonly throughputTrendPercent: number;
+    readonly heapTrendMb: number;
+};
+declare function profileRuntimeSoak(options?: RuntimeSoakOptions): Promise<RuntimeSoakReport>;
+declare function formatRuntimeSoakReport(report: RuntimeSoakReport): string;
+
+type RuntimePerfBudgetOptions = RuntimeAbOptions & {
+    readonly minOpsPerSecond?: number;
+    readonly maxHeapDeltaMb?: number;
+};
+type RuntimePerfBudgetViolation = {
+    readonly area: "regression" | "throughput" | "memory";
+    readonly message: string;
+};
+type RuntimePerfBudgetReport = {
+    readonly ab: RuntimeAbReport;
+    readonly passed: boolean;
+    readonly violations: readonly RuntimePerfBudgetViolation[];
+};
+declare function runRuntimePerfBudget(options?: RuntimePerfBudgetOptions): Promise<RuntimePerfBudgetReport>;
+declare function formatRuntimePerfBudgetReport(report: RuntimePerfBudgetReport): string;
+
+type HttpProfileVariant = "node-http-text" | "wire-raw" | "default-minimal-json" | "default-balanced-no-adaptive-json" | "default-balanced-json" | "default-json" | "default-json-observed";
+type HttpLayerProfileOptions = {
+    readonly calls?: number;
+    readonly concurrency?: number;
+    readonly delayMs?: number;
+    readonly timeoutMs?: number;
+    readonly warmupCalls?: number;
+    readonly statsSampleMs?: number;
+    readonly forceGc?: boolean;
+    readonly variants?: readonly HttpProfileVariant[];
+    readonly recorder?: PerfRecorder;
+};
+type HttpLayerProfileResult = {
+    readonly variant: HttpProfileVariant;
+    readonly label: string;
+    readonly calls: number;
+    readonly warmupCalls: number;
+    readonly concurrency: number;
+    readonly delayMs: number;
+    readonly timeoutMs: number;
+    readonly successCount: number;
+    readonly errorCount: number;
+    readonly durationMs: number;
+    readonly warmupDurationMs: number;
+    readonly httpPerSec: number;
+    readonly requestP50Ms: number;
+    readonly requestP90Ms: number;
+    readonly requestP95Ms: number;
+    readonly requestP99Ms: number;
+    readonly serverRequests: number;
+    readonly serverMaxInFlight: number;
+    readonly clientMaxInFlight: number;
+    readonly clientWireMaxInFlight: number;
+    readonly clientPoolMaxRunning?: number;
+    readonly clientPoolMaxQueued?: number;
+    readonly lifecycleMaxQueueDepth?: number;
+    readonly lifecycleStarted?: number;
+    readonly lifecycleCompleted?: number;
+    readonly lifecycleFailed?: number;
+    readonly clientStarted?: number;
+    readonly clientSucceeded?: number;
+    readonly clientFailed?: number;
+    readonly clientTimedOut?: number;
+    readonly adaptiveMinLimit?: number;
+    readonly adaptiveMaxLimit?: number;
+    readonly adaptiveFinalLimit?: number;
+    readonly adaptiveMaxInFlight?: number;
+    readonly adaptiveMaxQueueDepth?: number;
+    readonly adaptiveFinalGradient?: number;
+    readonly adaptiveWindowSize?: number;
+    readonly observedFinishedSpans?: number;
+    readonly observedPrunedSpans?: number;
+    readonly observabilityFlushMs?: number;
+    readonly gcAvailable: boolean;
+    readonly memory: {
+        readonly before: ReturnType<typeof captureMemorySnapshot>;
+        readonly after: ReturnType<typeof captureMemorySnapshot>;
+        readonly delta: PerfMemoryDelta;
+    };
+    readonly firstError?: string;
+};
+type HttpLayerProfileReport = {
+    readonly calls: number;
+    readonly concurrency: number;
+    readonly delayMs: number;
+    readonly timeoutMs: number;
+    readonly warmupCalls: number;
+    readonly variants: readonly HttpProfileVariant[];
+    readonly results: readonly HttpLayerProfileResult[];
+};
+declare const HTTP_PROFILE_VARIANTS: readonly HttpProfileVariant[];
+declare function profileHttpLayers(options?: HttpLayerProfileOptions): Promise<HttpLayerProfileReport>;
+
+type HttpMemoryVerdict = "ok" | "watch" | "critical" | "unknown-gc";
+type HttpMemoryLabOptions = Omit<HttpLayerProfileOptions, "recorder"> & {
+    readonly rounds?: number;
+    readonly heapWarnMb?: number;
+    readonly heapCriticalMb?: number;
+    readonly heapPer10kWarnMb?: number;
+};
+type HttpMemoryLabVariantSummary = {
+    readonly variant: HttpProfileVariant;
+    readonly label: string;
+    readonly rounds: number;
+    readonly callsPerRound: number;
+    readonly totalCalls: number;
+    readonly meanHttpPerSec: number;
+    readonly minHttpPerSec: number;
+    readonly maxHttpPerSec: number;
+    readonly maxP99Ms: number;
+    readonly totalHeapDeltaMb: number;
+    readonly maxHeapDeltaMb: number;
+    readonly heapDeltaPer10kRequestsMb: number;
+    readonly totalRssDeltaMb: number;
+    readonly maxRssDeltaMb: number;
+    readonly totalErrors: number;
+    readonly gcAvailable: boolean;
+    readonly observedFinishedSpans: number;
+    readonly adaptiveFinalLimit?: number;
+    readonly verdict: HttpMemoryVerdict;
+    readonly notes: readonly string[];
+};
+type HttpMemoryLabRound = {
+    readonly round: number;
+    readonly results: readonly HttpLayerProfileResult[];
+};
+type HttpMemoryLabReport = {
+    readonly calls: number;
+    readonly concurrency: number;
+    readonly delayMs: number;
+    readonly warmupCalls: number;
+    readonly rounds: number;
+    readonly forceGc: boolean;
+    readonly variants: readonly HttpProfileVariant[];
+    readonly summaries: readonly HttpMemoryLabVariantSummary[];
+    readonly roundsData: readonly HttpMemoryLabRound[];
+    readonly recommendations: readonly string[];
+};
+declare function profileHttpMemoryLab(options?: HttpMemoryLabOptions): Promise<HttpMemoryLabReport>;
+declare function formatHttpMemoryLabReport(report: HttpMemoryLabReport): string;
+
+type PerfHistoryProfile = "all" | "runtime" | "http" | "runtime-ab" | "runtime-soak" | "http-memory";
+type PerfMetricDirection = "higher-is-better" | "lower-is-better" | "neutral";
+type PerfHistoryMetric = {
+    readonly name: string;
+    readonly value: number;
+    readonly unit?: string;
+    readonly direction: PerfMetricDirection;
+    readonly tags?: Readonly<Record<string, string>>;
+};
+type PerfHistoryEntry = {
+    readonly id: string;
+    readonly timestamp: string;
+    readonly profile: PerfHistoryProfile;
+    readonly nodeVersion: string;
+    readonly platform: string;
+    readonly arch: string;
+    readonly metrics: readonly PerfHistoryMetric[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly report?: unknown;
+};
+type PerfBaseline = {
+    readonly name: string;
+    readonly savedAt: string;
+    readonly entry: PerfHistoryEntry;
+};
+type PerfHistoryStoreOptions = {
+    readonly directory?: string;
+    readonly historyFileName?: string;
+    readonly baselinesDirectoryName?: string;
+    readonly maxEntries?: number;
+    readonly includeReport?: boolean;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+};
+type PerfBaselineThresholds = {
+    readonly maxRegressionPercent?: number;
+    readonly maxHeapRegressionPercent?: number;
+    readonly warnAtRatio?: number;
+    readonly failOnMissingMetric?: boolean;
+};
+type PerfBaselineComparisonStatus = "pass" | "warn" | "fail";
+type PerfBaselineComparisonItem = {
+    readonly metric: PerfHistoryMetric;
+    readonly baselineValue: number;
+    readonly currentValue: number;
+    readonly delta: number;
+    readonly deltaPercent: number;
+    readonly status: PerfBaselineComparisonStatus;
+    readonly reason: string;
+};
+type PerfBaselineComparison = {
+    readonly baselineName: string;
+    readonly baselineId: string;
+    readonly currentId: string;
+    readonly comparedMetrics: number;
+    readonly missingMetrics: readonly string[];
+    readonly status: PerfBaselineComparisonStatus;
+    readonly passed: boolean;
+    readonly items: readonly PerfBaselineComparisonItem[];
+};
+declare function defaultPerfHistoryDirectory(cwd?: string): string;
+declare function createPerfHistoryEntry(profile: PerfHistoryProfile, report: unknown, options?: PerfHistoryStoreOptions): PerfHistoryEntry;
+declare function recordPerfHistoryRun(profile: PerfHistoryProfile, report: unknown, options?: PerfHistoryStoreOptions): Promise<{
+    readonly entry: PerfHistoryEntry;
+    readonly path: string;
+}>;
+declare function writePerfHistoryEntry(entry: PerfHistoryEntry, options?: PerfHistoryStoreOptions): Promise<string>;
+declare function readPerfHistory(options?: PerfHistoryStoreOptions): Promise<readonly PerfHistoryEntry[]>;
+declare function savePerfBaseline(name: string, entry: PerfHistoryEntry, options?: PerfHistoryStoreOptions): Promise<{
+    readonly baseline: PerfBaseline;
+    readonly path: string;
+}>;
+declare function loadPerfBaseline(name: string, options?: PerfHistoryStoreOptions): Promise<PerfBaseline | undefined>;
+declare function comparePerfToBaseline(current: PerfHistoryEntry, baseline: PerfBaseline, thresholds?: PerfBaselineThresholds): PerfBaselineComparison;
+declare function formatPerfBaselineComparison(comparison: PerfBaselineComparison): string;
+declare function extractPerfMetrics(profile: PerfHistoryProfile, report: unknown): readonly PerfHistoryMetric[];
+
+type PerfRecommendationSeverity = "info" | "warn" | "critical";
+type PerfRecommendation = {
+    readonly severity: PerfRecommendationSeverity;
+    readonly area: "runtime" | "http" | "memory" | "observability" | "benchmark";
+    readonly title: string;
+    readonly message: string;
+    readonly evidence?: Readonly<Record<string, unknown>>;
+    readonly action?: string;
+};
+type PerfRecommendationThresholds = {
+    readonly maxHeapDeltaMb?: number;
+    readonly criticalHeapDeltaMb?: number;
+    readonly minDefaultVsNodeRatio?: number;
+    readonly minObservedVsDefaultRatio?: number;
+    readonly maxHttpP99Ms?: number;
+    readonly minRuntimeOpsPerSecond?: number;
+};
+type PerfRecommendationInput = {
+    readonly http?: HttpLayerProfileReport;
+    readonly runtime?: RuntimePrimitiveProfileReport;
+    readonly memoryDelta?: PerfMemoryDelta;
+    readonly thresholds?: PerfRecommendationThresholds;
+};
+declare function recommendPerformance(input: PerfRecommendationInput): readonly PerfRecommendation[];
+
+type BrassPerformanceProfileOptions = {
+    readonly runtime?: false | RuntimePrimitiveProfileOptions;
+    readonly http?: false | HttpLayerProfileOptions;
+    readonly memory?: false | {
+        readonly forceGc?: boolean;
+        readonly gcPasses?: number;
+    };
+    readonly recorder?: PerfRecorder | PerfRecorderOptions;
+    readonly thresholds?: PerfRecommendationThresholds;
+};
+type BrassPerformanceReport = {
+    readonly timestamp: string;
+    readonly nodeVersion: string;
+    readonly platform: string;
+    readonly arch: string;
+    readonly runtime?: RuntimePrimitiveProfileReport;
+    readonly runtimeDiagnostics?: RuntimeDiagnosticsReport;
+    readonly http?: HttpLayerProfileReport;
+    readonly memory?: {
+        readonly before: PerfMemorySnapshot;
+        readonly after: PerfMemorySnapshot;
+        readonly delta: PerfMemoryDelta;
+    };
+    readonly recorder: {
+        readonly stats: PerfRecorderStats;
+        readonly summary: readonly PerfEventSummary[];
+    };
+    readonly recommendations: readonly PerfRecommendation[];
+};
+declare function runBrassPerformanceProfile(options?: BrassPerformanceProfileOptions): Promise<BrassPerformanceReport>;
+declare function formatPerformanceReport(report: BrassPerformanceReport): string;
+
+export { type BrassPerformanceProfileOptions, type BrassPerformanceReport, HTTP_PROFILE_VARIANTS, type HttpLayerProfileOptions, type HttpLayerProfileReport, type HttpLayerProfileResult, type HttpMemoryLabOptions, type HttpMemoryLabReport, type HttpMemoryLabRound, type HttpMemoryLabVariantSummary, type HttpMemoryVerdict, type HttpProfileVariant, type MemoryRetentionOptions, type MemoryRetentionReport, type MemoryRetentionResult, type PerfBaseline, type PerfBaselineComparison, type PerfBaselineComparisonItem, type PerfBaselineComparisonStatus, type PerfBaselineThresholds, type PerfEvent, type PerfEventSummary, type PerfEventType, type PerfHistoryEntry, type PerfHistoryMetric, type PerfHistoryProfile, type PerfHistoryStoreOptions, type PerfMemoryDelta, type PerfMemorySnapshot, type PerfMemorySnapshotOptions, type PerfMetricDirection, type PerfRecommendation, type PerfRecommendationInput, type PerfRecommendationSeverity, type PerfRecommendationThresholds, type PerfRecorder, type PerfRecorderOptions, type PerfRecorderStats, type PerfTagValue, type RuntimeAbComparison, type RuntimeAbOptions, type RuntimeAbReport, type RuntimeAbThresholds, type RuntimeAbVerdict, type RuntimeDiagnosticsReport, type RuntimePerfBudgetOptions, type RuntimePerfBudgetReport, type RuntimePerfBudgetViolation, type RuntimePrimitiveDiagnostic, type RuntimePrimitiveProfile, type RuntimePrimitiveProfileOptions, type RuntimePrimitiveProfileReport, type RuntimeProfileVariant, type RuntimeSoakOptions, type RuntimeSoakReport, type RuntimeSoakRound, captureMemorySnapshot, comparePerfToBaseline, compareRuntimeProfiles, createPerfHistoryEntry, defaultPerfHistoryDirectory, diagnoseRuntimeProfile, diffMemorySnapshots, extractPerfMetrics, forceGc, formatHttpMemoryLabReport, formatPerfBaselineComparison, formatPerformanceReport, formatRuntimeAbReport, formatRuntimePerfBudgetReport, formatRuntimeSoakReport, hasGc, loadPerfBaseline, makePerfRecorder, profileHttpLayers, profileHttpMemoryLab, profileMemoryRetention, profileRuntimeAb, profileRuntimePrimitives, profileRuntimeSoak, readPerfHistory, recommendPerformance, recordPerfHistoryRun, runBrassPerformanceProfile, runRuntimePerfBudget, savePerfBaseline, summarizePerfEvents, writePerfHistoryEntry };

package/dist/perf/index.js

@@ -0,0 +1,141 @@
+import {
+  HTTP_PROFILE_VARIANTS,
+  captureMemorySnapshot,
+  comparePerfToBaseline,
+  compareRuntimeProfiles,
+  createPerfHistoryEntry,
+  defaultPerfHistoryDirectory,
+  diagnoseRuntimeProfile,
+  diffMemorySnapshots,
+  extractPerfMetrics,
+  forceGc,
+  formatHttpMemoryLabReport,
+  formatPerfBaselineComparison,
+  formatPerformanceReport,
+  formatRuntimeAbReport,
+  formatRuntimeSoakReport,
+  hasGc,
+  loadPerfBaseline,
+  makePerfRecorder,
+  profileHttpLayers,
+  profileHttpMemoryLab,
+  profileMemoryRetention,
+  profileRuntimeAb,
+  profileRuntimePrimitives,
+  profileRuntimeSoak,
+  readPerfHistory,
+  recommendPerformance,
+  recordPerfHistoryRun,
+  runBrassPerformanceProfile,
+  savePerfBaseline,
+  summarizePerfEvents,
+  writePerfHistoryEntry
+} from "../chunk-BABBZK4Y.js";
+import "../chunk-5QC7LRZ3.js";
+import "../chunk-74ZTY6CP.js";
+import "../chunk-MIIYDLGM.js";
+import "../chunk-TRM4JUZQ.js";
+import "../chunk-7JIJOVCT.js";
+import "../chunk-UCUBNWM2.js";
+import "../chunk-6IXXWIUM.js";
+import "../chunk-L2SYFEBS.js";
+import "../chunk-AVNQLJ5V.js";
+import "../chunk-CIZFIMK5.js";
+import "../chunk-RKGKFN2A.js";
+import "../chunk-3Y2RIUMM.js";
+import "../chunk-FH2X7BVP.js";
+import "../chunk-UB4B6OFY.js";
+import "../chunk-C3MDXTRZ.js";
+import "../chunk-3RG5ZIWI.js";
+
+// src/perf/budget.ts
+async function runRuntimePerfBudget(options = {}) {
+  const ab = await profileRuntimeAb({
+    ...options,
+    thresholds: {
+      maxRegressionPercent: options.thresholds?.maxRegressionPercent ?? 50,
+      minSignificantDeltaPercent: options.thresholds?.minSignificantDeltaPercent ?? 5
+    }
+  });
+  const minOpsPerSecond = positiveNumber(options.minOpsPerSecond, 1e4);
+  const maxHeapDeltaMb = positiveNumber(options.maxHeapDeltaMb, 32);
+  const violations = [];
+  for (const violation of ab.budgetViolations) {
+    violations.push({ area: "regression", message: violation });
+  }
+  for (const result of ab.candidate.results) {
+    if (result.units >= 1e3 && result.operationsPerSecond < minOpsPerSecond) {
+      violations.push({
+        area: "throughput",
+        message: `${result.name} throughput ${result.operationsPerSecond} ops/s is below ${minOpsPerSecond} ops/s`
+      });
+    }
+  }
+  if (ab.memory.delta.heapUsedMb > maxHeapDeltaMb) {
+    violations.push({
+      area: "memory",
+      message: `runtime A/B heap delta ${ab.memory.delta.heapUsedMb}MB exceeds ${maxHeapDeltaMb}MB`
+    });
+  }
+  return Object.freeze({
+    ab,
+    passed: violations.length === 0,
+    violations: Object.freeze(violations.map((item) => Object.freeze(item)))
+  });
+}
+function formatRuntimePerfBudgetReport(report) {
+  const lines = [];
+  lines.push(`Runtime performance budget: ${report.passed ? "pass" : "fail"}`);
+  lines.push(`baseline=${report.ab.baselineVariant} candidate=${report.ab.candidateVariant}`);
+  for (const comparison of report.ab.comparisons) {
+    const sign = comparison.deltaPercent >= 0 ? "+" : "";
+    lines.push(`- ${comparison.primitive}: ${sign}${comparison.deltaPercent}%`);
+  }
+  if (report.violations.length > 0) {
+    lines.push("");
+    lines.push("Violations");
+    for (const violation of report.violations) {
+      lines.push(`- [${violation.area}] ${violation.message}`);
+    }
+  }
+  return lines.join("\n");
+}
+function positiveNumber(value, fallback) {
+  if (value === void 0 || !Number.isFinite(value)) return fallback;
+  return Math.max(0, value);
+}
+export {
+  HTTP_PROFILE_VARIANTS,
+  captureMemorySnapshot,
+  comparePerfToBaseline,
+  compareRuntimeProfiles,
+  createPerfHistoryEntry,
+  defaultPerfHistoryDirectory,
+  diagnoseRuntimeProfile,
+  diffMemorySnapshots,
+  extractPerfMetrics,
+  forceGc,
+  formatHttpMemoryLabReport,
+  formatPerfBaselineComparison,
+  formatPerformanceReport,
+  formatRuntimeAbReport,
+  formatRuntimePerfBudgetReport,
+  formatRuntimeSoakReport,
+  hasGc,
+  loadPerfBaseline,
+  makePerfRecorder,
+  profileHttpLayers,
+  profileHttpMemoryLab,
+  profileMemoryRetention,
+  profileRuntimeAb,
+  profileRuntimePrimitives,
+  profileRuntimeSoak,
+  readPerfHistory,
+  recommendPerformance,
+  recordPerfHistoryRun,
+  runBrassPerformanceProfile,
+  runRuntimePerfBudget,
+  savePerfBaseline,
+  summarizePerfEvents,
+  writePerfHistoryEntry
+};