@leostera/evalkit 0.8.0 → 0.9.0

package/dist/{index-db-vbqEGFaU.mjs → index-db-BbVblaHz.mjs}

@@ -1,3 +1,4 @@
+import { a as upgradeManifest, i as upgradeEvent, o as upgradeStatus, r as upgradeCatalog } from "./upgrade-60SIRius.mjs";
 import { Hono } from "hono";
 //#region ../share/src/bundle.ts
 /**
@@ -80,10 +81,127 @@ function escapeAttr(value) {
 	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;");
 }
 //#endregion
+//#region ../share/src/legacy.ts
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
+const parse = (data) => data ? JSON.parse(decoder.decode(data)) : void 0;
+const encode = (value) => encoder.encode(`${JSON.stringify(value)}\n`);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** True for a version 1 run.json: no `snapshotVersion`. */
+function isLegacyRun(runJson) {
+	return isRecord(runJson) && runJson.snapshotVersion === void 0;
+}
+function upgradeSnapshotRun(files) {
+	const run = parse(files.get("run.json"));
+	if (!isRecord(run)) throw new Error("run.json must be an object");
+	const listed = parse(files.get("trials.json"));
+	const trials = (isRecord(listed) && Array.isArray(listed.trials) ? listed.trials : []).filter(isRecord);
+	const size = trials.length;
+	return trials.map((trial) => {
+		const id = size === 1 ? String(run.id) : String(trial.id);
+		const prefix = `trials/${String(trial.id)}/`;
+		const detail = parse(files.get(`${prefix}detail.json`));
+		const trialManifest = isRecord(detail) && isRecord(detail.manifest) ? detail.manifest : {};
+		const trialSummary = isRecord(detail) && isRecord(detail.summary) ? detail.summary : {};
+		const index = typeof trial.index === "number" ? trial.index : trials.indexOf(trial);
+		const batch = size > 1 ? {
+			id: String(run.id),
+			index,
+			size
+		} : void 0;
+		const scores = Array.isArray(trial.scores) ? trial.scores.filter(isRecord) : [];
+		const metrics = Array.isArray(trial.metrics) ? trial.metrics.filter(isRecord) : [];
+		const datasets = Array.isArray(trialManifest.datasets) ? trialManifest.datasets.filter(isRecord) : [];
+		const status = String(trial.status);
+		const pick = (keys) => Object.fromEntries(keys.flatMap((key) => run[key] === void 0 ? [] : [[key, run[key]]]));
+		const out = /* @__PURE__ */ new Map();
+		out.set("run.json", encode({
+			snapshotVersion: 2,
+			id,
+			...pick([
+				"evalId",
+				"suiteId",
+				"agent",
+				"matrixId",
+				"cellKey",
+				"parameters",
+				"archived",
+				"source"
+			]),
+			status,
+			startedAt: trial.startedAt ?? run.startedAt,
+			...trial.completedAt ? { completedAt: trial.completedAt } : {},
+			...trial.durationMs === void 0 ? {} : { durationMs: trial.durationMs },
+			...batch ? { batch } : {},
+			...trial.score === void 0 ? {} : { score: trial.score },
+			...scores.length ? { scorers: scores.map((score) => ({
+				name: score.name,
+				kind: score.kind,
+				...score.skipped ? { skipped: true } : {},
+				...score.value === void 0 || score.skipped ? {} : { value: score.value }
+			})) } : {},
+			...metrics.length ? { metrics: metrics.map((metric) => ({
+				name: metric.name,
+				...metric.unit ? { unit: metric.unit } : {},
+				...metric.better ? { better: metric.better } : {},
+				...metric.builtIn ? { builtIn: true } : {},
+				...metric.value === void 0 ? {} : { value: metric.value }
+			})) } : {},
+			...datasets.length ? { datasets: datasets.map((dataset) => ({
+				id: dataset.id,
+				digest: dataset.digest
+			})) } : {}
+		}));
+		const passed = trialSummary.scoring?.passed;
+		out.set("detail.json", encode({
+			scores,
+			...metrics.length ? { metrics } : {},
+			checkpoints: Array.isArray(trial.checkpoints) ? trial.checkpoints : [],
+			...trial.skippedScorers ? { skippedScorers: trial.skippedScorers } : {},
+			...trial.attachments ? { attachments: trial.attachments } : {},
+			manifest: upgradeManifest({
+				run: { ...pick([
+					"evalId",
+					"suiteId",
+					"parameters",
+					"source"
+				]) },
+				trial: trialManifest,
+				runId: id,
+				...batch ? { batch } : {},
+				status: upgradeStatus(trialSummary.status, passed)
+			}),
+			summary: {
+				...trialSummary,
+				status: upgradeStatus(trialSummary.status, passed)
+			}
+		}));
+		for (const [path, data] of files) {
+			if (!path.startsWith(prefix)) continue;
+			const rest = path.slice(prefix.length);
+			if (rest === "detail.json") continue;
+			if (rest === "events.json") {
+				const events = parse(data);
+				out.set(rest, encode({ events: isRecord(events) && Array.isArray(events.events) ? events.events.map(upgradeEvent) : [] }));
+			} else out.set(rest, data);
+		}
+		return {
+			id,
+			files: out
+		};
+	});
+}
+/** A stored or uploaded version 1 catalog, as version 2 stores it. */
+function upgradeCatalogFile(data) {
+	return encode(upgradeCatalog(parse(data)));
+}
+//#endregion
 //#region ../share/src/paths.ts
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const TRIAL_JSON = /^trials\/([^/]+)\/(detail|events|artifacts|workspace)\.json$/;
-const TRIAL_FILE = /^trials\/([^/]+)\/workspace\/(.+)$/;
+const RUN_JSON = /^(detail|events|artifacts|workspace)\.json$/;
+const RUN_FILE$1 = /^(?:workspace|attachments)\/(.+)$/;
+const LEGACY_TRIAL_JSON = /^trials\/([^/]+)\/(detail|events|artifacts|workspace)\.json$/;
+const LEGACY_TRIAL_FILE = /^trials\/([^/]+)\/(?:workspace|attachments)\/(.+)$/;
 const isUuid = (value) => UUID.test(value);
 const isSha = (value) => /^[0-9a-f]{40}$/.test(value);
 /** One path segment that cannot escape or alias another location. */
