stim 1.8.0 → 1.9.0

package/dist/{stop-C8JW6kKp.mjs → stop-BO28HGqF.mjs}

@@ -1,15 +1,15 @@
-import { B as validateDeviceSlot, C as withConfigLock, I as deviceSlotPlatforms, L as parseDeviceSlotKey, R as projectDeviceSlots, S as upsertProject, a as clearSupervisor, f as getProject, w as process_identity_exports } from "./config-B7iyKWkL.mjs";
-import { a as withWorkspaceStateLock, h as workspaceDir, n as clearWorkspaceStateKeys, o as writeWorkspaceState, r as readWorkspaceState } from "./workspace-state-BT5E3SA2.mjs";
-import { a as findProjectRoot } from "./project-DDZWf_16.mjs";
-import { a as clearRemoteSession, i as clearManagedMetroTunnel, l as readRemoteSession, o as clearWorkspaceSupervisor, s as readMetroTunnel } from "./state-DZobzxLW.mjs";
-import { a as resolveProjectMetro, i as pidExists, n as killMetroTree, o as signalProcessTree } from "./metro-C7bcJ0uo.mjs";
-import { n as verifyCollectorOwnership } from "./ownership-Cp52QAK1.mjs";
-import { f as releasedLeaseFact, l as phaseLine, u as plural } from "./command-output-B3ycpsYv.mjs";
-import { S as resolveEasCliBin, n as teardownOwnedIosSim, t as teardownOwnedAvd } from "./teardown-BJqEzPo_.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BYfZz_S-.mjs";
-import { l as releaseWorkspaceLeases } from "./device-lease-Ffz_M5t0.mjs";
-import { i as endRecordedSession } from "./device-remote-ByN8P6CB.mjs";
-import { r as stopTunnel, t as resolveSupervisorTarget } from "./ownership-wolE-0Do.mjs";
+import { D as process_identity_exports, G as parseDeviceSlotOption, J as validateDeviceSlot, K as projectDeviceSlots, T as withConfigLock, U as deviceSlotPlatforms, W as parseDeviceSlotKey, a as clearSupervisor, f as getProject, w as upsertProject } from "./config-Cp9lM3wX.mjs";
+import { _ as workspaceDir, c as writeWorkspaceState, n as clearWorkspaceStateKeys, o as withWorkspaceStateLock, r as readWorkspaceState } from "./workspace-state-DF2gCFhx.mjs";
+import { o as findProjectRoot } from "./project-DS112DYB.mjs";
+import { a as clearRemoteSession, i as clearManagedMetroTunnel, l as readRemoteSession, o as clearWorkspaceSupervisor, s as readMetroTunnel } from "./state-NcJzMEBF.mjs";
+import { a as pidExists, c as resolveProjectMetro, l as signalProcessTree, n as killMetroTree } from "./metro-DrLHaMn2.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-D15Op8vN.mjs";
+import { f as refuseNoProject, l as phaseLine, p as releasedLeaseFact, u as plural } from "./command-output-gByVmIjy.mjs";
+import { b as resolveEasCliBin } from "./sim-pool-KaIsp2Ft.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-DWaiRD0e.mjs";
+import { l as releaseWorkspaceLeases } from "./device-lease-Crs-HkJY.mjs";
+import { E as teardownOwnedIosSim, T as teardownOwnedAvd, i as endRecordedSession } from "./device-remote-AQ5rQPqr.mjs";
+import { i as stopTunnel, t as resolveSupervisorTarget } from "./ownership-DCQPuWEc.mjs";
 import chalk from "chalk";
 //#region src/commands/stop.ts
 const DEFAULT_WAIT_MS = 1e4;
@@ -143,7 +143,7 @@ async function runStop(options) {
 	result.summary = summarize(root, result.outcomes, result.ok);
 	return result;
 }
