stim 1.17.2 → 1.18.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-CgYMahz7.mjs";
+import { a as unregister, n as readManifest } from "./cache-manifest-BI7ozfmH.mjs";
+import { Qt as pruneCache, Zt as discoverCaches, l as resolveBudget, pt as planCacheEmptying, r as cacheLabel, st as emptyCaches } from "./budget-DIhL2BKx.mjs";
+import { F as takeGcResults, I as canonicalPath, a as collectWorkspaceOutputs, i as collectOrphanedWorkspaces, o as deleteOrphanedWorkspaces, r as clearWorkspaceOutputs } from "./workspaces-xXItD8Dj.mjs";
+import { D as projectMaintenancePinned } from "./settings-CQyMElEP.mjs";
+import { r as createNdjsonWriter } from "./ndjson-LGZAMsqa.mjs";
+import { t as relaunchWithLogFile } from "./detached-entry-BLfcgc4O.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-D5V07Nrl.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/{metro-g8NqiJp-.mjs → metro-Dh8T4Ytd.mjs}

@@ -1,9 +1,9 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { M as isOnMountedVolume, N as listMountedVolumes, _ as loadConfig, n as allMetroPorts, r as claimMetroPort, x as releaseMetroPort } from "./config-D0DbpZtM.mjs";
-import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { r as readWorkspaceState } from "./workspace-state-DqcCbpE7.mjs";
-import { existsSync, readlinkSync, realpathSync } from "fs";
+import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { M as isOnMountedVolume, N as listMountedVolumes, _ as loadConfig, n as allMetroPorts, r as claimMetroPort, x as releaseMetroPort } from "./config-CgYMahz7.mjs";
+import { r as readWorkspaceState } from "./workspace-state-C59dqG-Z.mjs";
 import { sep } from "path";
+import { existsSync, readlinkSync, realpathSync } from "fs";
 import { request } from "http";
 import { connect } from "net";
 //#region src/ports.ts

package/dist/{metro-gateway-C-ijGI2F.mjs → metro-gateway-CEUw9RMH.mjs}

@@ -1,8 +1,8 @@
-import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-DqcCbpE7.mjs";
-import { S as realIo } from "./client-SvBdgObD.mjs";
-import { randomBytes, randomUUID } from "node:crypto";
+import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-C59dqG-Z.mjs";
+import { w as realIo } from "./client-DzhapoMB.mjs";
 import { HOSTED_METRO_REQUESTS_KEY, findPeer, hostedMetroGateways, hostedMetroRequests, isJsonObject, parseMachine } from "@stim-cli/core/state";
