stim 1.20.2 → 1.21.0

package/dist/maintenance-run.mjs

@@ -1,236 +1,19 @@
-import { F as listMountedVolumes, N as formatBytes, P as isOnMountedVolume, _ as loadConfig$1 } from "./config-BYDxlMY3.mjs";
-import { a as unregister, n as readManifest } from "./cache-manifest-XH-fvDUj.mjs";
-import { T as canonicalPath, a as collectWorkspaceOutputs, i as collectOrphanedWorkspaces, o as deleteOrphanedWorkspaces, r as clearWorkspaceOutputs, w as takeGcResults } from "./workspaces-C36s2jb9.mjs";
-import { N as emptyCaches, at as discoverCaches, l as resolveBudget, ot as pruneCache, r as cacheLabel, z as planCacheEmptying } from "./budget-f7516Zk0.mjs";
-import { r as createNdjsonWriter } from "./ndjson-GOnbyvso.mjs";
-import { t as relaunchWithLogFile } from "./detached-entry-B9C_zeQC.mjs";
-import { F as memoryCulpritAdvice, N as memoryCulpritsUnder } from "./ios-RkW4pnQf.mjs";
+import { P as formatBytes } from "./config-CYcBF478.mjs";
+import { Tt as deviceSweepIsScoped, u as resolveBudget } from "./budget-Bs6SxxzO.mjs";
+import { I as memoryCulpritAdvice, N as memoryCulpritsUnder } from "./ios-CpByZy12.mjs";
+import { h as maintenanceLogger } from "./client-UXD70ZbM.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
+import { A as lowestFree, C as measurePressure, D as diskPressureLevel, E as sizeScanDeferred, O as levelFloors, S as measureDisk, T as measureSizes, k as levelStillShort } from "./worktree-DQ6Zi2Mv.mjs";
+import { i as plannedMaintenance, m as measureOwnedDevices, n as diskRecovered, o as triggeringRoot, r as executeAction } from "./act-DHAw2A2S.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-DFRyG1_o.mjs";
 import { r as due, t as capChildLog } from "./attempt-DW-mQqM7.mjs";
-import { a as maintenancePinned, c as removeWorktrees, d as cacheBlocked, f as measureDisk, h as sizeScanDeferred, i as cacheEntryProtection, m as measureSizes, o as recentUse, p as measurePressure, r as triggeringRoot, t as plannedMaintenance } from "./preview-78a9kR_-.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 { randomBytes } from "node:crypto";
+import { appendFileSync, mkdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { withDirLock } from "@stim-cli/core";
+import { maintenanceChildLogFile, maintenanceDir, maintenanceRunClaims, maintenanceStateFile, readMaintenanceState } 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 (maintenancePinned(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(maintenancePinned)) 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();
-	const rotated = rotatedLogPath(file);
-	withDirLock(`${file}.lock`, () => {
-		try {
-			if (Date.now() - statSync(rotated).mtimeMs > settings.logRetentionDays * 864e5) unlinkSync(rotated);
-		} catch {}
-	});
-	const writer = createNdjsonWriter(file, { maxBytes: settings.logMaxMb * 1024 ** 2 });
-	return {
-		write(event, level, msg, fields = {}) {
-			if (level === "debug" && !settings.logChecks) return null;
-			const record = {
-				...fields,
-				ts: Date.now(),
-				src: "maintenance",
-				level,
-				msg,
-				event,
-				pass,
-				trigger,
-				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" && [
-				"maintenance_action",
-				"maintenance_failure",
-				"maintenance_skip"
-			].includes(event)) {
-				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 {
-					workspace.close();
-				}
-			}
-			return record;
-		},
-		close: () => writer.close()
-	};
-}
-//#endregion
 //#region src/maintenance/run.ts
 function writeState(state) {
 	mkdirSync(maintenanceDir(), { recursive: true });
@@ -247,14 +30,65 @@ function writeState(state) {
 		}
 	});
 }
