@untestutils/perf 0.5.0

package/dist/load/index.mjs

@@ -0,0 +1,48 @@
+import { runArtillery } from "./artillery.mjs";
+import { runAutocannon } from "./autocannon.mjs";
+export async function runLoadPhase(opts) {
+	const { target, started, artifactsDir } = opts;
+	const load = target.load;
+	const base = started.takeProcessMetrics();
+	if (!load) return base;
+	let autocannon;
+	if (load.autocannon) {
+		const ac = load.autocannon === true ? {} : load.autocannon;
+		console.log(`  → autocannon ${ac.connections ?? 10}c × ${ac.durationSec ?? 10}s @ ${started.url}`);
+		autocannon = await runAutocannon({
+			url: started.url,
+			connections: ac.connections,
+			durationSec: ac.durationSec,
+			artifactsDir,
+			name: target.id
+		});
+	}
+	let artillery;
+	if (load.artillery?.config) {
+		console.log(`  → artillery ${load.artillery.config}`);
+		artillery = await runArtillery({
+			configPath: load.artillery.config,
+			artifactsDir,
+			name: target.id,
+			cwd: target.root,
+			targetUrl: started.url
+		});
+	}
+	const summary = artillery?.aggregate;
+	const durationSec = summary ? (summary.lastMetricAt - summary.firstMetricAt) / 1e3 : undefined;
+	const rt = summary?.summaries["http.response_time"];
+	return {
+		...base,
+		durationSec,
+		responseTimeAvg: rt?.mean ?? autocannon?.latency.average,
+		responseTimeMin: rt?.min ?? autocannon?.latency.min,
+		responseTimeMax: rt?.max ?? autocannon?.latency.max,
+		responseTimeP50: rt?.p50 ?? autocannon?.latency.p50,
+		responseTimeP95: rt?.p95 ?? autocannon?.latency.p97_5,
+		responseTimeP99: rt?.p99 ?? autocannon?.latency.p99,
+		requestsPerSecond: summary?.rates["http.request_rate"] ?? autocannon?.requests.average,
+		errorRate: summary?.counters["http.codes.500"] && summary?.counters["http.requests"] ? summary.counters["http.codes.500"] / summary.counters["http.requests"] * 100 : autocannon ? autocannon.errors / Math.max(1, autocannon.requests.total) * 100 : undefined,
+		autocannon,
+		artillery
+	};
+}

package/dist/load/parse.d.mts

@@ -0,0 +1,5 @@
+import type { ArtilleryResult, AutocannonResult } from "../types.mjs";
+/** Parse autocannon `-j` stdout into a typed result. */
+export declare function parseAutocannonJson(raw: string): AutocannonResult;
+/** Parse Artillery `--output` JSON into a typed result. */
+export declare function parseArtilleryJson(raw: string): ArtilleryResult;

package/dist/load/parse.d.ts

@@ -0,0 +1,6 @@
+import type { ArtilleryResult, AutocannonResult } from '../types';
+/** Parse autocannon `-j` stdout into a typed result. */
+export declare function parseAutocannonJson(raw: string): AutocannonResult;
+/** Parse Artillery `--output` JSON into a typed result. */
+export declare function parseArtilleryJson(raw: string): ArtilleryResult;
+//# sourceMappingURL=parse.d.ts.map

package/dist/load/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/load/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAElE,wDAAwD;AACxD,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAEjE;AAED,2DAA2D;AAC3D,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAE/D"}

package/dist/load/parse.mjs

@@ -0,0 +1,8 @@
+
+export function parseAutocannonJson(raw) {
+	return JSON.parse(raw);
+}
+
+export function parseArtilleryJson(raw) {
+	return JSON.parse(raw);
+}

package/dist/process-sample.d.ts

