stim 1.13.0 → 1.15.0

package/dist/build-progress-C2Jv1AtA.mjs

@@ -0,0 +1,872 @@
+import { D as withConfigLock$1 } from "./config-D0DbpZtM.mjs";
+import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
+import { a as updateWorkspaceState, t as clearWorkspaceStateKey } from "./workspace-state-CL2V2Ons.mjs";
+import { a as formatElapsed, u as plural } from "./command-output-CliHHn7a.mjs";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { BUILD_HISTORY_KEY, BUILD_HISTORY_LIMIT, BUILD_PHASES, LAST_BUILD_KEYS, STATS_VERSION, decodeStats, parseMissReason, readRunEstimates, readStats, statsFile, statsProjectKey as statsProjectKey$1, trimSamples, wholePhases, workspaceBuildDetailFile } from "@stim-cli/core/state";
+//#region src/engine/stats.ts
+const PLACEMENT_MAX_AGE_MS = 6048e5;
+function emptyStats() {
+	return {
+		version: STATS_VERSION,
+		machine: {},
+		projects: {}
+	};
+}
+function updateStats(record, run, now) {
+	const at = new Date(now).toISOString();
+	const durationMs = wholeMs(run.durationMs);
+	const phases = {
+		coldBuildMs: wholeMs(run.coldBuildMs),
+		podsMs: wholeMs(run.podsMs)
+	};
+	const projects = { ...record.projects };
+	const scope = { ...projects[run.projectKey] };
+	const machine = { ...record.machine };
+	const before = scope[run.platform] ?? null;
+	const credit = creditMs(before, run, durationMs);
+	scope[run.platform] = applyRun(before, run, {
+		at,
+		durationMs,
+		credit,
+		phases
+	});
+	projects[run.projectKey] = scope;
+	machine[run.platform] = applyRun(machine[run.platform] ?? null, run, {
+		at,
+		durationMs,
+		credit,
+		phases
+	});
+	const history = { ...record.history };
+	if (run.phases && !run.failed && !run.waitedForBuild && !run.offloadedTo) {
+		const outcome = isHit(run.cacheHit) ? "hit" : "cold";
+		const project = { ...history[run.projectKey] };
+		const lists = { ...project[run.platform] };
+		const sample = {
+			at,
+			durationMs,
+			phases: wholePhases(run.phases),
+			...run.deviceSetup === void 0 ? {} : { deviceSetup: run.deviceSetup }
+		};
+		lists[outcome] = trimSamples([...lists[outcome] ?? [], sample]);
+		project[run.platform] = lists;
+		history[run.projectKey] = project;
+	}
+	let placements = record.placements;
+	let buildMachines = record.buildMachines;
+	if (run.placement) {
+		const placement = buildPlacement(run, before, at);
+		placements = trimPlacements([...placements ?? [], placement], now);
+		if (placement.machine && placement.decision !== "here") buildMachines = {
+			...buildMachines,
+			[placement.machine]: applyPlacement(buildMachines?.[placement.machine], placement)
+		};
+	}
+	return {
+		version: STATS_VERSION,
+		machine,
+		projects,
+		...Object.keys(history).length ? { history } : {},
+		...placements?.length ? { placements } : {},
+		...buildMachines && Object.keys(buildMachines).length ? { buildMachines } : {}
+	};
+}
+function buildPlacement(run, before, at) {
+	const placement = run.placement;
+	const buildMs = wholeMs(placement.decision === "offloaded" ? placement.buildMs : run.coldBuildMs);
+	const localEstimateMs = wholeMs(before?.lastColdBuildMs);
+	return {
+		at,
+		project: run.projectKey,
+		platform: run.platform,
+		decision: placement.decision,
+		reason: placement.reason,
+		...placement.machine ? { machine: placement.machine } : {},
+		...buildMs > 0 ? { buildMs } : {},
+		...localEstimateMs > 0 ? { localEstimateMs } : {},
+		...run.failed ? { failed: true } : {}
+	};
+}
+function applyPlacement(totals, placement) {
+	const next = totals ? { ...totals } : {
+		offloaded: 0,
+		offloadedMs: 0,
+		savedMs: 0,
+		fallbacks: 0
+	};
+	if (placement.decision === "fell-back") {
+		next.fallbacks += 1;
+		next.lastFallbackAt = placement.at;
+		return next;
+	}
+	next.offloaded += 1;
+	next.offloadedMs += placement.buildMs ?? 0;
+	if (placement.localEstimateMs && placement.buildMs) next.savedMs += placement.localEstimateMs - placement.buildMs;
+	next.lastOffloadAt = placement.at;
+	return next;
+}
+function trimPlacements(placements, now) {
+	return placements.filter((each) => now - Date.parse(each.at) <= PLACEMENT_MAX_AGE_MS).slice(-100);
+}
+function recordRunStats(run, now) {
+	return withConfigLock$1(() => {
+		const path = statsFile();
+		const loaded = loadForUpdate(path, now);
+		if (loaded.newerVersion !== null) return {
+			recorded: false,
+			note: `Run statistics at ${path} are version ${loaded.newerVersion}, which this Stim does not understand, so this run was not recorded.`
+		};
+		writeStats(path, updateStats(loaded.record, run, now));
+		return {
+			recorded: true,
+			note: loaded.note
+		};
+	});
+}
+function createRunRecorder({ platform, write, now, note, phases, deviceSetup }) {
+	let projectKey = null;
+	let cacheKey = null;
+	let coldBuildMs = 0;
+	let podsMs = 0;
+	let placement = null;
+	let recorded = false;
+	return {
+		setProject(key) {
+			projectKey = key;
+		},
+		setCacheKey(key) {
+			cacheKey = key;
+		},
+		setBuildMs(ms) {
+			coldBuildMs = wholeMs(ms);
+		},
+		setPodsMs(ms) {
+			podsMs = wholeMs(ms);
+		},
+		setPlacement(next) {
+			placement = next;
+		},
+		record({ failed, cacheHit = false, waited = null, durationMs, offloadedTo = null }) {
+			if (!projectKey || !cacheKey || recorded) return;
+			recorded = true;
+			const ran = failed ? {} : phases?.() ?? {};
+			try {
+				const outcome = write({
+					platform,
+					projectKey,
+					failed,
+					cacheHit,
+					waitedForBuild: Boolean(waited),
+					durationMs,
+					...offloadedTo ? { offloadedTo } : {},
+					...coldBuildMs > 0 ? { coldBuildMs } : {},
+					...podsMs > 0 ? { podsMs } : {},
+					...Object.keys(ran).length ? { phases: ran } : {},
+					...failed || deviceSetup?.() === void 0 ? {} : { deviceSetup: deviceSetup() },
+					...placement ? { placement } : {}
+				}, now());
+				if (outcome?.note) note(outcome.note);
+			} catch (error) {
+				note(`Run statistics could not be recorded: ${error?.message || error}`);
+			}
+		}
+	};
+}
+function loadForUpdate(path, now) {
+	let text;
+	try {
+		text = readFileSync(path, "utf-8");
+	} catch {
+		return {
+			record: emptyStats(),
+			note: null,
+			newerVersion: null
+		};
+	}
+	const parsed = decodeStats(text);
+	if (!parsed.record && parsed.newerVersion === null) {
+		const aside = `${path}.corrupt-${now}`;
+		renameSync(path, aside);
+		return {
+			record: emptyStats(),
+			note: `Run statistics at ${path} could not be read, so they were moved to ${aside} and a new file was started.`,
+			newerVersion: null
+		};
+	}
+	if (parsed.newerVersion !== null) return {
+		record: emptyStats(),
+		note: null,
+		newerVersion: parsed.newerVersion
+	};
+	return {
+		record: parsed.record,
+		note: null,
+		newerVersion: null
+	};
+}
+function writeStats(path, record) {
+	const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(record)}\n`);
+	try {
+		renameSync(tmp, path);
+	} catch (error) {
+		rmSync(tmp, { force: true });
+		throw error;
+	}
+}
+function applyRun(bucket, run, { at, durationMs, credit, phases }) {
+	const next = bucket ? { ...bucket } : {
+		runs: 0,
+		failed: 0,
+		hits: 0,
+		misses: 0,
+		coldRuns: 0,
+		coldRunMs: 0,
+		hitRuns: 0,
+		hitRunMs: 0,
+		timeSavedMs: 0,
+		firstRunAt: at,
+		lastRunAt: at
+	};
+	next.runs += 1;
+	next.lastRunAt = at;
+	if (phases.coldBuildMs > 0) next.lastColdBuildMs = phases.coldBuildMs;
+	if (phases.podsMs > 0) next.lastPodsMs = phases.podsMs;
+	if (run.failed) {
+		next.failed += 1;
+		return next;
+	}
+	if (isHit(run.cacheHit)) {
+		next.hits += 1;
+		if (!run.waitedForBuild) {
+			next.hitRuns += 1;
+			next.hitRunMs += durationMs;
+			next.timeSavedMs += credit;
+		}
+		return next;
+	}
+	next.misses += 1;
+	if (run.offloadedTo) {
+		next.offloadedRuns = (next.offloadedRuns ?? 0) + 1;
+		next.offloadedRunMs = (next.offloadedRunMs ?? 0) + durationMs;
+		next.lastOffloadHost = run.offloadedTo;
+		return next;
+	}
+	next.coldRuns += 1;
+	next.coldRunMs += durationMs;
+	return next;
+}
+function creditMs(bucket, run, durationMs) {
+	if (run.failed || !isHit(run.cacheHit) || run.waitedForBuild) return 0;
+	if (!bucket || bucket.coldRuns <= 0) return 0;
+	return Math.max(0, Math.round(bucket.coldRunMs / bucket.coldRuns) - durationMs);
+}
+function isHit(cacheHit) {
+	return cacheHit === "local" || cacheHit === "remote";
+}
+function wholeMs(value) {
+	const ms = Number(value);
+	return Number.isFinite(ms) && ms > 0 ? Math.round(ms) : 0;
+}
+//#endregion
+//#region src/engine/build-detail.ts
+const LINE_MAX = 160;
+const TARGET_GRAPH = /^note: Target dependency graph \((\d+) targets?\)/;
+const XCODE_ACTION = /^([A-Z][A-Za-z]+)\s(.*)\s\(in target '([^']+)' from project '([^']+)'\)$/;
+const XCODE_CONFIGURE = /^(ComputeTargetDependencyGraph|CreateBuildDescription|CreateBuildRequest|Resolve Package Graph|Prepare packages)$/;
+const GRADLE_TASK = /^> Task (:\S+)/;
+/**
+* xcodebuild actions that end a target's work: a clean build touches each product last, and an incremental build
+* that touches nothing still signs framework products last. Targets that end any other way are not counted.
+*/
+const XCODE_TARGET_DONE = /^(Touch|RegisterExecutionPolicyException|CodeSign)$/;
+const GRADLE_CONFIGURE = /^> Configure project /;
+const XCODE_STEPS = [
+	[/^(CpResource|CopyPNGFile|CopyStringsFile|CompileAssetCatalog\w*|CompileStoryboard|CompileXIB|LinkStoryboards|ProcessInfoPlistFile)$/, "resources"],
+	[/^(Compile\w*|Swift\w*|ScanDependencies|Precompile\w*)$/, "compile"],
+	[/^(Ld|Libtool|CreateUniversalBinary|GenerateDSYMFile)$/, "link"],
+	[/^PhaseScriptExecution$/, "script"],
+	[/^CodeSign$/, "sign"]
+];
+const GRADLE_STEPS = [
+	[/[Dd]ex/, "dex"],
+	[/^(createBundle\w*JsAndAssets|generateCodegen\w*)$/, "script"],
+	[/(Resources?|Assets|Manifest|ResValues|RFile|JavaRes)$/, "resources"],
+	[/^(compile|kapt|ksp|javaPreCompile|buildCMake|configureCMake|externalNativeBuild)/, "compile"],
+	[/^(package|assemble|install|zipalign|validateSigning|merge\w*NativeLibs|strip\w*Symbols)/, "package"]
+];
+function stepOf(name, table) {
+	return table.find(([pattern]) => pattern.test(name))?.[1] ?? null;
+}
+function clip(text) {
+	return text.length > LINE_MAX ? `${text.slice(0, 157)}...` : text;
+}
+function unescape(token) {
+	return token.replace(/\\(.)/g, "$1");
+}
+function baseName(path) {
+	return path.split("/").findLast(Boolean) ?? path;
+}
+/**
+* An xcodebuild action line in short form: the action, the file it works on and its target, as in
+* `CompileC sqlite3.c (sqlite3)`. The file is the last absolute path in the arguments, which xcodebuild prints
+* as the source for compile, copy and plist steps and as the product for link and sign steps; a script phase
+* shows its name instead.
+*/
+function shortXcodeAction(action, args, target) {
+	const tokens = args.match(/(?:\\.|\S)+/g) ?? [];
+	const subject = action === "PhaseScriptExecution" ? unescape(tokens[0] ?? "") : baseName(unescape(tokens.findLast((token) => token.startsWith("/")) ?? ""));
+	return clip(`${action}${subject ? ` ${subject}` : ""} (${target})`);
+}
+/** What one line of xcodebuild or Gradle output says about the build's progress, or null for any other line. */
+function parseBuildToolLine(msg) {
+	const graph = TARGET_GRAPH.exec(msg);
+	if (graph) return {
+		kind: "total",
+		unit: "targets",
+		total: Number(graph[1])
+	};
+	if (XCODE_CONFIGURE.test(msg) || GRADLE_CONFIGURE.test(msg)) return { kind: "configure" };
+	const action = XCODE_ACTION.exec(msg);
+	if (action) {
+		const [, name, args, target, project] = action;
+		const step = stepOf(name, XCODE_STEPS);
+		return {
+			kind: "unit",
+			unit: "targets",
+			id: `${project}/${target}`,
+			step,
+			line: step ? shortXcodeAction(name, args, target) : null,
+			finished: XCODE_TARGET_DONE.test(name)
+		};
+	}
+	const task = GRADLE_TASK.exec(msg);
+	if (task) {
+		const path = task[1];
+		return {
+			kind: "unit",
+			unit: "tasks",
+			id: path,
+			step: stepOf(path.slice(path.lastIndexOf(":") + 1), GRADLE_STEPS),
+			line: clip(`> Task ${path}`),
+			finished: false
+		};
+	}
+	return null;
+}
+/**
+* Accumulates a build's tool output into its detail: xcodebuild counts the distinct targets it finished against the
+* total its dependency graph note gives; Gradle counts the task lines it printed and has no total.
+*/
+function createBuildDetailParser() {
+	let seen = false;
+	let step = null;
+	let unit = null;
+	let total = null;
+	let line = null;
+	let tasks = 0;
+	const targets = /* @__PURE__ */ new Set();
+	return {
+		push(msg) {
+			const parsed = parseBuildToolLine(msg);
+			if (!parsed) return false;
+			seen = true;
+			if (parsed.kind === "total") {
+				unit = "targets";
+				total = parsed.total;
+				return true;
+			}
+			if (parsed.kind === "configure") {
+				step = "configure";
+				return true;
+			}
+			unit = parsed.unit;
+			if (parsed.unit === "tasks") tasks += 1;
+			else if (parsed.finished) targets.add(parsed.id);
+			if (parsed.step) step = parsed.step;
+			if (parsed.line) line = parsed.line;
+			return true;
+		},
+		detail(updatedAt) {
+			if (!seen) return null;
+			const done = unit === "tasks" ? tasks : unit === "targets" ? targets.size : null;
+			return {
+				step,
+				unit,
+				done: done !== null && total !== null ? Math.min(done, total) : done,
+				total: unit === "tasks" ? null : total,
+				line,
+				updatedAt
+			};
+		}
+	};
+}
+//#endregion
+//#region src/engine/build-progress.ts
+const ACTIVE_BUILD_KEY = "activeBuild";
+const NO_BUILD_PROGRESS = {
+	step: () => {},
+	estimate: () => {},
+	miss: () => {},
+	hit: () => {},
+	deviceSetup: () => {},
+	deviceSetupKnown: () => void 0,
+	place: () => {},
+	waitingOn: () => {},
+	output: () => {},
+	durations: () => ({}),
+	clear: () => {}
+};
+/** `writer`, with each record it writes also passed to `progress.output`. */
+function tapBuildLog(writer, progress) {
+	if (progress === NO_BUILD_PROGRESS) return writer;
+	return {
+		get file() {
+			return writer.file;
+		},
+		write(record) {
+			progress.output(record);
+			return writer.write(record);
+		},
+		close: () => writer.close(),
+		get written() {
+			return writer.written;
+		},
+		get dropped() {
+			return writer.dropped;
+		},
+		get lastError() {
+			return writer.lastError;
+		}
+	};
+}
+const DETAIL_WRITE_MS = 2e3;
+function toolLine(record) {
+	if (!record || typeof record !== "object") return null;
+	const { src, level, msg } = record;
+	return src === "build" && level === "debug" && typeof msg === "string" ? msg : null;
+}
+function writeBuildDetail(root, claimId, detail) {
+	const file = workspaceBuildDetailFile(root);
+	const tmp = `${file}.tmp-${process.pid}`;
+	mkdirSync(dirname(file), { recursive: true });
+	writeFileSync(tmp, JSON.stringify({
+		claimId,
+		detail
+	}));
+	renameSync(tmp, file);
+}
+const COLD_PHASES = [
+	"prebuild",
+	"pods",
+	"compile"
+];
+const HIT_PHASES = ["install", "launch"];
+function settledOutcome(phase, entered) {
+	if (COLD_PHASES.includes(phase)) return "cold";
+	if (phase === "device") return entered.some((entry) => entry.phase === "cache-lookup") ? "hit" : null;
+	return HIT_PHASES.includes(phase) ? "hit" : null;
+}
+function projectHistory(projectKey) {
+	try {
+		return readStats().record?.history?.[projectKey];
+	} catch {
+		return;
+	}
+}
+function startBuildProgress({ root, platform, slot, claim, now = Date.now, note = () => {} }) {
+	const startedAt = new Date(now()).toISOString();
+	const record = {
+		platform,
+		slot,
+		startedAt,
+		phase: "prepare",
+		phaseStartedAt: startedAt,
+		phases: [{
+			phase: "prepare",
+			startedAt
+		}],
+		claim: {
+			root: claim.root,
+			path: claim.path,
+			claimId: claim.claimId,
+			pid: claim.owner.pid
+		}
+	};
+	let warned = false;
+	const guard = (fn) => {
+		try {
+			fn();
+		} catch (error) {
+			if (warned) return;
+			warned = true;
+			note(`Build progress could not be recorded in the workspace state: ${error?.message || error}`);
+		}
+	};
+	const write = (before = (state) => state) => guard(() => updateWorkspaceState(root, (state) => ({
+		...before(state),
+		[ACTIVE_BUILD_KEY]: record
+	})));
+	write(withInterruptedBuild);
+	let projectKey = null;
+	const parser = createBuildDetailParser();
+	let detailWrittenAt = -Infinity;
+	let detailTimer = null;
+	const flushDetail = () => {
+		detailTimer = null;
+		detailWrittenAt = now();
+		const detail = parser.detail(new Date(detailWrittenAt).toISOString());
+		if (detail) guard(() => writeBuildDetail(root, record.claim.claimId, detail));
+	};
+	const settle = (outcome) => {
+		record.outcome = outcome;
+		if (projectKey) record.estimate = estimateBuild(projectHistory(projectKey), platform, outcome, record.deviceSetup);
+	};
+	return {
+		step(phase) {
+			if (phase === record.phase) return;
+			const at = new Date(now()).toISOString();
+			record.phase = phase;
+			record.phaseStartedAt = at;
+			record.phases.push({
+				phase,
+				startedAt: at
+			});
+			if (phase !== "wait") delete record.waitingOn;
+			const outcome = record.outcome ? null : settledOutcome(phase, record.phases);
+			if (outcome) settle(outcome);
+			write();
+		},
+		estimate(key) {
+			projectKey = key;
+			record.estimate = estimateBuild(projectHistory(key), platform, record.outcome ?? null, record.outcome ? record.deviceSetup : void 0);
+			write();
+		},
+		miss(reason, provisional = false) {
+			record.missReason = reason;
+			settle("cold");
+			if (provisional) record.missProvisional = true;
+			else delete record.missProvisional;
+			write();
+		},
+		hit() {
+			delete record.missReason;
+			delete record.missProvisional;
+			settle("hit");
+			write();
+		},
+		deviceSetup(setup) {
+			if (setup === void 0) return;
+			record.deviceSetup = setup;
+			write();
+		},
+		deviceSetupKnown() {
+			return record.deviceSetup;
+		},
+		place(remote) {
+			const current = record.placement;
+			if (!remote) {
+				if (!current) return;
+				delete record.placement;
+				return write();
+			}
+			if (current?.host === remote.host && current.phase === remote.phase) return;
+			const at = new Date(now()).toISOString();
+			record.placement = {
+				host: remote.host,
+				phase: remote.phase,
+				startedAt: current?.host === remote.host ? current.startedAt : at,
+				phaseStartedAt: at
+			};
+			write();
+		},
+		waitingOn(holder) {
+			if (holder === null) {
+				if (!record.waitingOn) return;
+				delete record.waitingOn;
+			} else {
+				if (record.waitingOn?.path === holder) return;
+				record.waitingOn = { path: holder };
+			}
+			write();
+		},
+		output(line) {
+			const msg = toolLine(line);
+			if (msg === null || !parser.push(msg) || detailTimer) return;
+			const wait = detailWrittenAt + DETAIL_WRITE_MS - now();
+			if (wait <= 0) return flushDetail();
+			detailTimer = setTimeout(flushDetail, wait);
+			detailTimer.unref?.();
+		},
+		durations() {
+			return phaseDurations(record.phases, now());
+		},
+		clear() {
+			if (detailTimer) clearTimeout(detailTimer);
+			detailTimer = null;
+			guard(() => rmSync(workspaceBuildDetailFile(root), { force: true }));
+			guard(() => {
+				clearWorkspaceStateKey(root, ACTIVE_BUILD_KEY, (value) => parseActiveBuild(value)?.claim.claimId === record.claim.claimId);
+			});
+		}
+	};
+}
+function phaseDurations(phases, now) {
+	const out = {};
+	phases.forEach(({ phase, startedAt }, index) => {
+		const start = Date.parse(startedAt);
+		const next = phases[index + 1];
+		const end = next ? Date.parse(next.startedAt) : now;
+		if (!Number.isFinite(start) || !Number.isFinite(end)) return;
+		out[phase] = (out[phase] ?? 0) + Math.max(0, end - start);
+	});
+	return out;
+}
+const HISTORY_FIELDS = [
+	"platform",
+	"status",
+	"configuration",
+	"fingerprint",
+	"cacheKey",
+	"cacheHit",
+	"cacheSkipped",
+	"durationMs",
+	"startedAt",
+	"errorCode",
+	"missReason",
+	"buildMachine",
+	"builtOn",
+	"offloadedTo",
+	"offloadFallback",
+	"diagnostics"
+];
+function withHistoryEntry(state, platform, entry) {
+	const saved = state[BUILD_HISTORY_KEY];
+	const history = saved && typeof saved === "object" && !Array.isArray(saved) ? saved : {};
+	const list = Array.isArray(history[platform]) ? history[platform] : [];
+	return {
+		...state,
+		[BUILD_HISTORY_KEY]: {
+			...history,
+			[platform]: [entry, ...list].slice(0, BUILD_HISTORY_LIMIT)
+		}
+	};
+}
+function finishedResult(record) {
+	if (record.status === "ok") return "succeeded";
+	return record.errorCode === "STIM_CANCELLED" ? "cancelled" : "failed";
+}
+function recordFinishedBuild(root, record, { update = updateWorkspaceState, now = Date.now } = {}) {
+	const platform = record.platform;
+	update(root, (state) => {
+		const active = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
+		const own = active?.platform === platform ? active : null;
+		const entry = {
+			...Object.fromEntries(HISTORY_FIELDS.filter((key) => key in record).map((key) => [key, record[key]])),
+			result: finishedResult(record),
+			slot: own?.slot ?? "default",
+			phases: own ? phaseDurations(own.phases, now()) : {}
+		};
+		return withHistoryEntry({
+			...state,
+			lastBuild: record,
+			[LAST_BUILD_KEYS[platform]]: record
+		}, platform, entry);
+	});
+}
+function withInterruptedBuild(state) {
+	const left = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
+	if (!left) return state;
+	const last = state[LAST_BUILD_KEYS[left.platform]];
+	if (Date.parse(String(last?.startedAt)) >= Date.parse(left.startedAt)) return state;
+	return withHistoryEntry(state, left.platform, {
+		platform: left.platform,
+		status: "failed",
+		result: "interrupted",
+		slot: left.slot,
+		configuration: null,
+		fingerprint: null,
+		cacheKey: null,
+		cacheHit: false,
+		cacheSkipped: false,
+		durationMs: null,
+		startedAt: left.startedAt,
+		phases: {
+			...phaseDurations(left.phases, Date.parse(left.phaseStartedAt)),
+			[left.phase]: 0
+		}
+	});
+}
+function parseActiveBuild(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const claim = record.claim;
+	if (record.platform !== "ios" && record.platform !== "android") return null;
+	if (!isPhase(record.phase)) return null;
+	if (typeof record.startedAt !== "string" || typeof record.phaseStartedAt !== "string") return null;
+	if (!claim || typeof claim.root !== "string" || typeof claim.claimId !== "string") return null;
+	const phases = Array.isArray(record.phases) ? record.phases.filter((entry) => isPhase(entry?.phase) && typeof entry?.startedAt === "string") : [];
+	const missReason = parseMissReason(record.missReason);
+	const placement = parsePlacement(record.placement);
+	const waitingOn = parseWaitingOn(record.waitingOn);
+	const estimate = parseEstimate(record.estimate);
+	return {
+		platform: record.platform,
+		slot: typeof record.slot === "string" ? record.slot : "default",
+		startedAt: record.startedAt,
+		phase: record.phase,
+		phaseStartedAt: record.phaseStartedAt,
+		phases,
+		...missReason ? { missReason } : {},
+		...missReason && record.missProvisional === true ? { missProvisional: true } : {},
+		...placement ? { placement } : {},
+		...waitingOn ? { waitingOn } : {},
+		...typeof record.deviceSetup === "boolean" ? { deviceSetup: record.deviceSetup } : {},
+		...record.outcome === "hit" || record.outcome === "cold" ? { outcome: record.outcome } : {},
+		...estimate ? { estimate } : {},
+		claim: {
+			root: claim.root,
+			path: typeof claim.path === "string" ? claim.path : "",
+			claimId: claim.claimId,
+			pid: typeof claim.pid === "number" ? claim.pid : 0
+		}
+	};
+}
+function parsePlacement(value) {
+	if (!value || typeof value !== "object") return null;
+	const { host, phase, startedAt, phaseStartedAt } = value;
+	if ([
+		host,
+		phase,
+		startedAt,
+		phaseStartedAt
+	].some((field) => typeof field !== "string")) return null;
+	return {
+		host,
+		phase,
+		startedAt,
+		phaseStartedAt
+	};
+}
+function parseWaitingOn(value) {
+	const path = value?.path;
+	return typeof path === "string" && path ? { path } : null;
+}
+function parseEstimate(value) {
+	if (!value || typeof value !== "object") return null;
+	const { outcome, expectedMs, basis, phaseMs, planned } = value;
+	if (outcome !== null && outcome !== "hit" && outcome !== "cold") return null;
+	if (expectedMs !== null && typeof expectedMs !== "number") return null;
+	if (typeof basis !== "number" || !Array.isArray(planned) || !phaseMs || typeof phaseMs !== "object") return null;
+	const durations = Object.entries(phaseMs).filter((entry) => isPhase(entry[0]) && typeof entry[1] === "number");
+	return {
+		outcome,
+		expectedMs,
+		basis,
+		phaseMs: Object.fromEntries(durations),
+		planned: planned.filter(isPhase)
+	};
+}
+function isPhase(value) {
+	return BUILD_PHASES.includes(value);
+}
+function activeBuildState(claim, survey = (0, ownership_claim_exports.readClaimSet)(claim.root)) {
+	if (survey.live.some((holder) => holder.claimId === claim.claimId)) return "running";
+	if (survey.dead.some((holder) => holder.claimId === claim.claimId)) return "stale";
+	return survey.unresolved.length ? "unknown" : "stale";
+}
+function median(values) {
+	if (!values.length) return null;
+	const sorted = values.toSorted((a, b) => a - b);
+	const mid = Math.floor(sorted.length / 2);
+	return sorted.length % 2 ? sorted[mid] : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
+}
+function estimateBuild(history, platform, known, deviceSetup) {
+	const lists = history?.[platform];
+	const outcome = known ?? latestOutcome(lists);
+	const samples = matchDeviceSetup(outcome && lists?.[outcome] || [], deviceSetup);
+	const phaseMs = {};
+	const planned = [];
+	for (const phase of BUILD_PHASES) {
+		const durations = samples.flatMap((sample) => phase in sample.phases ? [sample.phases[phase]] : []);
+		const ms = median(durations);
+		if (ms === null) continue;
+		phaseMs[phase] = ms;
+		if (durations.length * 2 >= samples.length) planned.push(phase);
+	}
+	return {
+		outcome,
+		expectedMs: median(samples.map((sample) => sample.durationMs)),
+		basis: samples.length,
+		phaseMs,
+		planned
+	};
+}
+const MIN_TAGGED_SAMPLES = 3;
+function matchDeviceSetup(samples, deviceSetup) {
+	if (deviceSetup === void 0) return samples;
+	const tagged = samples.filter((sample) => sample.deviceSetup === deviceSetup);
+	if (deviceSetup || tagged.length >= MIN_TAGGED_SAMPLES) return tagged;
+	return samples.filter((sample) => sample.deviceSetup !== true);
+}
+function latestOutcome(lists) {
+	let latest = null;
+	for (const outcome of ["hit", "cold"]) {
+		const last = lists?.[outcome]?.at(-1);
+		const at = last ? Date.parse(last.at) : NaN;
+		if (Number.isFinite(at) && (!latest || at > latest.at)) latest = {
+			outcome,
+			at
+		};
+	}
+	return latest?.outcome ?? null;
+}
+function buildReport(record, { state, history }) {
+	const estimate = record.estimate ?? estimateBuild(history, record.platform, record.outcome ?? null, record.outcome ? record.deviceSetup : void 0);
+	const plannedPhases = estimate.planned.flatMap((phase) => {
+		const expectedMs = estimate.phaseMs[phase];
+		return expectedMs === void 0 ? [] : [{
+			phase,
+			expectedMs
+		}];
+	});
+	return {
+		platform: record.platform,
+		slot: record.slot,
+		state,
+		phase: record.phase,
+		startedAt: record.startedAt,
+		phaseStartedAt: record.phaseStartedAt,
+		outcome: estimate.outcome,
+		outcomeKnown: record.outcome !== void 0,
+		...record.outcome && record.phases.some(({ phase }) => phase === "cache-lookup") ? { cacheLookupOutcome: record.outcome === "hit" ? "hit" : "miss" } : {},
+		expectedMs: estimate.expectedMs,
+		expectedPhaseMs: estimate.phaseMs[record.phase] ?? null,
+		basis: estimate.basis,
+		plannedPhases: plannedPhases.length ? plannedPhases : null,
+		...record.missReason ? { missReason: record.missReason } : {},
+		...record.missReason && record.missProvisional ? { missProvisional: true } : {},
+		placement: record.placement ?? "local",
+		...record.waitingOn ? { waitingOn: record.waitingOn } : {}
+	};
+}
+function remainingText(remainingMs) {
+	return remainingMs < 6e4 ? "under a minute left" : `about ${Math.ceil(remainingMs / 6e4)} min left`;
+}
+function buildStatusLine(report, now) {
+	const slot = report.slot === "default" ? "" : ` [${report.slot}]`;
+	if (report.state === "stale") return `build: stale ${report.platform}${slot} record from ${report.startedAt} (its run is gone; the next run replaces it)`;
+	const elapsedMs = Math.max(0, now - Date.parse(report.startedAt));
+	const remote = typeof report.placement === "object" ? ` on ${report.placement.host} (${report.placement.phase}, ${formatElapsed(Math.max(0, now - Date.parse(report.placement.phaseStartedAt)))})` : "";
+	const waiting = report.waitingOn ? ` on ${report.waitingOn.path}` : "";
+	const head = `build: ${report.platform}${slot} ${report.phase}${waiting}${remote}, ${formatElapsed(elapsedMs)} elapsed`;
+	if (report.state === "unknown") return `${head} (its native-run claim cannot be resolved, so it may not be running)`;
+	if (report.expectedMs === null) return head;
+	const basis = `median of ${plural(report.basis, `${report.outcome} run`)}`;
+	const remainingMs = report.expectedMs - elapsedMs;
+	return remainingMs > 0 ? `${head} -- ${remainingText(remainingMs)} (${basis})` : `${head} (usually ~${formatElapsed(report.expectedMs)}, ${basis})`;
+}
+//#endregion
+export { buildStatusLine as a, recordFinishedBuild as c, createRunRecorder as d, readRunEstimates as f, statsProjectKey$1 as h, buildReport as i, startBuildProgress as l, recordRunStats as m, NO_BUILD_PROGRESS as n, estimateBuild as o, readStats as p, activeBuildState as r, parseActiveBuild as s, ACTIVE_BUILD_KEY as t, tapBuildLog as u };