stim 1.17.2 → 1.19.0

package/dist/maintenance-run.mjs

@@ -1,16 +1,193 @@
-import { j as formatBytes } from "./config-D0DbpZtM.mjs";
-import { t as relaunchWithLogFile } from "./detached-entry-CiTEgMR1.mjs";
-import { c as resolveBudget } from "./budget-DfcgFdQB.mjs";
-import { r as createNdjsonWriter } from "./ndjson-PclOIwVY.mjs";
-import { t as resolveMaintenanceSettings } from "./settings-BBpMcDbD.mjs";
-import { r as due, t as capChildLog } from "./attempt-Bk2ouQVL.mjs";
-import { a as sizeScanDeferred, i as measureSizes, r as measurePressure, t as plannedMaintenance } from "./preview-B-g9d7kV.mjs";
-import { appendFileSync, mkdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
-import { LOG_ROTATE_BYTES, rotatedLogPath, withDirLock } from "@stim-cli/core";
-import { maintenanceChildLogFile, maintenanceDir, maintenanceNdjsonFile, maintenanceRunClaims, maintenanceStateFile, readMaintenanceState, workspaceLogsDir } from "@stim-cli/core/state";
-import { releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
+import { M as isOnMountedVolume, N as listMountedVolumes, _ as loadConfig$1, j as formatBytes } from "./config-DC5jEtd1.mjs";
+import { D as projectMaintenancePinned } from "./settings-CxgngUZk.mjs";
+import { a as unregister, n as readManifest } from "./cache-manifest-DiwKSyv9.mjs";
+import { Nt as discoverCaches, Pt as pruneCache, l as resolveBudget, pt as planCacheEmptying, r as cacheLabel, st as emptyCaches } from "./budget-Dz-kyXLv.mjs";
+import { I as takeGcResults, L as canonicalPath, a as collectWorkspaceOutputs, i as collectOrphanedWorkspaces, o as deleteOrphanedWorkspaces, r as clearWorkspaceOutputs } from "./workspaces-Djb2gfi9.mjs";
+import { r as createNdjsonWriter } from "./ndjson-LGZAMsqa.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-pB_IPfV4.mjs";
+import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
+import { r as due, t as capChildLog } from "./attempt-DW-mQqM7.mjs";
+import { a as recentUse, d as measureDisk, f as measurePressure, i as cacheEntryProtection, m as sizeScanDeferred, p as measureSizes, r as triggeringRoot, s as removeWorktrees, t as plannedMaintenance, u as cacheBlocked } from "./preview-BbSottmO.mjs";
+import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, join, resolve, sep } from "node:path";
+import { MAINTENANCE_LOG_NAME, maintenanceChildLogFile, maintenanceDir, maintenanceNdjsonFile, maintenanceRunClaims, maintenanceStateFile, readMaintenanceState, sharedCompilationCache, workspaceLogsDir } from "@stim-cli/core/state";
 import { fileURLToPath } from "node:url";
+import { LOG_ROTATE_BYTES, buildCacheRoot, metroCacheRoot, rotatedLogPath, withDirLock } from "@stim-cli/core";
+import { releaseClaim, tryAcquireClaim } from "@stim-cli/core/ownership-claim";
+//#region src/maintenance/act.ts
+const kept = (detail) => ({
+	status: "kept",
+	bytes: 0,
+	detail
+});
+async function quietly(run) {
+	const { log, error } = {
+		log: console.log,
+		error: console.error
+	};
+	const exitCode = process.exitCode;
+	takeGcResults();
+	console.log = () => {};
+	console.error = () => {};
+	try {
+		return {
+			value: await run(),
+			results: takeGcResults()
+		};
+	} finally {
+		console.log = log;
+		console.error = error;
+		process.exitCode = exitCode;
+		takeGcResults();
+	}
+}
+function outcomeOf(results, fallbackBytes) {
+	const failed = results.find((result) => result.status === "failed");
+	if (failed) return {
+		status: "failed",
+		bytes: 0,
+		detail: failed.detail ?? `could not process ${failed.label}`
+	};
+	const done = results.filter((result) => result.status === "done");
+	if (done.length) return {
+		status: "done",
+		bytes: done.reduce((sum, result) => sum + (result.bytes ?? 0), 0) || fallbackBytes,
+		detail: done.map((result) => result.label).join(", ")
+	};
+	return kept(results.find((result) => result.detail)?.detail ?? "nothing was eligible when the action ran");
+}
+function rootCache(dir) {
+	const name = canonicalPath(dir) === canonicalPath(buildCacheRoot()) ? "Build cache" : canonicalPath(dir) === canonicalPath(metroCacheRoot()) ? "Metro transform caches" : null;
+	return name ? {
+		name,
+		dir,
+		prune: "entries",
+		entriesDepth: name === "Build cache" ? 2 : 3,
+		note: ""
+	} : null;
+}
+function cacheOf(action) {
+	const discovered = discoverCaches();
+	if (action.dir) {
+		const dir = canonicalPath(action.dir);
+		return discovered.find((cache) => canonicalPath(cache.dir) === dir) ?? rootCache(action.dir);
+	}
+	return discovered.find((cache) => cacheLabel(cache) === action.target) ?? null;
+}
+function trimCache(action, context) {
+	const cache = cacheOf(action);
+	if (!cache) return kept("it is no longer a cache Stim may trim");
+	const [planned] = planCacheEmptying([cache], false);
+	if (!planned || planned.machineGlobal) return kept(planned?.machineGlobal ?? "it is no longer a cache Stim may trim");
+	const aged = action.olderThanDays !== void 0;
+	const result = pruneCache(cache, {
+		olderThanDays: Math.max(action.olderThanDays ?? 0, context.settings.protectRecentHours / 24),
+		byMtime: true,
+		protect: context.protect ??= cacheEntryProtection(),
+		...aged ? {} : { evictBytes: action.bytes }
+	});
+	if (result.skipped) return kept(result.skipped);
+	if (result.failed) return {
+		status: "failed",
+		bytes: result.bytes,
+		detail: `${result.failed} entries could not be removed`
+	};
+	const protectedNote = result.protectedEntries ? `; ${result.protectedEntries} protected entries kept` : "";
+	if (result.removed === 0) return kept(`no unprotected entry was old enough${protectedNote}`);
+	return {
+		status: "done",
+		bytes: result.bytes,
+		detail: `${result.removed} entries${protectedNote}`,
+		...!aged && result.bytes < action.bytes ? { shortfall: `${action.target} reached ${result.bytes} of ${action.bytes} bytes${protectedNote}` } : {}
+	};
+}
+async function emptyCompilationCache(action, context) {
+	if (!measureDisk().some((disk) => disk.freeMb < context.budget.hardFloorDiskMb)) return kept("free disk is above budget.hardFloorDiskGb, and this cache can only be emptied whole");
+	const dir = sharedCompilationCache();
+	const blocked = cacheBlocked({
+		name: "Swift compilation cache",
+		dir,
+		category: "compilation-cache"
+	});
+	if (blocked) return kept(blocked);
+	const cache = discoverCaches().find((candidate) => canonicalPath(candidate.dir) === canonicalPath(dir));
+	if (cache?.prune !== "atomic") return kept("it is not a registered cache Stim empties whole");
+	const [planned] = planCacheEmptying([{
+		...cache,
+		bytes: action.bytes
+	}], true);
+	const { results } = await quietly(() => emptyCaches(planned ? [planned] : []));
+	return outcomeOf(results, action.bytes);
+}
+async function clearOutputs(action, context) {
+	const root = action.workspace;
+	if (!root) return kept("the action names no workspace");
+	if (root === context.protectedRoot) return kept("the command that started this pass runs in it");
+	if (projectMaintenancePinned(root)) return kept("pinned by maintenance.keep");
+	const recent = recentUse(root, context.settings);
+	if (recent) return kept(recent);
+	const olderThan = action.olderThanDays ?? null;
+	const now = Date.now();
+	const report = collectWorkspaceOutputs({
+		olderThan,
+		now,
+		measure: false
+	});
+	const entry = report.workspaces.find((candidate) => candidate.projectRoot && canonicalPath(candidate.projectRoot) === root);
+	if (!entry) return kept("it has no build outputs any more");
+	const { results } = await quietly(() => clearWorkspaceOutputs({
+		...report,
+		workspaces: [entry]
+	}, {
+		olderThan,
+		now
+	}));
+	return outcomeOf(results, action.bytes);
+}
+async function removeWorktree(action, context) {
+	const sweep = context.worktreeSweep;
+	const worktree = sweep?.worktrees.find((candidate) => candidate.path === action.target);
+	if (!sweep || !worktree) return kept("it is not in this pass's worktree check");
+	const path = canonicalPath(worktree.path);
+	if (context.protectedRoot === path || context.protectedRoot.startsWith(`${path}${sep}`)) return kept("the command that started this pass runs inside it");
+	if (worktree.keys.some(projectMaintenancePinned)) return kept("pinned by maintenance.keep");
+	const { results } = await quietly(() => removeWorktrees({
+		...sweep,
+		worktrees: [worktree]
+	}));
+	return outcomeOf(results, 0);
+}
+async function removeOrphan(action) {
+	const orphan = collectOrphanedWorkspaces(Object.keys(loadConfig$1()?.projects ?? {}), listMountedVolumes()).orphaned.find((candidate) => candidate.dir === action.target);
+	if (!orphan) return kept("it is no longer an orphaned workspace directory");
+	const { results } = await quietly(() => deleteOrphanedWorkspaces([orphan]));
+	return outcomeOf(results, orphan.bytes ?? 0);
+}
+function unregisterCache(action) {
+	const dir = action.dir ?? action.target;
+	if (existsSync(dir) || !isOnMountedVolume(dir, listMountedVolumes()) || !readManifest().caches.some((c) => c.dir === dir)) return kept("it can no longer be shown to be a stale registration");
+	return unregister(dir) ? {
+		status: "done",
+		bytes: 0,
+		detail: dir
+	} : kept("it was already unregistered");
+}
+async function executeAction(action, context) {
+	switch (action.kind) {
+		case "would-clear-outputs": return clearOutputs(action, context);
+		case "would-trim-cache": return trimCache(action, context);
+		case "would-empty-cache": return emptyCompilationCache(action, context);
+		case "would-remove-worktree": return removeWorktree(action, context);
+		case "would-remove-orphan": return removeOrphan(action);
+		case "would-unregister-cache": return unregisterCache(action);
+		default: return kept("automatic maintenance does not stop devices or dev servers yet");
+	}
+}
+function diskRecovered(budget) {
+	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
+	return measureDisk().every((disk) => disk.freeMb >= floor);
+}
+//#endregion
 //#region src/maintenance/log.ts
 function maintenanceLogger(settings, pass, trigger) {
 	const file = maintenanceNdjsonFile();
@@ -33,7 +210,7 @@ function maintenanceLogger(settings, pass, trigger) {
 				event,
 				pass,
 				trigger,
-				mode: "report"
+				mode: settings.mode === "on" ? "on" : "report"
 			};
 			if (!writer.write(record)) throw writer.lastError ?? /* @__PURE__ */ new Error(`Could not append ${file}`);
 			if (typeof fields.workspace === "string" && [
@@ -41,7 +218,7 @@ function maintenanceLogger(settings, pass, trigger) {
 				"maintenance_failure",
 				"maintenance_skip"
 			].includes(event)) {
-				const workspace = createNdjsonWriter(join(workspaceLogsDir(fields.workspace), "maintenance.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
+				const workspace = createNdjsonWriter(join(workspaceLogsDir(fields.workspace), MAINTENANCE_LOG_NAME), { maxBytes: LOG_ROTATE_BYTES });
 				try {
 					if (!workspace.write(record)) throw workspace.lastError ?? /* @__PURE__ */ new Error("Could not append workspace maintenance log");
 				} finally {
@@ -70,6 +247,37 @@ function writeState(state) {
 		}
 	});
 }
+const EXECUTION_ORDER = {
+	"would-unregister-cache": 0,
+	"would-remove-orphan": 0,
+	"would-clear-outputs": 1,
+	"would-trim-cache": 2,
+	"would-empty-cache": 3,
+	"would-remove-worktree": 4
+};
+function shrinkSizes(state, action, outcome) {
+	state.sizes = state.sizes.flatMap((size) => {
+		if (action.kind === "would-clear-outputs" && size.category === "workspace-outputs" && size.workspace === action.workspace) return [];
+		if (action.kind === "would-trim-cache" && action.dir && size.dir === action.dir) return [{
+			...size,
+			bytes: Math.max(0, size.bytes - outcome.bytes)
+		}];
+		if (action.kind === "would-empty-cache" && size.dir === action.target) return [];
+		return [size];
+	});
+}
+const executedKind = (action) => action.kind.replace(/^would-/, "");
+function describeDone(action) {
+	const name = basename(action.workspace ?? action.target);
+	switch (action.kind) {
+		case "would-clear-outputs": return `Cleared build outputs of ${name}`;
+		case "would-trim-cache": return `Trimmed ${action.target}`;
+		case "would-empty-cache": return `Emptied ${action.target}`;
+		case "would-remove-worktree": return `Removed the worktree ${action.target}`;
+		case "would-remove-orphan": return `Removed the orphaned workspace directory ${action.target}`;
+		default: return `Unregistered the stale cache ${action.target}`;
+	}
+}
 const actionKey = (action) => JSON.stringify([action.kind, action.target]);
 const stableText = (text) => text.replace(/\d+(?:\.\d+)?/g, "#");
 const sameSet = (before, after) => before.size === after.size && [...before].every((key) => after.has(key));
@@ -113,10 +321,11 @@ async function runMaintenance(trigger) {
 		const failures = [];
 		let measuredSizes = false;
 		const budget = resolveBudget().budget;
+		const ran = /* @__PURE__ */ new Set();
 		for (const check of checks) {
-			if (check === "size" && sizeScanDeferred(settings)) {
-				record("maintenance_skip", "debug", "Size check deferred: host load exceeds maintenance.maxLoadPerCore", {
-					target: "size",
+			if (check !== "pressure" && sizeScanDeferred(settings)) {
+				record("maintenance_skip", "debug", `${check} check deferred: host load exceeds maintenance.maxLoadPerCore`, {
+					target: check,
 					reason: "host load exceeds maintenance.maxLoadPerCore"
 				});
 				state.deferredAt = {
@@ -127,9 +336,11 @@ async function runMaintenance(trigger) {
 				continue;
 			}
 			state.lastAt[check] = Date.now();
+			ran.add(check);
 			delete state.deferredAt?.[check];
 			writeState(state);
 			try {
+				if (check === "worktree" || check === "sweep") continue;
 				if (check === "pressure") {
 					state.pressure = measurePressure(settings, state.pressure, state.lastAt[check]);
 					const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
@@ -175,7 +386,10 @@ async function runMaintenance(trigger) {
 		}
 		let result;
 		try {
-			result = await plannedMaintenance(state.pressure, state.sizes, settings);
+			result = await plannedMaintenance(state.pressure, state.sizes, settings, {
+				sweep: ran.has("sweep"),
+				worktrees: ran.has("worktree")
+			});
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
 			failures.push(message);
@@ -188,42 +402,130 @@ async function runMaintenance(trigger) {
 				blocked: [],
 				skips: []
 			};
+			for (const check of ["sweep", "worktree"]) if (ran.has(check)) delete state.lastAt[check];
+		}
+		async function executePlan(actions) {
+			const context = {
+				settings,
+				budget,
+				protectedRoot: triggeringRoot(),
+				worktreeSweep: result.worktreeSweep
+			};
+			const results = [];
+			const ordered = actions.toSorted((a, b) => (EXECUTION_ORDER[a.kind] ?? 9) - (EXECUTION_ORDER[b.kind] ?? 9));
+			for (const action of ordered) {
+				const began = Date.now();
+				let outcome;
+				try {
+					outcome = action.check === "disk" && diskRecovered(budget) ? {
+						status: "kept",
+						bytes: 0,
+						detail: "free disk recovered before this action"
+					} : await executeAction(action, context);
+				} catch (error) {
+					outcome = {
+						status: "failed",
+						bytes: 0,
+						detail: error instanceof Error ? error.message : String(error)
+					};
+				}
+				results.push({
+					action,
+					outcome
+				});
+				const fields = {
+					action: {
+						kind: executedKind(action),
+						target: action.target,
+						bytes: outcome.bytes,
+						durationMs: Date.now() - began
+					},
+					...action.workspace && action.kind !== "would-remove-worktree" ? { workspace: action.workspace } : {}
+				};
+				if (outcome.status === "done") record("maintenance_action", action.kind === "would-remove-worktree" ? "warn" : "info", `${describeDone(action)} (${formatBytes(outcome.bytes)}): ${action.reason}`, fields);
+				else if (outcome.status === "failed") {
+					failures.push(`${describeDone(action)} failed: ${outcome.detail}`);
+					record("maintenance_failure", "error", `Could not process ${action.target}: ${outcome.detail}`, {
+						target: action.target,
+						error: outcome.detail,
+						...fields.workspace ? { workspace: fields.workspace } : {}
+					});
+				} else if (!loggedSkips.has(action.target)) {
+					loggedSkips.add(action.target);
+					record("maintenance_skip", "info", `Kept ${action.target}: ${outcome.detail}`, {
+						target: action.target,
+						reason: outcome.detail,
+						...fields.workspace ? { workspace: fields.workspace } : {}
+					});
+				}
+			}
+			return results;
 		}
+		const retained = state.plan.filter((action) => (action.check === "sweep" || action.check === "worktree") && !ran.has(action.check));
 		const previousActions = new Set(state.plan.map(actionKey));
-		const nextActions = new Set(result.actions.map(actionKey));
 		const previousSkips = new Set(state.skipKeys ?? []);
 		const nextSkips = new Set(result.skips.map((skip) => skip.target));
-		const blocked = [...result.blocked, ...failures];
-		const changed = !state.lastPass || !sameSet(previousActions, nextActions) || !sameSet(previousSkips, nextSkips) || !sameSet(new Set(state.lastPass.blocked.map(stableText)), new Set(blocked.map(stableText)));
-		for (const action of result.actions) {
-			if (previousActions.has(actionKey(action))) continue;
-			previousActions.add(actionKey(action));
-			record("maintenance_action", "info", `Would ${action.kind === "would-clear-outputs" ? `clear build outputs of ${basename(action.workspace ?? action.target)}` : `${action.kind.slice(6).replaceAll("-", " ")} ${action.target}`} (${formatBytes(action.bytes)}): ${action.reason}`, {
-				action: {
-					...action,
-					durationMs: 0
-				},
-				...action.workspace ? { workspace: action.workspace } : {}
-			});
-		}
+		const loggedSkips = new Set(previousSkips);
 		for (const skip of result.skips) {
-			if (previousSkips.has(skip.target)) continue;
-			previousSkips.add(skip.target);
+			if (loggedSkips.has(skip.target)) continue;
+			loggedSkips.add(skip.target);
 			record("maintenance_skip", "info", `Kept ${skip.target}: ${skip.reason}`, skip);
 		}
-		state.plan = result.actions;
-		state.skipKeys = [...nextSkips];
-		state.lastPass = {
-			startedAt,
-			durationMs: Date.now() - startedAt,
-			trigger,
-			mode: "report",
-			freedBytes: 0,
-			actions: result.actions.length,
-			stopped: 0,
-			blocked
-		};
-		if (measuredSizes || changed) record("maintenance_pass", state.lastPass.blocked.length ? "warn" : "info", `Report-only pass: ${result.actions.length} planned actions${state.lastPass.blocked.length ? `; ${state.lastPass.blocked.join("; ")}` : ""}`, { ...state.lastPass });
+		if (settings.mode === "on") {
+			const outcomes = await executePlan(result.actions);
+			const blockedNow = [
+				...result.blocked,
+				...failures,
+				...outcomes.flatMap(({ outcome }) => outcome.shortfall ? [outcome.shortfall] : [])
+			];
+			const done = outcomes.filter(({ outcome }) => outcome.status === "done");
+			const freedBytes = done.reduce((sum, { outcome }) => sum + outcome.bytes, 0);
+			for (const { action, outcome } of done) shrinkSizes(state, action, outcome);
+			state.plan = outcomes.filter(({ outcome }) => outcome.status !== "done").map(({ action }) => action);
+			state.skipKeys = [...nextSkips, ...outcomes.filter(({ outcome }) => outcome.status === "kept").map(({ action }) => action.target)];
+			const previousBlocked = state.lastPass?.blocked;
+			state.lastPass = {
+				startedAt,
+				durationMs: Date.now() - startedAt,
+				trigger,
+				mode: "on",
+				freedBytes,
+				actions: done.length,
+				stopped: 0,
+				blocked: blockedNow
+			};
+			const blockedChanged = !sameSet(new Set((previousBlocked ?? []).map(stableText)), new Set(state.lastPass.blocked.map(stableText)));
+			if (done.length || measuredSizes || blockedChanged) record("maintenance_pass", state.lastPass.blocked.length ? "warn" : "info", `Pass: ${done.length} actions, ${formatBytes(freedBytes)} freed${state.lastPass.blocked.length ? `; ${state.lastPass.blocked.join("; ")}` : ""}`, { ...state.lastPass });
+		} else {
+			const blocked = [...result.blocked, ...failures];
+			const planned = [...result.actions, ...retained];
+			const nextActions = new Set(planned.map(actionKey));
+			const changed = !state.lastPass || !sameSet(previousActions, nextActions) || !sameSet(previousSkips, nextSkips) || !sameSet(new Set(state.lastPass.blocked.map(stableText)), new Set(blocked.map(stableText)));
+			for (const action of result.actions) {
+				if (previousActions.has(actionKey(action))) continue;
+				previousActions.add(actionKey(action));
+				record("maintenance_action", "info", `Would ${action.kind === "would-clear-outputs" ? `clear build outputs of ${basename(action.workspace ?? action.target)}` : `${action.kind.slice(6).replaceAll("-", " ")} ${action.target}`} (${formatBytes(action.bytes)}): ${action.reason}`, {
+					action: {
+						...action,
+						durationMs: 0
+					},
+					...action.workspace ? { workspace: action.workspace } : {}
+				});
+			}
+			state.plan = planned;
+			state.skipKeys = [...nextSkips];
+			state.lastPass = {
+				startedAt,
+				durationMs: Date.now() - startedAt,
+				trigger,
+				mode: "report",
+				freedBytes: 0,
+				actions: planned.length,
+				stopped: 0,
+				blocked
+			};
+			if (measuredSizes || changed) record("maintenance_pass", state.lastPass.blocked.length ? "warn" : "info", `Report-only pass: ${planned.length} planned actions${state.lastPass.blocked.length ? `; ${state.lastPass.blocked.join("; ")}` : ""}`, { ...state.lastPass });
+		}
 		writeState(state);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);

package/dist/manifest-CX0d1IkZ.mjs

@@ -0,0 +1,148 @@
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { l as phaseLine } from "./command-output-Bt8ygHE7.mjs";
+import { _ as loadConfig } from "./config-DC5jEtd1.mjs";
+import { f as sharedCcache, x as workspaceLogsDir } from "./workspace-state-CR9X86xJ.mjs";
+import { r as register } from "./cache-manifest-DiwKSyv9.mjs";
+import { o as machineNumber } from "./budget-Dz-kyXLv.mjs";
+import { readFileSync, realpathSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import chalk from "chalk";
+import { createHash } from "node:crypto";
+const CCACHE_SLOPPINESS = "pch_defines,time_macros";
+const STATS_LOG_FILE = "ccache-stats.log";
+const CCACHE_UNAVAILABLE = {
+	status: "unavailable",
+	hits: null,
+	misses: null,
+	hitRatePercent: null
+};
+const CCACHE_NOT_RUN = {
+	status: "not-run",
+	hits: null,
+	misses: null,
+	hitRatePercent: null
+};
+function ccacheStatsLog(root) {
+	return join(workspaceLogsDir(root), STATS_LOG_FILE);
+}
+function ccacheMaxSize(config = loadConfig(), env = process.env) {
+	const { value, error } = machineNumber("caches.ccacheMaxGb", config, env);
+	return error || value === void 0 ? "5G" : `${value}G`;
+}
+function ccacheEnvironment({ binary, dir, workspaceRoot, statsLog, maxSize = "5G" }) {
+	return {
+		CMAKE_C_COMPILER_LAUNCHER: binary,
+		CMAKE_CXX_COMPILER_LAUNCHER: binary,
+		CCACHE_DIR: dir,
+		CCACHE_BASEDIR: workspaceRoot,
+		CCACHE_NOHASHDIR: "true",
+		CCACHE_SLOPPINESS,
+		CCACHE_MAXSIZE: maxSize,
+		CCACHE_STATSLOG: statsLog
+	};
+}
+function parseCcacheBinary(output) {
+	const first = String(output ?? "").split("\n")[0]?.trim();
+	if (!first || !isAbsolute(first)) return null;
+	return first;
+}
+const CMAKE_LAUNCHER = /CMAKE_(C|CXX)_COMPILER_LAUNCHER\b/;
+function projectCmakeLauncher(source) {
+	if (typeof source !== "string") return null;
+	const match = CMAKE_LAUNCHER.exec(source);
+	return match ? `CMAKE_${match[1]}_COMPILER_LAUNCHER` : null;
+}
+const HIT_COUNTERS = /* @__PURE__ */ new Set(["direct_cache_hit", "preprocessed_cache_hit"]);
+function parseCcacheStatsLog(text) {
+	if (typeof text !== "string") return null;
+	let hits = 0;
+	let misses = 0;
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (HIT_COUNTERS.has(line)) hits += 1;
+		else if (line === "cache_miss") misses += 1;
+	}
+	const total = hits + misses;
+	if (total === 0) return null;
+	return {
+		status: "reported",
+		hits,
+		misses,
+		hitRatePercent: Math.round(hits / total * 1e3) / 10
+	};
+}
+function readCcacheActivity(statsLog) {
+	let text;
+	try {
+		text = readFileSync(statsLog, "utf-8");
+	} catch {
+		return CCACHE_UNAVAILABLE;
+	}
+	return parseCcacheStatsLog(text) ?? CCACHE_UNAVAILABLE;
+}
+function ccacheActivityLine(activity) {
+	if (activity.status === "reported") return `${activity.hits} hits / ${activity.misses} misses (${activity.hitRatePercent}%)`;
+	if (activity.status === "not-run") return "not run; artifact cache supplied the app";
+	return "unavailable; no C++ compile went through ccache";
+}
+function lookupCcache() {
+	try {
+		return parseCcacheBinary(getExecutor().findExecutable("ccache"));
+	} catch {
+		return null;
+	}
+}
+function readOrNull(file) {
+	try {
+		return readFileSync(file, "utf-8");
+	} catch {
+		return null;
+	}
+}
+function canonical(root) {
+	try {
+		return realpathSync(root);
+	} catch {
+		return root;
+	}
+}
+function resolveCcache({ root, dir = sharedCcache(), lookup = lookupCcache, onNote = (line) => console.error(line) }) {
+	const binary = lookup();
+	if (!binary) {
+		onNote(chalk.dim(phaseLine("cache", "ccache off (not installed; brew install ccache)")));
+		return null;
+	}
+	const declared = projectCmakeLauncher(readOrNull(join(root, "android", "app", "build.gradle")));
+	if (declared) {
+		onNote(chalk.dim(phaseLine("cache", `ccache off (android/app/build.gradle sets ${declared} itself)`)));
+		return null;
+	}
+	const statsLog = ccacheStatsLog(root);
+	register({
+		dir,
+		name: "ccache",
+		prune: "atomic",
+		note: "ccache keeps itself under CCACHE_MAXSIZE, so it is emptied whole or not at all"
+	});
+	onNote(chalk.dim(phaseLine("cache", `ccache on (${dir})`)));
+	return {
+		dir,
+		statsLog,
+		env: ccacheEnvironment({
+			binary,
+			dir,
+			workspaceRoot: canonical(root),
+			statsLog,
+			maxSize: ccacheMaxSize()
+		})
+	};
+}
+//#endregion
+//#region src/offload/manifest.ts
+function manifestDigest(entries) {
+	const hash = createHash("sha256");
+	for (const entry of entries.toSorted((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0)) hash.update(`${entry.path}\0${entry.kind}\0${entry.sha256}\n`);
+	return hash.digest("hex");
+}
+//#endregion
+export { projectCmakeLauncher as a, ccacheActivityLine as i, CCACHE_NOT_RUN as n, readCcacheActivity as o, CCACHE_UNAVAILABLE as r, resolveCcache as s, manifestDigest as t };