+const RESERVE_BYTES = 1048576;
+const reserveFile = () => join(maintenanceDir(), "disk-reserve");
+function releaseReserve() {
+	try {
+		const bytes = statSync(reserveFile()).size;
+		rmSync(reserveFile());
+		return bytes > 0;
+	} catch {
+		return false;
+	}
+}
+function keepReserve() {
+	try {
+		if (statSync(reserveFile()).size === RESERVE_BYTES) return;
+	} catch {}
+	try {
+		mkdirSync(maintenanceDir(), { recursive: true });
+		writeFileSync(reserveFile(), randomBytes(RESERVE_BYTES));
+	} catch {
+		try {
+			rmSync(reserveFile(), { force: true });
+		} catch {}
+	}
+}
+function claimPass(trigger) {
+	const take = () => {
+		const attempt = tryAcquireClaim({
+			root: maintenanceRunClaims(),
+			mode: "exclusive",
+			label: "maintenance",
+			details: { trigger }
+		});
+		if (attempt.pending) releaseClaim(attempt.pending);
+		return attempt.acquired;
+	};
+	try {
+		return take();
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && (error.code === "ENOSPC" || error.code === "EDQUOT")) || !releaseReserve()) throw error;
+		return take();
+	}
+}
 const EXECUTION_ORDER = {
 	"would-unregister-cache": 0,
 	"would-remove-orphan": 0,
 	"would-clear-outputs": 1,
+	"would-delete-parked-device": 2,
+	"would-delete-temp-leftovers": 2,
 	"would-trim-cache": 2,
+	"would-clear-build-dirs": 3,
 	"would-empty-cache": 3,
-	"would-remove-worktree": 4
+	"would-remove-worktree": 4,
+	"would-stop-workspace": 5,
+	"would-delete-devices": 5,
+	"would-delete-dependencies": 6,
+	"would-stop-gradle-daemons": 7,
+	"would-delete-gradle-version": 8
 };
+const executionRank = (action) => (action.level ?? 1) * 10 + (EXECUTION_ORDER[action.kind] ?? 9);
 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 [];
@@ -263,6 +97,7 @@ function shrinkSizes(state, action, outcome) {
 			bytes: Math.max(0, size.bytes - outcome.bytes)
 		}];
 		if (action.kind === "would-empty-cache" && size.dir === action.target) return [];
+		if (action.kind === "would-delete-devices" && outcome.status === "done" && size.category === "owned-devices" && size.workspace === action.workspace) return [];
 		return [size];
 	});
 }
