stim 1.14.0 → 1.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stim",
-  "version": "1.14.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.14.0",
-    "@stim-cli/core": "^1.14.0",
-    "@stim-cli/metro": "^1.14.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.14.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

@@ -3,6 +3,10 @@
 const { randomUUID } = require('node:crypto');
 
 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}$`);
@@ -30,7 +34,7 @@ function bundleResponseMiddleware(write, { runLsof } = {}) {
       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');
@@ -42,34 +46,46 @@ function bundleResponseMiddleware(write, { runLsof } = {}) {
       return next();
     }
     const requestId = randomUUID();
-    const clientPid = platform === 'ios' ? lookupClientPid(req, runLsof) : null;
-    const send = (ts, event, statusCode, pid) => {
+    const kind = prefetch ? 'prefetch' : 'response';
+    const clientPid = platform === 'ios' && !prefetch ? lookupClientPid(req, runLsof) : null;
+    const send = (ts, stage, statusCode, pid, progress) => {
       try {
         write({
           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 {}
     };
-    const emit = (event, statusCode) => {
+    const emit = (stage, statusCode, progress) => {
       const ts = Date.now();
-      if (clientPid) clientPid.then((pid) => send(ts, event, statusCode, pid));
-      else send(ts, event, statusCode, null);
+      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);
     };
-    emit('bundle_response_started');
     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/dist/build-progress-DxKpwnaS.mjs

@@ -1,247 +0,0 @@
-import { A as ownership_claim_exports } from "./config-lvc7d3C2.mjs";
-import { _ as updateWorkspaceState, p as clearWorkspaceStateKey } from "./metro-CcEo8Fl8.mjs";
-import { a as formatElapsed, u as plural } from "./command-output-DVcpw6eE.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-DlqBDKqY.mjs

@@ -1,249 +0,0 @@
-import { A as ownership_claim_exports, d as getConfigDir, p as getProject } from "./config-lvc7d3C2.mjs";
-import { h as readWorkspaceState, k as workspaceDir } from "./metro-CcEo8Fl8.mjs";
-import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-Drw_o-Fb.mjs";
-import { a as withWorkspaceProcessLock, o as workspaceProcessLockError, s as workspaceProcessLockPath } from "./named-ports-Blg8IxOh.mjs";
-import { a as formatElapsed } from "./command-output-DVcpw6eE.mjs";
-import { h as listBuildLocks } from "./device-lease-5c3WrVRm.mjs";
-import { d as managedLockHolders, u as resolveSupervisorTarget } from "./stop-cause-hjGBOZTG.mjs";
-import { a as readWebRecord, l as webFacts } from "./state-Dk9RVXI7.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 };

package/dist/server-expo-DIHDhvGg.mjs

@@ -1,2 +0,0 @@
-import { p as startExpoServer } from "./server-expo-BVuwQ65v.mjs";
-export { startExpoServer };

package/dist/start-Cetfvy8l.mjs

@@ -1,2 +0,0 @@
-import { a as registerStart, c as startFacts, d as wantsExpoOwnTunnel, i as readLogTail, l as supervisorEntry, n as liveSupervisor, o as startCommand, r as parseWait, s as startDevServer, t as failureEvidence, u as tailLines } from "./start-s4RXp1wy.mjs";
-export { startCommand as default, failureEvidence, liveSupervisor, parseWait, readLogTail, registerStart, startDevServer, startFacts, supervisorEntry, tailLines, wantsExpoOwnTunnel };

package/dist/stats-CFpFGlJV.mjs

@@ -1,62 +0,0 @@
-import { s as gitCommonDir, y as repoRoot } from "./worktree-BVrHsYZG.mjs";
-import { a as findProjectRoot } from "./project-CWlvEaeN.mjs";
-import { o as formatLongDuration } from "./command-output-DVcpw6eE.mjs";
-import { a as statsProjectKey, r as readStats } from "./stats-CX1Z8Tca.mjs";
-import chalk from "chalk";
-//#region src/commands/stats.ts
-const PLATFORMS = ["ios", "android"];
-const PLATFORM_WIDTH = 9;
-function statsCommand(program) {
-	program.command("stats").description("Show how many `ios` and `android` runs this project and this machine have recorded, how many hit the build cache, and an estimate of the time that cache saved.").option("--json", "print the aggregates as JSON").action((opts) => {
-		const root = findProjectRoot(process.cwd());
-		const key = root ? statsProjectKey({
-			root,
-			commonDir: gitCommonDir(root),
-			repoRoot: repoRoot(root)
-		}) : null;
-		const { record, note } = readStats();
-		if (note) console.error(chalk.dim(note));
-		const machine = record?.machine ?? {};
-		const project = key ? record?.projects?.[key] ?? {} : {};
-		if (opts.json) {
-			console.log(JSON.stringify({
-				version: 1,
-				project: key ? {
-					key,
-					ios: project.ios ?? null,
-					android: project.android ?? null
-				} : null,
-				machine: {
-					ios: machine.ios ?? null,
-					android: machine.android ?? null
-				}
-			}));
-			return;
-		}
-		const lines = [];
-		if (key) lines.push(`project ${key}`, ...sectionLines(project));
-		lines.push("machine", ...sectionLines(machine));
-		for (const line of lines) console.log(line);
-	});
-}
-function sectionLines(scope) {
-	const lines = PLATFORMS.filter((platform) => scope[platform]).map((platform) => bucketLine(platform, scope[platform]));
-	return lines.length ? lines : [chalk.dim("  no runs recorded")];
-}
-function bucketLine(platform, bucket) {
-	const finished = bucket.runs - bucket.failed;
-	const cells = [
-		`${bucket.runs} runs${bucket.failed > 0 ? ` (${bucket.failed} failed)` : ""}`,
-		`${bucket.hits} hits (${finished > 0 ? `${Math.round(bucket.hits / finished * 100)}%` : "-"})`,
-		`cold run ${average(bucket.coldRunMs, bucket.coldRuns)} avg`,
-		`hit run ${average(bucket.hitRunMs, bucket.hitRuns)} avg`,
-		`saved ~${formatLongDuration(bucket.timeSavedMs)} (estimated)`,
-		`since ${bucket.firstRunAt.slice(0, 10)}`
-	];
-	return `  ${platform.padEnd(PLATFORM_WIDTH)}${cells.join("   ")}`;
-}
-function average(totalMs, runs) {
-	return runs > 0 ? formatLongDuration(Math.round(totalMs / runs)) : "-";
-}
-//#endregion
-export { statsCommand as default };