stim 1.13.0 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stim",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "Stim: fast, isolated React Native environments for coding agents",
   "keywords": [
     "agent",
@@ -39,13 +39,18 @@
       "types": "./dist/cache-manifest.d.mts",
       "module-sync": "./dist/cache-manifest.mjs",
       "default": "./dist/cache-manifest.mjs"
+    },
+    "./pull-requests": {
+      "types": "./dist/pull-requests.d.mts",
+      "module-sync": "./dist/pull-requests.mjs",
+      "default": "./dist/pull-requests.mjs"
     }
   },
   "dependencies": {
     "@expo/fingerprint": "^0.20.10",
-    "@stim-cli/cache": "^1.13.0",
-    "@stim-cli/core": "^1.13.0",
-    "@stim-cli/metro": "^1.13.0",
+    "@stim-cli/cache": "^1.15.0",
+    "@stim-cli/core": "^1.15.0",
+    "@stim-cli/metro": "^1.15.0",
     "chalk": "^6.0.0",
     "commander": "^15.0.0",
     "cross-spawn": "^7.0.6",
@@ -53,7 +58,7 @@
     "ws": "^8.21.3"
   },
   "devDependencies": {
-    "@stim-cli/expo-build-cache": "1.13.0",
+    "@stim-cli/expo-build-cache": "1.15.0",
     "@types/cross-spawn": "^6.0.6",
     "@types/which": "^3.0.4",
     "@types/ws": "^8.18.1",

package/shim/bundle-response.cjs

@@ -2,13 +2,39 @@
 
 const { randomUUID } = require('node:crypto');
 
-function bundleResponseMiddleware(write) {
+const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+// Metro writes each progress update of a multipart bundle response as its own JSON part:
+// https://github.com/facebook/metro/blob/main/packages/metro/src/Server.js (`writeChunk` with done, total, percent).
+const PROGRESS_PART = /^\{"done":(\d+),"total":(\d+),"percent":(\d+)\}$/;
+const PROGRESS_INTERVAL_MS = 1000;
+
+function clientPidFromLsof(output, clientPort, serverPort) {
+  const connection = new RegExp(`:${clientPort}->\\S*:${serverPort}$`);
+  let pid = null;
+  for (const line of String(output).split('\n')) {
+    if (line.startsWith('p')) pid = Number(line.slice(1));
+    else if (line.startsWith('n') && connection.test(line) && Number.isInteger(pid) && pid > 0) return pid;
+  }
+  return null;
+}
+
+// An iOS simulator app is a host process, so the peer of its loopback connection names the device's app.
+function lookupClientPid(req, runLsof) {
+  const { remoteAddress, remotePort, localPort } = req.socket;
+  if (!runLsof || !LOOPBACK.has(remoteAddress)) return null;
+  return Promise.resolve()
+    .then(() => runLsof(['-nP', `-iTCP:${remotePort}`, '-Fpn']))
+    .then((output) => clientPidFromLsof(output, remotePort, localPort))
+    .catch(() => null);
+}
+
+function bundleResponseMiddleware(write, { runLsof } = {}) {
   return (req, res, next) => {
     if (req.method === 'GET' && req.url === '/_stim/metro-warmup') {
       res.end('ready');
       return;
     }
-    if (req.headers['x-stim-metro-warmup'] === '1') return next();
+    const prefetch = req.headers['x-stim-metro-warmup'] === '1';
     let url;
     try {
       url = new URL(req.url, 'http://localhost');
@@ -20,27 +46,46 @@ function bundleResponseMiddleware(write) {
       return next();
     }
     const requestId = randomUUID();
-    const emit = (event, statusCode) => {
+    const kind = prefetch ? 'prefetch' : 'response';
+    const clientPid = platform === 'ios' && !prefetch ? lookupClientPid(req, runLsof) : null;
+    const send = (ts, stage, statusCode, pid, progress) => {
       try {
         write({
-          ts: Date.now(),
+          ts,
           src: 'metro',
-          level: event === 'bundle_response_failed' ? 'error' : 'debug',
-          event,
+          level: stage === 'failed' && !prefetch ? 'error' : 'debug',
+          event: `bundle_${kind}_${stage}`,
           platform,
           requestId,
-          statusCode,
-          msg: `${platform} bundle response ${event.slice('bundle_response_'.length)}`,
+          ...(progress ?? { statusCode }),
+          msg: progress ? `${platform} bundle ${progress.percent}%` : `${platform} bundle ${kind} ${stage}`,
+          ...(pid ? { clientPid: pid } : {}),
         });
       } catch {}
     };
-    emit('bundle_response_started');
+    const emit = (stage, statusCode, progress) => {
+      const ts = Date.now();
+      if (clientPid) clientPid.then((pid) => send(ts, stage, statusCode, pid, progress));
+      else send(ts, stage, statusCode, null, progress);
+    };
+    emit('started');
+    const writeChunk = res.write;
+    let progressAt = 0;
+    res.write = function (chunk, ...rest) {
+      const part = typeof chunk === 'string' && chunk.length < 100 ? PROGRESS_PART.exec(chunk) : null;
+      const now = part ? Date.now() : 0;
+      if (part && now - progressAt >= PROGRESS_INTERVAL_MS) {
+        progressAt = now;
+        emit('progress', undefined, { done: Number(part[1]), total: Number(part[2]), percent: Number(part[3]) });
+      }
+      return writeChunk.call(this, chunk, ...rest);
+    };
     let ended = false;
     const finish = (complete) => {
       if (ended) return;
       ended = true;
       const success = complete && (res.statusCode === 200 || res.statusCode === 304);
-      emit(success ? 'bundle_response_finished' : 'bundle_response_failed', res.statusCode);
+      emit(success ? 'finished' : 'failed', res.statusCode);
     };
     res.once('finish', () => finish(true));
     res.once('close', () => finish(false));

package/shim/bundle-response.d.cts

@@ -2,4 +2,5 @@ import type { IncomingMessage, ServerResponse } from 'node:http';
 
 export function bundleResponseMiddleware(
   write: (record: Record<string, unknown>) => unknown,
+  options?: { runLsof?: (args: string[]) => Promise<string> },
 ): (req: IncomingMessage, res: ServerResponse, next: () => unknown) => unknown;

package/shim/expo-metro-config.cjs

@@ -3,6 +3,7 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const { execFile } = require('node:child_process');
 const { createRequire } = require('node:module');
 const { pathToFileURL } = require('node:url');
 const { bundleResponseMiddleware } = require('./bundle-response.cjs');
@@ -118,6 +119,12 @@ function storeAtRoot(store) {
   return store[STORE_ROOT_TAG] === storeRoot || store['_root'] === storeRoot;
 }
 
+function runLsof(args) {
+  return new Promise((resolve, reject) =>
+    execFile('lsof', args, { timeout: 2000 }, (error, stdout) => (error ? reject(error) : resolve(stdout))),
+  );
+}
+
 function appendStore(config, defaultConfig) {
   const output = config && typeof config === 'object' ? config : {};
   const configuredStores = output.cacheStores != null ? output.cacheStores : defaultConfig.cacheStores;
@@ -130,8 +137,9 @@ function appendStore(config, defaultConfig) {
       ...server,
       enhanceMiddleware(middleware, metroServer) {
         const enhanced = enhanceMiddleware ? enhanceMiddleware(middleware, metroServer) : middleware;
-        const observe = bundleResponseMiddleware((record) =>
-          process.stderr.write(`stim-bundle-response: ${JSON.stringify(record)}\n`),
+        const observe = bundleResponseMiddleware(
+          (record) => process.stderr.write(`stim-bundle-response: ${JSON.stringify(record)}\n`),
+          { runLsof: process.platform === 'darwin' ? runLsof : undefined },
         );
         return (req, res, next) => observe(req, res, () => enhanced(req, res, next));
       },

package/dist/build-progress-l7d-X-ZP.mjs

@@ -1,247 +0,0 @@
-import { A as ownership_claim_exports } from "./config-0jCcMM0E.mjs";
-import { _ as updateWorkspaceState, p as clearWorkspaceStateKey } from "./metro-BPeY1YMh.mjs";
-import { a as formatElapsed, u as plural } from "./command-output-BIL7rlX7.mjs";
-import { BUILD_HISTORY_KEY, BUILD_HISTORY_LIMIT, BUILD_PHASES, LAST_BUILD_KEYS } from "@stim-cli/core/state";
-//#region src/engine/build-progress.ts
-const ACTIVE_BUILD_KEY = "activeBuild";
-const NO_BUILD_PROGRESS = {
-	step: () => {},
-	durations: () => ({}),
-	clear: () => {}
-};
-const COLD_PHASES = [
-	"prebuild",
-	"pods",
-	"compile"
-];
-const DEVICE_PHASES = ["install", "launch"];
-function startBuildProgress({ root, platform, slot, claim, now = Date.now, note = () => {} }) {
-	const startedAt = new Date(now()).toISOString();
-	const record = {
-		platform,
-		slot,
-		startedAt,
-		phase: "prepare",
-		phaseStartedAt: startedAt,
-		phases: [{
-			phase: "prepare",
-			startedAt
-		}],
-		claim: {
-			root: claim.root,
-			path: claim.path,
-			claimId: claim.claimId,
-			pid: claim.owner.pid
-		}
-	};
-	let warned = false;
-	const guard = (fn) => {
-		try {
-			fn();
-		} catch (error) {
-			if (warned) return;
-			warned = true;
-			note(`Build progress could not be recorded in the workspace state: ${error?.message || error}`);
-		}
-	};
-	const write = (before = (state) => state) => guard(() => updateWorkspaceState(root, (state) => ({
-		...before(state),
-		[ACTIVE_BUILD_KEY]: record
-	})));
-	write(withInterruptedBuild);
-	return {
-		step(phase) {
-			if (phase === record.phase) return;
-			const at = new Date(now()).toISOString();
-			record.phase = phase;
-			record.phaseStartedAt = at;
-			record.phases.push({
-				phase,
-				startedAt: at
-			});
-			write();
-		},
-		durations() {
-			return phaseDurations(record.phases, now());
-		},
-		clear() {
-			guard(() => {
-				clearWorkspaceStateKey(root, ACTIVE_BUILD_KEY, (value) => parseActiveBuild(value)?.claim.claimId === record.claim.claimId);
-			});
-		}
-	};
-}
-function phaseDurations(phases, now) {
-	const out = {};
-	phases.forEach(({ phase, startedAt }, index) => {
-		const start = Date.parse(startedAt);
-		const next = phases[index + 1];
-		const end = next ? Date.parse(next.startedAt) : now;
-		if (!Number.isFinite(start) || !Number.isFinite(end)) return;
-		out[phase] = (out[phase] ?? 0) + Math.max(0, end - start);
-	});
-	return out;
-}
-const HISTORY_FIELDS = [
-	"platform",
-	"status",
-	"configuration",
-	"fingerprint",
-	"cacheKey",
-	"cacheHit",
-	"cacheSkipped",
-	"durationMs",
-	"startedAt",
-	"errorCode",
-	"missReason",
-	"diagnostics"
-];
-function withHistoryEntry(state, platform, entry) {
-	const saved = state[BUILD_HISTORY_KEY];
-	const history = saved && typeof saved === "object" && !Array.isArray(saved) ? saved : {};
-	const list = Array.isArray(history[platform]) ? history[platform] : [];
-	return {
-		...state,
-		[BUILD_HISTORY_KEY]: {
-			...history,
-			[platform]: [entry, ...list].slice(0, BUILD_HISTORY_LIMIT)
-		}
-	};
-}
-function finishedResult(record) {
-	if (record.status === "ok") return "succeeded";
-	return record.errorCode === "STIM_CANCELLED" ? "cancelled" : "failed";
-}
-function recordFinishedBuild(root, record, { update = updateWorkspaceState, now = Date.now } = {}) {
-	const platform = record.platform;
-	update(root, (state) => {
-		const active = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
-		const own = active?.platform === platform ? active : null;
-		const entry = {
-			...Object.fromEntries(HISTORY_FIELDS.filter((key) => key in record).map((key) => [key, record[key]])),
-			result: finishedResult(record),
-			slot: own?.slot ?? "default",
-			phases: own ? phaseDurations(own.phases, now()) : {}
-		};
-		return withHistoryEntry({
-			...state,
-			lastBuild: record,
-			[LAST_BUILD_KEYS[platform]]: record
-		}, platform, entry);
-	});
-}
-function withInterruptedBuild(state) {
-	const left = parseActiveBuild(state[ACTIVE_BUILD_KEY]);
-	if (!left) return state;
-	const last = state[LAST_BUILD_KEYS[left.platform]];
-	if (Date.parse(String(last?.startedAt)) >= Date.parse(left.startedAt)) return state;
-	return withHistoryEntry(state, left.platform, {
-		platform: left.platform,
-		status: "failed",
-		result: "interrupted",
-		slot: left.slot,
-		configuration: null,
-		fingerprint: null,
-		cacheKey: null,
-		cacheHit: false,
-		cacheSkipped: false,
-		durationMs: null,
-		startedAt: left.startedAt,
-		phases: phaseDurations(left.phases, Date.parse(left.phaseStartedAt))
-	});
-}
-function parseActiveBuild(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-	const record = value;
-	const claim = record.claim;
-	if (record.platform !== "ios" && record.platform !== "android") return null;
-	if (!isPhase(record.phase)) return null;
-	if (typeof record.startedAt !== "string" || typeof record.phaseStartedAt !== "string") return null;
-	if (!claim || typeof claim.root !== "string" || typeof claim.claimId !== "string") return null;
-	const phases = Array.isArray(record.phases) ? record.phases.filter((entry) => isPhase(entry?.phase) && typeof entry?.startedAt === "string") : [];
-	return {
-		platform: record.platform,
-		slot: typeof record.slot === "string" ? record.slot : "default",
-		startedAt: record.startedAt,
-		phase: record.phase,
-		phaseStartedAt: record.phaseStartedAt,
-		phases,
-		claim: {
-			root: claim.root,
-			path: typeof claim.path === "string" ? claim.path : "",
-			claimId: claim.claimId,
-			pid: typeof claim.pid === "number" ? claim.pid : 0
-		}
-	};
-}
-function isPhase(value) {
-	return BUILD_PHASES.includes(value);
-}
-function activeBuildState(claim, survey = (0, ownership_claim_exports.readClaimSet)(claim.root)) {
-	if (survey.live.some((holder) => holder.claimId === claim.claimId)) return "running";
-	if (survey.dead.some((holder) => holder.claimId === claim.claimId)) return "stale";
-	return survey.unresolved.length ? "unknown" : "stale";
-}
-function liveOutcome(record) {
-	const seen = new Set(record.phases.map((entry) => entry.phase));
-	if (COLD_PHASES.some((phase) => seen.has(phase))) return "cold";
-	if (DEVICE_PHASES.some((phase) => seen.has(phase))) return "hit";
-	return null;
-}
-function median(values) {
-	if (!values.length) return null;
-	const sorted = values.toSorted((a, b) => a - b);
-	const mid = Math.floor(sorted.length / 2);
-	return sorted.length % 2 ? sorted[mid] : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
-}
-function estimateBuild(history, platform, known, phase) {
-	const lists = history?.[platform];
-	const outcome = known ?? latestOutcome(lists);
-	const samples = outcome && lists?.[outcome] || [];
-	const phaseSamples = samples.flatMap((sample) => phase in sample.phases ? [sample.phases[phase]] : []);
-	return {
-		outcome,
-		expectedMs: median(samples.map((sample) => sample.durationMs)),
-		expectedPhaseMs: median(phaseSamples),
-		basis: samples.length
-	};
-}
-function latestOutcome(lists) {
-	let latest = null;
-	for (const outcome of ["hit", "cold"]) {
-		const last = lists?.[outcome]?.at(-1);
-		const at = last ? Date.parse(last.at) : NaN;
-		if (Number.isFinite(at) && (!latest || at > latest.at)) latest = {
-			outcome,
-			at
-		};
-	}
-	return latest?.outcome ?? null;
-}
-function buildReport(record, { state, history }) {
-	return {
-		platform: record.platform,
-		slot: record.slot,
-		state,
-		phase: record.phase,
-		startedAt: record.startedAt,
-		phaseStartedAt: record.phaseStartedAt,
-		...estimateBuild(history, record.platform, liveOutcome(record), record.phase)
-	};
-}
-function remainingText(remainingMs) {
-	return remainingMs < 6e4 ? "under a minute left" : `about ${Math.ceil(remainingMs / 6e4)} min left`;
-}
-function buildStatusLine(report, now) {
-	const slot = report.slot === "default" ? "" : ` [${report.slot}]`;
-	if (report.state === "stale") return `build: stale ${report.platform}${slot} record from ${report.startedAt} (its run is gone; the next run replaces it)`;
-	const elapsedMs = Math.max(0, now - Date.parse(report.startedAt));
-	const head = `build: ${report.platform}${slot} ${report.phase}, ${formatElapsed(elapsedMs)} elapsed`;
-	if (report.state === "unknown") return `${head} (its native-run claim cannot be resolved, so it may not be running)`;
-	if (report.expectedMs === null) return head;
-	const basis = `median of ${plural(report.basis, `${report.outcome} run`)}`;
-	const remainingMs = report.expectedMs - elapsedMs;
-	return remainingMs > 0 ? `${head} -- ${remainingText(remainingMs)} (${basis})` : `${head} (usually ~${formatElapsed(report.expectedMs)}, ${basis})`;
-}
-//#endregion
-export { buildStatusLine as a, recordFinishedBuild as c, buildReport as i, startBuildProgress as l, NO_BUILD_PROGRESS as n, estimateBuild as o, activeBuildState as r, parseActiveBuild as s, ACTIVE_BUILD_KEY as t };

package/dist/in-use-wYEaKQM9.mjs

@@ -1,249 +0,0 @@
-import { A as ownership_claim_exports, d as getConfigDir, p as getProject } from "./config-0jCcMM0E.mjs";
-import { h as readWorkspaceState, k as workspaceDir } from "./metro-BPeY1YMh.mjs";
-import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-PT8aQpCa.mjs";
-import { a as withWorkspaceProcessLock, o as workspaceProcessLockError, s as workspaceProcessLockPath } from "./named-ports-n7tnJsI8.mjs";
-import { a as formatElapsed } from "./command-output-BIL7rlX7.mjs";
-import { h as listBuildLocks } from "./device-lease-CL9dZf73.mjs";
-import { n as managedLockHolders, t as resolveSupervisorTarget } from "./ownership-PUP4Dwai.mjs";
-import { a as readWebRecord, l as webFacts } from "./state-l1pYwOre.mjs";
-import { lstatSync, readdirSync, rmSync, rmdirSync, statSync, unlinkSync } from "node:fs";
-import { realpathSync as realpathSync$1 } from "fs";
-import { resolve } from "path";
-import { join as join$1 } from "node:path";
-//#region src/engine/build-slots.ts
-const SLOT_PREFIX = "slot-";
-const SLOT_LABEL = "build slot";
-const SLOT_POLL_MS = 1e3;
-const SLOT_PROGRESS_MS = 3e4;
-const SLOT_CEILING_MS = 54e5;
-function sleepAsync(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function buildSlotsDir() {
-	return join$1(getConfigDir(), "build-slots");
-}
-function buildSlotPath(index) {
-	return join$1(buildSlotsDir(), `${SLOT_PREFIX}${index}`);
-}
-function toRecord(holder) {
-	const details = holder.details;
-	return {
-		pid: holder.owner.pid,
-		index: typeof details.index === "number" ? details.index : null,
-		projectRoot: typeof details.projectRoot === "string" ? details.projectRoot : null,
-		startedAt: holder.startedAt || null,
-		logFile: typeof details.logFile === "string" ? details.logFile : null
-	};
-}
-function tryAcquireBuildSlot({ max, root = null, logFile = null }) {
-	if (!max || max <= 0) return {
-		acquired: true,
-		unlimited: true
-	};
-	let refusal = null;
-	let busy = false;
-	for (let index = 0; index < max; index++) {
-		const path = buildSlotPath(index);
-		let attempt;
-		try {
-			attempt = (0, ownership_claim_exports.tryAcquireClaim)({
-				root: path,
-				mode: "exclusive",
-				label: SLOT_LABEL,
-				details: {
-					index,
-					projectRoot: root,
-					logFile
-				}
-			});
-		} catch (err) {
-			if (!(0, ownership_claim_exports.isClaimRefusal)(err)) throw err;
-			refusal ??= err;
-			continue;
-		}
-		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
-		if (!attempt.acquired) {
-			busy = true;
-			continue;
-		}
-		declareSpawnsOn(attempt.acquired);
-		return {
-			acquired: true,
-			path,
-			index,
-			slot: {
-				pid: attempt.acquired.owner.pid,
-				index,
-				projectRoot: root,
-				startedAt: attempt.acquired.startedAt,
-				logFile
-			},
-			claim: attempt.acquired
-		};
-	}
-	if (refusal && !busy) throw refusal;
-	return null;
-}
-function slotWaitingLine({ max, elapsedMs }) {
-	return `${"build".padEnd(11)} waiting for a build slot (all ${max} in use, ${formatElapsed(elapsedMs)} elapsed) -- stim guide lifecycle concurrency`;
-}
-async function acquireBuildSlot({ max, root = null, logFile = null, now = Date.now, out = () => {}, sleep = sleepAsync, intervalMs = SLOT_POLL_MS, progressMs = SLOT_PROGRESS_MS, ceilingMs = SLOT_CEILING_MS }) {
-	if (!max || max <= 0) return {
-		acquired: true,
-		unlimited: true
-	};
-	const started = now();
-	let lastProgress = started;
-	for (;;) {
-		const got = tryAcquireBuildSlot({
-			max,
-			root,
-			logFile
-		});
-		if (got) return got;
-		const elapsed = now() - started;
-		if (elapsed >= ceilingMs) {
-			const err = /* @__PURE__ */ new Error(`Waited ${formatElapsed(elapsed)} for one of ${max} build slots, and every slot is held by a process that is still running, or by a holder Stim cannot identify. Slots live under ` + buildSlotsDir() + "; remove a slot directory whose builder is not really building, or raise concurrency.maxBuilds.");
-			err.code = "STIM_BUILD_SLOT_TIMEOUT";
-			throw err;
-		}
-		if (now() - lastProgress >= progressMs) {
-			lastProgress = now();
-			out(slotWaitingLine({
-				max,
-				elapsedMs: elapsed
-			}));
-		}
-		await sleep(intervalMs);
-	}
-}
-function releaseBuildSlot(handle) {
-	if (!handle || handle.unlimited) return false;
-	stopDeclaringSpawnsOn(handle.claim);
-	return (0, ownership_claim_exports.releaseClaim)(handle.claim);
-}
-function listBuildSlots() {
-	const dir = buildSlotsDir();
-	let names;
-	try {
-		names = readdirSync(dir);
-	} catch {
-		return [];
-	}
-	const slots = [];
-	for (const name of names) {
-		if (!name.startsWith(SLOT_PREFIX)) continue;
-		const path = join$1(dir, name);
-		try {
-			if (!statSync(path).isDirectory()) continue;
-		} catch {
-			continue;
-		}
-		const survey = (0, ownership_claim_exports.readClaimSet)(path);
-		const holder = survey.live[0] ?? survey.dead[0];
-		const info = holder ? toRecord(holder) : null;
-		const index = Number(name.slice(5));
-		slots.push({
-			path,
-			name,
-			index: Number.isFinite(index) ? index : null,
-			pid: info?.pid ?? null,
-			projectRoot: info?.projectRoot ?? null,
-			startedAt: info?.startedAt ?? null,
-			logFile: info?.logFile ?? null,
-			alive: survey.live.length > 0,
-			unresolved: survey.unresolved.length > 0
-		});
-	}
-	return slots;
-}
-//#endregion
-//#region src/commands/gc/paths.ts
-function canonicalPath(p) {
-	try {
-		return realpathSync$1(p);
-	} catch {
-		return resolve(p);
-	}
-}
-//#endregion
-//#region src/workspace/in-use.ts
-const NATIVE_RUN = "native-run";
-const NATIVE_RUN_HELD = "a stim ios, android or stop run holds its native-run.lock";
-function workspaceInUse(root, { supervisor = true, managedLocks = true, nativeRun = true } = {}) {
-	const reasons = [];
-	if (supervisor) {
-		const project = getProject(root);
-		const target = resolveSupervisorTarget({
-			state: readWorkspaceState(root)?.supervisor,
-			record: project?.supervisor,
-			reservedPort: project?.metroPort
-		});
-		if (target.status === "ours") reasons.push(`its dev server supervisor (pid ${target.pid}) is running`);
-		else if (target.status === "unverified") reasons.push(`its dev server supervisor cannot be verified: ${target.reason ?? "unknown identity"}`);
-		const browser = webFacts(readWebRecord(root));
-		if (browser?.status === "running" || browser?.status === "orphaned") reasons.push(`its owned Chrome (pid ${browser.record.chromeProcess?.pid}) is running`);
-		else if (browser?.status === "unverified") reasons.push("its owned Chrome cannot be verified");
-	}
-	if (nativeRun) {
-		const claims = (0, ownership_claim_exports.readClaimSet)(workspaceProcessLockPath(workspaceDir(root), NATIVE_RUN, true));
-		if (claims.live.length) reasons.push(NATIVE_RUN_HELD);
-		else if (claims.unresolved[0]) reasons.push(`its native-run.lock cannot be resolved: ${claims.unresolved[0].reason}`);
-	}
-	const self = canonicalPath(root);
-	for (const [kind, entries] of [["build lock", listBuildLocks()], ["build slot", listBuildSlots()]]) for (const entry of entries) {
-		if (!entry.alive && !entry.unresolved) continue;
-		if (entry.projectRoot !== null && canonicalPath(entry.projectRoot) === self) reasons.push(`a ${entry.alive ? "live" : "unresolvable"} ${kind} at ${entry.path} names it`);
-	}
-	if (managedLocks) reasons.push(...managedLockHolders(root));
-	return reasons;
-}
-function emptyWorkspaceDir(dir) {
-	if (lstatSync(dir).isSymbolicLink()) {
-		unlinkSync(dir);
-		return;
-	}
-	for (const name of readdirSync(dir)) if (name !== `${NATIVE_RUN}.lock`) rmSync(join$1(dir, name), {
-		recursive: true,
-		force: true
-	});
-}
-async function withIdleWorkspace(root, fn, { purpose, ...checks }) {
-	try {
-		return await withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN, async () => {
-			const reasons = workspaceInUse(root, {
-				...checks,
-				nativeRun: false
-			});
-			if (reasons.length) return {
-				ran: false,
-				reasons
-			};
-			return {
-				ran: true,
-				value: await fn()
-			};
-		}, {
-			external: true,
-			waitMs: 0,
-			ownerPurpose: purpose
-		});
-	} catch (error) {
-		if (workspaceProcessLockError(error)) return {
-			ran: false,
-			reasons: [NATIVE_RUN_HELD]
-		};
-		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return {
-			ran: false,
-			reasons: [`its native-run.lock cannot be taken: ${error.reason}`]
-		};
-		throw error;
-	} finally {
-		try {
-			const dir = workspaceDir(root);
-			if (!lstatSync(dir).isSymbolicLink()) rmdirSync(dir);
-		} catch {}
-	}
-}
-//#endregion
-export { acquireBuildSlot as a, canonicalPath as i, withIdleWorkspace as n, listBuildSlots as o, workspaceInUse as r, releaseBuildSlot as s, emptyWorkspaceDir as t };