-async function stopWorkspace({ root, project = void 0, state = void 0, collectors = void 0, signalCollector = (pid) => signalProcessTree(pid), verifyCollector = verifyCollectorOwnership, clearCollectors = clearCollectorState, isAlive = pidExists, killGroup = killMetroTree, inspectIdentity = process_identity_exports.inspectProcessIdentity, waitForDeath = void 0, waitMs = DEFAULT_WAIT_MS, resolveMetro = resolveProjectMetro, teardownIos = teardownOwnedIosSim, teardownAvd = teardownOwnedAvd, remoteDevice = void 0, teardownRemoteSession = defaultTeardownRemoteSession, metroTunnel = void 0, stopMetroTunnel = stopTunnel, releaseLeases = releaseWorkspaceLeases, freePort = defaultFreePort, clearRegistration = defaultClearRegistration, clearState = clearSupervisorState, report = (line) => console.error(line) }) {
+async function stopWorkspace({ root, project = void 0, state = void 0, collectors = void 0, signalCollector = (pid) => signalProcessTree(pid), verifyCollector = verifyCollectorOwnership, clearCollectors = clearCollectorState, isAlive = pidExists, killGroup = killMetroTree, signalServer = (pid) => signalProcessTree(pid), inspectIdentity = process_identity_exports.inspectProcessIdentity, waitForDeath = void 0, waitMs = DEFAULT_WAIT_MS, resolveMetro = resolveProjectMetro, teardownIos = teardownOwnedIosSim, teardownAvd = teardownOwnedAvd, remoteDevice = void 0, teardownRemoteSession = defaultTeardownRemoteSession, metroTunnel = void 0, stopMetroTunnel = stopTunnel, releaseLeases = releaseWorkspaceLeases, freePort = defaultFreePort, clearRegistration = defaultClearRegistration, clearState = clearSupervisorState, report = (line) => console.error(line) }) {
 	const proj = project === void 0 ? getProject(root) : project;
 	const sup = state === void 0 ? readSupervisorState(root) : state;
 	const collectorRecords = collectors === void 0 ? readCollectorState(root) : collectors;
@@ -172,6 +172,7 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 	};
 	let ok = true;
 	let stillHolding = null;
+	let keepPort = null;
 	const target = resolveSupervisorTarget({
 		state: sup,
 		record: proj?.supervisor ?? null,
@@ -232,10 +233,17 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 	};
 	else if (reservedPort === null) report(chalk.dim(phaseLine("metro", "no port reserved")));
 	else {
-		outcomes.metro = await stopMetro(reservedPort, root, {
+		const metro = await stopMetro(reservedPort, root, {
+			server: sup,
+			supervisorGone: target.status === "stale",
+			signalServer,
+			inspectIdentity,
+			waiter,
 			resolveMetro,
 			report
 		});
+		outcomes.metro = metro.outcome;
+		keepPort = metro.keepPort;
 		if (outcomes.metro.status === "refused" || outcomes.metro.status === "failed") {
 			ok = false;
 			stillHolding = outcomes.metro.reason;
@@ -254,6 +262,15 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 			return;
 		}
 		if (reservedPort !== null) {
+			if (keepPort) {
+				outcomes.port = {
+					status: "kept",
+					port: reservedPort,
+					reason: keepPort
+				};
+				report(chalk.dim(phaseLine("port", `keeping reservation ${reservedPort} -- ${keepPort}`)));
+				return;
+			}
 			if (freePort(root, reservedPort) === false) {
 				ok = false;
 				outcomes.port = {
@@ -334,8 +351,12 @@ async function stopWorkspace({ root, project = void 0, state = void 0, collector
 			reason: stillHolding
 		};
 		report(chalk.yellow(phaseLine("port", `keeping reservation ${reservedPort ?? "(none)"} -- ${stillHolding}`)));
-		const supervisorIsDown = outcomes.supervisor.status === "none" || outcomes.supervisor.status === "already-stopped" || outcomes.supervisor.status === "stopped";
-		if (tunnelHolding && supervisorIsDown) {
+		const serverIsDown = [
+			"none",
+			"already-stopped",
+			"stopped"
+		].includes(outcomes.supervisor.status) && !["refused", "failed"].includes(outcomes.metro.status);
+		if (tunnelHolding && serverIsDown) {
 			clearState(root, sup);
 			await clearRegistration(root, proj?.supervisor ?? null);
 		}
@@ -476,21 +497,76 @@ async function stopSupervisor(target, { killGroup, waiter, report }) {
 		reason
 	};
 }
-async function stopMetro(port, root, { resolveMetro, report }) {
+async function stopMetro(port, root, { server, supervisorGone, signalServer, inspectIdentity, waiter, resolveMetro, report }) {
+	const serverPid = numberOrNull(server?.serverPid);
+	const serverProcessToken = server?.serverProcessToken;
+	const serverRecord = {
+		pid: serverPid,
+		processToken: serverProcessToken
+	};
+	const identity = supervisorGone && serverPid && typeof serverProcessToken === "string" ? inspectIdentity(serverRecord) : null;
+	if (identity === "unknown") {
+		const reason = `the identity of dev server pid ${serverPid} left by the supervisor could not be verified`;
+		report(chalk.yellow(phaseLine("metro", `refusing to signal it: ${reason}`)));
+		return {
+			outcome: {
+				status: "refused",
+				port,
+				pid: serverPid,
+				reason
+			},
+			keepPort: null
+		};
+	}
+	if (identity === "same") {
+		report(chalk.dim(phaseLine("metro", `sending SIGTERM to dev server pid ${serverPid} left by the supervisor`)));
+		let signalled = false;
+		try {
+			signalled = signalServer(serverPid);
+		} catch {}
+		if (signalled ? await waiter(serverPid, serverProcessToken) : ["gone", "different"].includes(inspectIdentity(serverRecord))) {
+			report(chalk.green(phaseLine("metro", `dev server pid ${serverPid}`)));
+			return {
+				outcome: {
+					status: "stopped",
+					port,
+					pid: serverPid
+				},
+				keepPort: null
+			};
+		}
+		const reason = `dev server pid ${serverPid} left by the supervisor did not exit`;
+		report(chalk.red(phaseLine("metro", reason)));
+		return {
+			outcome: {
+				status: "failed",
+				port,
+				pid: serverPid,
+				reason
+			},
+			keepPort: null
+		};
+	}
 	const resolution = await resolveMetro(port, root);
 	if (resolution.missing) {
 		report(chalk.dim(phaseLine("metro", `nothing listening on port ${port}`)));
 		return {
-			status: "missing",
-			port
+			outcome: {
+				status: "missing",
+				port
+			},
+			keepPort: null
 		};
 	}
 	const reason = resolution.notOurs || "no recorded Stim supervisor owns this server; stop it with the tool that started it";
 	report(chalk.yellow(phaseLine("metro", `leaving port ${port} alone: ${reason}`)));
 	return {
-		status: "not-managed",
-		port,
-		reason
+		outcome: {
+			status: "not-managed",
+			port,
+			reason
+		},
+		keepPort: resolution.metro ? `a dev server from this project still answers on port ${port}` : null
 	};
 }
 const OCCUPANCY_HINT = "often a UI-test runner or device tool still attached";
@@ -617,11 +693,11 @@ async function defaultClearRegistration(root, expected) {
 	}
 }
 function stopCommand(program) {
-	program.command("stop").description("The inverse of `start`: halt this workspace's supervisor, shut the owned device down (never deleted), and free the reserved port. Non-destructive -- the device stays assigned, so coming back costs a boot. Acts on the current workspace.").option("--slot <name>", "Stop only this device slot, keeping the shared server running", validateDeviceSlot).option("--json", "print the per-step outcomes as JSON").action(async (opts) => {
+	program.command("stop").description("The inverse of `start`: halt this workspace's supervisor, shut the owned device down (never deleted), and free the reserved port. Non-destructive -- the device stays assigned, so coming back costs a boot. Acts on the current workspace.").option("--slot <name>", "Stop only this device slot, keeping the shared server running", parseDeviceSlotOption).option("--json", "print the per-step outcomes as JSON").action(async (opts) => {
 		const root = findProjectRoot(process.cwd());
 		if (!root) {
-			console.error(chalk.red("Not inside a project (no package.json found above the current directory)."));
-			process.exit(1);
+			refuseNoProject({ json: Boolean(opts.json) });
+			return;
 		}
 		const { ok, outcomes, summary } = await withWorkspaceProcessLock(workspaceDir(root), "native-run", () => runStop({
 			root,

package/dist/{stop-B1kOpYei.mjs → stop-T1R-cZRz.mjs}

@@ -1,3 +1,3 @@
-import { t as resolveSupervisorTarget } from "./ownership-wolE-0Do.mjs";
-import { a as resolveCollectorTargets, i as readSupervisorState, n as clearSupervisorState, o as runStop, r as readCollectorState, s as stopCommand, t as clearCollectorState } from "./stop-C8JW6kKp.mjs";
+import { t as resolveSupervisorTarget } from "./ownership-DCQPuWEc.mjs";
+import { a as resolveCollectorTargets, i as readSupervisorState, n as clearSupervisorState, o as runStop, r as readCollectorState, s as stopCommand, t as clearCollectorState } from "./stop-BO28HGqF.mjs";
 export { clearCollectorState, clearSupervisorState, stopCommand as default, readCollectorState, readSupervisorState, resolveCollectorTargets, resolveSupervisorTarget, runStop };

package/dist/supervisor-run.mjs

@@ -1,11 +1,12 @@
-import { a as clearSupervisor, w as process_identity_exports, x as setSupervisor } from "./config-B7iyKWkL.mjs";
-import { r as createNdjsonWriter } from "./ndjson-BZwI1NBv.mjs";
-import { _ as workspaceLogsDir, a as withWorkspaceStateLock, o as writeWorkspaceState, r as readWorkspaceState } from "./workspace-state-BT5E3SA2.mjs";
-import { i as detectIsExpo } from "./project-DDZWf_16.mjs";
+import { C as setSupervisor, D as process_identity_exports, a as clearSupervisor } from "./config-Cp9lM3wX.mjs";
+import { r as createNdjsonWriter } from "./ndjson-9uFNRwfe.mjs";
+import { b as workspaceLogsDir, c as writeWorkspaceState, o as withWorkspaceStateLock, r as readWorkspaceState } from "./workspace-state-DF2gCFhx.mjs";
+import { a as detectIsExpo } from "./project-DS112DYB.mjs";
 import { t as describeError } from "./errors-B6W7FkxQ.mjs";
-import { t as relaunchWithLogFile } from "./detached-entry-Bpo6ZY_I.mjs";
-import { c as readPidFile, f as writePidFile, n as MODE_EXPO, o as clearWorkspaceSupervisor, r as clearExpoMetroTunnel, t as MODE_BARE } from "./state-DZobzxLW.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-KEu0_AXL.mjs";
+import { c as readPidFile, f as writePidFile, n as MODE_EXPO, o as clearWorkspaceSupervisor, r as clearExpoMetroTunnel, t as MODE_BARE } from "./state-NcJzMEBF.mjs";
 import { existsSync, realpathSync } from "node:fs";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 import { isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/supervisor/run.ts
@@ -48,7 +49,7 @@ function parseArgs(argv) {
 async function runSupervisor({ root, port, tunnel = false, resetCache = false, isExpo = detectIsExpo, startBare = null, startExpo = null, now = Date.now, onExit = (code) => process.exit(code), attachSignals = true, stderr = (line) => console.error(line) }) {
 	root = realpathSync(root);
 	const logsDir = workspaceLogsDir(root);
-	const writer = createNdjsonWriter(join(logsDir, "metro.ndjson"));
+	const writer = createNdjsonWriter(join(logsDir, "metro.ndjson"), { maxBytes: LOG_ROTATE_BYTES });
 	const mode = isExpo(root) ? MODE_EXPO : MODE_BARE;
 	const startedAt = new Date(now()).toISOString();
 	const processToken = (0, process_identity_exports.captureProcessToken)(process.pid);
@@ -104,8 +105,32 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 		onExit(code);
 	};
 	let server;
+	const shutdown = async (code, event, msg) => {
+		if (stopping || !server) return;
+		stopping = true;
+		try {
+			await server.close();
+		} catch (err) {
+			writer.write({
+				src: "metro",
+				level: "warn",
+				event: "server_close_failed",
+				msg: describeError(err)
+			});
+		}
+		finish(code, event, code === 0 ? "info" : "error", msg);
+	};
+	if (attachSignals) for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
+		if (server) {
+			shutdown(0, "supervisor_stopped", `received ${signal}; stopping the ${mode} dev server`);
+			return;
+		}
+		if (stopping) return;
+		stopping = true;
+		finish(signal === "SIGINT" ? 130 : 143, "supervisor_stopped", "warn", `received ${signal} before the ${mode} dev server started; stopping`);
+	});
 	try {
-		server = await (mode === "expo-child" ? startExpo || (await import("./server-expo-YDDG3eP7.mjs")).startExpoServer : startBare || (await import("./server-bare-BQkyxa_b.mjs")).startBareServer)({
+		server = await (mode === "expo-child" ? startExpo || (await import("./server-expo-CeILEu86.mjs")).startExpoServer : startBare || (await import("./server-bare-DWkkcIxV.mjs")).startBareServer)({
 			root,
 			port,
 			logsDir,
@@ -132,46 +157,39 @@ async function runSupervisor({ root, port, tunnel = false, resetCache = false, i
 			}
 		});
 	} catch (err) {
+		if (stopping) return null;
 		stderr(`Stim supervisor: failed to start the ${mode} dev server: ${describeError(err)}`);
 		finish(1, "supervisor_failed", "fatal", `failed to start the ${mode} dev server: ${describeError(err)}`);
 		return null;
 	}
-	const readyServer = server;
-	if (readyServer.serverPid) withWorkspaceStateLock(root, () => {
-		if (readWorkspaceState(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { supervisor: {
-			...record,
-			serverPid: readyServer.serverPid
-		} });
-	});
+	if (stopping) {
+		try {
+			await server.close();
+		} catch {}
+		return null;
+	}
+	const serverPid = server.serverPid;
+	if (serverPid) {
+		const serverProcessToken = (0, process_identity_exports.captureProcessToken)(serverPid);
+		withWorkspaceStateLock(root, () => {
+			if (readWorkspaceState(root)?.supervisor?.processToken === processToken) writeWorkspaceState(root, { supervisor: {
+				...record,
+				serverPid,
+				...serverProcessToken ? { serverProcessToken } : {}
+			} });
+		});
+	}
 	writer.write({
 		src: "metro",
 		level: "info",
 		event: "server_started",
 		msg: `${mode} dev server listening on port ${port}`
 	});
-	const shutdown = async (code, event, msg) => {
-		if (stopping) return;
-		stopping = true;
-		try {
-			await readyServer.close();
-		} catch (err) {
-			writer.write({
-				src: "metro",
-				level: "warn",
-				event: "server_close_failed",
-				msg: describeError(err)
-			});
-		}
-		finish(code, event, code === 0 ? "info" : "error", msg);
-	};
-	readyServer.onExit?.((info) => {
+	server.onExit?.((info) => {
 		if (stopping) return;
 		const detail = info?.signal ? `signal ${info.signal}` : `exit code ${info?.code ?? "unknown"}`;
 		shutdown(1, "supervisor_stopped", `the ${mode} dev server exited unexpectedly (${detail}); shutting the supervisor down`);
 	});
-	if (attachSignals) for (const signal of ["SIGTERM", "SIGINT"]) process.on(signal, () => {
-		shutdown(0, "supervisor_stopped", `received ${signal}; stopping the ${mode} dev server`);
-	});
 	return {
 		mode,
 		server,

package/dist/{workspace-process-lock-BYfZz_S-.mjs → workspace-process-lock-DWaiRD0e.mjs}

@@ -1,4 +1,5 @@
-import { E as ownership_claim_exports } from "./config-B7iyKWkL.mjs";
+import { k as ownership_claim_exports } from "./config-Cp9lM3wX.mjs";
+import { r as stopDeclaringSpawnsOn, t as declareSpawnsOn } from "./spawn-claims-Dn3C_N6w.mjs";
 import { join } from "node:path";
 //#region src/engine/workspace-process-lock.ts
 const DEFAULT_WAIT_MS = 6e4;
@@ -10,11 +11,11 @@ function workspaceProcessLockError(err) {
 	if (code === "STIM_LOCK_TIMEOUT") return "timeout";
 	return null;
 }
-function lockPath(root, name, external) {
+function workspaceProcessLockPath(root, name, external) {
 	return external ? join(root, `${name}.lock`) : join(root, ".stim", `${name}.lock`);
 }
-async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, sleep = defaultSleep, waitMs = DEFAULT_WAIT_MS, ownerPurpose, rejectOwnerPurposes = [], external = false } = {}) {
-	const path = lockPath(root, name, external);
+async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, sleep = defaultSleep, waitMs = DEFAULT_WAIT_MS, ownerPurpose, rejectOwnerPurposes = [], external = false, declareSpawns = false } = {}) {
+	const path = workspaceProcessLockPath(root, name, external);
 	const deadline = now() + waitMs;
 	for (;;) {
 		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
@@ -24,10 +25,14 @@ async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, sleep
 			details: ownerPurpose ? { purpose: ownerPurpose } : {}
 		});
 		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
-		if (attempt.acquired) try {
-			return await fn();
-		} finally {
-			(0, ownership_claim_exports.releaseClaim)(attempt.acquired);
+		if (attempt.acquired) {
+			if (declareSpawns) declareSpawnsOn(attempt.acquired);
+			try {
+				return await fn(attempt.acquired);
+			} finally {
+				stopDeclaringSpawnsOn(attempt.acquired);
+				(0, ownership_claim_exports.releaseClaim)(attempt.acquired);
+			}
 		}
 		const purpose = (attempt.held ?? attempt.waitingFor?.[0])?.details.purpose;
 		if (typeof purpose === "string" && rejectOwnerPurposes.includes(purpose)) {
@@ -44,4 +49,4 @@ async function withWorkspaceProcessLock(root, name, fn, { now = Date.now, sleep
 	}
 }
 //#endregion
-export { workspaceProcessLockError as n, withWorkspaceProcessLock as t };
+export { workspaceProcessLockError as n, workspaceProcessLockPath as r, withWorkspaceProcessLock as t };

package/dist/{workspace-state-BT5E3SA2.mjs → workspace-state-DF2gCFhx.mjs}

@@ -1,19 +1,19 @@
-import { D as withDirLock, u as getConfigDir } from "./config-B7iyKWkL.mjs";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import { join as join$1, resolve as resolve$1 } from "path";
+import { A as withDirLock, N as readJsonObject, u as getConfigDir } from "./config-Cp9lM3wX.mjs";
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve } from "path";
 import { buildCacheRoot as sharedBuildCache, workspaceId, workspaceName as workspaceName$1, workspaceStateDir as workspaceDir } from "@stim-cli/core";
+import { dirname as dirname$1, join as join$1 } from "node:path";
 //#region src/workspace/paths.ts
 const WORKSPACE_METADATA_FILE_NAME = "workspace.json";
 function workspaceMetadataFile(projectRoot) {
-	return join$1(workspaceDir(projectRoot), WORKSPACE_METADATA_FILE_NAME);
+	return join(workspaceDir(projectRoot), WORKSPACE_METADATA_FILE_NAME);
 }
 function ensureWorkspaceStorage(projectRoot) {
-	const canonicalRoot = resolve$1(projectRoot);
+	const canonicalRoot = resolve(projectRoot);
 	const dir = workspaceDir(canonicalRoot);
 	const file = workspaceMetadataFile(canonicalRoot);
 	mkdirSync(dir, { recursive: true });
-	return withDirLock(join$1(dir, "metadata.lock"), () => {
+	return withDirLock(join(dir, "metadata.lock"), () => {
 		if (!existsSync(file)) {
 			const metadata = {
 				projectRoot: canonicalRoot,
@@ -30,57 +30,52 @@ function ensureWorkspaceStorage(projectRoot) {
 			}
 			return dir;
 		}
-		try {
-			if (JSON.parse(readFileSync(file, "utf-8")).projectRoot === canonicalRoot) return dir;
-		} catch {}
+		if (readJsonObject(file)?.projectRoot === canonicalRoot) return dir;
 		const error = /* @__PURE__ */ new Error(`Stim workspace collision at ${dir}: its workspace.json does not belong to ${canonicalRoot}.`);
 		error.code = "STIM_WORKSPACE_COLLISION";
 		throw error;
 	});
 }
 function workspaceLogsDir(projectRoot) {
-	return join$1(workspaceDir(projectRoot), "logs");
+	return join(workspaceDir(projectRoot), "logs");
+}
+function workspaceLogErrorIndex(projectRoot) {
+	return join(workspaceDir(projectRoot), "log-error-index.json");
 }
 function workspaceDerivedData(projectRoot) {
-	return join$1(workspaceDir(projectRoot), "derived-data");
+	return join(workspaceDir(projectRoot), "derived-data");
 }
 function supervisorPidFile(projectRoot) {
-	return join$1(workspaceDir(projectRoot), "supervisor.pid");
+	return join(workspaceDir(projectRoot), "supervisor.pid");
 }
 function workspaceStateFile(projectRoot) {
-	return join$1(workspaceDir(projectRoot), "state.json");
+	return join(workspaceDir(projectRoot), "state.json");
 }
 function workspaceStateLock(projectRoot) {
-	return join$1(workspaceDir(projectRoot), "state.lock");
+	return join(workspaceDir(projectRoot), "state.lock");
 }
 function supervisorLogFile(projectRoot) {
-	return join$1(workspaceLogsDir(projectRoot), "supervisor.log");
+	return join(workspaceLogsDir(projectRoot), "supervisor.log");
 }
 function emulatorLogFile(projectRoot) {
-	return join$1(workspaceLogsDir(projectRoot), "emulator.log");
+	return join(workspaceLogsDir(projectRoot), "emulator.log");
 }
 function sharedCompilationCache() {
-	return join$1(getConfigDir(), "compilation-cache");
+	return join(getConfigDir(), "compilation-cache");
 }
 function sharedCcache() {
-	return join$1(getConfigDir(), "ccache");
+	return join(getConfigDir(), "ccache");
 }
 //#endregion
 //#region src/workspace/workspace-state.ts
 function readWorkspaceState(root) {
-	try {
-		const parsed = JSON.parse(readFileSync(workspaceStateFile(root), "utf-8"));
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-		return parsed;
-	} catch {
-		return null;
-	}
+	return readJsonObject(workspaceStateFile(root));
 }
 function withWorkspaceStateLock(root, fn) {
 	const file = workspaceStateFile(root);
 	return withDirLock(workspaceStateLock(root), fn, { ensureParent: () => {
 		ensureWorkspaceStorage(root);
-		mkdirSync(dirname(file), { recursive: true });
+		mkdirSync(dirname$1(file), { recursive: true });
 	} });
 }
 function writeWorkspaceState(root, patch) {
@@ -94,7 +89,7 @@ function updateWorkspaceState(root, update) {
 }
 function replaceWorkspaceState(root, state) {
 	const file = workspaceStateFile(root);
-	mkdirSync(dirname(file), { recursive: true });
+	mkdirSync(dirname$1(file), { recursive: true });
 	const tmp = `${file}.tmp-${process.pid}`;
 	writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
 	renameSync(tmp, file);
@@ -142,5 +137,33 @@ function clearWorkspaceStateKey(root, key, shouldClear) {
 		return true;
 	});
 }
+function recordWorkspaceUse(root, now = /* @__PURE__ */ new Date()) {
+	try {
+		writeWorkspaceState(root, { lastUsedAt: now.toISOString() });
+	} catch {}
+}
+function lastUseFrom(state, logMtimes) {
+	const candidates = [
+		Date.parse(String(state?.lastUsedAt ?? "")),
+		Date.parse(String(state?.lastBuild?.startedAt ?? "")),
+		Date.parse(String(state?.supervisor?.startedAt ?? "")),
+		...logMtimes
+	].filter(Number.isFinite);
+	return candidates.length ? Math.max(...candidates) : NaN;
+}
+function workspaceLastUsed(root) {
+	const logs = workspaceLogsDir(root);
+	let mtimes = [];
+	try {
+		mtimes = readdirSync(logs).flatMap((name) => {
+			try {
+				return [statSync(join$1(logs, name)).mtimeMs];
+			} catch {
+				return [];
+			}
+		});
+	} catch {}
+	return lastUseFrom(readWorkspaceState(root), mtimes);
+}
 //#endregion
-export { workspaceLogsDir as _, withWorkspaceStateLock as a, ensureWorkspaceStorage as c, sharedCompilationCache as d, supervisorLogFile as f, workspaceId as g, workspaceDir as h, updateWorkspaceState as i, sharedBuildCache as l, workspaceDerivedData as m, clearWorkspaceStateKeys as n, writeWorkspaceState as o, supervisorPidFile as p, readWorkspaceState as r, emulatorLogFile as s, clearWorkspaceStateKey as t, sharedCcache as u, workspaceName$1 as v, workspaceStateFile as y };
+export { workspaceStateFile as S, workspaceDir as _, updateWorkspaceState as a, workspaceLogsDir as b, writeWorkspaceState as c, sharedBuildCache as d, sharedCcache as f, workspaceDerivedData as g, supervisorPidFile as h, recordWorkspaceUse as i, emulatorLogFile as l, supervisorLogFile as m, clearWorkspaceStateKeys as n, withWorkspaceStateLock as o, sharedCompilationCache as p, readWorkspaceState as r, workspaceLastUsed as s, clearWorkspaceStateKey as t, ensureWorkspaceStorage as u, workspaceId as v, workspaceName$1 as x, workspaceLogErrorIndex as y };

package/dist/worktree-DKhSF0UX.mjs

@@ -0,0 +1,2 @@
+import { a as reclaimKeys, c as removalBlockers, d as removeWorktreeTarget, f as worktreeCommand, i as porcelainPath, l as removalPath, n as excludePodChurn, o as registerRemove, r as matchWorktreeEntry, s as registerWarm, t as dependencyInstallCommand, u as removalRemedy } from "./worktree-LGB-UwgG.mjs";
+export { worktreeCommand as default, dependencyInstallCommand, excludePodChurn, matchWorktreeEntry, porcelainPath, reclaimKeys, registerRemove, registerWarm, removalBlockers, removalPath, removalRemedy, removeWorktreeTarget };