stim 1.17.2 → 1.18.0

package/dist/build-progress-D0WkjCPd.mjs

@@ -1,1036 +0,0 @@
-import { D as withConfigLock$1 } from "./config-D0DbpZtM.mjs";
-import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
-import { a as formatElapsed, u as plural } from "./command-output-CDAIFD-8.mjs";
-import { a as updateWorkspaceState, t as clearWorkspaceStateKey } from "./workspace-state-DqcCbpE7.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, isJsonObject, parseMissReason, readRunEstimates, readStats as readStats$1, statsFile, statsProjectKey as statsProjectKey$1, trimCapacityRefusals, trimCapacityWaits, 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)
-		};
-	}
-	const capacityRefusals = trimCapacityRefusals(record.capacityRefusals ?? [], now);
-	const capacityWaits = trimCapacityWaits(record.capacityWaits ?? [], now);
-	return {
-		version: STATS_VERSION,
-		machine,
-		projects,
-		...Object.keys(history).length ? { history } : {},
-		...placements?.length ? { placements } : {},
-		...capacityRefusals.length ? { capacityRefusals } : {},
-		...capacityWaits.length ? { capacityWaits } : {},
-		...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);
-	const slotWaitMs = wholeMs(placement.slotWaitMs);
-	const deviceSlotWaitMs = wholeMs(placement.deviceSlotWaitMs);
-	return {
-		at,
-		project: run.projectKey,
-		platform: run.platform,
-		decision: placement.decision,
-		reason: placement.reason,
-		...placement.machine ? { machine: placement.machine } : {},
-		...buildMs > 0 ? { buildMs } : {},
-		...slotWaitMs > 0 ? { slotWaitMs } : {},
-		...deviceSlotWaitMs > 0 ? { deviceSlotWaitMs } : {},
-		...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 recordCapacityRefusal(event, now) {
-	try {
-		withConfigLock$1(() => {
-			const path = statsFile();
-			const loaded = loadForUpdate(path, now, false);
-			if (!loaded.record || loaded.newerVersion !== null) return;
-			const capacityRefusals = trimCapacityRefusals([...loaded.record.capacityRefusals ?? [], {
-				...event,
-				at: new Date(now).toISOString(),
-				kind: "device"
-			}], now);
-			writeStats(path, {
-				...loaded.record,
-				capacityRefusals
-			});
-		});
-	} catch {}
-}
-function recordCapacityWait(event, now) {
-	try {
-		withConfigLock$1(() => {
-			const path = statsFile();
-			const loaded = loadForUpdate(path, now, false);
-			if (!loaded.record || loaded.newerVersion !== null) return;
-			const capacityWaits = trimCapacityWaits([...loaded.record.capacityWaits ?? [], {
-				platform: event.platform,
-				max: event.max,
-				workspace: event.workspace,
-				ms: wholeMs(event.ms),
-				...event.reclaimed && Number.isInteger(event.reclaimed) && event.reclaimed > 0 ? { reclaimed: event.reclaimed } : {},
-				at: new Date(now).toISOString(),
-				kind: "device-wait"
-			}], now);
-			writeStats(path, {
-				...loaded.record,
-				capacityWaits
-			});
-		});
-	} catch {}
-}
-function createRunRecorder({ platform, write, now, note, phases, deviceSetup }) {
-	let projectKey = null;
-	let cacheKey = null;
-	let coldBuildMs = 0;
-	let podsMs = 0;
-	let placement = null;
-	let deviceSlotWaitMs = 0;
-	let recorded = false;
-	return {
-		setProject(key) {
-			projectKey = key;
-		},
-		setCacheKey(key) {
-			cacheKey = key;
-		},
-		setBuildMs(ms) {
-			coldBuildMs = wholeMs(ms);
-		},
-		setPodsMs(ms) {
-			podsMs = wholeMs(ms);
-		},
-		addDeviceSlotWaitMs(ms) {
-			deviceSlotWaitMs += wholeMs(ms);
-		},
-		deviceSlotWaitMs() {
-			return deviceSlotWaitMs || void 0;
-		},
-		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: {
-						...placement,
-						...deviceSlotWaitMs > 0 ? { deviceSlotWaitMs } : {}
-					} } : {}
-				}, now());
-				if (outcome?.note) note(outcome.note);
-			} catch (error) {
-				note(`Run statistics could not be recorded: ${error?.message || error}`);
-			}
-		}
-	};
-}
-function loadForUpdate(path, now, recoverCorrupt = true) {
-	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) {
-		if (!recoverCorrupt) return {
-			record: null,
-			note: null,
-			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 /;
-/**
-* SwiftPM prints `[done / total] name` once it plans the build (with U+2009 thin spaces around the slash in Swift 6.4
-* output), `[done/total] Compiling ...` in older toolchains; Swift 6.4 names the target being worked on, and
-* `<product>-product` is the link of a product.
-*/
-const SWIFTPM_PROGRESS = /^\[(\d+)\s*\/\s*(\d+)\](?:\s+(.*))?$/;
-const SWIFTPM_CONFIGURE = /^(Fetching|Fetched|Computing version|Computed|Creating working copy|Working copy of)\b|^\[(Pre-planning|Planning|Using on-disk description)/;
-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})`);
-}
-function swiftpmStep(text) {
-	return /^Linking\b|-product$/.test(text) ? "link" : "compile";
-}
-/** What one line of xcodebuild, Gradle or SwiftPM output says about the build's progress, or null for any other line. */
-function parseBuildToolLine(msg) {
-	const counted = SWIFTPM_PROGRESS.exec(msg);
-	if (counted) {
-		const text = counted[3]?.trim() ?? "";
-		return {
-			kind: "count",
-			done: Number(counted[1]),
-			total: Number(counted[2]),
-			step: swiftpmStep(text),
-			line: text ? clip(text) : null
-		};
-	}
-	if (SWIFTPM_CONFIGURE.test(msg)) return { kind: "configure" };
-	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; SwiftPM reports
-* its own `[done / total]` counts, which the parser passes through.
-*/
-function createBuildDetailParser() {
-	let seen = false;
-	let step = null;
-	let unit = null;
-	let total = null;
-	let line = null;
-	let tasks = 0;
-	let counted = null;
-	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;
-			}
-			if (parsed.kind === "count") {
-				unit = "steps";
-				counted = {
-					done: parsed.done,
-					total: parsed.total
-				};
-				step = parsed.step;
-				if (parsed.line) line = parsed.line;
-				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;
-			if (unit === "steps" && counted) return {
-				step,
-				unit,
-				done: Math.min(counted.done, counted.total),
-				total: counted.total,
-				line,
-				updatedAt
-			};
-			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: () => {},
-	waitingFor: () => {},
-	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$1().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 && platform !== "macos") record.estimate = estimateBuild(projectHistory(projectKey), platform, outcome, record.deviceSetup);
-	};
-	const waits = /* @__PURE__ */ new Map();
-	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 || platform === "macos" ? null : settledOutcome(phase, record.phases);
-			if (outcome) settle(outcome);
-			write();
-		},
-		estimate(key) {
-			if (platform === "macos") return;
-			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();
-		},
-		waitingFor(info, kind) {
-			if (info) waits.set(info.kind, info);
-			else if (kind) waits.delete(kind);
-			else waits.clear();
-			const first = [...waits.values()].toSorted((a, b) => Date.parse(a.since) - Date.parse(b.since))[0];
-			if (first) record.waitingFor = first;
-			else delete record.waitingFor;
-			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;
-}
-function completedPhaseDurations(phases) {
-	if (phases.length < 2) return void 0;
-	const durations = phaseDurations(phases.slice(0, -1), Date.parse(phases.at(-1).startedAt));
-	return Object.keys(durations).length ? durations : void 0;
-}
-const HISTORY_FIELDS = [
-	"devicePlacement",
-	"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()) : {}
-		};
-		const slot = own?.slot ?? "default";
-		const slots = isJsonObject(state.deviceSlots) ? state.deviceSlots : {};
-		const savedSlot = isJsonObject(slots[slot]) ? slots[slot] : {};
-		const savedDevice = slot === "default" ? state[platform] : savedSlot[platform];
-		if (platform !== "macos" && (record.devicePlacement || isJsonObject(savedDevice))) {
-			const device = isJsonObject(savedDevice) ? { ...savedDevice } : {};
-			if (record.devicePlacement) device.devicePlacement = record.devicePlacement;
-			else delete device.devicePlacement;
-			state = slot === "default" ? {
-				...state,
-				[platform]: device
-			} : {
-				...state,
-				deviceSlots: {
-					...slots,
-					[slot]: {
-						...savedSlot,
-						[platform]: device
-					}
-				}
-			};
-		}
-		if (platform === "macos") return withHistoryEntry(state, platform, entry);
-		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 = left.platform === "macos" ? state[BUILD_HISTORY_KEY]?.macos?.[0] : 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" && record.platform !== "macos") 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 waitingFor = parseWaitingFor(record.waitingFor);
-	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 } : {},
-		...waitingFor ? { waitingFor } : {},
-		...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 parseWaitingFor(value) {
-	if (!value || typeof value !== "object") return null;
-	const { kind, inUse, max, since } = value;
-	if (kind !== "build-slot" && kind !== "device-slot") return null;
-	if (!Number.isInteger(inUse) || inUse < 0 || !Number.isInteger(max) || max <= 0) return null;
-	if (typeof since !== "string" || !Number.isFinite(Date.parse(since))) return null;
-	return {
-		kind,
-		inUse,
-		max,
-		since
-	};
-}
-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 = platform === "macos" ? void 0 : 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
-		}];
-	});
-	const completedPhaseMs = completedPhaseDurations(record.phases);
-	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,
-		...completedPhaseMs ? { completedPhaseMs } : {},
-		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 } : {},
-		...record.waitingFor ? { waitingFor: record.waitingFor } : {}
-	};
-}
-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 { statsProjectKey$1 as _, buildStatusLine as a, recordFinishedBuild as c, createRunRecorder as d, readRunEstimates as f, recordRunStats as g, recordCapacityWait as h, buildReport as i, startBuildProgress as l, recordCapacityRefusal as m, NO_BUILD_PROGRESS as n, estimateBuild as o, readStats$1 as p, activeBuildState as r, parseActiveBuild as s, ACTIVE_BUILD_KEY as t, tapBuildLog as u };