benchforge 0.1.9 → 0.2.4

package/dist/ViewerServer-BJhdnxlN.mjs

@@ -0,0 +1,639 @@
+import { C as swapDirection, S as subsample, _ as prepareBlocks, a as computeInterval, c as defaultConfidence, d as maxBootstrapInput, f as maxOf, g as percentile, h as minOf, l as flipCI, o as computeStat, r as bootstrapSamples, s as createResample, t as average, u as isBootstrappable, v as quickSelect, x as statKindToFn, y as resampleInto } from "./StatisticalUtils-BD92crgM.mjs";
+import { writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { createServer } from "node:http";
+import open from "open";
+import sirv from "sirv";
+//#region src/profiling/node/ResolvedProfile.ts
+/** Convert a V8 0-indexed CallFrame to a display-ready 1-indexed ResolvedFrame */
+function resolveCallFrame(cf) {
+	return {
+		name: cf.functionName || "(anonymous)",
+		url: cf.url || "",
+		line: cf.lineNumber + 1,
+		col: cf.columnNumber != null ? cf.columnNumber + 1 : void 0
+	};
+}
+/** Walk a HeapProfile tree once, producing a fully resolved intermediate form */
+function resolveProfile(profile) {
+	const nodes = [];
+	const nodeMap = /* @__PURE__ */ new Map();
+	let totalBytes = 0;
+	function walk(node, parentStack) {
+		const frame = resolveCallFrame(node.callFrame);
+		const stack = [...parentStack, frame];
+		const resolved = {
+			frame,
+			stack,
+			selfSize: node.selfSize,
+			nodeId: node.id
+		};
+		nodes.push(resolved);
+		nodeMap.set(node.id, resolved);
+		totalBytes += node.selfSize;
+		for (const child of node.children ?? []) walk(child, stack);
+	}
+	walk(profile.head, []);
+	return {
+		nodes,
+		nodeMap,
+		allocationNodes: nodes.filter((n) => n.selfSize > 0).sort((a, b) => b.selfSize - a.selfSize),
+		sortedSamples: profile.samples ? [...profile.samples].sort((a, b) => a.ordinal - b.ordinal) : void 0,
+		totalBytes
+	};
+}
+//#endregion
+//#region src/stats/BootstrapDifference.ts
+/** Shared-resample difference CI: one resample pair per iteration, all stats computed.
+*  @return DifferenceCI[] in same order as input stats. */
+function multiSampleDifferenceCI(a, b, stats, options = {}) {
+	const { resamples = bootstrapSamples, confidence: conf = defaultConfidence } = options;
+	const subA = subsample(a, maxBootstrapInput);
+	const subB = subsample(b, maxBootstrapInput);
+	const bufA = new Array(subA.length);
+	const bufB = new Array(subB.length);
+	const ops = buildDiffOps(stats, subA.length, subB.length);
+	const allDiffs = ops.map(() => new Array(resamples));
+	const baseVals = ops.map((op) => op.pointEstimate(a));
+	const currVals = ops.map((op) => op.pointEstimate(b));
+	const observedPcts = ops.map((_, j) => (currVals[j] - baseVals[j]) / baseVals[j] * 100);
+	for (let i = 0; i < resamples; i++) {
+		resampleInto(subA, bufA);
+		resampleInto(subB, bufB);
+		for (let j = 0; j < ops.length; j++) {
+			const base = ops[j].computeA(bufA);
+			const curr = ops[j].computeB(bufB);
+			allDiffs[j][i] = (curr - base) / base * 100;
+		}
+	}
+	const capped = subA !== a || subB !== b;
+	const results = new Array(stats.length);
+	for (const op of ops) {
+		const j = op.execIndex;
+		const ci = computeInterval(allDiffs[j], conf);
+		results[op.origIndex] = {
+			percent: observedPcts[j],
+			ci,
+			direction: classifyDirection(ci, observedPcts[j], options.equivMargin),
+			histogram: binValues(allDiffs[j]),
+			ciLevel: "sample",
+			...capped && { subsampled: Math.max(a.length, b.length) }
+		};
+	}
+	return results;
+}
+/** Difference CIs for multiple stats, dispatching block vs sample automatically.
+*  Returns undefined for non-bootstrappable stats (min/max). */
+function diffCIs(a, aOffsets, b, bOffsets, stats, options = {}) {
+	const bsStats = stats.filter(isBootstrappable);
+	if (bsStats.length === 0) return stats.map(() => void 0);
+	const bsResults = (aOffsets?.length ?? 0) >= 2 && (bOffsets?.length ?? 0) >= 2 ? bsStats.map((s) => blockDifferenceCI(a, aOffsets, b, statKindToFn(s), {
+		...options,
+		blocksB: bOffsets
+	})) : multiSampleDifferenceCI(a, b, bsStats, options);
+	const results = new Array(stats.length);
+	let bi = 0;
+	for (let i = 0; i < stats.length; i++) results[i] = isBootstrappable(stats[i]) ? bsResults[bi++] : void 0;
+	return results;
+}
+/** @return block bootstrap CI for percentage difference between baseline (a) and current (b).
+*  Tukey-trims outlier batches, then resamples per-block statFn values. Requires 2+ blocks. */
+function blockDifferenceCI(a, blocksA, b, statFn, options = {}) {
+	const { resamples = bootstrapSamples, confidence: conf = defaultConfidence } = options;
+	const bB = options.blocksB ?? blocksA;
+	const noTrim = options.noBatchTrim;
+	const sideA = prepareBlocks(a, blocksA, statFn, noTrim);
+	const sideB = prepareBlocks(b, bB, statFn, noTrim);
+	const baseVal = statFn(sideA.filtered);
+	const observedPct = (statFn(sideB.filtered) - baseVal) / baseVal * 100;
+	const drawA = () => average(createResample(sideA.blockVals));
+	const drawB = () => average(createResample(sideB.blockVals));
+	const diffs = Array.from({ length: resamples }, () => {
+		const base = drawA();
+		return (drawB() - base) / base * 100;
+	});
+	const ci = computeInterval(diffs, conf);
+	return {
+		percent: observedPct,
+		ci,
+		direction: classifyDirection(ci, observedPct, options.equivMargin),
+		histogram: binValues(diffs),
+		trimmed: [sideA.trimCount, sideB.trimCount],
+		ciLevel: "block"
+	};
+}
+/** @return binned CI with histogram from a BootstrapResult */
+function binBootstrapResult(result) {
+	const { estimate, ci, samples } = result;
+	return {
+		estimate,
+		ci,
+		histogram: binValues(samples)
+	};
+}
+/** @return CI direction, with optional equivalence margin (in percent) */
+function classifyDirection(ci, observed, margin) {
+	if (margin != null && margin > 0 && ci[0] >= -margin && ci[1] <= margin) return "equivalent";
+	if (ci[0] > 0 || ci[1] < 0) return observed < 0 ? "faster" : "slower";
+	return "uncertain";
+}
+/** @return values binned into histogram for compact visualization */
+function binValues(values, binCount = 30) {
+	let min = values[0];
+	let max = values[0];
+	for (let i = 1; i < values.length; i++) {
+		if (values[i] < min) min = values[i];
+		if (values[i] > max) max = values[i];
+	}
+	if (min === max) return [{
+		x: min,
+		count: values.length
+	}];
+	const step = (max - min) / binCount;
+	const counts = new Array(binCount).fill(0);
+	for (const v of values) {
+		const bin = Math.min(Math.floor((v - min) / step), binCount - 1);
+		counts[bin]++;
+	}
+	return counts.map((count, i) => ({
+		x: min + (i + .5) * step,
+		count
+	}));
+}
+/** Build diff operations: mean/min/max first (non-destructive), then percentiles ascending.
+*  Each side (A, B) gets its own quickSelect k values since sample sizes may differ. */
+function buildDiffOps(stats, nA, nB) {
+	const uniform = (order, i, fn) => ({
+		order,
+		origIndex: i,
+		execIndex: 0,
+		computeA: fn,
+		computeB: fn,
+		pointEstimate: fn
+	});
+	const entries = stats.map((s, i) => {
+		if (s === "mean") return uniform(-3, i, average);
+		if (s === "min") return uniform(-2, i, minOf);
+		if (s === "max") return uniform(-1, i, maxOf);
+		const p = s.percentile;
+		const kA = Math.max(0, Math.ceil(nA * p) - 1);
+		const kB = Math.max(0, Math.ceil(nB * p) - 1);
+		return {
+			order: p,
+			origIndex: i,
+			execIndex: 0,
+			computeA: (buf) => quickSelect(buf, kA),
+			computeB: (buf) => quickSelect(buf, kB),
+			pointEstimate: (v) => percentile(v, p)
+		};
+	});
+	entries.sort((a, b) => a.order - b.order);
+	for (let i = 0; i < entries.length; i++) entries[i].execIndex = i;
+	return entries;
+}
+//#endregion
+//#region src/report/BenchmarkReport.ts
+/** Compute column values for a section from results + metadata.
+*  statKind columns: computeStat(samples, kind), then toDisplay.
+*  value columns: call the accessor directly. */
+function computeColumnValues(section, results, metadata) {
+	return Object.fromEntries(section.columns.map((col) => {
+		const key = col.key ?? col.title;
+		if (col.value) return [key, col.value(results, metadata)];
+		if (col.statKind) {
+			const raw = computeStat(results.samples, col.statKind);
+			return [key, col.toDisplay ? col.toDisplay(raw, metadata) : raw];
+		}
+		return [key, void 0];
+	}));
+}
+/** Run each section's computeColumnValues and merge into one record */
+function extractSectionValues(measuredResults, sections, metadata) {
+	const entries = sections.flatMap((s) => Object.entries(computeColumnValues(s, measuredResults, metadata)));
+	return Object.fromEntries(entries);
+}
+/** All reports in a group, including the baseline if present */
+function groupReports(group) {
+	return group.baseline ? [...group.reports, group.baseline] : group.reports;
+}
+/** True if any result in the groups has the specified field with a defined value */
+function hasField(groups, field) {
+	return groups.some((group) => groupReports(group).some(({ measuredResults }) => measuredResults[field] !== void 0));
+}
+/** @return true if the first comparable column in sections has higherIsBetter set */
+function isHigherIsBetter(sections) {
+	return sections.flatMap((s) => s.columns).find((c) => c.comparable)?.higherIsBetter ?? false;
+}
+/** @return the first comparable column with a statKind across all sections */
+function findPrimaryColumn(sections) {
+	if (!sections) return void 0;
+	return sections.flatMap((s) => s.columns).find((c) => c.comparable && c.statKind);
+}
+/** Bootstrap difference CI for a column, using batch structure when available */
+function computeDiffCI(baseline, current, statKind, comparison, higherIsBetter) {
+	if (!baseline?.samples?.length || !current.samples?.length) return void 0;
+	const { equivMargin, noBatchTrim } = comparison ?? {};
+	const rawCIs = diffCIs(baseline.samples, baseline.batchOffsets, current.samples, current.batchOffsets, [statKind], {
+		equivMargin,
+		noBatchTrim
+	});
+	if (!rawCIs[0]) return void 0;
+	return higherIsBetter ? swapDirection(flipCI(rawCIs[0])) : rawCIs[0];
+}
+//#endregion
+//#region src/export/SpeedscopeTypes.ts
+/** Create an empty FrameContext for building speedscope profiles. */
+function frameContext() {
+	return {
+		frames: [],
+		index: /* @__PURE__ */ new Map()
+	};
+}
+/** Wrap profiles in a SpeedscopeFile envelope */
+function speedscopeFile(ctx, profiles) {
+	return {
+		$schema: "https://www.speedscope.app/file-format-schema.json",
+		shared: { frames: ctx.frames },
+		profiles,
+		exporter: "benchforge"
+	};
+}
+/** Intern a call frame, returning its index in the shared frames array.
+*  All values should be 1-indexed (caller converts from V8's 0-indexed if needed). */
+function internFrame(name, url, line, col, ctx) {
+	const key = `${name}\0${url}\0${line}\0${col}`;
+	const existing = ctx.index.get(key);
+	if (existing !== void 0) return existing;
+	const idx = ctx.frames.length;
+	const entry = { name: displayName(name, url, line) };
+	if (url) entry.file = url;
+	if (line > 0) entry.line = line;
+	if (col != null) entry.col = col;
+	ctx.frames.push(entry);
+	ctx.index.set(key, idx);
+	return idx;
+}
+/** Display name for a frame: named functions use their name, anonymous get a location hint */
+function displayName(name, url, line) {
+	if (name !== "(anonymous)") return name;
+	const file = url?.split("/").pop();
+	return file ? `(anonymous ${file}:${line})` : "(anonymous)";
+}
+//#endregion
+//#region src/export/AllocExport.ts
+/** Heap profile export to Speedscope format. */
+/** Export heap profiles to speedscope JSON. Returns output path, or undefined if no profiles. */
+function exportSpeedscope(groups, outputPath) {
+	const file = buildSpeedscopeFile(groups);
+	if (!file) {
+		console.log("No heap profiles to export.");
+		return;
+	}
+	const absPath = resolve(outputPath);
+	writeFileSync(absPath, JSON.stringify(file));
+	console.log(`Speedscope profile exported to: ${outputPath}`);
+	return absPath;
+}
+/** Convert a single HeapProfile to speedscope format. */
+function heapProfileToSpeedscope(name, profile) {
+	const ctx = frameContext();
+	return speedscopeFile(ctx, [buildProfile(name, resolveProfile(profile), ctx)]);
+}
+/** Build SpeedscopeFile from report groups. Returns undefined if no profiles found. */
+function buildSpeedscopeFile(groups) {
+	const ctx = frameContext();
+	const profiles = [];
+	for (const group of groups) for (const report of groupReports(group)) {
+		const { heapProfile } = report.measuredResults;
+		if (!heapProfile) continue;
+		const resolved = resolveProfile(heapProfile);
+		profiles.push(buildProfile(report.name, resolved, ctx));
+	}
+	if (profiles.length === 0) return void 0;
+	return speedscopeFile(ctx, profiles);
+}
+/** Build a single speedscope profile from a resolved heap profile. */
+function buildProfile(name, resolved, ctx) {
+	const intern = (f) => internFrame(f.name, f.url, f.line, f.col, ctx);
+	const nodeStacks = new Map(resolved.nodes.map((node) => [node.nodeId, node.stack.map(intern)]));
+	if (!resolved.sortedSamples?.length) {
+		console.error(`Speedscope export: no samples in heap profile for "${name}", skipping`);
+		return emptyProfile(name);
+	}
+	const samples = [];
+	const weights = [];
+	for (const sample of resolved.sortedSamples) {
+		const stack = nodeStacks.get(sample.nodeId);
+		if (stack) {
+			samples.push(stack);
+			weights.push(sample.size);
+		}
+	}
+	return {
+		type: "sampled",
+		name,
+		unit: "bytes",
+		startValue: 0,
+		endValue: weights.reduce((sum, w) => sum + w, 0),
+		samples,
+		weights
+	};
+}
+/** Placeholder profile with no samples (used when heap data is missing). */
+function emptyProfile(name) {
+	return {
+		type: "sampled",
+		name,
+		unit: "bytes",
+		startValue: 0,
+		endValue: 0,
+		samples: [],
+		weights: []
+	};
+}
+//#endregion
+//#region src/export/ArchiveFormat.ts
+/** Migrate a parsed archive from older schema versions to current. */
+function migrateArchive(raw) {
+	if ((raw.schema ?? 0) <= 1 && "profile" in raw && !("allocProfile" in raw)) {
+		raw.allocProfile = raw.profile;
+		delete raw.profile;
+	}
+	return raw;
+}
+//#endregion
+//#region src/export/ArchiveExport.ts
+/** .benchforge archive creation, source collection, and archive filename derivation. */
+/** Build a .benchforge archive file. Returns output path, or undefined if nothing to archive. */
+async function archiveBenchmark(options) {
+	const { groups, reportData, timeProfileData, coverageData, outputPath } = options;
+	const allocProfile = buildSpeedscopeFile(groups) ?? void 0;
+	const timeProfile = timeProfileData ? JSON.parse(timeProfileData) : void 0;
+	if (!allocProfile && !timeProfile && !reportData) {
+		console.log("No data to archive.");
+		return;
+	}
+	const allFrames = collectProfileFrames(allocProfile, timeProfile);
+	const sources = allFrames.length ? await collectSources(allFrames) : {};
+	const { archive, timestamp } = buildArchiveObject({
+		allocProfile,
+		timeProfile,
+		coverage: coverageData ? JSON.parse(coverageData) : void 0,
+		report: reportData,
+		sources
+	});
+	const filename = outputPath || defaultArchiveName(allocProfile, timestamp);
+	const absPath = resolve(filename);
+	writeFileSync(absPath, JSON.stringify(archive));
+	console.log(`Archive written to: ${filename}`);
+	return absPath;
+}
+function buildArchiveObject(input) {
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+	return {
+		archive: {
+			schema: 2,
+			allocProfile: input.allocProfile,
+			timeProfile: input.timeProfile,
+			coverage: input.coverage,
+			report: input.report,
+			sources: input.sources,
+			metadata: {
+				timestamp,
+				benchforgeVersion: process.env.npm_package_version || "unknown"
+			}
+		},
+		timestamp
+	};
+}
+function collectProfileFrames(allocProfile, timeProfile) {
+	const heapFrames = allocProfile?.shared?.frames ?? [];
+	const timeFrames = timeProfile?.shared?.frames ?? [];
+	return [...heapFrames, ...timeFrames];
+}
+/** Fetch source code for all unique file URLs in profile frames. */
+async function collectSources(frames, cache) {
+	const urls = new Set(frames.map((f) => f.file).filter((u) => !!u));
+	const sources = {};
+	for (const url of urls) {
+		const cached = cache?.get(url);
+		const text = cached ?? await fetchSource(url);
+		if (text === void 0) continue;
+		sources[url] = text;
+		if (!cached) cache?.set(url, text);
+	}
+	return sources;
+}
+/** Derive archive filename from profile (or generic fallback). */
+function defaultArchiveName(profile, timestamp) {
+	return profile ? archiveFileName(profile, timestamp) : `benchforge-${timestamp}.benchforge`;
+}
+/** Fetch source text from a file:// or http(s):// URL. */
+async function fetchSource(url) {
+	try {
+		if (url.startsWith("file://")) return await readFile(fileURLToPath(url), "utf-8");
+		const resp = await fetch(url, { signal: AbortSignal.timeout(5e3) });
+		if (!resp.ok) return void 0;
+		return await resp.text();
+	} catch {
+		return;
+	}
+}
+/** Derive an archive filename from the profile name (sanitizes URLs to safe filenames). */
+function archiveFileName(file, timestamp) {
+	return `${(file.profiles[0]?.name || "profile").replace(/^https?:\/\//, "").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "profile"}-${timestamp}.benchforge`;
+}
+//#endregion
+//#region src/cli/ViewerServer.ts
+/** Start the viewer HTTP server and open in browser. */
+async function startViewerServer(options) {
+	const port = options.port ?? 3939;
+	const bound = await tryListen(createServer(createRequestHandler(options, new Map(Object.entries(options.sources ?? {})), sirv(join(packageRoot(), "dist/viewer"), { single: true }))), port);
+	const url = `http://localhost:${bound.port}`;
+	if (options.open !== false) await open(url);
+	console.log(`Viewer: ${url}`);
+	const close = () => {
+		bound.server.closeAllConnections();
+		bound.server.close();
+	};
+	return {
+		server: bound.server,
+		port: bound.port,
+		close
+	};
+}
+/** Open a .benchforge archive in the viewer. */
+async function viewArchive(filePath) {
+	const content = await readFile(resolve(filePath), "utf-8");
+	const raw = JSON.parse(content);
+	const schema = raw.schema ?? 0;
+	if (schema > 2) {
+		const msg = `Archive schema version ${schema} is newer than supported (2).`;
+		console.error(`${msg} Please update benchforge to view this archive.`);
+		process.exit(1);
+	}
+	const archive = migrateArchive(raw);
+	const sources = archive.sources;
+	const { close } = await startViewerServer({
+		profileData: optionalJson(archive.allocProfile),
+		timeProfileData: optionalJson(archive.timeProfile),
+		coverageData: optionalJson(archive.coverage),
+		reportData: optionalJson(archive.report),
+		sources
+	});
+	await waitForCtrlC();
+	close();
+}
+/** Serialize a value to JSON if truthy, otherwise return undefined. */
+function optionalJson(v) {
+	return v ? JSON.stringify(v) : void 0;
+}
+/** Wait for Ctrl+C (SIGINT) before resolving. */
+function waitForCtrlC() {
+	return new Promise((resolve) => {
+		console.log("\nPress Ctrl+C to exit");
+		process.once("SIGINT", () => {
+			console.log();
+			resolve();
+		});
+	});
+}
+/** Resolve the package root (dev: src/cli/ ==> up 2, dist: dist/ ==> up 1). */
+function packageRoot() {
+	const thisDir = dirname(fileURLToPath(import.meta.url));
+	if (basename(thisDir) === "cli") return join(thisDir, "../..");
+	return join(thisDir, "..");
+}
+/** Build HTTP request handler with API routes and static asset fallback. */
+function createRequestHandler(ctx, sourceCache, assets) {
+	const routes = {
+		"/api/config": (res) => {
+			const config = {
+				editorUri: ctx.editorUri || null,
+				hasReport: !!ctx.reportData,
+				hasProfile: !!ctx.profileData,
+				hasTimeProfile: !!ctx.timeProfileData,
+				hasCoverage: !!ctx.coverageData
+			};
+			res.setHeader("Content-Type", "application/json");
+			res.end(JSON.stringify(config));
+		},
+		"/api/report-data": (res) => sendJson(res, ctx.reportData, "report data"),
+		"/api/coverage": (res) => sendJson(res, ctx.coverageData, "coverage data"),
+		"/api/profile": (res) => sendJson(res, ctx.profileData, "profile data", true),
+		"/api/profile/alloc": (res) => sendJson(res, ctx.profileData, "profile data", true),
+		"/api/profile/time": (res) => sendJson(res, ctx.timeProfileData, "time profile data", true),
+		"/api/source": (res, query) => handleSourceRequest(res, query, sourceCache),
+		"/api/archive": (res, _q, method) => {
+			if (method !== "POST") {
+				res.statusCode = 405;
+				res.end("Method not allowed");
+				return;
+			}
+			return handleArchiveRequest(res, ctx, sourceCache);
+		}
+	};
+	return async (req, res) => {
+		const url = req.url || "/";
+		const qIdx = url.indexOf("?");
+		const pathname = qIdx >= 0 ? url.slice(0, qIdx) : url;
+		const query = qIdx >= 0 ? url.slice(qIdx + 1) : "";
+		const handler = routes[pathname];
+		if (handler) {
+			await handler(res, query, req.method || "GET");
+			return;
+		}
+		assets(req, res, () => {
+			res.statusCode = 404;
+			res.end("Not found");
+		});
+	};
+}
+/** Listen on port, retrying on next port if EADDRINUSE. */
+function tryListen(server, port, maxRetries = 10) {
+	return new Promise((resolve, reject) => {
+		let attempt = 0;
+		const listen = (p) => {
+			server.once("error", (err) => {
+				if (err.code === "EADDRINUSE" && attempt < maxRetries) {
+					attempt++;
+					listen(p + 1);
+				} else reject(err);
+			});
+			server.listen(p, () => {
+				server.removeAllListeners("error");
+				const addr = server.address();
+				resolve({
+					server,
+					port: typeof addr === "object" && addr ? addr.port : p
+				});
+			});
+		};
+		listen(port);
+	});
+}
+/** Send pre-serialized JSON or 404 if data is absent. */
+function sendJson(res, data, label, cors = false) {
+	if (!data) {
+		res.statusCode = 404;
+		res.end(`No ${label}`);
+		return;
+	}
+	res.setHeader("Content-Type", "application/json");
+	if (cors) res.setHeader("Access-Control-Allow-Origin", "*");
+	res.end(data);
+}
+/** Fetch source text by URL query param, caching for subsequent requests. */
+async function handleSourceRequest(res, query, cache) {
+	const sourceUrl = new URLSearchParams(query).get("url");
+	if (!sourceUrl) {
+		res.statusCode = 400;
+		res.end("Missing url parameter");
+		return;
+	}
+	try {
+		let source = cache.get(sourceUrl);
+		if (source === void 0) {
+			source = await fetchSource(sourceUrl);
+			if (source === void 0) throw new Error("not found");
+			cache.set(sourceUrl, source);
+		}
+		res.setHeader("Content-Type", "text/plain; charset=utf-8");
+		res.end(source);
+	} catch {
+		res.statusCode = 404;
+		res.end("Source unavailable");
+	}
+}
+/** Build a .benchforge archive from current session data and send as download. */
+async function handleArchiveRequest(res, ctx, sourceCache) {
+	try {
+		const parse = (s) => s ? JSON.parse(s) : void 0;
+		const profile = parse(ctx.profileData);
+		const timeProfile = parse(ctx.timeProfileData);
+		const coverage = parse(ctx.coverageData);
+		const report = parse(ctx.reportData);
+		const allFrames = collectProfileFrames(profile, timeProfile);
+		const { archive, timestamp } = buildArchiveObject({
+			allocProfile: profile,
+			timeProfile,
+			coverage,
+			report,
+			sources: allFrames.length ? await collectSources(allFrames, sourceCache) : Object.fromEntries(sourceCache)
+		});
+		const body = JSON.stringify(archive);
+		const filename = defaultArchiveName(profile, timestamp);
+		res.setHeader("Content-Type", "application/json");
+		res.setHeader("Content-Disposition", `attachment; filename="${filename}"`);
+		res.end(body);
+	} catch {
+		res.statusCode = 500;
+		res.end("Archive failed");
+	}
+}
+//#endregion
+export { resolveProfile as C, resolveCallFrame as S, groupReports as _, archiveBenchmark as a, binBootstrapResult as b, exportSpeedscope as c, internFrame as d, speedscopeFile as f, findPrimaryColumn as g, extractSectionValues as h, waitForCtrlC as i, heapProfileToSpeedscope as l, computeDiffCI as m, startViewerServer as n, collectSources as o, computeColumnValues as p, viewArchive as r, buildSpeedscopeFile as s, optionalJson as t, frameContext as u, hasField as v, diffCIs as x, isHigherIsBetter as y };
+
+//# sourceMappingURL=ViewerServer-BJhdnxlN.mjs.map