+import { randomBytes, randomUUID } from "node:crypto";
 import { isIP } from "node:net";
 //#region src/device-host/metro-gateway.ts
 function gatewayAddresses(credential, status) {

package/dist/{metro-store-CDDZHtPl.mjs → metro-store-BAHFcJm6.mjs}

@@ -1,7 +1,21 @@
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import { METRO_NAMED_CACHE_LAYOUT, metroCacheRoot, registerCache, sharedStoreRoot, tagSharedStore } from "@stim-cli/core";
 import { fileURLToPath } from "node:url";
+import { METRO_NAMED_CACHE_LAYOUT, metroCacheRoot, registerCache, sharedStoreRoot, tagSharedStore } from "@stim-cli/core";
+//#region src/supervisor/errors.ts
+function supervisorError(code, message, remedy) {
+	const err = new Error(message);
+	err.code = code;
+	if (remedy) err.remedy = remedy;
+	return err;
+}
+function describeError(err) {
+	if (!err) return "unknown error";
+	const e = err;
+	const message = e.message || String(err);
+	return `${e.code ? `${e.code}: ` : ""}${message}${e.remedy ? ` Remedy: ${e.remedy}` : ""}`;
+}
+//#endregion
 //#region src/supervisor/metro-store.ts
 function metroStoreName(root) {
 	try {
@@ -89,4 +103,4 @@ function expoMetroStoreEnv({ root, storeRoot, adapterPath, existingOverride }) {
 	};
 }
 //#endregion
-export { metroStoreRoot as a, metroStoreConfirmedRoot as i, expoMetroConfigPath as n, registerMetroStore as o, expoMetroStoreEnv as r, appendCacheStore as t };
+export { metroStoreRoot as a, supervisorError as c, metroStoreConfirmedRoot as i, expoMetroConfigPath as n, registerMetroStore as o, expoMetroStoreEnv as r, describeError as s, appendCacheStore as t };

package/dist/{named-ports-C8m8EQs2.mjs → named-ports-BFIz1Shz.mjs}

@@ -1,9 +1,64 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { C as saveConfig, D as withConfigLock, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-D0DbpZtM.mjs";
-import { t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { f as isPortFree, i as listeningPids, u as signalProcessTree } from "./metro-g8NqiJp-.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-2mNzOlaB.mjs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { C as saveConfig, D as withConfigLock, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-CgYMahz7.mjs";
+import { f as isPortFree, i as listeningPids, u as signalProcessTree } from "./metro-Dh8T4Ytd.mjs";
+import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-Kqiifsk2.mjs";
 import { realpathSync } from "node:fs";
+import { join } from "node:path";
+import { setTimeout } from "node:timers/promises";
+//#region src/engine/workspace-process-lock.ts
+const DEFAULT_WAIT_MS = 6e4;
+const POLL_MS = 25;
+function workspaceProcessLockError(err) {
+	const code = err?.code;
+	if (code === "STIM_LOCK_REFUSED") return "refused";
+	if (code === "STIM_LOCK_TIMEOUT") return "timeout";
+	return null;
+}
+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, signal, sleep = (ms) => setTimeout(ms, void 0, { signal }), waitMs = DEFAULT_WAIT_MS, ownerPurpose, details = {}, onHeld, rejectOwnerPurposes = [], external = false, declareSpawns = false } = {}) {
+	const path = workspaceProcessLockPath(root, name, external);
+	const deadline = now() + waitMs;
+	for (;;) {
+		signal?.throwIfAborted();
+		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+			root: path,
+			mode: "exclusive",
+			label: `${name} lock`,
+			details: ownerPurpose ? {
+				...details,
+				purpose: ownerPurpose
+			} : details
+		});
+		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+		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 holder = attempt.held ?? attempt.waitingFor?.[0];
+		const purpose = holder?.details.purpose;
+		if (typeof purpose === "string" && rejectOwnerPurposes.includes(purpose)) {
+			const error = /* @__PURE__ */ new Error(`The ${name} lock at ${path} is held for ${purpose}.`);
+			error.code = "STIM_LOCK_REFUSED";
+			throw error;
+		}
+		if (holder && onHeld) await onHeld(holder);
+		if (now() >= deadline) {
+			const error = /* @__PURE__ */ new Error(`Timed out waiting for the ${name} lock at ${path}.`);
+			error.code = "STIM_LOCK_TIMEOUT";
+			throw error;
+		}
+		await sleep(POLL_MS);
+	}
+}
+//#endregion
 //#region src/named-ports.ts
 const FIRST_PORT = 8900;
 const LAST_PORT = 8999;
@@ -165,4 +220,4 @@ async function clearNamedPorts(projectPath, { label, stop = false, dryRun = fals
 	});
 }
 //#endregion
-export { reserveBrowserPort as i, getNamedPort as n, releaseBrowserPort as r, clearNamedPorts as t };
+export { withWorkspaceProcessLock as a, reserveBrowserPort as i, getNamedPort as n, workspaceProcessLockError as o, releaseBrowserPort as r, workspaceProcessLockPath as s, clearNamedPorts as t };

package/dist/{native-run-D1Q56rAD.mjs → native-run-B06FkmZx.mjs}

