@tangle-network/sandbox-cli 0.22.0-develop.20260814062836.bb3da78 → 0.22.0

package/dist/graph-viewer/run-receipt-Bt2iXJUy.js

@@ -0,0 +1,1113 @@
+import { z as e } from "zod";
+//#region src/workspace/view.ts
+var t = e.enum([
+	"pass",
+	"live",
+	"attention",
+	"fail",
+	"neutral"
+]), n = e.object({
+	key: e.string(),
+	label: e.string(),
+	tone: t,
+	icon: e.string(),
+	at: e.string().nullable().optional(),
+	reason: e.string().nullable().optional()
+}), r = e.object({
+	name: e.string().nullable(),
+	label: e.string(),
+	state: e.enum([
+		"pass",
+		"fail",
+		"undecided",
+		"unrun"
+	]),
+	line: e.string().nullable().optional(),
+	runs: e.number().optional()
+}), i = e.object({
+	release: e.string().nullable(),
+	at: e.string().nullable().optional(),
+	passed: e.number(),
+	total: e.number(),
+	steps: e.array(r),
+	workloads: e.object({
+		passed: e.number().nullable().optional(),
+		total: e.number().nullable().optional()
+	}).nullable().optional(),
+	solved: e.boolean(),
+	checker: e.string().nullable().optional(),
+	runId: e.string().optional(),
+	sentence: e.string()
+}), a = e.object({
+	role: e.string(),
+	label: e.string()
+}), o = e.object({
+	kind: e.string(),
+	text: e.string(),
+	sentence: e.string().optional(),
+	cause: e.string().nullable().optional(),
+	release: e.string().nullable().optional(),
+	detail: e.string().optional(),
+	actor: a.optional(),
+	owner: e.string().nullable().optional(),
+	since: e.string().nullable().optional(),
+	action: e.string().nullable().optional(),
+	dispute: e.string().nullable().optional(),
+	why: e.string().nullable().optional()
+}), s = e.object({
+	days: e.array(e.string()),
+	passed: e.array(e.number().nullable()),
+	total: e.number(),
+	best: e.number(),
+	movement: e.enum([
+		"moving",
+		"stuck",
+		"regressed",
+		"solved"
+	]),
+	since: e.string().nullable(),
+	newest: e.object({
+		release: e.string(),
+		passed: e.number(),
+		at: e.string().nullable()
+	}),
+	series: e.array(e.object({
+		release: e.string(),
+		runId: e.string().nullable().optional(),
+		at: e.string(),
+		passed: e.number()
+	})).optional()
+}), c = e.object({
+	value: e.number(),
+	kind: e.enum([
+		"measured",
+		"upper-bound",
+		"lower-bound"
+	]),
+	release: e.string().nullable().optional(),
+	runId: e.string().nullable().optional(),
+	at: e.string().nullable().optional(),
+	size: e.string().nullable().optional(),
+	reason: e.string().nullable().optional()
+}), l = e.object({
+	metric: e.string(),
+	label: e.string(),
+	unit: e.string(),
+	scale: e.enum(["log", "linear"]).nullable().optional(),
+	direction: e.enum(["up", "down"]).nullable().optional(),
+	target: e.object({
+		min: e.number().nullable().optional(),
+		max: e.number().nullable().optional(),
+		approx: e.number().nullable().optional()
+	}).nullable().optional(),
+	stretch: e.object({
+		min: e.number().nullable().optional(),
+		max: e.number().nullable().optional(),
+		label: e.string().nullable().optional()
+	}).nullable().optional(),
+	latest: c.nullable(),
+	best: c.nullable().optional(),
+	ratio: e.object({
+		x: e.number(),
+		side: e.enum([
+			"short",
+			"met",
+			"past"
+		])
+	}).nullable().optional(),
+	change: e.object({
+		from: e.number(),
+		to: e.number(),
+		since: e.string()
+	}).nullable().optional()
+}), u = e.object({
+	runId: e.string().nullable().optional(),
+	text: e.string(),
+	owner: e.string().nullable().optional(),
+	actor: a.optional(),
+	options: e.array(e.object({
+		label: e.string(),
+		command: e.string(),
+		consequence: e.string().optional()
+	})).optional(),
+	since: e.string().nullable().optional(),
+	href: e.string().nullable().optional()
+}), d = e.object({
+	schema: e.literal("agent-workspace.view.v1"),
+	asOf: e.string(),
+	status: n,
+	sentence: e.string(),
+	blocker: o.nullable(),
+	progress: i.nullable(),
+	needsYou: e.array(u),
+	trend: s.nullable().optional(),
+	bars: e.array(l).optional()
+}).catchall(e.unknown()), ee = e.object({
+	status: n,
+	sentence: e.string(),
+	progress: i.nullable(),
+	runs: e.record(e.string(), n).nullable().optional(),
+	blocker: o.nullable().optional(),
+	needsYou: e.array(u).optional(),
+	asOf: e.string().optional()
+}).catchall(e.unknown()), f = (e, t = "run") => ({
+	axis: t,
+	word: e.label,
+	tone: e.tone,
+	shape: e.icon
+}), p = (e) => ({
+	at: e.asOf,
+	meaning: "when the host last composed this page",
+	source: "the view the host serves"
+}), m = e.iso.datetime({ offset: !0 }), h = e.object({
+	at: m.nullable().optional(),
+	tag: e.string().nullable().optional(),
+	commit: e.string().nullable().optional(),
+	checker: e.string().nullable().optional(),
+	verdict: e.string().nullable().optional(),
+	line: e.string().nullable().optional(),
+	score: e.object({
+		stage: e.string().nullable().optional(),
+		reached: e.number().nullable().optional(),
+		of: e.number().nullable().optional(),
+		workloads: e.object({
+			passed: e.number().nullable(),
+			total: e.number().nullable()
+		}).nullable().optional()
+	}).catchall(e.unknown()).nullable().optional()
+}).catchall(e.unknown()), g = e.enum([
+	"calibrated",
+	"uncalibrated",
+	"nondeterministic",
+	"unknown"
+]), _ = e.object({
+	state: g,
+	stages: e.array(e.object({
+		name: e.string().nullable(),
+		state: g
+	}).catchall(e.unknown())),
+	source: e.string().nullable().optional(),
+	unknown: e.string().nullable().optional()
+}).catchall(e.unknown()), te = e.object({
+	latest: h.nullable(),
+	best: h.nullable(),
+	passes: e.array(e.object({
+		tag: e.string().nullable(),
+		checker: e.string().nullable(),
+		count: e.number(),
+		firstAt: m,
+		lastAt: m
+	}).catchall(e.unknown())).optional(),
+	gate: h.nullable().optional(),
+	gateUnknown: e.object({
+		count: e.number(),
+		from: m,
+		to: m,
+		line: e.string().nullable(),
+		tags: e.array(e.string()).optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	headline: e.string().nullable().optional(),
+	counts: e.object({
+		checks: e.number(),
+		known: e.number(),
+		solved: e.number()
+	}).partial().catchall(e.unknown()).nullable().optional(),
+	checkerNames: e.array(e.object({
+		sha256: e.string(),
+		label: e.string().nullable().optional(),
+		ruling: e.string().nullable().optional(),
+		current: e.boolean().optional()
+	}).catchall(e.unknown())).optional(),
+	held: h.extend({ stages: e.array(e.string()) }).nullable().optional(),
+	calibration: _.nullable().optional()
+}).catchall(e.unknown()), v = e.object({
+	id: e.string().nullable(),
+	at: m.nullable(),
+	line: e.string().nullable(),
+	state: e.enum([
+		"open",
+		"operator",
+		"upheld",
+		"rejected",
+		"undecided"
+	]).nullable(),
+	ruledAt: m.nullable(),
+	by: e.enum(["referee", "operator"]).nullable(),
+	attempts: e.number().int().nonnegative().nullable(),
+	referees: e.array(e.object({
+		seat: e.string().nullable(),
+		family: e.string().nullable(),
+		verdict: e.enum([
+			"upheld",
+			"rejected",
+			"undecided"
+		]).nullable()
+	}).catchall(e.unknown())).optional()
+}).catchall(e.unknown()), y = e.number().nullable(), b = e.string().nullable(), x = e.object({
+	passed: y,
+	total: y
+}).catchall(e.unknown()).nullable(), S = e.object({
+	kind: b.optional(),
+	provider: b.optional(),
+	model: b.optional(),
+	at: b.optional(),
+	error: b.optional(),
+	source: b.optional()
+}).catchall(e.unknown()).nullable().optional(), C = e.object({
+	class: e.string(),
+	severity: e.enum(["red", "amber"]).or(e.string()),
+	since: b.optional(),
+	evidence: b.optional(),
+	source: b.optional(),
+	owner: b.optional(),
+	cause: S,
+	also: e.array(e.object({
+		class: e.string(),
+		since: b.optional(),
+		evidence: b.optional(),
+		source: b.optional(),
+		cause: S
+	}).catchall(e.unknown())).optional()
+}).catchall(e.unknown()), w = e.object({
+	checker: b.optional(),
+	tag: b.optional(),
+	runId: b.optional(),
+	columnId: b.optional(),
+	verdict: b.optional(),
+	stage: b.optional(),
+	reached: y.optional(),
+	of: y.optional(),
+	workloads: x.optional(),
+	progress: y.optional(),
+	line: b.optional(),
+	at: b.optional(),
+	count: y.optional(),
+	firstAt: b.optional(),
+	lastAt: b.optional(),
+	supersededBy: b.optional(),
+	state: b.optional()
+}).catchall(e.unknown()), T = e.object({
+	sha256: e.string(),
+	label: e.string(),
+	firstAt: b.optional(),
+	runIds: e.array(e.string()).optional(),
+	ruling: e.object({
+		at: b,
+		by: b,
+		verdict: b,
+		label: b.optional(),
+		reason: b
+	}).catchall(e.unknown()).nullable().optional(),
+	current: e.boolean().optional(),
+	rows: y.optional()
+}).catchall(e.unknown()), E = e.object({
+	value: e.number(),
+	columnId: b.optional(),
+	tag: b.optional(),
+	runId: b.optional(),
+	checker: b.optional(),
+	verdict: b.optional(),
+	comparable: e.boolean().nullable().optional(),
+	why: b.optional(),
+	short: b.optional(),
+	workloads: x.optional()
+}).catchall(e.unknown()), D = e.object({
+	id: e.string(),
+	label: e.string(),
+	unit: e.string(),
+	scale: e.enum(["log", "linear"]).optional(),
+	direction: e.enum(["up", "down"]).optional(),
+	target: e.object({
+		min: y.optional(),
+		max: y.optional(),
+		approx: y.optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	stretch: e.object({
+		min: y.optional(),
+		max: y.optional(),
+		label: b.optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	precondition: e.boolean().optional(),
+	best: E.nullable().optional(),
+	nearest: E.nullable().optional(),
+	missing: e.object({ why: e.string() }).nullable().optional()
+}).catchall(e.unknown()), ne = e.object({
+	path: b.optional(),
+	digest: b.optional(),
+	source: b.optional(),
+	condition: b.optional(),
+	checkCondition: b.optional(),
+	metrics: e.array(D)
+}).catchall(e.unknown()), O = e.array(e.object({
+	label: e.string(),
+	at: b.optional(),
+	clause: b.optional(),
+	due: e.boolean().optional(),
+	measured: e.object({
+		publishedTags: y.optional(),
+		bestStage: e.union([e.string(), e.object({
+			reached: y.optional(),
+			of: y.optional(),
+			stage: b.optional(),
+			tag: b.optional()
+		}).catchall(e.unknown())]).nullable().optional(),
+		checksOnCommit: y.optional()
+	}).catchall(e.unknown()).nullable().optional()
+}).catchall(e.unknown())), re = e.object({
+	status: e.string(),
+	sentence: e.string(),
+	current: w.nullable().optional(),
+	bestCurrent: w.nullable().optional(),
+	bestEver: w.nullable().optional(),
+	releases: e.object({
+		published: y,
+		checked: y,
+		withheld: y,
+		superseded: y,
+		passingCurrent: y,
+		neverChecked: y,
+		checker: b,
+		checkedCurrent: y,
+		checkedCurrentTags: e.array(e.string()),
+		neverCheckedCurrent: y,
+		source: b
+	}).partial().catchall(e.unknown()).nullable().optional(),
+	lastEnding: e.object({
+		runId: e.string(),
+		run: b.optional(),
+		word: e.string(),
+		glyph: b.optional(),
+		at: b.optional(),
+		reason: b.optional(),
+		startedAt: b.optional(),
+		wallHours: y.optional(),
+		status: n.optional(),
+		blocker: C.nullable().optional(),
+		killCheckpoints: O.optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	cost: e.object({
+		apiEquivalentUsd: y.optional(),
+		provenance: b.optional(),
+		priced: y.optional(),
+		started: y.optional(),
+		unpriced: e.array(e.string()).optional(),
+		unmetered: e.array(e.string()).optional(),
+		neverStarted: e.array(e.string()).optional(),
+		seatNow: e.object({
+			seat: b,
+			kind: b
+		}).catchall(e.unknown()).nullable().optional(),
+		billed: e.union([e.string(), e.number()]).nullable().optional()
+	}).catchall(e.unknown()).nullable().optional()
+}).catchall(e.unknown()), ie = e.object({
+	runId: e.string(),
+	run: b.optional(),
+	startedAt: b.optional(),
+	elapsedMs: y.optional(),
+	word: b.optional(),
+	blocker: C.nullable().optional(),
+	killCheckpoints: O.optional()
+}).catchall(e.unknown()), k = e.object({
+	kind: e.string(),
+	parentRun: b.optional(),
+	parentTag: b.optional(),
+	commit: b.optional(),
+	basis: b.optional(),
+	why: b.optional()
+}).catchall(e.unknown()).nullable(), ae = e.object({
+	groups: e.array(e.object({
+		runId: e.string(),
+		label: e.string(),
+		from: b.optional(),
+		to: b.optional(),
+		end: e.object({
+			kind: e.string(),
+			glyph: b.optional(),
+			label: b.optional()
+		}).catchall(e.unknown()).nullable().optional(),
+		checked: y.optional(),
+		published: y.optional(),
+		withheld: y.optional(),
+		superseded: y.optional(),
+		noTag: y.optional(),
+		unscored: e.boolean().optional(),
+		lineage: k.optional(),
+		summary: b.optional(),
+		untagged: y.optional(),
+		note: b.optional(),
+		calibration: _.nullable().optional(),
+		held: e.object({
+			stages: e.array(e.string()),
+			label: b.optional()
+		}).catchall(e.unknown()).nullable().optional()
+	}).catchall(e.unknown())),
+	columns: e.array(e.object({
+		id: e.string(),
+		runId: e.string(),
+		tag: b.optional(),
+		commit: b.optional(),
+		order: e.number().optional(),
+		at: b.optional(),
+		state: b.optional(),
+		weight: y.optional(),
+		tags: e.array(e.string()).optional(),
+		label: b.optional()
+	}).catchall(e.unknown())),
+	gaps: e.array(e.object({
+		afterColumnId: e.string(),
+		hours: e.number()
+	}).catchall(e.unknown())).optional(),
+	y: e.object({
+		label: b.optional(),
+		gridlines: e.array(e.object({
+			at: e.number(),
+			label: e.string()
+		})).optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	marks: e.array(e.object({
+		id: e.string(),
+		columnId: e.string(),
+		kind: e.string(),
+		scope: b.optional(),
+		checker: b.optional(),
+		verdict: e.string(),
+		progress: y,
+		count: y.optional(),
+		firstAt: b.optional(),
+		lastAt: b.optional(),
+		stage: b.optional(),
+		reached: y.optional(),
+		of: y.optional(),
+		workloads: x.optional(),
+		line: b.optional(),
+		source: b.optional(),
+		calibration: g.nullable().optional()
+	}).catchall(e.unknown())),
+	strip: e.array(e.object({
+		columnId: b.optional(),
+		runId: e.string(),
+		kind: e.string(),
+		checker: b.optional(),
+		verdict: e.string(),
+		count: y.optional(),
+		firstAt: b.optional(),
+		lastAt: b.optional(),
+		line: b.optional(),
+		source: b.optional(),
+		calibration: g.nullable().optional(),
+		score: e.object({
+			stage: b.optional(),
+			reached: y.optional(),
+			of: y.optional(),
+			workloads: e.object({
+				passed: y.optional(),
+				total: y.optional()
+			}).nullable().optional()
+		}).catchall(e.unknown()).nullable().optional()
+	}).catchall(e.unknown())).optional(),
+	rulings: e.array(e.object({
+		at: e.string(),
+		dispute: b.optional(),
+		verdict: e.string(),
+		by: b.optional(),
+		line: b.optional(),
+		reason: b.optional(),
+		newDigest: b.optional(),
+		checkerFrom: b.optional(),
+		checkerTo: b.optional()
+	}).catchall(e.unknown())).optional(),
+	best: b.optional(),
+	bestEver: b.optional()
+}).catchall(e.unknown()), oe = e.array(e.object({
+	metric: e.string(),
+	points: e.array(e.object({
+		columnId: e.string(),
+		value: e.number(),
+		verdict: b.optional(),
+		comparable: e.boolean().nullable().optional(),
+		note: b.optional(),
+		basis: b.optional()
+	}).catchall(e.unknown())),
+	missing: e.object({ why: e.string() }).nullable().optional()
+}).catchall(e.unknown())), se = e.object({
+	runId: e.string(),
+	label: b.optional(),
+	lineage: k.optional(),
+	ending: e.object({
+		word: e.string(),
+		glyph: b.optional(),
+		reason: b.optional(),
+		status: n.optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	startedAt: b.optional(),
+	settledAt: b.optional(),
+	wallHours: y.optional(),
+	idleHours: y.optional(),
+	agentHours: y.optional(),
+	hoursByOutcome: e.record(e.string(), e.number()).nullable().optional(),
+	triesByOutcome: e.record(e.string(), e.number()).nullable().optional(),
+	outcomeBasis: b.optional(),
+	outcomeNotes: e.union([
+		e.string(),
+		e.array(e.string()),
+		e.record(e.string(), e.string())
+	]).nullable().optional(),
+	open: e.object({
+		agent: b.optional(),
+		since: b.optional(),
+		hours: y.optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	completedShare: y.optional(),
+	contractBlockedShare: y.optional(),
+	best: w.nullable().optional(),
+	cost: e.object({
+		apiUsd: y.optional(),
+		provenance: b.optional(),
+		billedUsd: y.optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	seat: b.optional(),
+	seatKind: b.optional(),
+	tokens: e.object({
+		in: y.optional(),
+		out: y.optional(),
+		cacheRead: y.optional(),
+		known: y.optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	agents: y.optional(),
+	depth: y.optional(),
+	model: b.optional(),
+	harness: b.optional(),
+	inputDiffers: b.optional()
+}).catchall(e.unknown()), A = e.object({
+	rows: e.array(se),
+	runsShown: y.optional(),
+	runsTotal: y.optional(),
+	page: y.optional(),
+	olderSummary: e.object({
+		runs: e.number(),
+		endings: e.record(e.string(), e.number())
+	}).catchall(e.unknown()).nullable().optional()
+}).catchall(e.unknown()), j = e.object({
+	tag: e.string(),
+	runId: e.string(),
+	run: b.optional(),
+	columnId: b.optional(),
+	commit: b.optional(),
+	taggedAt: b.optional(),
+	firstCheckedAt: b.optional(),
+	state: b.optional(),
+	gate: e.object({
+		verdict: b,
+		count: y.optional(),
+		line: b.optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	checks: e.record(e.string(), e.object({
+		verdict: b,
+		count: y.optional(),
+		progress: y.optional(),
+		stage: b.optional(),
+		of: y.optional(),
+		workloads: x.optional()
+	}).catchall(e.unknown())).optional(),
+	metrics: e.record(e.string(), e.unknown()).nullable().optional(),
+	findings: e.array(e.string()).optional(),
+	take: e.object({
+		enabled: e.boolean(),
+		why: b.optional()
+	}).catchall(e.unknown()).nullable().optional()
+}).catchall(e.unknown()), M = {
+	id: b.optional(),
+	group: e.enum([
+		"verified",
+		"contradicted",
+		"mixed",
+		"undecided",
+		"unchecked"
+	]).or(e.string()).optional(),
+	writer: b.optional(),
+	writtenAt: b.optional(),
+	commits: e.array(e.object({
+		sha: e.string(),
+		tag: b.optional(),
+		run: b.optional(),
+		verdict: b.optional(),
+		checker: b.optional(),
+		kind: b.optional(),
+		line: b.optional(),
+		at: b.optional(),
+		workloads: x.optional(),
+		reached: y.optional(),
+		of: y.optional()
+	}).catchall(e.unknown())).optional(),
+	duplicates: e.array(e.string()).optional(),
+	href: b.optional()
+}, N = {
+	goal: e.object({
+		text: e.string(),
+		full: b.optional(),
+		source: b.optional(),
+		runId: b.optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	checkers: e.array(T).optional(),
+	bar: ne.nullable().optional(),
+	standing: re.nullable().optional(),
+	live: ie.nullable().optional(),
+	climb: ae.nullable().optional(),
+	barSeries: oe.nullable().optional(),
+	ledger: A.nullable().optional(),
+	releases: e.array(j).nullable().optional(),
+	view: d.optional()
+};
+function P(e) {
+	if (typeof document > "u") return null;
+	let t = document.getElementById("discovery-play-head");
+	if (!t?.textContent) return null;
+	try {
+		let n = JSON.parse(t.textContent);
+		return !n.id || n.id === e ? n : null;
+	} catch {
+		return null;
+	}
+}
+var F = (e) => {
+	if (!e) return null;
+	let t = new Date(e);
+	if (!Number.isFinite(t.valueOf())) return null;
+	let n = t.toISOString();
+	return `${n.slice(5, 10)} ${n.slice(11, 16)}Z`;
+}, I = (e) => {
+	if (e == null || !Number.isFinite(e) || e < 0) return null;
+	let t = Math.round(e / 6e4);
+	if (t < 60) return `${t} min`;
+	let n = Math.floor(t / 60);
+	return t % 60 ? `${n} h ${t % 60} min` : `${n} h`;
+}, L = (e, t) => {
+	if (!t) return "";
+	let n = t.startsWith(e + "-") ? t.slice(e.length + 1) : t;
+	return /^\d{6}(\d{2}[a-z])$/.exec(n)?.[1] ?? n;
+}, R = (e) => e ? e.split("/").pop() ?? e : null, z = (e) => e?.split("/").pop() ?? null, B = (e, t) => [
+	e,
+	t?.from && `from ${t.from}`,
+	t?.ordinals[e] && `release ${t.ordinals[e]} of ${t.of} in the play`
+].filter(Boolean).join(" · ");
+function V(e, t) {
+	let n = (e.releases ?? []).filter((e) => e.state === "published"), r = e.ledger?.rows.find((e) => e.runId === t)?.lineage;
+	return {
+		from: r?.kind === "fork" && r.parentRun ? `${L(e.id, r.parentRun)}${r.parentTag ? `/${z(r.parentTag)}` : ""}` : null,
+		of: n.length,
+		ordinals: Object.fromEntries(n.flatMap((e, n) => e.runId === t ? [[e.tag, n + 1]] : []))
+	};
+}
+var H = {
+	solved: "passed",
+	"not-solved": "no pass yet",
+	"contract-held": "contract held",
+	"contract-failed": "fails the contract",
+	undecided: "unverified",
+	held: "check passed; held",
+	superseded: "superseded",
+	"no-tag": "not checked"
+}, U = (e) => e ? H[e] ?? e.replaceAll("-", " ") : "no verdict", W = {
+	solved: "✓",
+	died: "□",
+	crashed: "□",
+	cancelled: "⊘",
+	stalled: "⏸",
+	live: "▶",
+	"never started": "·",
+	ended: "○",
+	attention: "▲",
+	lost: "△",
+	unknown: "◌",
+	fail: "■"
+}, G = {
+	published: "published",
+	withheld: "not published",
+	superseded: "superseded",
+	unknown: "state unknown"
+}, ce = [
+	[/\bwithheld by the gate\b/gi, G.withheld],
+	[/\bwithheld\b/gi, G.withheld],
+	[/\bnot solved\b/gi, H["not-solved"]],
+	[/\bcancelled after (?:a )?stall\b/gi, "stopped by Lab (stall)"],
+	[/\bcancelled\b/gi, "stopped by operator"],
+	[/\bstalled\b/gi, "stopped by Lab (stall)"],
+	[/\bdriver[- ]failed\b/gi, "crashed (driver)"],
+	[/\bdied\b/gi, "crashed"],
+	[/\bnever[- ]started\b/gi, "not started"],
+	[/\bstuck\b/gi, "hung"],
+	[/\bfailed\b/gi, "did not pass"],
+	[/\bundecided\b/gi, H.undecided],
+	[/\babsent\b/gi, "missing"],
+	[/\bno record\b/gi, "nothing on record"]
+], le = (e, t) => e[0] === e[0].toUpperCase() && e[0] !== e[0].toLowerCase() ? t[0].toUpperCase() + t.slice(1) : t, K = (e) => ce.reduce((e, [t, n]) => e.replace(t, (e) => le(e, n)), e);
+function ue(e, t) {
+	return t ? e?.find((e) => e.sha256 === t || e.label === t || e.sha256.startsWith(t))?.label ?? `checker ${t.slice(0, 8)}` : "checker unrecorded";
+}
+var de = (e) => e?.reached !== null && e?.reached !== void 0 && e.of ? `stage ${e.reached} of ${e.of}${e.stage ? ` (${e.stage})` : ""}` : null;
+function q(e, t) {
+	if (e == null || !Number.isFinite(e)) return "not measured";
+	let n = t.toLowerCase();
+	return n === "bytes" || n === "b" ? e >= 1048576 ? `${(e / 1024 / 1024).toFixed(1)} MiB` : e >= 1024 ? `${Math.round(e / 1024)} KiB` : `${Math.round(e)} B` : n === "kib" ? e >= 1048576 ? `${(e / 1024 / 1024).toFixed(1)} GiB` : e >= 1024 ? `${(e / 1024).toFixed(1)} MiB` : `${Math.round(e)} KiB` : `${fe(e)} ${t}`.trim();
+}
+var fe = (e) => Math.abs(e) >= 1e4 ? new Intl.NumberFormat("en-US", {
+	notation: "compact",
+	maximumSignificantDigits: 3
+}).format(e) : new Intl.NumberFormat("en-US", { maximumSignificantDigits: 3 }).format(e);
+function pe(e) {
+	let t = e.target;
+	return t ? t.approx !== null && t.approx !== void 0 ? `≈ ${q(t.approx, e.unit)}` : t.min !== null && t.min !== void 0 && t.max !== null && t.max !== void 0 ? `${q(t.min, e.unit).replace(` ${e.unit}`, "")}–${q(t.max, e.unit)}` : t.min !== null && t.min !== void 0 ? `≥ ${q(t.min, e.unit)}` : t.max !== null && t.max !== void 0 ? `≤ ${q(t.max, e.unit)}` : null : null;
+}
+var J = (e) => K((e ?? "").replace(/^(NOT SOLVED|SOLVED|UNKNOWN|UNDECIDED)\s*:\s*/i, "").replace(/\b[0-9a-f]{7,64}\b/g, "…").split(/\s\|\s/)[0].trim());
+function me(e) {
+	let t = /* @__PURE__ */ new Map();
+	if (!e) return t;
+	let n = new Map(e.columns.map((e) => [e.id, e.runId])), r = new Map(e.columns.map((e) => [e.id, z(e.tag)])), i = [...e.marks.map((e) => ({
+		...e,
+		runId: n.get(e.columnId) ?? null,
+		scored: e.progress !== null
+	})), ...(e.strip ?? []).map((e) => ({
+		...e,
+		scored: !1
+	}))];
+	for (let e of i) {
+		if (!e.runId || e.verdict === "superseded") continue;
+		let n = t.get(e.runId);
+		n || t.set(e.runId, n = {
+			runId: e.runId,
+			rows: 0,
+			solved: 0,
+			scored: 0,
+			checkers: [],
+			lines: []
+		});
+		let i = e.count ?? 1;
+		n.rows += i, e.verdict === "solved" && (n.solved += i), e.scored && (n.scored += i), e.checker && !n.checkers.includes(e.checker) && n.checkers.push(e.checker);
+		let a = J(e.line) || U(e.verdict), o = n.lines.find((e) => e.reason === a);
+		o || n.lines.push(o = {
+			reason: a,
+			line: e.line ?? a,
+			count: 0,
+			verdicts: [],
+			checkers: [],
+			tags: [],
+			firstAt: null,
+			lastAt: null
+		}), o.count += i, o.verdicts.includes(e.verdict) || o.verdicts.push(e.verdict), e.checker && !o.checkers.includes(e.checker) && o.checkers.push(e.checker);
+		let s = e.columnId ? r.get(e.columnId) : null;
+		s && !o.tags.includes(s) && o.tags.push(s);
+		let c = e.firstAt ?? null, l = e.lastAt ?? e.firstAt ?? null;
+		c && (!o.firstAt || c < o.firstAt) && (o.firstAt = c), l && (!o.lastAt || l > o.lastAt) && (o.lastAt = l);
+	}
+	for (let e of t.values()) e.lines.sort((e, t) => t.count - e.count || String(t.lastAt).localeCompare(String(e.lastAt)));
+	return t;
+}
+//#endregion
+//#region src/workspace/run-receipt.ts
+var Y = e.number().nullable(), X = e.string().nullable(), Z = e.enum([
+	"met",
+	"violated",
+	"unknown"
+]), Q = e.object({
+	schema: e.literal("disco.behavior-expectations.v1"),
+	advisory: e.literal(!0),
+	verdict: Z,
+	basis: e.string(),
+	profiles: e.array(e.object({
+		name: X,
+		digest: X,
+		verdict: Z,
+		nodes: e.array(e.object({
+			nodeId: e.string(),
+			verdict: Z,
+			reason: X.optional(),
+			dimensions: e.array(e.object({
+				dimension: e.string(),
+				expected: e.union([e.string(), e.object({
+					min: e.number(),
+					max: e.number()
+				})]),
+				count: Y,
+				observed: e.number(),
+				verdict: Z,
+				reason: X,
+				interpretation: e.string().optional(),
+				evidence: e.array(e.object({
+					eventId: X.optional(),
+					at: X.optional(),
+					source: e.object({
+						path: e.string(),
+						offset: e.number(),
+						bytes: e.number(),
+						lineSha256: e.string()
+					}).catchall(e.unknown()).nullable().optional()
+				}).catchall(e.unknown()))
+			}).catchall(e.unknown()))
+		}).catchall(e.unknown()))
+	}).catchall(e.unknown()))
+}).catchall(e.unknown()), he = e.object({
+	at: e.string(),
+	tag: X,
+	commit: X,
+	solved: e.boolean(),
+	progress: Y.optional(),
+	gate: e.string().optional(),
+	settle: e.boolean().optional(),
+	checker: e.union([e.string(), e.object({ sha256: X }).catchall(e.unknown())]).nullable().optional(),
+	score: e.object({
+		stage: X.optional(),
+		reached: e.number(),
+		of: e.number(),
+		hidden: e.boolean().optional(),
+		workloads: e.object({
+			passed: e.number(),
+			total: e.number()
+		}).optional()
+	}).catchall(e.unknown()).nullable().optional()
+}).catchall(e.unknown()), ge = e.object({
+	at: e.string(),
+	line: e.string(),
+	tag: X,
+	commit: X,
+	targets: e.array(e.string()),
+	resolvedAt: X,
+	resolution: X,
+	resolvedOn: X,
+	lastFailingAt: X,
+	fixCommit: X.optional(),
+	acknowledgements: e.array(e.object({
+		worker: X,
+		effect: e.string(),
+		at: X
+	}).catchall(e.unknown())).optional()
+}).catchall(e.unknown()), $ = e.object({
+	schema: e.literal("discovery-lab.run-receipt"),
+	runId: e.string(),
+	tag: e.string(),
+	title: e.string(),
+	brief: X,
+	outcome: e.object({
+		status: e.enum([
+			"running",
+			"passed",
+			"not-passed",
+			"unmeasured",
+			"cancelled"
+		]),
+		sentence: e.string(),
+		at: X,
+		reason: X,
+		class: X
+	}),
+	chosen: e.object({
+		tag: e.string(),
+		commit: X,
+		why: e.string(),
+		checked: e.boolean().nullable().optional()
+	}).catchall(e.unknown()),
+	behaviorExpectations: Q.nullable().optional(),
+	check: e.object({
+		passed: e.boolean().nullable(),
+		known: e.boolean(),
+		output: X,
+		commit: X,
+		tag: X,
+		at: X,
+		checker: e.object({
+			path: X,
+			sha256: X
+		}),
+		inputs: e.object({
+			source: X,
+			sha256: X,
+			count: Y
+		}),
+		rerun: X
+	}).catchall(e.unknown()).nullable(),
+	files: e.array(e.object({
+		file: e.string(),
+		label: e.string(),
+		size: e.number().optional()
+	}).catchall(e.unknown())),
+	decisions: e.array(e.object({
+		id: e.string(),
+		label: e.string(),
+		consequence: e.string(),
+		command: X,
+		enabled: e.boolean(),
+		reason: X
+	})),
+	work: e.object({
+		wallHours: Y,
+		recordedHours: Y,
+		agentHours: Y,
+		idleHours: Y,
+		untracedHours: Y,
+		toolCalls: Y,
+		tokens: e.object({
+			fresh: Y,
+			cached: Y,
+			total: Y
+		}).catchall(e.unknown()),
+		tries: Y
+	}),
+	waste: e.object({
+		afterPass: e.object({
+			hours: Y,
+			tokens: Y,
+			usd: Y
+		}),
+		verdictDelay: e.object({
+			minutes: Y,
+			refusedChecks: Y
+		})
+	}),
+	timeline: e.object({
+		start: X,
+		end: X,
+		deadline: X,
+		lanes: e.array(e.object({
+			id: e.string(),
+			label: e.string(),
+			profile: X.optional(),
+			spans: e.array(e.object({
+				start: e.string(),
+				end: X,
+				state: e.string(),
+				note: X.optional()
+			})),
+			ticks: e.array(e.object({
+				at: e.string(),
+				outcome: e.string(),
+				cause: X.optional()
+			})).optional()
+		})),
+		marks: e.array(e.object({
+			t: e.string(),
+			label: e.string(),
+			kind: e.enum([
+				"pass",
+				"deadline",
+				"died",
+				"event"
+			])
+		}))
+	}),
+	versions: e.object({
+		rows: e.array(e.object({
+			tag: e.string(),
+			commit: X,
+			at: X,
+			exactPassed: Y,
+			exactTotal: Y,
+			checks: e.array(e.object({
+				id: e.string(),
+				label: e.string().optional(),
+				result: e.string()
+			}).catchall(e.unknown()))
+		})),
+		line: e.object({
+			x: e.tuple([e.number(), e.number()]).nullable(),
+			y: e.tuple([e.number(), e.number()]),
+			marks: e.array(e.object({
+				t: e.string(),
+				label: e.string(),
+				kind: e.enum([
+					"pass",
+					"deadline",
+					"died",
+					"event"
+				])
+			}))
+		})
+	}).optional(),
+	lineage: e.object({
+		chain: e.array(e.string()),
+		ancestors: e.array(e.unknown())
+	}).catchall(e.unknown()).nullable().optional(),
+	sources: e.record(e.string(), X),
+	cost: e.object({
+		apiEquivalentUsd: e.object({
+			usd: Y,
+			provenance: X.optional()
+		}).catchall(e.unknown()).nullable().optional(),
+		billedUsd: e.object({ total: e.object({
+			usd: Y,
+			provenance: X.optional()
+		}).catchall(e.unknown()) }).catchall(e.unknown()),
+		plan: X.optional()
+	}).catchall(e.unknown()),
+	scores: e.object({ checks: e.array(e.object({
+		id: e.string(),
+		label: e.string().optional(),
+		result: e.string()
+	}).catchall(e.unknown())) }).catchall(e.unknown()).nullable(),
+	system: e.object({
+		behaviorExpectations: Q.nullable().optional(),
+		errors: e.object({ top: e.array(e.object({
+			count: e.number(),
+			tool: e.string(),
+			message: e.string()
+		})) }).nullable().optional(),
+		retention: e.object({
+			disposition: e.string(),
+			workspace: e.string(),
+			nativeCapture: e.string(),
+			cloudEvidence: e.string(),
+			requestedNativeCapture: e.string().optional(),
+			requestedCloudEvidence: e.string().optional(),
+			removed: e.number().int().nonnegative(),
+			pending: e.number().int().nonnegative(),
+			snapshotAbsenceVerified: e.boolean().nullable(),
+			evidenceRetirement: e.object({
+				status: e.string(),
+				requestedAt: e.string().optional(),
+				completedAt: e.string().optional(),
+				cloudRemovedObjects: Y.optional(),
+				cloudRemovedPayloadBytes: Y.optional(),
+				cloudRemainingObjects: Y.optional(),
+				cloudRemainingBytes: Y.optional(),
+				localRemovedObjects: Y.optional(),
+				localRemovedBytes: Y.optional(),
+				localRemainingObjects: Y.optional(),
+				localRemainingBytes: Y.optional(),
+				billedSavings: Y.optional(),
+				versionHistoryReclaimedBytes: Y.optional()
+			}).catchall(e.unknown()).nullable().optional(),
+			resources: e.array(e.object({
+				id: e.string(),
+				admittedAt: X,
+				removedAt: X,
+				removal: e.string()
+			}).catchall(e.unknown()))
+		}).catchall(e.unknown()).nullable().optional(),
+		play: e.object({
+			scores: e.array(he).optional(),
+			firstPassAt: X.optional()
+		}).catchall(e.unknown()).nullable().optional(),
+		attempts: e.object({
+			tries: e.number(),
+			failed: e.number(),
+			hours: Y.optional(),
+			failedHours: Y.optional(),
+			causes: e.array(e.object({
+				cause: e.string(),
+				label: e.string().optional(),
+				tries: e.number(),
+				hours: Y
+			}).catchall(e.unknown()))
+		}).catchall(e.unknown()).nullable().optional(),
+		workers: e.object({
+			count: e.number(),
+			neverFinished: e.number(),
+			neverFinishedHours: Y.optional(),
+			hours: Y.optional()
+		}).catchall(e.unknown()).nullable().optional()
+	}).catchall(e.unknown()).nullable().optional(),
+	contract: e.array(ge).optional()
+}).catchall(e.unknown()), _e = (e) => `${new Intl.NumberFormat("en-US", { maximumFractionDigits: 2 }).format(e)} h`, ve = (e) => new Intl.NumberFormat("en-US", {
+	notation: "compact",
+	maximumFractionDigits: 2
+}).format(e), ye = (e) => `${e.replace("T", " ").replace(/\.\d+Z$/, " UTC")}`;
+//#endregion
+export { f as A, pe as C, te as D, v as E, p as O, de as S, U as T, B as _, W as a, z as b, me as c, J as d, q as f, N as g, V as h, ye as i, d as j, ee as k, K as l, M as m, $ as n, G as o, C as p, ve as r, ue as s, _e as t, P as u, R as v, F as w, I as x, L as y };