@@ -0,0 +1,31 @@
+export type ProcessSample = {
+    cpu: number;
+    memoryMb: number;
+};
+/** Sample CPU% and RSS (MB) for a PID via `ps` (Unix). Returns null if gone. */
+export declare function sampleProcess(pid: number): ProcessSample | null;
+export type SampleAccumulator = {
+    maxMemoryMb: number;
+    minMemoryMb: number;
+    maxCpuPct: number;
+    minCpuPct: number;
+    totalMemoryMb: number;
+    totalCpuPct: number;
+    samples: number;
+};
+export declare function createSampleAccumulator(): SampleAccumulator;
+export declare function pushSample(acc: SampleAccumulator, sample: ProcessSample): void;
+export declare function finalizeSamples(acc: SampleAccumulator): {
+    maxMemoryMb: number;
+    minMemoryMb: number;
+    avgMemoryMb: number;
+    maxCpuPct: number;
+    minCpuPct: number;
+    avgCpuPct: number;
+};
+/** Poll `sampleProcess` until stopped. */
+export declare function startProcessMonitor(pid: number, intervalMs?: number, onSample?: (s: ProcessSample) => void): {
+    acc: SampleAccumulator;
+    stop: () => void;
+};
+//# sourceMappingURL=process-sample.d.ts.map

package/dist/process-sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-sample.d.ts","sourceRoot":"","sources":["../src/process-sample.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,aAAa,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9D,gFAAgF;AAChF,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAiB/D;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,wBAAgB,uBAAuB,IAAI,iBAAiB,CAU3D;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,iBAAiB,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,CAQ9E;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,iBAAiB;;;;;;;EASrD;AAED,0CAA0C;AAC1C,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,UAAU,SAAO,EACjB,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,GACpC;IAAE,GAAG,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,MAAM,IAAI,CAAA;CAAE,CAY9C"}

package/dist/process-sample.mjs

@@ -0,0 +1,64 @@
+import { execSync } from "node:child_process";
+
+export function sampleProcess(pid) {
+	if (!pid || pid <= 0) return null;
+	try {
+		const result = execSync(`ps -p ${pid} -o %cpu,rss`, {
+			encoding: "utf-8",
+			stdio: "pipe"
+		}).toString();
+		const lines = result.trim().split("\n");
+		if (lines.length < 2 || !lines[1]?.trim()) return null;
+		const parts = lines[1].trim().split(/\s+/).map(Number.parseFloat);
+		return {
+			cpu: parts[0] || 0,
+			memoryMb: parts[1] ? parts[1] / 1024 : 0
+		};
+	} catch {
+		return null;
+	}
+}
+export function createSampleAccumulator() {
+	return {
+		maxMemoryMb: 0,
+		minMemoryMb: Infinity,
+		maxCpuPct: 0,
+		minCpuPct: Infinity,
+		totalMemoryMb: 0,
+		totalCpuPct: 0,
+		samples: 0
+	};
+}
+export function pushSample(acc, sample) {
+	acc.maxCpuPct = Math.max(acc.maxCpuPct, sample.cpu);
+	acc.minCpuPct = Math.min(acc.minCpuPct, sample.cpu);
+	acc.totalCpuPct += sample.cpu;
+	acc.maxMemoryMb = Math.max(acc.maxMemoryMb, sample.memoryMb);
+	acc.minMemoryMb = Math.min(acc.minMemoryMb, sample.memoryMb);
+	acc.totalMemoryMb += sample.memoryMb;
+	acc.samples++;
+}
+export function finalizeSamples(acc) {
+	return {
+		maxMemoryMb: acc.maxMemoryMb,
+		minMemoryMb: Number.isFinite(acc.minMemoryMb) ? acc.minMemoryMb : 0,
+		avgMemoryMb: acc.samples > 0 ? acc.totalMemoryMb / acc.samples : 0,
+		maxCpuPct: acc.maxCpuPct,
+		minCpuPct: Number.isFinite(acc.minCpuPct) ? acc.minCpuPct : 0,
+		avgCpuPct: acc.samples > 0 ? acc.totalCpuPct / acc.samples : 0
+	};
+}
+
+export function startProcessMonitor(pid, intervalMs = 1e3, onSample) {
+	const acc = createSampleAccumulator();
+	const timer = setInterval(() => {
+		const s = sampleProcess(pid);
+		if (!s) return;
+		pushSample(acc, s);
+		onSample?.(s);
+	}, intervalMs);
+	return {
+		acc,
+		stop: () => clearInterval(timer)
+	};
+}