@@ -91,14 +209,21 @@ function safeSegment(segment) {
 	return segment.length > 0 && segment.length <= 255 && segment !== "." && segment !== ".." && !/[\\/\0]/.test(segment);
 }
 /**
-* The only files a run bundle may contain (the snapshot format from
-* `evalkit build`, for one run). Never evaluator workspaces.
+* The only files a run bundle may contain (snapshot format version 2, from
+* `evalkit build`, for one run): its JSON, candidate workspace files and
+* attachments. Never evaluator workspaces.
 */
 function allowedRunPath(path) {
+	if (path === "run.json" || path === "catalog.json" || RUN_JSON.test(path)) return true;
+	const file = RUN_FILE$1.exec(path);
+	return Boolean(file && file[1].split("/").every(safeSegment));
+}
+/** The same for snapshot format version 1 (EvalKit before 0.9): a run of trials. */
+function allowedLegacyRunPath(path) {
 	if (path === "run.json" || path === "catalog.json" || path === "trials.json") return true;
-	const json = TRIAL_JSON.exec(path);
+	const json = LEGACY_TRIAL_JSON.exec(path);
 	if (json) return isUuid(json[1]);
-	const file = TRIAL_FILE.exec(path);
+	const file = LEGACY_TRIAL_FILE.exec(path);
 	return Boolean(file && isUuid(file[1]) && file[2].split("/").every(safeSegment));
 }
 /**
@@ -116,26 +241,48 @@ function validRepoKey(key) {
 //#region ../share/src/upload.ts
 /** Rejected input: the client sent something the server will not store. */
 var Rejected = class extends Error {};