@@ -275,6 +110,14 @@ function describeDone(action) {
 		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}`;
+		case "would-delete-parked-device": return `Deleted the parked device ${action.target}`;
+		case "would-delete-temp-leftovers": return `Deleted the recognized leftovers in ${action.target}`;
+		case "would-delete-devices": return `Deleted the owned devices of ${name}`;
+		case "would-clear-build-dirs": return `Cleared the build directory ${action.target}`;
+		case "would-delete-dependencies": return `Deleted the installed dependencies ${action.target}`;
+		case "would-stop-gradle-daemons": return "Stopped idle Gradle and Kotlin daemons";
+		case "would-delete-gradle-version": return `Deleted the unpinned Gradle ${action.target} caches and distributions`;
+		case "would-stop-workspace": return `Stopped ${name} and deleted its owned devices`;
 		default: return `Unregistered the stale cache ${action.target}`;
 	}
 }
@@ -285,14 +128,7 @@ async function runMaintenance(trigger) {
 	const startedAt = Date.now();
 	let claim;
 	try {
-		const attempt = tryAcquireClaim({
-			root: maintenanceRunClaims(),
-			mode: "exclusive",
-			label: "maintenance",
-			details: { trigger }
-		});
-		if (attempt.pending) releaseClaim(attempt.pending);
-		claim = attempt.acquired;
+		claim = claimPass(trigger);
 	} catch (error) {
 		crashLine(error);
 		return;
@@ -313,9 +149,29 @@ async function runMaintenance(trigger) {
 		};
 		const checks = due(state, settings, startedAt);
 		if (checks.length === 0) return;
-		logger = maintenanceLogger(settings, `p-${claim.claimId}`, trigger);
+		let writeError = null;
+		const noteWriteError = (error) => {
+			writeError ??= error instanceof Error ? error.message : String(error);
+		};
+		const keepState = () => {
+			try {
+				writeState(state);
+			} catch (error) {
+				noteWriteError(error);
+			}
+		};
+		try {
+			logger = maintenanceLogger(settings, `p-${claim.claimId}`, trigger);
+		} catch (error) {
+			noteWriteError(error);
+		}
 		const record = (event, level, msg, fields = {}) => {
-			const entry = logger.write(event, level, msg, fields);
+			let entry = null;
+			try {
+				entry = logger?.write(event, level, msg, fields) ?? null;
+			} catch (error) {
+				noteWriteError(error);
+			}
 			if (entry && (event === "maintenance_action" || event === "maintenance_failure" || Array.isArray(fields.blocked) && fields.blocked.length > 0)) state.recent = [...state.recent, entry].slice(-20);
 		};
 		const failures = [];
@@ -332,17 +188,18 @@ async function runMaintenance(trigger) {
 					...state.deferredAt,
 					[check]: Date.now()
 				};
-				writeState(state);
+				keepState();
 				continue;
 			}
 			state.lastAt[check] = Date.now();
 			ran.add(check);
 			delete state.deferredAt?.[check];
-			writeState(state);
+			keepState();
 			try {
 				if (check === "worktree" || check === "sweep") continue;
 				if (check === "pressure") {
 					state.pressure = measurePressure(settings, state.pressure, state.lastAt[check]);
+					state.pressure.diskLevel = diskPressureLevel(lowestFree(state.pressure.disk), budget, settings);
 					const culprits = settings.memoryPressureLevel === "off" ? null : memoryCulpritsUnder(state.pressure.memory.level);
 					if (culprits) state.pressure.memory.culprits = culprits;
 					const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
@@ -361,14 +218,15 @@ async function runMaintenance(trigger) {
 					for (const culprit of state.pressure.memory.culprits ?? []) record("maintenance_check", "info", memoryCulpritAdvice([culprit]), { culprit });
 				} else {
 					measuredSizes = true;
-					state.sizes = measureSizes(state.lastAt[check], (target, workspace) => {
+					const measureFailed = (target, workspace) => {
 						failures.push(`Could not measure ${target}`);
 						record("maintenance_failure", "error", `Could not measure ${target}`, {
 							target,
 							error: "du failed or timed out",
 							...workspace ? { workspace } : {}
 						});
-					});
+					};
+					state.sizes = [...await measureSizes(state.lastAt[check], measureFailed), ...deviceSweepIsScoped() ? [] : await measureOwnedDevices(state.lastAt[check], measureFailed)];
 					for (const size of state.sizes) record("maintenance_check", "debug", `${size.name}: ${formatBytes(size.bytes)}`, {
 						check: {
 							kind: `size:${size.category}`,
@@ -412,10 +270,11 @@ async function runMaintenance(trigger) {
 				settings,
 				budget,
 				protectedRoot: triggeringRoot(),
-				worktreeSweep: result.worktreeSweep
+				worktreeSweep: result.worktreeSweep,
+				pressureSweep: result.pressureSweep
 			};
 			const results = [];
-			const ordered = actions.toSorted((a, b) => (EXECUTION_ORDER[a.kind] ?? 9) - (EXECUTION_ORDER[b.kind] ?? 9));
+			const ordered = actions.toSorted((a, b) => executionRank(a) - executionRank(b));
 			for (const action of ordered) {
 				const began = Date.now();
 				let outcome;
@@ -424,6 +283,10 @@ async function runMaintenance(trigger) {
 						status: "kept",
 						bytes: 0,
 						detail: "free disk recovered before this action"
+					} : action.level !== void 0 && !levelStillShort(action, lowestFree(measureDisk()), budget, settings) ? {
+						status: "kept",
+						bytes: 0,
+						detail: `free disk is back above the level ${action.level} floor`
 					} : await executeAction(action, context);
 				} catch (error) {
 					outcome = {
@@ -474,8 +337,15 @@ async function runMaintenance(trigger) {
 			loggedSkips.add(skip.target);
 			record("maintenance_skip", "info", `Kept ${skip.target}: ${skip.reason}`, skip);
 		}
+		if (writeError) failures.push(`Could not write the maintenance state or log: ${writeError}`);
+		if (settings.mode !== "on" && state.pressure?.diskLevel === 3) failures.push(criticalLine(state.pressure.disk, budget, settings));
 		if (settings.mode === "on") {
 			const outcomes = await executePlan(result.actions);
+			if (state.pressure) {
+				state.pressure.disk = measureDisk();
+				state.pressure.diskLevel = diskPressureLevel(lowestFree(state.pressure.disk), budget, settings);
+				if (state.pressure.diskLevel === 3) failures.push(criticalLine(state.pressure.disk, budget, settings));
+			}
 			const blockedNow = [
 				...result.blocked,
 				...failures,
@@ -498,7 +368,7 @@ async function runMaintenance(trigger) {
 				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 });
+			if (done.length || measuredSizes || blockedChanged || (state.pressure?.diskLevel ?? 0) > 0) 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];
@@ -541,9 +411,14 @@ async function runMaintenance(trigger) {
 		crashLine(error);
 	} finally {
 		logger?.close();
+		keepReserve();
 		releaseClaim(claim);
 	}
 }
+function criticalLine(disk, budget, settings) {
+	const floor = levelFloors(budget, settings)[3];
+	return `disk pressure level 3: ${disk.filter((volume) => volume.freeMb < floor).map((volume) => `${(volume.freeMb / 1024).toFixed(1)}G free on ${volume.volume}`).join(", ")} after this pass, under the ${(floor / 1024).toFixed(1)}G critical floor; builds refuse below budget.hardFloorDiskGb`;
+}
 function crashLine(error) {
 	try {
 		mkdirSync(maintenanceDir(), { recursive: true });

package/dist/{metro-DnCEjCxs.mjs → metro-DEXpIhHC.mjs}

@@ -1,6 +1,6 @@
-import { F as listMountedVolumes, P as isOnMountedVolume, _ as loadConfig, k as process_identity_exports, n as allMetroPorts, r as claimMetroPort, x as releaseMetroPort } from "./config-BYDxlMY3.mjs";
-import { t as getExecutor } from "./exec-DqKo9GKJ.mjs";
-import { r as readWorkspaceState } from "./workspace-state-DJt_MMvf.mjs";
+import { p as process_identity_exports, t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { F as isOnMountedVolume, I as listMountedVolumes, _ as loadConfig, n as allMetroPorts, r as claimMetroPort, x as releaseMetroPort } from "./config-CYcBF478.mjs";
+import { r as readWorkspaceState } from "./workspace-state-Cjuigeeu.mjs";
 import { sep } from "path";
 import { existsSync, readlinkSync, realpathSync } from "fs";
 import { readFile } from "node:fs/promises";
@@ -192,25 +192,34 @@ function createPortProbe() {
 		throw new PortInspectionError(`Cannot tell whether TCP port ${port} is free: the TCP listener table failed (${listening.message.replace(/\s+/g, " ").trim()}), lsof could not list listeners, and a loopback connect failed.`);
 	};
 }
-function isMetroRunning(port) {
+function isMetroRunning(port, signal) {
 	return new Promise((resolve) => {
 		const req = request({
 			hostname: "localhost",
 			port,
 			path: "/status",
-			timeout: 2e3
+			timeout: 2e3,
+			signal
 		}, (res) => {
 			let data = "";
+			let bytes = 0;
 			res.on("data", (chunk) => {
+				bytes += Buffer.byteLength(chunk);
+				if (bytes > 65536) return finish(false);
 				data += chunk;
 			});
-			res.on("end", () => resolve(data.includes("packager-status:running")));
+			res.on("end", () => finish(data.includes("packager-status:running")));
+			res.on("error", () => finish(false));
+			res.on("aborted", () => finish(false));
 		});
-		req.on("error", () => resolve(false));
-		req.on("timeout", () => {
+		const deadline = setTimeout(() => finish(false), 2e3);
+		const finish = (running) => {
+			clearTimeout(deadline);
 			req.destroy();
-			resolve(false);
-		});
+			resolve(running);
+		};
+		req.on("error", () => finish(false));
+		req.on("timeout", () => finish(false));
 		req.end();
 	});
 }
@@ -305,6 +314,23 @@ function listeningPids(port, platform = process.platform) {
 	if (pids.length > 0 || platform !== "win32") return pids;
 	return parseNetstatPids(getExecutor().runQuiet("netstat -ano", { timeoutMs: 1e4 }), port);
 }
+/** Reads listener pids without blocking on lsof or netstat. */
+async function listeningPidsAsync(port, platform = process.platform) {
+	const pids = parseLsofPids(await getExecutor().runFileQuietAsync("lsof", [
+		"-nP",
+		`-iTCP:${port}`,
+		"-sTCP:LISTEN",
+		"-t"
+	], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL"
+	}));
+	if (pids.length > 0 || platform !== "win32") return pids;
+	return parseNetstatPids(await getExecutor().runFileQuietAsync("netstat", ["-ano"], {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL"
+	}), port);
+}
 function parseLsofCwd(out) {
 	if (!out) return null;
 	const lines = String(out).split("\n");
@@ -314,7 +340,10 @@ function parseLsofCwd(out) {
 	return nLine ? nLine.slice(1) : null;
 }
 function lsofOutput(args) {
-	return getExecutor().runFileAsync("lsof", args, { timeoutMs: 1e4 }).catch((error) => typeof error?.stdout === "string" ? error.stdout : null);
+	return getExecutor().runFileAsync("lsof", args, {
+		timeoutMs: 1e4,
+		killSignal: "SIGKILL"
+	}).catch((error) => typeof error?.stdout === "string" ? error.stdout : null);
 }
 /**
 * `listeningPids` for several ports with one lsof call. A port lsof could not be asked about is
@@ -470,5 +499,31 @@ function killMetroTree(leader, processToken) {
 		return false;
 	}
 }
+/** Signals a process tree without blocking on Windows taskkill. */
+async function signalProcessTreeAsync(pid, signal = "SIGTERM", options = {}) {
+	if (!Number.isSafeInteger(pid) || pid <= 1) throw new Error(`Refusing to signal pid ${pid}.`);
+	if ((options.platform ?? process.platform) !== "win32") return signalProcessTree(pid, signal, options);
+	return await getExecutor().runFileQuietAsync("taskkill", [
+		"/PID",
+		String(pid),
+		"/T",
+		"/F"
+	], {
+		timeoutMs: 3e4,
+		killSignal: "SIGKILL"
+	}) !== null;
+}
+/** Stops the verified Metro process tree without blocking on Windows taskkill. */
+async function killMetroTreeAsync(leader, processToken) {
+	if (!leader || leader === process.pid || (0, process_identity_exports.inspectProcessIdentity)({
+		pid: leader,
+		processToken
+	}) !== "same") return false;
+	try {
+		return await signalProcessTreeAsync(leader, "SIGTERM", { group: true });
+	} catch {
+		return false;
+	}
+}
 //#endregion
-export { listeningPidsByPort as a, processCwd as c, signalProcessTree as d, createPortProbe as f, PortInspectionError as g, PORT_INSPECTION_REMEDY as h, listeningPids as i, processCwds as l, reserveMetroPort as m, isInsideProject as n, parseNetstatPids as o, isMetroRunning as p, killMetroTree as r, pidExists as s, NOT_OURS_FOREIGN_CWD as t, resolveProjectMetro as u };
+export { reserveMetroPort as _, listeningPids as a, parseNetstatPids as c, processCwds as d, resolveProjectMetro as f, isMetroRunning as g, createPortProbe as h, killMetroTreeAsync as i, pidExists as l, signalProcessTreeAsync as m, isInsideProject as n, listeningPidsAsync as o, signalProcessTree as p, killMetroTree as r, listeningPidsByPort as s, NOT_OURS_FOREIGN_CWD as t, processCwd as u, PORT_INSPECTION_REMEDY as v, PortInspectionError as y };