package/dist/report/console.d.mts

@@ -0,0 +1,2 @@
+import type { PerfReporter } from "../types.mjs";
+export declare function consoleReporter(): PerfReporter;

package/dist/report/console.d.ts

@@ -0,0 +1,3 @@
+import type { PerfReporter } from '../types';
+export declare function consoleReporter(): PerfReporter;
+//# sourceMappingURL=console.d.ts.map

package/dist/report/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../src/report/console.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,UAAU,CAAC;AAE/D,wBAAgB,eAAe,IAAI,YAAY,CA6B9C"}

package/dist/report/console.mjs

@@ -0,0 +1,25 @@
+import { formatBytes, formatSec } from "../format.mjs";
+export function consoleReporter() {
+	return {
+		name: "console",
+		onTarget(result) {
+			const b = result.build;
+			console.log(`\n── ${result.label} (${result.id}) ──`);
+			console.log(`  build  ${formatSec(b.buildTimeSec)} · peak RSS ${b.maxMemoryMb.toFixed(0)} MB · CPU ${b.avgCpuPct.toFixed(0)}%`);
+			if (b.bundle) {
+				console.log(`  bundle ${formatBytes(b.bundle.total)} (code ${formatBytes(b.bundle.code)}, asset ${formatBytes(b.bundle.asset)})`);
+			}
+			if (result.load) {
+				const l = result.load;
+				console.log(`  load   ${(l.requestsPerSecond ?? 0).toFixed(1)} RPS · p95 ${(l.responseTimeP95 ?? 0).toFixed(1)} ms · err ${(l.errorRate ?? 0).toFixed(2)}%`);
+			}
+		},
+		onEnd({ results, runs }) {
+			console.log(`\n══════════ summary (mean of ${runs}) ══════════`);
+			for (const r of results) {
+				const load = r.load ? ` · ${r.load.requestsPerSecond?.toFixed(0) ?? "—"} RPS` : "";
+				console.log(`  ${r.label.padEnd(20)} build ${formatSec(r.build.buildTimeSec)}${load}`);
+			}
+		}
+	};
+}

package/dist/report/json.d.mts

@@ -0,0 +1,4 @@
+import type { PerfReporter } from "../types.mjs";
+export declare function jsonReporter(opts?: {
+	dir?: string;
+}): PerfReporter;

package/dist/report/json.d.ts

@@ -0,0 +1,5 @@
+import type { PerfReporter } from '../types';
+export declare function jsonReporter(opts?: {
+    dir?: string;
+}): PerfReporter;
+//# sourceMappingURL=json.d.ts.map

package/dist/report/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/report/json.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C,wBAAgB,YAAY,CAAC,IAAI,CAAC,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,YAAY,CAclE"}

package/dist/report/json.mjs

@@ -0,0 +1,19 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "pathe";
+export function jsonReporter(opts) {
+	return {
+		name: "json",
+		onEnd({ results, suite, runs, skipLoad }) {
+			const dir = opts?.dir ?? suite.artifactsDir ?? ".untestutils/perf";
+			mkdirSync(dir, { recursive: true });
+			const path = join(dir, `results-${Date.now()}.json`);
+			writeFileSync(path, JSON.stringify({
+				runs,
+				skipLoad,
+				results,
+				generatedAt: new Date().toISOString()
+			}, null, 2));
+			console.log(`Wrote JSON report: ${path}`);
+		}
+	};
+}

package/dist/run.d.mts

@@ -0,0 +1,5 @@
+import { consoleReporter } from "./report/console.mjs";
+import { jsonReporter } from "./report/json.mjs";
+import type { PerfSuite, PerfTargetResult, RunPerfOptions } from "./types.mjs";
+export declare function runPerfSuite(suite: PerfSuite, options?: RunPerfOptions): Promise<PerfTargetResult[]>;
+export { consoleReporter, jsonReporter };