+/**
+* A run bundle's runs. A bundle from EvalKit 0.9 or later is one run; one
+* from an older CLI (snapshot format version 1, a run of trials) is
+* converted into one run per trial, as `POST /api/v1/upgrade` converts
+* stored runs (RFD0008).
+*/
 function parseUpload(bundle) {
 	const byPath = /* @__PURE__ */ new Map();
 	for (const file of bundle) {
-		if (!allowedRunPath(file.path)) throw new Rejected(`File not allowed in a run bundle: ${file.path}`);
 		if (byPath.has(file.path)) throw new Rejected(`Duplicate file in bundle: ${file.path}`);
 		byPath.set(file.path, file.data);
 	}
 	const runJson = byPath.get("run.json");
 	if (!runJson) throw new Rejected("Bundle has no run.json");
-	const catalog = byPath.get("catalog.json");
-	if (catalog) parseCatalog(catalog);
+	const legacy = isLegacyRun(parseJson(runJson, "run.json"));
+	const allowed = legacy ? allowedLegacyRunPath : allowedRunPath;
+	for (const path of byPath.keys()) if (!allowed(path)) throw new Rejected(`File not allowed in a run bundle: ${path}`);
+	const storedCatalog = byPath.get("catalog.json");
+	if (storedCatalog) parseCatalog(storedCatalog);
+	const catalog = storedCatalog && legacy ? upgradeCatalogFile(storedCatalog) : storedCatalog;
+	if (!legacy) return [runUpload(byPath, catalog)];
+	parseRun(runJson, { legacy: true });
+	return upgradeSnapshotRun(byPath).filter(({ files }) => {
+		const status = JSON.parse(new TextDecoder().decode(files.get("run.json"))).status;
+		return status === "passed" || status === "failed" || status === "errored";
+	}).map(({ files }) => runUpload(files, catalog));
+}
+function runUpload(files, catalog) {
+	const runJson = files.get("run.json");
 	return {
 		run: parseRun(runJson),
 		runJson,
 		...catalog ? { catalog } : {},
-		files: bundle.filter((file) => file.path !== "run.json" && file.path !== "catalog.json")
+		files: [...files].filter(([path]) => path !== "run.json" && path !== "catalog.json").map(([path, data]) => ({
+			path,
+			data
+		}))
 	};
 }
