stim 1.13.0 → 1.15.0

package/dist/{metro-BPeY1YMh.mjs → metro-Di8EN2Tb.mjs}

@@ -1,116 +1,11 @@
-import { N as isOnMountedVolume, O as process_identity_exports, P as listMountedVolumes, _ as loadConfig$1, b as releaseMetroPort, n as allMetroPorts, r as claimMetroPort } from "./config-0jCcMM0E.mjs";
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { existsSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { existsSync as existsSync$1, readlinkSync as readlinkSync$1, realpathSync as realpathSync$1 } from "fs";
-import { join, resolve, sep } from "path";
-import { buildCacheRoot as sharedBuildCache, withDirLock, workspaceId, workspaceName as workspaceName$1, workspaceStateDir as workspaceDir } from "@stim-cli/core";
-import { emulatorLogFile, readJsonObject, readWorkspaceState, readWorkspaceState as readWorkspaceState$1, sharedCcache, sharedCompilationCache, supervisorLogFile, supervisorPidFile, workspaceDerivedData, workspaceLastUsed, workspaceLogErrorIndex, workspaceLogsDir, workspaceMetadataFile, workspaceStateFile, workspaceStateLock } from "@stim-cli/core/state";
-import { dirname as dirname$1 } from "node:path";
+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-CL2V2Ons.mjs";
+import { existsSync, readlinkSync, realpathSync } from "fs";
+import { sep } from "path";
 import { request } from "http";
 import { connect } from "net";
-//#region src/workspace/paths.ts
-function ensureWorkspaceStorage(projectRoot) {
-	const canonicalRoot = resolve(projectRoot);
-	const dir = workspaceDir(canonicalRoot);
-	const file = workspaceMetadataFile(canonicalRoot);
-	mkdirSync(dir, { recursive: true });
-	return withDirLock(join(dir, "metadata.lock"), () => {
-		if (!existsSync(file)) {
-			const metadata = {
-				projectRoot: canonicalRoot,
-				workspace: workspaceName$1(canonicalRoot),
-				version: 1
-			};
-			const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-			writeFileSync(tmp, `${JSON.stringify(metadata, null, 2)}\n`);
-			try {
-				renameSync(tmp, file);
-			} catch (error) {
-				rmSync(tmp, { force: true });
-				throw error;
-			}
-			return dir;
-		}
-		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;
-	});
-}
-//#endregion
-//#region src/workspace/workspace-state.ts
-function withWorkspaceStateLock(root, fn) {
-	const file = workspaceStateFile(root);
-	return withDirLock(workspaceStateLock(root), fn, { ensureParent: () => {
-		ensureWorkspaceStorage(root);
-		mkdirSync(dirname$1(file), { recursive: true });
-	} });
-}
-function writeWorkspaceState(root, patch) {
-	return updateWorkspaceState(root, (state) => ({
-		...state,
-		...patch
-	}));
-}
-function updateWorkspaceState(root, update) {
-	return withWorkspaceStateLock(root, () => replaceWorkspaceState(root, update(readWorkspaceState(root) ?? {})));
-}
-function replaceWorkspaceState(root, state) {
-	const file = workspaceStateFile(root);
-	mkdirSync(dirname$1(file), { recursive: true });
-	const tmp = `${file}.tmp-${process.pid}`;
-	writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
-	renameSync(tmp, file);
-	return state;
-}
-function clearWorkspaceStateKeys(root, keys) {
-	if (!existsSync(workspaceStateFile(root))) return;
-	withWorkspaceStateLock(root, () => {
-		const state = readWorkspaceState(root);
-		const file = workspaceStateFile(root);
-		if (!state) {
-			try {
-				rmSync(file, { force: true });
-			} catch {}
-			return;
-		}
-		let changed = false;
-		for (const key of keys) {
-			if (!(key in state)) continue;
-			delete state[key];
-			changed = true;
-		}
-		if (!changed) return;
-		if (Object.keys(state).length === 0) {
-			rmSync(file, { force: true });
-			return;
-		}
-		replaceWorkspaceState(root, state);
-	});
-}
-function clearWorkspaceStateKey(root, key, shouldClear) {
-	return withWorkspaceStateLock(root, () => {
-		const state = readWorkspaceState(root);
-		if (!state || !(key in state)) return true;
-		if (!shouldClear(state[key])) return false;
-		delete state[key];
-		const file = workspaceStateFile(root);
-		if (Object.keys(state).length === 0) {
-			try {
-				rmSync(file, { force: true });
-			} catch {}
-			return true;
-		}
-		replaceWorkspaceState(root, state);
-		return true;
-	});
-}
-function recordWorkspaceUse(root, now = /* @__PURE__ */ new Date()) {
-	try {
-		writeWorkspaceState(root, { lastUsedAt: now.toISOString() });
-	} catch {}
-}
-//#endregion
 //#region src/ports.ts
 function isMetroRunning(port) {
 	return new Promise((resolve) => {
@@ -161,14 +56,14 @@ async function computeNextPort(isFree = isPortFree) {
 	throw new Error(`Found no free Metro port between ${FIRST_PORT} and 8281. Free one up, or stop a stale bundler (\`stim status\`, \`stim stop <port>\`).`);
 }
 async function findReclaimablePort(excludeProjectPath, probe = isMetroRunning, { isMounted = isOnMountedVolume, mountedVolumes } = {}) {
-	const cfg = loadConfig$1();
+	const cfg = loadConfig();
 	if (!cfg?.projects) return null;
 	const mounted = mountedVolumes || listMountedVolumes();
 	const candidates = [];
 	for (const [path, proj] of Object.entries(cfg.projects)) {
 		if (path === excludeProjectPath) continue;
 		if (Object.keys(proj.ports ?? {}).length) continue;
-		if (existsSync$1(path)) continue;
+		if (existsSync(path)) continue;
 		if (!isMounted(path, mounted)) continue;
 		if (typeof proj.metroPort === "number") candidates.push({
 			port: proj.metroPort,
@@ -187,7 +82,11 @@ async function allocatePort(projectPath, probe = isMetroRunning, isFree = isPort
 	return computeNextPort(isFree);
 }
 const RESERVE_ATTEMPTS = 5;
-async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree = isPortFree) {
+async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree = isPortFree, pinned = null) {
+	if (pinned !== null) {
+		if (claimMetroPort(projectPath, pinned) !== null) return pinned;
+		throw new Error(`metro.port ${pinned} is already reserved by another workspace's Metro or named port.`);
+	}
 	for (let attempt = 0; attempt < RESERVE_ATTEMPTS; attempt++) {
 		const port = await allocatePort(projectPath, probe, isFree);
 		const claimed = claimMetroPort(projectPath, port);
@@ -296,7 +195,7 @@ async function processCwds(pids) {
 	for (const pid of new Set(pids)) {
 		let cwd = null;
 		if (process.platform === "linux") try {
-			cwd = readlinkSync$1(`/proc/${pid}/cwd`);
+			cwd = readlinkSync(`/proc/${pid}/cwd`);
 		} catch {}
 		if (cwd) cwds.set(pid, cwd);
 		else viaLsof.push(pid);
@@ -317,13 +216,13 @@ async function processCwds(pids) {
 }
 function processCwd(pid) {
 	if (process.platform === "linux") try {
-		return readlinkSync$1(`/proc/${pid}/cwd`);
+		return readlinkSync(`/proc/${pid}/cwd`);
 	} catch {}
 	return parseLsofCwd(getExecutor().runQuiet(`lsof -a -p ${pid} -d cwd -Fn`));
 }
 function canonicalPath(path) {
 	try {
-		return realpathSync$1(path);
+		return realpathSync(path);
 	} catch {
 		return path;
 	}
@@ -338,7 +237,7 @@ const NOT_OURS_UNRESPONSIVE = "unresponsive";
 const NOT_OURS_UNREADABLE_CWD = "unreadable-cwd";
 const NOT_OURS_FOREIGN_CWD = "foreign-cwd";
 function ownedSupervisor(projectPath, port) {
-	const supervisor = readWorkspaceState$1(canonicalPath(projectPath))?.supervisor;
+	const supervisor = readWorkspaceState(canonicalPath(projectPath))?.supervisor;
 	if (supervisor?.port !== port || (0, process_identity_exports.inspectProcessIdentity)(supervisor) !== "same") return null;
 	return supervisor;
 }
@@ -368,7 +267,8 @@ async function resolveProjectMetro(port, projectPath, { probe = isMetroRunning,
 	if (!isInsideProject(cwd, projectPath)) return {
 		notOurs: `pid ${pid} on port ${port} runs from ${cwd}, outside ${projectPath}`,
 		kind: NOT_OURS_FOREIGN_CWD,
-		pid
+		pid,
+		cwd
 	};
 	const owner = ownedSupervisor(projectPath, port);
 	return { metro: {
@@ -406,4 +306,4 @@ function killMetroTree(leader, processToken) {
 	}
 }
 //#endregion
-export { workspaceId as A, sharedBuildCache as C, supervisorPidFile as D, supervisorLogFile as E, withDirLock as F, workspaceLogsDir as M, workspaceName$1 as N, workspaceDerivedData as O, workspaceStateFile as P, ensureWorkspaceStorage as S, sharedCompilationCache as T, updateWorkspaceState as _, pidExists as a, writeWorkspaceState as b, resolveProjectMetro as c, isPortFree as d, reserveMetroPort as f, recordWorkspaceUse as g, readWorkspaceState$1 as h, listeningPidsByPort as i, workspaceLogErrorIndex as j, workspaceDir as k, signalProcessTree as l, clearWorkspaceStateKeys as m, killMetroTree as n, processCwd as o, clearWorkspaceStateKey as p, listeningPids as r, processCwds as s, NOT_OURS_FOREIGN_CWD as t, isMetroRunning as u, withWorkspaceStateLock as v, sharedCcache as w, emulatorLogFile as x, workspaceLastUsed as y };
+export { listeningPidsByPort as a, processCwds as c, isMetroRunning as d, isPortFree as f, listeningPids as i, resolveProjectMetro as l, isInsideProject as n, pidExists as o, reserveMetroPort as p, killMetroTree as r, processCwd as s, NOT_OURS_FOREIGN_CWD as t, signalProcessTree as u };

package/dist/{named-ports-n7tnJsI8.mjs → named-ports-Dj_XBNaL.mjs}

@@ -1,62 +1,9 @@
-import { A as ownership_claim_exports, E as withConfigLock, O as process_identity_exports, S as saveConfig, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-0jCcMM0E.mjs";
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-import { d as isPortFree, l as signalProcessTree, r as listeningPids } from "./metro-BPeY1YMh.mjs";
-import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-PT8aQpCa.mjs";
+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 { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { f as isPortFree, i as listeningPids, u as signalProcessTree } from "./metro-Di8EN2Tb.mjs";
 import { realpathSync } from "node:fs";
-import { join } from "node:path";
-//#region src/engine/workspace-process-lock.ts
-const DEFAULT_WAIT_MS = 6e4;
-const POLL_MS = 25;
-const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-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, sleep = defaultSleep, waitMs = DEFAULT_WAIT_MS, ownerPurpose, details = {}, onHeld, rejectOwnerPurposes = [], external = false, declareSpawns = false } = {}) {
-	const path = workspaceProcessLockPath(root, name, external);
-	const deadline = now() + waitMs;
-	for (;;) {
-		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;
@@ -124,17 +71,14 @@ function releaseBrowserPort(projectPath, port) {
 		saveConfig(cfg);
 	}));
 }
-async function allocateNamedPort(projectPath, label, { isFree = async (port) => await isPortFree(port) && portListeners(port, process.platform).length === 0, log = console.error }) {
+async function allocateNamedPort(projectPath, label, { isFree = async (port) => await isPortFree(port) && portListeners(port, process.platform).length === 0 }) {
 	const root = realpathSync(projectPath);
 	return withPortsLock(async () => {
 		const existing = getProject(root)?.ports;
 		if (existing && Object.hasOwn(existing, label)) return existing[label];
 		for (let port = FIRST_PORT; port <= LAST_PORT; port++) {
 			if (Object.values(loadConfig()?.projects ?? {}).some((project) => project.metroPort === port || Object.values(project.ports ?? {}).includes(port))) continue;
-			if (!await isFree(port)) {
-				log(`Port ${port} already in use, trying next...`);
-				continue;
-			}
+			if (!await isFree(port)) continue;
 			if (withConfigLock(() => {
 				const cfg = ensureConfig();
 				if (Object.values(cfg.projects).some((project) => project.metroPort === port || Object.values(project.ports ?? {}).includes(port))) return false;
@@ -221,4 +165,4 @@ async function clearNamedPorts(projectPath, { label, stop = false, dryRun = fals
 	});
 }
 //#endregion
-export { withWorkspaceProcessLock as a, reserveBrowserPort as i, getNamedPort as n, workspaceProcessLockError as o, releaseBrowserPort as r, workspaceProcessLockPath as s, clearNamedPorts as t };
+export { reserveBrowserPort as i, getNamedPort as n, releaseBrowserPort as r, clearNamedPorts as t };

package/dist/native-run-DFDoIRbY.mjs

@@ -0,0 +1,147 @@
+import { a as updateWorkspaceState, b as workspaceDir, r as readWorkspaceState, t as clearWorkspaceStateKey } from "./workspace-state-CL2V2Ons.mjs";
+import { i as signalDeclaredSpawns, r as refuseDeclaredSpawns, t as allowDeclaredSpawns } from "./spawn-claims-D0XfSe8u.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { a as formatElapsed } from "./command-output-CliHHn7a.mjs";
+//#region src/engine/native-run.ts
+const NATIVE_RUN_LOCK = "native-run";
+const NATIVE_RUN_WAIT_MS = 18e5;
+const WAIT_HEARTBEAT_MS = 3e4;
+const CANCEL_REQUEST_KEY = "nativeRunCancel";
+function nativeRunHolder(holder) {
+	const { command, platform, slot } = holder.details;
+	return {
+		command: typeof command === "string" ? command : null,
+		platform: typeof platform === "string" ? platform : null,
+		slot: typeof slot === "string" ? slot : "default"
+	};
+}
+function describeNativeRunHolder(holder, now) {
+	const { command, slot } = nativeRunHolder(holder);
+	const started = Date.parse(holder.startedAt);
+	const facts = [`pid ${holder.owner.pid}`];
+	if (Number.isFinite(started)) facts.push(`running for ${formatElapsed(now - started)}`);
+	if (command === null) return `another Stim run (${facts.join(", ")})`;
+	return `\`stim ${command}${slot === "default" ? "" : ` --slot ${slot}`}\` (${facts.join(", ")})`;
+}
+/**
+* Report a wait on the native-run lock: one line as soon as a holder is seen, a line for each new
+* holder, and a heartbeat every WAIT_HEARTBEAT_MS while the same holder keeps it.
+*/
+function nativeRunWaitNotice({ write, now = Date.now, describe = describeNativeRunHolder }) {
+	let claimId = null;
+	let lastAt = 0;
+	return (holder, firstLine) => {
+		const at = now();
+		if (holder.claimId !== claimId) {
+			claimId = holder.claimId;
+			lastAt = at;
+			write(firstLine ?? `waiting for ${describe(holder, at)} in this workspace to finish`);
+			return;
+		}
+		if (at - lastAt < WAIT_HEARTBEAT_MS) return;
+		lastAt = at;
+		write(`still waiting for ${describe(holder, at)}`);
+	};
+}
+/**
+* What `stop` does about the run holding the native-run lock. A build is interrupted only when the stop
+* leaves it nothing to deploy to: the whole workspace stops, the build targets the stopped slot, or the
+* stopped slot is the workspace's only device. A build for another slot that stays is left running and
+* the stop proceeds without the lock. Only an owner whose identity is proven live is signalled.
+*/
+function decideStopAction({ stopSlot, holder, ownerIdentity, deviceSlots }) {
+	if (holder.command === "macos") {
+		if (stopSlot !== void 0) return { action: "proceed" };
+		return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
+	}
+	if (holder.command !== "ios" && holder.command !== "android") return { action: "wait" };
+	if (!(stopSlot === void 0 || holder.slot === stopSlot || deviceSlots.includes(stopSlot) && deviceSlots.every((slot) => slot === stopSlot))) return { action: "proceed" };
+	return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
+}
+function requestNativeRunCancel(root, claimId, pid = process.pid) {
+	updateWorkspaceState(root, (state) => ({
+		...state,
+		[CANCEL_REQUEST_KEY]: {
+			claimId,
+			pid,
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	}));
+}
+function cancelRequestFor(root, claimId) {
+	const request = readWorkspaceState(root)?.[CANCEL_REQUEST_KEY];
+	if (request?.claimId !== claimId || typeof request.pid !== "number") return null;
+	return { pid: request.pid };
+}
+function clearNativeRunCancel(root, claimId) {
+	try {
+		clearWorkspaceStateKey(root, CANCEL_REQUEST_KEY, (value) => value?.claimId === claimId);
+	} catch {}
+}
+let cancelled = null;
+/** Why this process's native run was cancelled, or null while it was not. */
+function runCancellation() {
+	return cancelled;
+}
+function cancelledFailure(platform, { code, message }) {
+	if (cancelled === null) return null;
+	return {
+		code: "STIM_CANCELLED",
+		message: `The ${platform} run was ${cancelled} before it finished.`,
+		remedy: `Run \`stim ${platform}\` again when you want the app on a device.`,
+		lines: [`it stopped at ${code ?? "an unfinished step"}${message ? `: ${message}` : ""}`]
+	};
+}
+function cancelOnInterrupt({ root, claim, write, exit }) {
+	let signals = 0;
+	const onInterrupt = () => {
+		signals += 1;
+		if (signals > 1) {
+			exit(130);
+			return;
+		}
+		const request = cancelRequestFor(root, claim.claimId);
+		cancelled = request ? `cancelled by \`stim stop\` (pid ${request.pid})` : "cancelled by an interrupt";
+		refuseDeclaredSpawns(`the run was ${cancelled}`);
+		const signalled = signalDeclaredSpawns("SIGINT");
+		write(signalled > 0 ? `${cancelled}; stopping the running build tool` : request ? `${cancelled}; stopping before the next build tool or install` : cancelled);
+		if (signalled === 0 && !request) exit(130);
+	};
+	process.on("SIGINT", onInterrupt);
+	return () => {
+		process.off("SIGINT", onInterrupt);
+		allowDeclaredSpawns();
+		clearNativeRunCancel(root, claim.claimId);
+	};
+}
+/**
+* Run an `ios`, `android` or `macos` invocation under the workspace's native-run lock: the claim records the
+* command, platform and slot, and a wait for another holder is reported on `write`. The first SIGINT
+* forwards the interrupt to the running declared build tool; a run `stim stop` cancelled between build
+* tools starts no further one; a terminal interrupt with no build tool running, or a second SIGINT, exits
+* with 130 at once.
+*/
+function withNativeBuildRun(root, details, fn, { write, exit = (code) => process.exit(code) }) {
+	const notice = nativeRunWaitNotice({ write });
+	return withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN_LOCK, async (claim) => {
+		const dispose = cancelOnInterrupt({
+			root,
+			claim,
+			write,
+			exit
+		});
+		try {
+			return await fn(claim);
+		} finally {
+			dispose();
+		}
+	}, {
+		external: true,
+		waitMs: NATIVE_RUN_WAIT_MS,
+		declareSpawns: true,
+		details: { ...details },
+		onHeld: (holder) => notice(holder)
+	});
+}
+//#endregion
+export { decideStopAction as a, nativeRunWaitNotice as c, withNativeBuildRun as d, clearNativeRunCancel as i, requestNativeRunCancel as l, NATIVE_RUN_WAIT_MS as n, describeNativeRunHolder as o, cancelledFailure as r, nativeRunHolder as s, NATIVE_RUN_LOCK as t, runCancellation as u };

package/dist/{native-runtime-CiiFHt0e.mjs → native-runtime-i6OkVg-w.mjs}

@@ -1,13 +1,17 @@
-import { S as ensureWorkspaceStorage, c as resolveProjectMetro, h as readWorkspaceState$1 } from "./metro-BPeY1YMh.mjs";
-import { l as phaseLine } from "./command-output-BIL7rlX7.mjs";
-import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-CuJaBpEa.mjs";
-import { s as startDevServer } from "./start-BZhItkiL.mjs";
+import { p as ensureWorkspaceStorage, r as readWorkspaceState$1 } from "./workspace-state-CL2V2Ons.mjs";
+import { l as phaseLine } from "./command-output-CliHHn7a.mjs";
+import { l as resolveProjectMetro } from "./metro-Di8EN2Tb.mjs";
+import { S as metroPortSetting } from "./settings-CduVcoxj.mjs";
+import { r as LAUNCH_UNVERIFIED, t as LAUNCH_BUNDLING } from "./launch-verify-CLlofxRt.mjs";
+import { c as startDevServer } from "./start-CUD9nasA.mjs";
 import { readIdleStop } from "@stim-cli/core/state";
 import chalk from "chalk";
 //#region src/commands/native-runtime.ts
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function ensureDevServer({ root, port, settings, remote, note, resolve = resolveProjectMetro, start = startDevServer, readState = readWorkspaceState$1 }) {
-	const held = port === null ? null : (await resolve(port, root)).metro;
+	const pin = metroPortSetting(root);
+	const canReuse = !pin.error && (pin.port === null || pin.port === port);
+	const held = port === null || !canReuse ? null : (await resolve(port, root)).metro;
 	if (port !== null && held) return {
 		ok: true,
 		port,
@@ -52,11 +56,12 @@ async function ensureWorkspaceStorageSafely(root, { note = (_line) => {} } = {})
 		throw err;
 	}
 }
-function launchOutcomeRecord({ launchState, release, bundleId, configuration, metroPort }) {
+function launchOutcomeRecord({ launchState, release, bundleId, configuration, metroPort, unattributed = false }) {
 	const unverified = launchState === LAUNCH_UNVERIFIED;
 	const bundling = launchState === LAUNCH_BUNDLING;
 	let msg;
 	if (release) msg = unverified ? `${bundleId} could not be verified as running after its ${configuration} launch` : `${bundleId} is running its embedded ${configuration} bundle`;
+	else if (unverified && unattributed) msg = `a bundle delivered on this workspace's Metro port ${metroPort} could not be attributed to ${bundleId} on this device: another slot of the same platform shares that Metro`;
 	else if (unverified) msg = `no bundle request from ${bundleId} reached this workspace's Metro on port ${metroPort}`;
 	else if (bundling) msg = `${bundleId} requested a bundle from this workspace's Metro on port ${metroPort}; it was still being built when the launch check ended`;
 	else msg = `${bundleId} fetched a bundle from this workspace's Metro on port ${metroPort}`;

package/dist/offload-worker.d.mts

@@ -0,0 +1,121 @@
+import "./ndjson-Du3j0AQ9.mjs";
+import "./state-B4PQFXMW.mjs";
+import { readFileSync } from "fs";
+import "@stim-cli/core/state";
+import "@expo/fingerprint";
+//#region src/engine/build-facts.d.ts
+interface CompilationCacheActivity {
+  status: "reported" | "unavailable" | "not-run";
+  hits: number | null;
+  cacheableTasks: number | null;
+  hitRatePercent: number | null;
+  swiftTargetsWithoutExplicitModules?: number;
+}
+interface CcacheActivity {
+  status: "reported" | "unavailable" | "not-run";
+  hits: number | null;
+  misses: number | null;
+  hitRatePercent: number | null;
+}
+//#endregion
+//#region src/optimizations.d.ts
+interface Optimizations {
+  buildCache: boolean;
+  remoteBuildCache: boolean;
+  releaseBundleSwap: boolean;
+  metroSharedCache: boolean;
+  metroWarmup: boolean;
+  ios: {
+    compilationCache: boolean;
+    swiftCompilationCache: boolean | null;
+    prefixMapping: boolean;
+  };
+  android: {
+    compilerCache: "ccache" | "cas" | "none";
+    casToolchain: string | null;
+    compilerCacheFallback: CompilerCacheFallback | null;
+    pch: "auto" | "on" | "off";
+    gradleBuildCache: boolean;
+    targetAbiOnly: boolean;
+  };
+}
+interface CompilerCacheFallback {
+  key: string;
+  reason: string;
+  fromEnvironment: boolean;
+  manifest: string | null;
+}
+//#endregion
+//#region src/offload/client.d.ts
+/** The Gradle choices that shape the APK, so the machine builds what this Mac's cache key describes. */
+interface AndroidBuildOptions {
+  variant: string | null;
+  abi: string | null;
+  gradleBuildCache: boolean;
+  pch: "auto" | "on" | "off";
+  compilerCache: "ccache" | "none";
+}
+//#endregion
+//#region src/offload/worker.d.ts
+/** One file of the client's checkout, as `git ls-files -co --exclude-standard` lists it. */
+interface ManifestEntry {
+  path: string;
+  kind: "file" | "exec" | "link";
+  size: number;
+  sha256: string;
+}
+/** What stim-server hands this process on stdin; it has already checked every path and blob. */
+interface WorkerJob {
+  job: string;
+  area: string;
+  blobs: string;
+  manifest: ManifestEntry[];
+  platform: "ios" | "android" | "macos";
+  macos: {
+    product: string;
+    infoPlist: string;
+    bundleId: string;
+    resources?: Record<string, string>;
+    assetCatalog?: string | null;
+  } | null;
+  swiftpmCache: string;
+  project: string;
+  packageName: string | null;
+  isExpo: boolean;
+  configuration: string | null;
+  scheme: string | null;
+  runtime: string | null;
+  android: AndroidBuildOptions | null;
+  expectedFingerprint: string;
+  optimizations: Optimizations["ios"] | null;
+  /** How long the client's Gradle daemon stays warm after an Android build; 0 or absent stops it when the build ends. */
+  gradleDaemonIdleMs?: number;
+}
+interface WorkerTimings {
+  syncMs: number;
+  depsMs: number;
+  prebuildMs: number;
+  podsMs: number;
+  fingerprintMs: number;
+  buildMs: number;
+  packageMs: number;
+}
+type WorkerResult = {
+  ok: true;
+  artifact: {
+    path: string;
+    name: string;
+    size: number;
+    sha256: string;
+  };
+  fingerprint: string;
+  compilationCache: CompilationCacheActivity | CcacheActivity | Record<string, never>;
+  timings: WorkerTimings;
+} | {
+  ok: false;
+  code: string;
+  message: string;
+  timings: WorkerTimings;
+};
+//#endregion
+export { ManifestEntry, WorkerJob, WorkerResult, WorkerTimings };