package/dist/run.d.ts

@@ -0,0 +1,6 @@
+import { consoleReporter } from './report/console';
+import { jsonReporter } from './report/json';
+import type { PerfSuite, PerfTargetResult, RunPerfOptions } from './types';
+export declare function runPerfSuite(suite: PerfSuite, options?: RunPerfOptions): Promise<PerfTargetResult[]>;
+export { consoleReporter, jsonReporter };
+//# sourceMappingURL=run.d.ts.map

package/dist/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,EAAE,SAAS,EAAc,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAsCvF,wBAAsB,YAAY,CAChC,KAAK,EAAE,SAAS,EAChB,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAuD7B;AAED,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,CAAC"}

package/dist/run.mjs

@@ -0,0 +1,88 @@
+import { mkdirSync } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
+import { resolve } from "pathe";
+import { averageTargetResults } from "./average.mjs";
+import { measureBuild } from "./build.mjs";
+import { runLoadPhase } from "./load/index.mjs";
+import { consoleReporter } from "./report/console.mjs";
+import { jsonReporter } from "./report/json.mjs";
+import { startTarget } from "./start.mjs";
+import { checkThresholds } from "./thresholds.mjs";
+function selectTargets(suite, only) {
+	const filter = only ?? suite.only;
+	if (!filter || filter === "all") return suite.targets;
+	const ids = new Set(Array.isArray(filter) ? filter : [filter]);
+	return suite.targets.filter((t) => ids.has(t.id) || ids.has(t.label ?? ""));
+}
+async function runTargetOnce(target, skipLoad, artifactsDir) {
+	console.log(`\n══════════ ${target.label ?? target.id} ══════════`);
+	console.log("  → build");
+	const build = await measureBuild(target);
+	let load;
+	if (!skipLoad && target.load) {
+		await delay(1e3);
+		console.log("  → start + load");
+		const started = await startTarget(target);
+		try {
+			load = await runLoadPhase({
+				target,
+				started,
+				artifactsDir
+			});
+		} finally {
+			await started.stop();
+		}
+	}
+	return {
+		id: target.id,
+		label: target.label ?? target.id,
+		build,
+		load
+	};
+}
+export async function runPerfSuite(suite, options = {}) {
+	const runs = options.runs ?? suite.runs ?? 1;
+	const skipLoad = options.skipLoad ?? suite.skipLoad ?? false;
+	const coolDownMs = suite.coolDownMs ?? 3e3;
+	const artifactsDir = resolve(suite.artifactsDir ?? ".untestutils/perf");
+	mkdirSync(artifactsDir, { recursive: true });
+	const targets = selectTargets(suite, options.only);
+	if (!targets.length) throw new Error("[untestutils/perf] no targets matched");
+	const reporters = [...suite.reporters ?? [consoleReporter()], ...options.json ? [jsonReporter({ dir: artifactsDir })] : []];
+	await suite.beforeAll?.(suite);
+	for (const r of reporters) await r.onStart?.(suite);
+	const averaged = [];
+	for (let ti = 0; ti < targets.length; ti++) {
+		const target = targets[ti];
+		await suite.beforeTarget?.(target);
+		const samples = [];
+		for (let run = 1; run <= runs; run++) {
+			console.log(`\n▸ ${target.label ?? target.id} · run ${run}/${runs}`);
+			samples.push(await runTargetOnce(target, skipLoad, artifactsDir));
+			if (run < runs) await delay(coolDownMs);
+		}
+		const mean = averageTargetResults(samples);
+		averaged.push(mean);
+		await suite.afterTarget?.(target, mean);
+		for (const r of reporters) await r.onTarget?.(mean);
+		if (ti < targets.length - 1) await delay(coolDownMs);
+	}
+	const ctx = {
+		suite,
+		results: averaged,
+		runs,
+		skipLoad
+	};
+	for (const r of reporters) await r.onEnd?.(ctx);
+	if (suite.thresholds) {
+		const failures = checkThresholds(averaged, suite.thresholds);
+		if (failures.length) {
+			for (const f of failures) {
+				console.error(`[untestutils/perf] threshold ${f.rule} failed for ${f.id}: ${f.actual} (limit ${f.limit})`);
+			}
+			process.exitCode = 1;
+		}
+	}
+	return averaged;
+}
+export { consoleReporter, jsonReporter };