@@ -1,7 +1,7 @@
-import { a as formatElapsed } from "./command-output-CDAIFD-8.mjs";
-import { a as updateWorkspaceState, r as readWorkspaceState, t as clearWorkspaceStateKey, v as workspaceDir } from "./workspace-state-DqcCbpE7.mjs";
-import { i as signalDeclaredSpawns, r as refuseDeclaredSpawns, t as allowDeclaredSpawns } from "./spawn-claims-D0XfSe8u.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-2mNzOlaB.mjs";
+import { a as formatElapsed } from "./command-output-CBtzyIgF.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState, t as clearWorkspaceStateKey, v as workspaceDir } from "./workspace-state-C59dqG-Z.mjs";
+import { i as signalDeclaredSpawns, r as refuseDeclaredSpawns, t as allowDeclaredSpawns } from "./spawn-claims-Kqiifsk2.mjs";
+import { a as withWorkspaceProcessLock } from "./named-ports-BFIz1Shz.mjs";
 //#region src/engine/native-run.ts
 const NATIVE_RUN_LOCK = "native-run";
 const NATIVE_RUN_WAIT_MS = 18e5;

package/dist/{native-runtime-BEK171xQ.mjs → native-runtime-D_603JiC.mjs}

@@ -1,9 +1,9 @@
-import { l as phaseLine } from "./command-output-CDAIFD-8.mjs";
-import { x as metroPortSetting } from "./settings-Cfd-0r2d.mjs";
-import { l as resolveProjectMetro } from "./metro-g8NqiJp-.mjs";
-import { r as readWorkspaceState$1, u as ensureWorkspaceStorage } from "./workspace-state-DqcCbpE7.mjs";
-import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-lTnWZikR.mjs";
-import { c as startDevServer } from "./start-DUz3mYdb.mjs";
+import { l as phaseLine } from "./command-output-CBtzyIgF.mjs";
+import { l as resolveProjectMetro } from "./metro-Dh8T4Ytd.mjs";
+import { r as readWorkspaceState$1, u as ensureWorkspaceStorage } from "./workspace-state-C59dqG-Z.mjs";
+import { x as metroPortSetting } from "./settings-CQyMElEP.mjs";
+import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-hskNcWkZ.mjs";
+import { c as startDevServer } from "./start-D-IeOyoK.mjs";
 import { readIdleStop } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/native-runtime.ts

package/dist/{ndjson-PclOIwVY.mjs → ndjson-LGZAMsqa.mjs}

@@ -1,7 +1,7 @@
-import { closeSync, mkdirSync, openSync, writeSync } from "fs";
 import { dirname } from "path";
+import { LEVELS, SOURCES, levelRank, parseNdjsonLine, readNdjsonGenerations as readNdjsonGenerations$1, runId } from "@stim-cli/core/state";
+import { closeSync, mkdirSync, openSync, writeSync } from "fs";
 import { rotateLog } from "@stim-cli/core";
-import { LEVELS, SOURCES, levelRank, parseNdjsonLine, readNdjsonGenerations as readNdjsonGenerations$1 } from "@stim-cli/core/state";
 //#region src/ndjson.ts
 const ROTATE_CHECK_MS = 1e3;
 function formatNdjsonLine(record) {
@@ -104,9 +104,13 @@ function createNdjsonWriter(file, { truncate = false, fields = {}, maxBytes, now
 }
 function stamp(record) {
 	const base = record && typeof record === "object" && !Array.isArray(record) ? record : { msg: String(record) };
-	if (typeof base.ts === "number" && Number.isFinite(base.ts)) return base;
-	return {
+	const withRun = typeof base.runId === "string" ? base : {
 		...base,
+		runId: runId()
+	};
+	if (typeof base.ts === "number" && Number.isFinite(base.ts)) return withRun;
+	return {
+		...withRun,
 		ts: Date.now()
 	};
 }