-function parseRun(data) {
+function parseRun(data, options = {}) {
 	const value = record(parseJson(data, "run.json"), "run.json");
+	if (!options.legacy && value.snapshotVersion !== 2) throw new Rejected("run.json must be snapshot format version 2");
 	const source = record(value.source, "run.json source");
 	const id = text(value.id, "id");
 	if (!isUuid(id)) throw new Rejected("run.json id must be a UUID");
@@ -206,6 +353,12 @@ function optionalText(value, key, name) {
 }
 //#endregion
 //#region ../share/src/app.ts
+/** `''` or `/a/b`: a path prefix with no trailing slash. */
+function normalizeBasePath(basePath) {
+	const path = (basePath ?? "").replace(/\/+$/, "");
+	if (path && !/^(\/[A-Za-z0-9._~-]+)+$/.test(path)) throw new Error(`basePath must look like /evals (letters, digits, ".", "_", "~" and "-" between slashes), got ${JSON.stringify(basePath)}`);
+	return path;
+}
 const IMMUTABLE = "public, max-age=31536000, immutable";
 const NO_CACHE = { "cache-control": "no-cache" };
 const RUN_FILE = /^repos\/(.+)\/commits\/([0-9a-f]{40})\/runs\/([^/]+)\/run\.json$/;
@@ -221,6 +374,7 @@ const jsonLine = (event) => console.log(JSON.stringify(event));
 *
 *   POST /api/v1/uploads                         one run bundle
 *   POST /api/v1/reindex                         rebuild the index from stored run.json files
+*   POST /api/v1/upgrade                         convert stored runs from before 0.9 (RFD0008)
 *   GET  /api/v1/repos                           indexed repositories
 *   GET  /api/v1/repos/<repo>/-/commits          commits, newest first
 *   GET  /api/v1/repos/<repo>/-/<sha>/data/…     snapshot data
@@ -229,13 +383,24 @@ const jsonLine = (event) => console.log(JSON.stringify(event));
 *   GET  /<repo>/-/<ref|prefix>/…                → full SHA
 *   GET  everything else                         the dashboard app
 *
+* All of it below `basePath` when set. With `repo` (single-repository mode)
+* pages are `/` (→ latest commit) and `/-/<ref|prefix>/…`.
+*
 * There is no authentication: run it on a private network.
 */
 function createShareApp(options) {
 	const { files, index, assets } = options;
 	const log = options.log ?? jsonLine;
 	const maxBundleBytes = options.maxBundleBytes ?? 268435456;
-	const app = new Hono();
+	const base = normalizeBasePath(options.basePath);
+	const single = options.repo;
+	if (single !== void 0 && !validRepoKey(single)) throw new Error(`repo must be a repository key such as github.com/acme/agents, got ${JSON.stringify(single)}`);
+	/** Where a repository's pages live: `<base>/<repo>`, or `<base>` for the single one. */
+	const pagesOf = (repo) => single ? base : `${base}/${repo}`;
+	const shown = (repo) => !single || repo === single;
+	/** The request path below `basePath`. */
+	const local = (path) => path.slice(base.length);
+	const app = base ? new Hono().basePath(base) : new Hono();
 	app.onError((error, context) => {
 		log({
 			event: "share.error",
@@ -246,9 +411,12 @@ function createShareApp(options) {
 		return context.json({ error: "Internal error" }, 500);
 	});
 	app.post("/api/v1/uploads", async (context) => {
-		let upload;
+		let uploads;
 		try {
-			upload = parseUpload(await decodeBundle(new Uint8Array(await context.req.arrayBuffer()), { maxBytes: maxBundleBytes }));
+			uploads = parseUpload(await decodeBundle(new Uint8Array(await context.req.arrayBuffer()), { maxBytes: maxBundleBytes }));
+			if (!uploads.length) throw new Rejected("The bundle has no finished runs");
+			const other = uploads.find(({ run }) => !shown(run.repoKey));
+			if (other) throw new Rejected(`This share server only accepts results for ${single}, not ${other.run.repoKey}`);
 		} catch (error) {
 			if (!(error instanceof BundleError || error instanceof Rejected)) throw error;
 			log({
@@ -258,25 +426,107 @@ function createShareApp(options) {
 			});
 			return context.json({ error: error.message }, 400);
 		}
-		const { run } = upload;
-		const url = new URL(`/${run.repoKey}/-/${run.source.commit}/runs/${run.id}`, context.req.url).href;
-		const exists = await index.hasRun(run.id);
-		if (!exists) await storeRun(upload);
-		const outcome = exists ? "exists" : "created";
-		log({
-			event: "share.upload",
-			outcome,
-			repo: run.repoKey,
-			commit: run.source.commit,
-			runId: run.id,
-			files: upload.files.length,
-			bytes: upload.files.reduce((sum, file) => sum + file.data.byteLength, 0)
-		});
+		let created = false;
+		for (const upload of uploads) {
+			const { run } = upload;
+			const exists = await index.hasRun(run.id);
+			if (!exists) await storeRun(upload);
+			created ||= !exists;
+			log({
+				event: "share.upload",
+				outcome: exists ? "exists" : "created",
+				repo: run.repoKey,
+				commit: run.source.commit,
+				runId: run.id,
+				files: upload.files.length,
+				bytes: upload.files.reduce((sum, file) => sum + file.data.byteLength, 0)
+			});
+		}
+		const { run } = uploads[0];
+		const url = new URL(`${pagesOf(run.repoKey)}/-/${run.source.commit}/runs/${run.id}`, context.req.url).href;
 		return context.json({
-			status: outcome,
+			status: created ? "created" : "exists",
 			url
-		}, outcome === "created" ? 201 : 200);
+		}, created ? 201 : 200);
 	});
+	/**
+	* Converts stored runs from before 0.9 (snapshot format version 1, a run of
+	* trials) into one run per trial, `limit` old runs per request (default
+	* 20), so it fits a Worker's limits. Call it until `remaining` is 0. New
+	* objects and index rows are written before old ones are removed, so an
+	* interrupted upgrade is finished by calling it again.
+	*/
+	app.post("/api/v1/upgrade", async (context) => {
+		const limit = Math.min(Math.max(Number(context.req.query("limit") ?? 20) || 20, 1), 200);
+		const legacy = [];
+		for await (const key of files.list("repos/")) {
+			if (!RUN_FILE.test(key)) continue;
+			const data = await readBytes(await files.get(key));
+			if (!data) continue;
+			let value;
+			try {
+				value = JSON.parse(new TextDecoder().decode(data));
+			} catch {
+				continue;
+			}
+			if (isLegacyRun(value)) legacy.push(key);
+		}
+		let runs = 0;
+		const batch = legacy.slice(0, limit);
+		for (const key of batch) runs += await upgradeStoredRun(key);
+		const result = {
+			upgraded: batch.length,
+			runs,
+			remaining: legacy.length - batch.length
+		};
+		log({
+			event: "share.upgrade",
+			...result
+		});
+		return context.json(result);
+	});
+	/** One stored version 1 run → version 2 runs; returns how many. */
+	async function upgradeStoredRun(runJsonKey) {
+		const [, repo, sha, oldRunId] = RUN_FILE.exec(runJsonKey);
+		const commitBase = `repos/${repo}/commits/${sha}`;
+		const runBase = `${commitBase}/runs/${oldRunId}`;
+		const stored = /* @__PURE__ */ new Map();
+		const keys = [];
+		for await (const key of files.list(`${runBase}/`)) keys.push(key);
+		for (const key of keys) {
+			const data = await readBytes(await files.get(key));
+			if (data) stored.set(key.slice(runBase.length + 1), data);
+		}
+		let count = 0;
+		const written = /* @__PURE__ */ new Set();
+		let newRunJson;
+		for (const upgraded of upgradeSnapshotRun(stored)) {
+			const runJson = upgraded.files.get("run.json");
+			const run = storedRun(runJson);
+			if (!run) continue;
+			count += 1;
+			const inPlace = run.id === oldRunId;
+			if (!inPlace && await index.hasRun(run.id)) continue;
+			const base = `${commitBase}/runs/${run.id}`;
+			for (const [path, data] of upgraded.files) {
+				if (path === "run.json") continue;
+				await files.put(`${base}/${path}`, data);
+				written.add(`${base}/${path}`);
+			}
+			if (inPlace) {
+				await index.forgetRun(run.id);
+				newRunJson = runJson;
+			} else await files.put(`${base}/run.json`, runJson);
+			await index.recordRun(run);
+		}
+		const catalog = await readBytes(await files.get(`${commitBase}/catalog.json`));
+		if (catalog) await files.put(`${commitBase}/catalog.json`, upgradeCatalogFile(catalog));
+		if (!newRunJson) await index.forgetRun(oldRunId);
+		for (const key of keys) if (key !== runJsonKey && !written.has(key)) await files.delete(key);
+		if (newRunJson) await files.put(runJsonKey, newRunJson);
+		else await files.delete(runJsonKey);
+		return count;
+	}
 	/** Files first, index last: a run becomes visible only once it is indexed. */
 	async function storeRun({ run, runJson, catalog, files: runFiles }) {
 		const commitBase = `repos/${run.repoKey}/commits/${run.source.commit}`;
@@ -307,12 +557,12 @@ function createShareApp(options) {
 			indexed
 		});
 	});
-	app.get("/api/v1/repos", async (context) => context.json({ repos: await index.repos() }, 200, NO_CACHE));
+	app.get("/api/v1/repos", async (context) => context.json({ repos: (await index.repos()).filter((repo) => shown(repo.key)) }, 200, NO_CACHE));
 	app.get("/api/v1/repos/*", async (context) => {
-		const path = context.req.path.slice(14);
+		const path = local(context.req.path).slice(14);
 		const marker = path.indexOf("/-/");
 		const key = marker === -1 ? "" : path.slice(0, marker);
-		if (!validRepoKey(key)) return context.json({ error: "Unknown repository" }, 404);
+		if (!validRepoKey(key) || !shown(key)) return context.json({ error: "Unknown repository" }, 404);
 		const [sha = "", kind, ...segments] = path.slice(marker + 3).split("/");
 		if (sha === "commits" && kind === void 0) return context.json({
 			repo: key,
@@ -322,7 +572,7 @@ function createShareApp(options) {
 		return serveData(context, key, sha, segments.map(decodeURIComponent));
 	});
 	app.get("/assets/*", async (context) => {
-		const path = context.req.path.slice(8);
+		const path = local(context.req.path).slice(8);
 		if (!path.split("/").every(safeSegment)) return context.notFound();
 		const response = await assets.get(path);
 		if (!response) return context.notFound();
@@ -336,29 +586,47 @@ function createShareApp(options) {
 	app.all("/api/*", (context) => context.json({ error: "Not found" }, 404));
 	app.get("*", async (context) => {
 		const url = new URL(context.req.url);
-		const path = url.pathname.replace(/\/+$/, "");
+		const pathname = local(url.pathname);
+		const path = pathname.replace(/\/+$/, "");
+		if (single) {
+			if (path === `/${single}` || path.startsWith(`/${single}/`)) return context.redirect(`${base}${path.slice(single.length + 1) || "/"}${url.search}`);
+			if (!path) return latestPage(context, single);
+			if (!path.startsWith("/-/")) return dashboardPage(context, {
+				kind: "missing",
+				repo: single
+			});
+			return commitPage(context, single, pathname.slice(3), url.search);
+		}
 		const marker = path.indexOf("/-/");
-		if (marker === -1) return repositoryPage(context, path.slice(1));
-		const repo = path.slice(1, marker);
-		const [ref = "", ...rest] = url.pathname.slice(marker + 3).split("/");
+		if (marker === -1) {
+			const repo = path.slice(1);
+			return repo ? latestPage(context, repo) : dashboardPage(context, { kind: "repositories" });
+		}
+		return commitPage(context, path.slice(1, marker), pathname.slice(marker + 3), url.search);
+	});
+	/**
+	* `<pages>/-/<ref>/…`: a short ref resolves to its full SHA first, so every
+	* commit page URL names one immutable commit.
+	*/
+	async function commitPage(context, repo, afterMarker, search) {
+		const [ref = "", ...rest] = afterMarker.split("/");
 		const sha = validRepoKey(repo) ? await index.resolve(repo, decodeURIComponent(ref)) : void 0;
 		if (!sha) return dashboardPage(context, {
 			kind: "missing",
 			repo,
 			ref
 		});
-		if (sha !== ref) return context.redirect(`/${repo}/-/${sha}/${rest.join("/")}${url.search}`);
+		if (sha !== ref) return context.redirect(`${pagesOf(repo)}/-/${sha}/${rest.join("/")}${search}`);
 		return dashboardPage(context, {
 			kind: "commit",
 			repo,
 			sha
 		});
-	});
-	/** `/` lists repositories; `/<repo>` opens its latest commit. */
-	async function repositoryPage(context, repo) {
-		if (!repo) return dashboardPage(context, { kind: "repositories" });
+	}
+	/** A repository's own page opens its latest commit. */
+	async function latestPage(context, repo) {
 		const latest = validRepoKey(repo) ? await index.latest(repo) : void 0;
-		if (latest) return context.redirect(`/${repo}/-/${latest}/`);
+		if (latest) return context.redirect(`${pagesOf(repo)}/-/${latest}/`);
 		return dashboardPage(context, {
 			kind: "missing",
 			repo
@@ -366,14 +634,17 @@ function createShareApp(options) {
 	}
 	/** The dashboard's index.html, told where this page's data lives. */
 	async function dashboardPage(context, page) {
-		const api = page.kind === "repositories" ? void 0 : `/api/v1/repos/${page.repo}/-/`;
+		const api = page.kind === "repositories" ? void 0 : `${base}/api/v1/repos/${page.repo}/-/`;
 		return context.html(dashboardIndex(await assets.index(), {
-			base: page.kind === "commit" ? `/${page.repo}/-/${page.sha}/` : "/",
-			assets: "/assets/",
+			base: page.kind === "commit" ? `${pagesOf(page.repo)}/-/${page.sha}/` : `${base}/`,
+			assets: `${base}/assets/`,
 			share: {
-				repos: "/api/v1/repos",
+				repos: `${base}/api/v1/repos`,
+				home: `${base}/`,
+				...single ? { single: true } : {},
 				...page.kind === "repositories" ? {} : {
 					repo: page.repo,
+					pages: pagesOf(page.repo),
 					commits: `${api}commits`
 				},
 				...page.kind === "commit" ? { data: `${api}${page.sha}/` } : {},
@@ -395,11 +666,11 @@ function createShareApp(options) {
 			const catalog = data ? parseCatalog(data) : EMPTY_CATALOG;
 			return context.json(path === "catalog.json" ? { evals: catalog.catalog } : path === "evals.json" ? { evals: catalog.evals } : { suites: catalog.suites }, 200, NO_CACHE);
 		}
-		const runFile = /^runs\/([^/]+)\/(trials\.json|trials\/.+)$/.exec(path);
+		const runFile = /^runs\/([^/]+)\/((?:detail|events|artifacts|workspace)\.json|(?:workspace|attachments)\/.+)$/.exec(path);
 		if (!runFile || !isUuid(runFile[1])) return context.notFound();
 		const body = await files.get(`${commitBase}/${path}`);
 		if (!body) return context.notFound();
-		const json = path.endsWith(".json") && !path.includes("/workspace/");
+		const json = path.endsWith(".json") && !path.includes("/workspace/") && !path.includes("/attachments/");
 		return new Response(body, { headers: json ? {
 			"content-type": "application/json",
 			"cache-control": IMMUTABLE
@@ -500,6 +771,16 @@ var ShareIndexDb = class {
            WHERE repo = ? AND sha = ?`, run.status === "passed" ? 1 : 0, run.status === "failed" || run.status === "errored" ? 1 : 0, run.repoKey, run.source.commit);
 		});
 	}
+	forgetRun(runId) {
+		this.sql.transaction(() => {
+			const [row] = this.sql.all("SELECT repo, sha, status, dirty FROM runs WHERE id = ?", runId);
+			if (!row) return;
+			this.sql.run("DELETE FROM runs WHERE id = ?", runId);
+			if (!row.dirty) this.sql.run(`UPDATE commits SET runs = runs - 1,
+             passed = passed - ?, failed = failed - ?
+           WHERE repo = ? AND sha = ?`, row.status === "passed" ? 1 : 0, row.status === "failed" || row.status === "errored" ? 1 : 0, row.repo, row.sha);
+		});
+	}
 	repos() {
 		return this.sql.all(`SELECT key, url, project, first_seen_at AS firstSeenAt,
               last_upload_at AS lastUploadAt,
@@ -535,6 +816,7 @@ function asyncIndex(db) {
 	return {
 		hasRun: async (runId) => db.hasRun(runId),
 		recordRun: async (run) => db.recordRun(run),
+		forgetRun: async (runId) => db.forgetRun(runId),
 		repos: async () => db.repos(),
 		commits: async (repo) => db.commits(repo),
 		runs: async (repo, sha) => db.runs(repo, sha),
@@ -543,4 +825,4 @@ function asyncIndex(db) {
 	};
 }
 //#endregion
-export { allowedRunPath as a, dashboardIndex as c, encodeBundle as d, parseUpload as i, BUNDLE_FORMAT as l, asyncIndex as n, repoKey as o, createShareApp as r, validRepoKey as s, ShareIndexDb as t, decodeBundle as u };
+export { parseUpload as a, validRepoKey as c, decodeBundle as d, encodeBundle as f, normalizeBasePath as i, dashboardIndex as l, asyncIndex as n, allowedRunPath as o, createShareApp as r, repoKey as s, ShareIndexDb as t, BUNDLE_FORMAT as u };