package/dist/start.d.ts

@@ -0,0 +1,12 @@
+import type { PerfTarget, ProcessMetrics } from './types';
+export type StartedTarget = {
+    url: string;
+    port: number;
+    pid?: number;
+    stop: () => Promise<void>;
+    takeProcessMetrics: () => ProcessMetrics;
+};
+/** True when nothing is listening / bound on host:port. */
+export declare function isPortFree(port: number, host?: string): Promise<boolean>;
+export declare function startTarget(target: PerfTarget): Promise<StartedTarget>;
+//# sourceMappingURL=start.d.ts.map

package/dist/start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.d.ts","sourceRoot":"","sources":["../src/start.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE1D,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,kBAAkB,EAAE,MAAM,cAAc,CAAC;CAC1C,CAAC;AAEF,2DAA2D;AAC3D,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,SAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ/E;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CAyF5E"}

package/dist/start.mjs

@@ -0,0 +1,114 @@
+import { spawn } from "node:child_process";
+import net from "node:net";
+import { getFreePort, LOOPBACK_HOST, waitForHttpReady } from "@untestutils/core";
+import { resolve } from "pathe";
+import { finalizeSamples, startProcessMonitor } from "./process-sample.mjs";
+
+export function isPortFree(port, host = LOOPBACK_HOST) {
+	return new Promise((resolvePromise) => {
+		const server = net.createServer();
+		server.once("error", () => resolvePromise(false));
+		server.listen(port, host, () => {
+			server.close(() => resolvePromise(true));
+		});
+	});
+}
+export async function startTarget(target) {
+	const cwd = resolve(target.start.cwd ?? target.root);
+	const host = target.start.host ?? LOOPBACK_HOST;
+	let port = target.start.port;
+	
+	
+	if (!await isPortFree(port, host)) {
+		const next = await getFreePort(host);
+		console.warn(`[untestutils/perf] ${host}:${port} busy — using ${next}`);
+		port = next;
+	}
+	const url = `http://${host}:${port}`;
+	const child = spawn(target.start.command, target.start.args ?? [], {
+		cwd,
+		env: {
+			...process.env,
+			PORT: String(port),
+			HOST: host,
+			NODE_ENV: "production",
+			...target.start.env
+		},
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: process.platform !== "win32"
+	});
+	child.stdout?.on("data", (b) => {
+		const t = b.toString().trim();
+		if (t) console.log(`  [server] ${t.slice(0, 200)}`);
+	});
+	child.stderr?.on("data", (b) => {
+		const t = b.toString().trim();
+		if (t) console.error(`  [server stderr] ${t.slice(0, 200)}`);
+	});
+	let monitorAcc;
+	let stopMonitor;
+	if (child.pid) {
+		const m = startProcessMonitor(child.pid);
+		monitorAcc = m.acc;
+		stopMonitor = m.stop;
+	}
+	const empty = {
+		maxMemoryMb: 0,
+		minMemoryMb: 0,
+		avgMemoryMb: 0,
+		maxCpuPct: 0,
+		minCpuPct: 0,
+		avgCpuPct: 0
+	};
+	try {
+		await new Promise((resolveReady, reject) => {
+			const onExit = (code) => {
+				reject(new Error(`[untestutils/perf] server exited before ready (code=${code})`));
+			};
+			child.once("exit", onExit);
+			waitForHttpReady(url, {
+				path: target.start.readyPath ?? "/",
+				timeoutMs: target.start.readyTimeoutMs ?? 6e4
+			}).then(() => {
+				child.off("exit", onExit);
+				resolveReady();
+			}).catch((err) => {
+				child.off("exit", onExit);
+				reject(err);
+			});
+		});
+	} catch (err) {
+		stopMonitor?.();
+		await killChild(child);
+		throw err;
+	}
+	return {
+		url,
+		port,
+		pid: child.pid,
+		takeProcessMetrics: () => monitorAcc ? finalizeSamples(monitorAcc) : empty,
+		stop: async () => {
+			stopMonitor?.();
+			await killChild(child);
+		}
+	};
+}
+async function killChild(child) {
+	if (!child.pid) return;
+	try {
+		if (process.platform !== "win32") {
+			try {
+				process.kill(-child.pid, "SIGTERM");
+			} catch {
+				process.kill(child.pid, "SIGTERM");
+			}
+		} else {
+			child.kill("SIGTERM");
+		}
+	} catch {}
+	await new Promise((r) => setTimeout(r, 300));
+}

package/dist/thresholds.d.mts

@@ -0,0 +1,8 @@
+import type { PerfTargetResult, PerfThresholds } from "./types.mjs";
+export type ThresholdFailure = {
+	id: string;
+	rule: string;
+	actual: number;
+	limit: number;
+};
+export declare function checkThresholds(results: PerfTargetResult[], thresholds: PerfThresholds): ThresholdFailure[];

package/dist/thresholds.d.ts

@@ -0,0 +1,9 @@
+import type { PerfTargetResult, PerfThresholds } from './types';
+export type ThresholdFailure = {
+    id: string;
+    rule: string;
+    actual: number;
+    limit: number;
+};
+export declare function checkThresholds(results: PerfTargetResult[], thresholds: PerfThresholds): ThresholdFailure[];
+//# sourceMappingURL=thresholds.d.ts.map

package/dist/thresholds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thresholds.d.ts","sourceRoot":"","sources":["../src/thresholds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEhE,MAAM,MAAM,gBAAgB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3F,wBAAgB,eAAe,CAC7B,OAAO,EAAE,gBAAgB,EAAE,EAC3B,UAAU,EAAE,cAAc,GACzB,gBAAgB,EAAE,CAmEpB"}

package/dist/thresholds.mjs

@@ -0,0 +1,48 @@
+export function checkThresholds(results, thresholds) {
+	const failures = [];
+	for (const r of results) {
+		if (thresholds.buildTimeSec !== null && thresholds.buildTimeSec !== undefined && r.build.buildTimeSec > thresholds.buildTimeSec) {
+			failures.push({
+				id: r.id,
+				rule: "buildTimeSec",
+				actual: r.build.buildTimeSec,
+				limit: thresholds.buildTimeSec
+			});
+		}
+		if (thresholds.maxMemoryMb !== null && thresholds.maxMemoryMb !== undefined && r.build.maxMemoryMb > thresholds.maxMemoryMb) {
+			failures.push({
+				id: r.id,
+				rule: "maxMemoryMb",
+				actual: r.build.maxMemoryMb,
+				limit: thresholds.maxMemoryMb
+			});
+		}
+		if (r.load) {
+			if (thresholds.requestsPerSecond !== null && thresholds.requestsPerSecond !== undefined && (r.load.requestsPerSecond ?? 0) < thresholds.requestsPerSecond) {
+				failures.push({
+					id: r.id,
+					rule: "requestsPerSecond",
+					actual: r.load.requestsPerSecond ?? 0,
+					limit: thresholds.requestsPerSecond
+				});
+			}
+			if (thresholds.responseTimeP95 !== null && thresholds.responseTimeP95 !== undefined && (r.load.responseTimeP95 ?? 0) > thresholds.responseTimeP95) {
+				failures.push({
+					id: r.id,
+					rule: "responseTimeP95",
+					actual: r.load.responseTimeP95 ?? 0,
+					limit: thresholds.responseTimeP95
+				});
+			}
+			if (thresholds.errorRate !== null && thresholds.errorRate !== undefined && (r.load.errorRate ?? 0) > thresholds.errorRate) {
+				failures.push({
+					id: r.id,
+					rule: "errorRate",
+					actual: r.load.errorRate ?? 0,
+					limit: thresholds.errorRate
+				});
+			}
+		}
+	}
+	return failures;
+}