stim 1.3.1 → 1.4.0

package/dist/{ios-device-CWOM_S44.mjs → ios-device-DJOi9FR5.mjs}

@@ -1,5 +1,5 @@
 import { t as getExecutor } from "./exec-CyylIdq9.mjs";
-import { r as INSTALL_ERROR } from "./app-install-DIp9riNx.mjs";
+import { r as INSTALL_ERROR } from "./app-install--PAocWvq.mjs";
 import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";

package/dist/{logs-CAdwW6c2.mjs → logs-BF3qPA7w.mjs}

@@ -1,9 +1,9 @@
-import { V as validateDeviceSlot, g as loadConfig, h as isPathPrefix } from "./config-CcefMY2Q.mjs";
+import { g as loadConfig, h as isPathPrefix, z as validateDeviceSlot } from "./config-6vdGngKa.mjs";
 import { n as SOURCES, t as LEVELS } from "./ndjson-BZwI1NBv.mjs";
-import { D as workspaceLogsDir, p as readWorkspaceState } from "./state-B3XA2wp2.mjs";
-import { a as findProjectRoot } from "./project-fKmuIaMI.mjs";
-import { _ as launchErrorPreview } from "./command-output-8wHMEde0.mjs";
-import { i as captureWorkspaceCrashes, t as errorDiagnostics } from "./error-diagnostics-DwhNBFDU.mjs";
+import { _ as workspaceLogsDir, r as readWorkspaceState } from "./workspace-state-Do1e2mOH.mjs";
+import { a as findProjectRoot } from "./project-CBFCwnN5.mjs";
+import { _ as launchErrorPreview } from "./command-output-BuIb_ZOI.mjs";
+import { i as captureWorkspaceCrashes, t as errorDiagnostics } from "./error-diagnostics-_VmkqRZo.mjs";
 import { a as followLogs, c as queryLogs, i as fileSizes, n as buildCriteria, o as logFiles, r as compileGrep, s as parseSince } from "./logs-query-Cdp5aaCH.mjs";
 import { realpathSync } from "node:fs";
 import { relative, sep } from "node:path";

package/dist/metro-DFLmaVz8.mjs

@@ -0,0 +1,99 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { w as process_identity_exports } from "./config-6vdGngKa.mjs";
+import { r as readWorkspaceState } from "./workspace-state-Do1e2mOH.mjs";
+import { t as isMetroRunning } from "./ports-ClqG8GPt.mjs";
+import { readlinkSync, realpathSync } from "fs";
+import { sep } from "path";
+//#region src/metro.ts
+/**
+* True when some process with this pid exists right now. It cannot tell a recycled pid from the
+* process that first held it, so it is only valid for a pid this run spawned and still holds a
+* handle on. For a pid read from a record on disk, decide with `inspectProcessIdentity` on that
+* record's process token, or take an ownership claim (`ownership-claim.ts`): this answer would keep
+* a dead holder's record looking live until some unrelated process exits.
+*/
+function pidExists(pid) {
+	if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
+	}
+}
+function parseLsofPids(out) {
+	if (!out) return [];
+	return String(out).split("\n").map((s) => parseInt(s.trim(), 10)).filter((n) => Number.isFinite(n));
+}
+function parseLsofCwd(out) {
+	if (!out) return null;
+	const lines = String(out).split("\n");
+	const idx = lines.findIndex((l) => l === "fcwd");
+	if (idx === -1) return null;
+	const nLine = lines.slice(idx + 1).find((l) => l.startsWith("n"));
+	return nLine ? nLine.slice(1) : null;
+}
+function processCwd(pid) {
+	if (process.platform === "linux") try {
+		return readlinkSync(`/proc/${pid}/cwd`);
+	} catch {}
+	return parseLsofCwd(getExecutor().runQuiet(`lsof -a -p ${pid} -d cwd -Fn`));
+}
+function canonicalPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+function isInsideProject(cwd, projectPath) {
+	if (!cwd || !projectPath) return false;
+	const a = canonicalPath(cwd);
+	const b = canonicalPath(projectPath);
+	return a === b || a.startsWith(b.endsWith(sep) ? b : b + sep);
+}
+const NOT_OURS_UNRESPONSIVE = "unresponsive";
+const NOT_OURS_UNREADABLE_CWD = "unreadable-cwd";
+const NOT_OURS_FOREIGN_CWD = "foreign-cwd";
+async function resolveProjectMetro(port, projectPath, { probe = isMetroRunning } = {}) {
+	const pid = parseLsofPids(getExecutor().runQuiet(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`))[0];
+	if (pid === void 0) return { missing: true };
+	if (!await probe(port)) return {
+		notOurs: `pid ${pid} on port ${port} does not answer Metro's /status`,
+		kind: NOT_OURS_UNRESPONSIVE,
+		pid
+	};
+	const cwd = processCwd(pid);
+	if (!cwd) return {
+		notOurs: `pid ${pid} on port ${port}: working directory could not be read`,
+		kind: NOT_OURS_UNREADABLE_CWD,
+		pid
+	};
+	if (!isInsideProject(cwd, projectPath)) return {
+		notOurs: `pid ${pid} on port ${port} runs from ${cwd}, outside ${projectPath}`,
+		kind: NOT_OURS_FOREIGN_CWD,
+		pid
+	};
+	const supervisor = readWorkspaceState(canonicalPath(projectPath))?.supervisor;
+	const owned = supervisor?.port === port && (0, process_identity_exports.inspectProcessIdentity)(supervisor) === "same";
+	return { metro: {
+		pid,
+		leader: owned ? supervisor.pid : pid,
+		cwd,
+		...owned ? { processToken: supervisor.processToken } : {}
+	} };
+}
+function killMetroTree(leader, processToken) {
+	if (!leader || leader === process.pid || (0, process_identity_exports.inspectProcessIdentity)({
+		pid: leader,
+		processToken
+	}) !== "same") return false;
+	try {
+		process.kill(-leader, "SIGTERM");
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { resolveProjectMetro as i, killMetroTree as n, pidExists as r, NOT_OURS_FOREIGN_CWD as t };

package/dist/named-ports-BO7Zpjp0.mjs

@@ -0,0 +1,137 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { C as withConfigLock, f as getProject, g as loadConfig, s as ensureConfig, u as getConfigDir, w as process_identity_exports, y as saveConfig } from "./config-6vdGngKa.mjs";
+import { n as isPortFree } from "./ports-ClqG8GPt.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-UEIrvZMJ.mjs";
+import { realpathSync } from "node:fs";
+//#region src/named-ports.ts
+const FIRST_PORT = 8900;
+const LAST_PORT = 8999;
+function validatePortLabel(label) {
+	if (label === "metro") throw new Error("metro is managed by stim start and stim stop; choose another label.");
+	if (!/^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/.test(label)) throw new Error("A port label must start with a letter and contain at most 64 letters, digits, underscores or hyphens.");
+}
+function portListeners(port) {
+	let out;
+	try {
+		out = getExecutor().runFile("lsof", [
+			"-nP",
+			`-iTCP:${port}`,
+			"-sTCP:LISTEN",
+			"-t"
+		], { timeoutMs: 5e3 });
+	} catch (error) {
+		const result = error;
+		if (result.status === 1 && !String(result.stdout ?? "").trim() && !String(result.stderr ?? "").trim()) return [];
+		throw new Error(`Could not inspect TCP port ${port} with lsof: ${error.message}`, { cause: error });
+	}
+	const pids = out.trim() ? out.trim().split(/\s+/).map(Number) : [];
+	if (pids.some((pid) => !Number.isSafeInteger(pid) || pid <= 0)) throw new Error(`lsof returned an invalid listener for TCP port ${port}.`);
+	return [...new Set(pids)];
+}
+function withPortsLock(fn) {
+	return withWorkspaceProcessLock(getConfigDir(), "ports", fn, { external: true });
+}
+async function getNamedPort(projectPath, label, { isFree = async (port) => await isPortFree(port) && portListeners(port).length === 0, log = console.error } = {}) {
+	validatePortLabel(label);
+	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 (withConfigLock(() => {
+				const cfg = ensureConfig();
+				if (Object.values(cfg.projects).some((project) => project.metroPort === port || Object.values(project.ports ?? {}).includes(port))) return false;
+				const project = cfg.projects[root] ??= {
+					metroPort: null,
+					platforms: {}
+				};
+				project.ports = {
+					...project.ports,
+					[label]: port
+				};
+				saveConfig(cfg);
+				return true;
+			})) return port;
+		}
+		throw new Error(`No free named port between ${FIRST_PORT} and ${LAST_PORT}. Use stim ports stop or stim ports release in a workspace that no longer needs its ports.`);
+	});
+}
+async function stopListeners(port, label, dryRun, log) {
+	for (const pid of portListeners(port)) {
+		if (pid === process.pid) throw new Error(`Refusing to stop Stim itself on ${label} (${port}).`);
+		const identity = (0, process_identity_exports.captureProcessIdentity)(pid);
+		if (!identity.ok) {
+			if (!portListeners(port).includes(pid)) continue;
+			throw new Error(`Cannot identify pid ${pid} on ${label} (${port}): ${identity.reason}`);
+		}
+		const record = {
+			pid,
+			processToken: identity.token
+		};
+		const command = getExecutor().runFile("ps", [
+			"-p",
+			String(pid),
+			"-o",
+			"args="
+		], { timeoutMs: 5e3 }).trim();
+		if (dryRun) {
+			log(`would stop ${label} (${port}): pid ${pid} ${command}`);
+			continue;
+		}
+		if (!portListeners(port).includes(pid)) continue;
+		const status = (0, process_identity_exports.inspectProcessIdentity)(record);
+		if (status === "gone" || status === "different") continue;
+		if (status !== "same") throw new Error(`Cannot verify pid ${pid} on ${label} (${port}); allocation kept.`);
+		try {
+			process.kill(pid, "SIGTERM");
+			if (!await (0, process_identity_exports.waitForProcessExit)(record, 2e3)) {
+				if ((0, process_identity_exports.inspectProcessIdentity)(record) !== "same") throw new Error(`Cannot verify pid ${pid} before SIGKILL.`);
+				process.kill(pid, "SIGKILL");
+				if (!await (0, process_identity_exports.waitForProcessExit)(record, 2e3)) throw new Error(`Pid ${pid} did not exit.`);
+			}
+		} catch (error) {
+			if (error.code !== "ESRCH") throw error;
+		}
+		log(`stopped ${label} (${port}): pid ${pid} ${command}`);
+	}
+	if (!dryRun && portListeners(port).length) throw new Error(`Port ${port} still has a listener; allocation kept.`);
+}
+async function clearNamedPorts(projectPath, { label, stop = false, dryRun = false, log = console.error } = {}) {
+	if (label !== void 0) validatePortLabel(label);
+	await withPortsLock(async () => {
+		const ports = getProject(projectPath)?.ports ?? {};
+		const failures = [];
+		for (const [name, port] of Object.entries(ports)) {
+			if (label !== void 0 && name !== label) continue;
+			try {
+				if (!Number.isInteger(port) || port < FIRST_PORT || port > LAST_PORT) throw new Error(`Invalid named port ${name} (${port}); repair its config record before cleanup.`);
+				if (stop) {
+					if (Object.values(loadConfig()?.projects ?? {}).some((project) => project.metroPort === port)) throw new Error(`Port ${port} is reserved for managed Metro; allocation kept.`);
+					await stopListeners(port, name, dryRun, log);
+				}
+				if (dryRun) {
+					log(`would release ${name} (${port})`);
+					continue;
+				}
+				withConfigLock(() => {
+					const cfg = loadConfig();
+					const current = cfg?.projects?.[projectPath]?.ports;
+					if (!cfg || current?.[name] !== port) return;
+					delete current[name];
+					saveConfig(cfg);
+				});
+				log(`released ${name} (${port})`);
+			} catch (error) {
+				failures.push(`${name} (${port}): ${error.message}`);
+			}
+		}
+		if (failures.length) throw new Error(failures.join("\n"));
+	});
+}
+//#endregion
+export { getNamedPort as n, clearNamedPorts as t };

package/dist/{ownership-8O073GIC.mjs → ownership-BvSpZVBk.mjs}

@@ -1,6 +1,6 @@
-import { D as sameProcessRecord, E as inspectProcessIdentity } from "./config-CcefMY2Q.mjs";
-import { _ as writeWorkspaceState, m as withWorkspaceStateLock, p as readWorkspaceState } from "./state-B3XA2wp2.mjs";
-import { r as pidExists } from "./metro-CORqXyTL.mjs";
+import { w as process_identity_exports } from "./config-6vdGngKa.mjs";
+import { a as withWorkspaceStateLock, o as writeWorkspaceState, r as readWorkspaceState } from "./workspace-state-Do1e2mOH.mjs";
+import { r as pidExists } from "./metro-DFLmaVz8.mjs";
 import { realpathSync } from "node:fs";
 //#region src/collector/state.ts
 function collectorRoot(root) {
@@ -42,12 +42,12 @@ function collectorProcessTitle(platform, root) {
 }
 function verifyCollectorOwnership({ pid, platform, root, isAlive = pidExists, expected }) {
 	const record = readCollectors(root)[platform];
-	if (expected !== void 0 && !sameProcessRecord(record, expected)) return {
+	if (expected !== void 0 && !(0, process_identity_exports.sameProcessRecord)(record, expected)) return {
 		status: "unverified",
 		reason: `the ${platform} collector registration changed during cleanup`
 	};
 	if (record?.pid === pid) {
-		const identity = inspectProcessIdentity(record);
+		const identity = (0, process_identity_exports.inspectProcessIdentity)(record);
 		if (identity === "same") return { status: "ours" };
 		if (identity === "gone" || identity === "different") return { status: "gone" };
 	}

package/dist/{ownership-DXcol4oU.mjs → ownership-C08Yzrp7.mjs}

@@ -1,8 +1,8 @@
 import { t as getExecutor } from "./exec-CyylIdq9.mjs";
-import { E as inspectProcessIdentity, T as captureProcessToken, u as getConfigDir } from "./config-CcefMY2Q.mjs";
+import { u as getConfigDir, w as process_identity_exports } from "./config-6vdGngKa.mjs";
 import { t as createLineReader } from "./process-output-C7IlIzd7.mjs";
-import { r as pidExists } from "./metro-CORqXyTL.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-IBj1Towr.mjs";
+import { r as pidExists } from "./metro-DFLmaVz8.mjs";
+import { t as withWorkspaceProcessLock } from "./workspace-process-lock-UEIrvZMJ.mjs";
 import { closeSync, mkdirSync, openSync, readFileSync, unlinkSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { basename, join, resolve, sep } from "node:path";
@@ -198,7 +198,7 @@ async function waitUntilReachable({ url, now, sleep, probe, timeoutMs }) {
 }
 const CLEANUP_TIMEOUT_MS = 1e3;
 const CLEANUP_POLL_MS = 25;
-async function startTunnel({ provider, port, spawnFn = null, urlTimeoutMs = URL_TIMEOUT_MS, reachableTimeoutMs = REACHABLE_TIMEOUT_MS, probeReachable = defaultProbeReachable, now = Date.now, sleep = defaultSleep, ngrokUrl = null, requireReachable = true, cleanupTimeoutMs = CLEANUP_TIMEOUT_MS, isChildAlive = pidExists, readProcessToken = captureProcessToken, logFile = null }) {
+async function startTunnel({ provider, port, spawnFn = null, urlTimeoutMs = URL_TIMEOUT_MS, reachableTimeoutMs = REACHABLE_TIMEOUT_MS, probeReachable = defaultProbeReachable, now = Date.now, sleep = defaultSleep, ngrokUrl = null, requireReachable = true, cleanupTimeoutMs = CLEANUP_TIMEOUT_MS, isChildAlive = pidExists, readProcessToken = process_identity_exports.captureProcessToken, logFile = null }) {
 	const spawn = spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts));
 	const outputFile = logFile || (spawnFn ? null : createTunnelLogFile(provider));
 	const { bin, args } = tunnelArgv(provider, port, ngrokUrl, outputFile);
@@ -377,7 +377,7 @@ function defaultKill(pid) {
 function isEsrch(err) {
 	return err?.code === "ESRCH";
 }
-async function stopTunnel(record, { isAlive = pidExists, inspectIdentity = inspectProcessIdentity, kill = defaultKill, now = Date.now, sleep = defaultSleep, timeoutMs = STOP_TIMEOUT_MS } = {}) {
+async function stopTunnel(record, { isAlive = pidExists, inspectIdentity = process_identity_exports.inspectProcessIdentity, kill = defaultKill, now = Date.now, sleep = defaultSleep, timeoutMs = STOP_TIMEOUT_MS } = {}) {
 	const missing = () => {
 		removeRecordedTunnelLogFile(record?.logFile);
 		return { status: "missing" };
@@ -418,7 +418,7 @@ async function stopTunnel(record, { isAlive = pidExists, inspectIdentity = inspe
 }
 //#endregion
 //#region src/supervisor/ownership.ts
-function resolveSupervisorTarget({ state, record, reservedPort, isAlive = pidExists, inspectIdentity = inspectProcessIdentity } = {}) {
+function resolveSupervisorTarget({ state, record, reservedPort, isAlive = pidExists, inspectIdentity = process_identity_exports.inspectProcessIdentity } = {}) {
 	const statePid = numberOrNull(state?.pid);
 	const recordPid = numberOrNull(record?.pid);
 	const pid = statePid ?? recordPid;

package/dist/ports-BiKqP92J.mjs

@@ -0,0 +1,39 @@
+import { f as getProject } from "./config-6vdGngKa.mjs";
+import { a as findProjectRoot } from "./project-CBFCwnN5.mjs";
+import { n as getNamedPort, t as clearNamedPorts } from "./named-ports-BO7Zpjp0.mjs";
+//#region src/commands/ports.ts
+async function inProject(action) {
+	try {
+		const root = findProjectRoot(process.cwd());
+		if (!root) throw new Error("No package.json found. Run stim ports from the workspace that owns the server.");
+		await action(root);
+	} catch (error) {
+		console.error(error.message);
+		process.exitCode = 1;
+	}
+}
+function portsCommand(program) {
+	const ports = program.command("ports").description("Reserve workspace ports for servers Stim does not manage");
+	ports.action(() => inProject(async (root) => {
+		const project = getProject(root);
+		const rows = Object.entries(project?.ports ?? {});
+		if (typeof project?.metroPort === "number") rows.push(["metro (managed)", project.metroPort]);
+		if (!rows.length) {
+			console.log("No ports allocated. Use stim ports get <label>.");
+			return;
+		}
+		const width = Math.max(...rows.map(([name]) => name.length));
+		for (const [name, port] of rows) console.log(`${name.padEnd(width)}  ${port}`);
+	}));
+	ports.command("get <label>").description("Allocate once and print only the port number").action((label) => inProject(async (root) => {
+		console.log(await getNamedPort(root, label));
+	}));
+	ports.command("stop [label]").description("Stop TCP listeners and release named ports; excludes Metro").option("--dry-run", "show the listeners and allocations that would be stopped and released").action((label, opts) => inProject((root) => clearNamedPorts(root, {
+		label,
+		stop: true,
+		dryRun: opts.dryRun
+	})));
+	ports.command("release [label]").description("Release named ports without stopping their listeners; excludes Metro").action((label) => inProject((root) => clearNamedPorts(root, { label })));
+}
+//#endregion
+export { portsCommand as default };

package/dist/ports-ClqG8GPt.mjs

@@ -0,0 +1,90 @@
+import { A as isOnMountedVolume, g as loadConfig, j as listMountedVolumes, n as allMetroPorts, r as claimMetroPort, v as removeProject } from "./config-6vdGngKa.mjs";
+import { existsSync } from "fs";
+import { request } from "http";
+import { connect } from "net";
+//#region src/ports.ts
+function isMetroRunning(port) {
+	return new Promise((resolve) => {
+		const req = request({
+			hostname: "localhost",
+			port,
+			path: "/status",
+			timeout: 2e3
+		}, (res) => {
+			let data = "";
+			res.on("data", (chunk) => {
+				data += chunk;
+			});
+			res.on("end", () => resolve(data.includes("packager-status:running")));
+		});
+		req.on("error", () => resolve(false));
+		req.on("timeout", () => {
+			req.destroy();
+			resolve(false);
+		});
+		req.end();
+	});
+}
+function isPortFree(port, { timeoutMs = 400 } = {}) {
+	return new Promise((resolve) => {
+		const sock = connect({
+			port,
+			host: "127.0.0.1"
+		});
+		const done = (free) => {
+			sock.removeAllListeners();
+			sock.destroy();
+			resolve(free);
+		};
+		sock.setTimeout(timeoutMs);
+		sock.once("connect", () => done(false));
+		sock.once("error", () => done(true));
+		sock.once("timeout", () => done(false));
+	});
+}
+const FIRST_PORT = 8082;
+async function computeNextPort(isFree = isPortFree) {
+	const taken = new Set(allMetroPorts());
+	for (let port = FIRST_PORT; port < 8282; port++) {
+		if (taken.has(port)) continue;
+		if (await isFree(port)) return port;
+	}
+	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();
+	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(path)) continue;
+		if (!isMounted(path, mounted)) continue;
+		if (typeof proj.metroPort === "number") candidates.push({
+			port: proj.metroPort,
+			ownerPath: path
+		});
+	}
+	for (const c of candidates) if (!await probe(c.port)) return c;
+	return null;
+}
+async function allocatePort(projectPath, probe = isMetroRunning, isFree = isPortFree) {
+	const reclaim = await findReclaimablePort(projectPath, probe);
+	if (reclaim && await isFree(reclaim.port)) {
+		removeProject(reclaim.ownerPath);
+		return reclaim.port;
+	}
+	return computeNextPort(isFree);
+}
+const RESERVE_ATTEMPTS = 5;
+async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree = isPortFree) {
+	for (let attempt = 0; attempt < RESERVE_ATTEMPTS; attempt++) {
+		const port = await allocatePort(projectPath, probe, isFree);
+		const claimed = claimMetroPort(projectPath, port);
+		if (claimed !== null) return claimed;
+	}
+	throw new Error(`Could not reserve a Metro port after ${RESERVE_ATTEMPTS} attempts: another Stim run claimed each one first. Retry.`);
+}
+//#endregion
+export { isPortFree as n, reserveMetroPort as r, isMetroRunning as t };

package/dist/{project-fKmuIaMI.mjs → project-CBFCwnN5.mjs}

@@ -1,5 +1,5 @@
-import { c as findEnclosingWorktreeRoot, f as getProject } from "./config-CcefMY2Q.mjs";
-import { g as repoRoot } from "./worktree-Eq6TLH8N.mjs";
+import { c as findEnclosingWorktreeRoot, f as getProject } from "./config-6vdGngKa.mjs";
+import { _ as repoRoot } from "./worktree-DWNx4tUg.mjs";
 import { existsSync, readFileSync, readdirSync, realpathSync } from "fs";
 import { basename, dirname, join, resolve } from "path";
 import { createRequire } from "module";

package/dist/{reclaim-CUmwucWG.mjs → reclaim-DpDVo-AP.mjs}

@@ -1,11 +1,13 @@
-import { D as sameProcessRecord, O as waitForProcessExit, f as getProject, v as removeProject, z as projectDeviceSlots } from "./config-CcefMY2Q.mjs";
-import { T as workspaceDir, a as clearRemoteSession, c as readMetroTunnel, d as readRemoteSessionId, i as clearManagedMetroTunnel, p as readWorkspaceState } from "./state-B3XA2wp2.mjs";
-import { i as resolveProjectMetro, n as killMetroTree, r as pidExists } from "./metro-CORqXyTL.mjs";
-import { n as verifyCollectorOwnership } from "./ownership-8O073GIC.mjs";
-import { c as parkedMaxSetting, n as teardownOwnedIosSim, t as teardownOwnedAvd, x as resolveEasCliBin } from "./teardown--gESs9ck.mjs";
-import { l as releaseWorkspaceLeases } from "./device-lease-CJwK7OZr.mjs";
-import { i as endRecordedSession } from "./device-remote-DAA0Zm6Z.mjs";
-import { r as stopTunnel, t as resolveSupervisorTarget } from "./ownership-DXcol4oU.mjs";
+import { E as ownership_claim_exports, L as projectDeviceSlots, T as acquireAvdClaim, f as getProject, v as removeProject, w as process_identity_exports } from "./config-6vdGngKa.mjs";
+import { h as workspaceDir, r as readWorkspaceState } from "./workspace-state-Do1e2mOH.mjs";
+import { a as clearRemoteSession, i as clearManagedMetroTunnel, s as readMetroTunnel, u as readRemoteSessionId } from "./state-CDbvmZdt.mjs";
+import { i as resolveProjectMetro, n as killMetroTree, r as pidExists } from "./metro-DFLmaVz8.mjs";
+import { n as verifyCollectorOwnership } from "./ownership-BvSpZVBk.mjs";
+import { S as resolveEasCliBin, l as parkedMaxSetting, n as teardownOwnedIosSim, t as teardownOwnedAvd } from "./teardown-KsPpvldq.mjs";
+import { l as releaseWorkspaceLeases } from "./device-lease-DDJr85OK.mjs";
+import { i as endRecordedSession } from "./device-remote-CMfHhoc8.mjs";
+import { t as clearNamedPorts } from "./named-ports-BO7Zpjp0.mjs";
+import { r as stopTunnel, t as resolveSupervisorTarget } from "./ownership-C08Yzrp7.mjs";
 import { existsSync, rmSync } from "node:fs";
 //#region src/reclaim.ts
 async function reapCollectors(root, { verify = verifyCollectorOwnership, collectors }) {
@@ -35,7 +37,7 @@ async function reapCollectors(root, { verify = verifyCollectorOwnership, collect
 		}
 		try {
 			process.kill(pid, "SIGTERM");
-			if (await waitForProcessExit(rec, 5e3)) continue;
+			if (await (0, process_identity_exports.waitForProcessExit)(rec, 5e3)) continue;
 		} catch (error) {
 			if (error.code === "ESRCH") continue;
 		}
@@ -138,7 +140,7 @@ async function reclaimMetroTunnel(root, { stopMetroTunnel = defaultStopMetroTunn
 	};
 }
 function describeDereferenced(project) {
-	const devices = [];
+	const devices = Object.entries(project?.ports ?? {}).map(([label, port]) => `port ${label} (${port})`);
 	for (const { platforms } of projectDeviceSlots(project)) {
 		const ios = platforms.ios;
 		if (ios?.deviceUdid) devices.push(`ios sim ${ios.deviceUdid}`);
@@ -211,7 +213,10 @@ function reclaimOwnedDevices(project, projectPath, { park = false } = {}) {
 			const bound = parkedMaxSetting("android");
 			const r = teardownOwnedAvd(android.avdName, {
 				del: true,
-				owner: { projectPath },
+				owner: {
+					projectPath,
+					slot
+				},
 				...park && !bound.error && bound.max > 0 ? { park: {
 					projectPath,
 					slot,
@@ -251,7 +256,9 @@ function reclaimOwnedDevices(project, projectPath, { park = false } = {}) {
 	};
 }
 async function reclaimProject(path, { deleteOwnedDevices = false, parkOwnedDevices = false, preserveProjectRecord = false, stopSession = defaultStopSession, stopMetroTunnel = defaultStopMetroTunnel, releaseLeases = releaseWorkspaceLeases, verifyCollector = verifyCollectorOwnership } = {}) {
+	await clearNamedPorts(path, { stop: true });
 	const project = getProject(path);
+	for (const { platforms } of projectDeviceSlots(project)) if (platforms.android?.owned && platforms.android.avdName) (0, ownership_claim_exports.releaseClaim)(acquireAvdClaim(platforms.android.avdName));
 	const dereferenced = describeDereferenced(project);
 	const initialState = readWorkspaceState(path);
 	let killedPid = null;
@@ -263,7 +270,7 @@ async function reclaimProject(path, { deleteOwnedDevices = false, parkOwnedDevic
 		reservedPort: project?.metroPort
 	});
 	if (supervisor.status === "ours") {
-		if (killMetroTree(supervisor.pid, supervisor.processToken) && await waitForProcessExit(supervisor, 1e4)) killedPid = supervisor.pid;
+		if (killMetroTree(supervisor.pid, supervisor.processToken) && await (0, process_identity_exports.waitForProcessExit)(supervisor, 1e4)) killedPid = supervisor.pid;
 		else {
 			skippedMetro = `could not confirm supervisor pid ${supervisor.pid} exited`;
 			supervisorHeld = true;
@@ -281,7 +288,7 @@ async function reclaimProject(path, { deleteOwnedDevices = false, parkOwnedDevic
 	function retainReplacementProcesses() {
 		const currentState = readWorkspaceState(path);
 		const currentProject = getProject(path);
-		if (Boolean(currentState?.supervisor && !sameProcessRecord(currentState.supervisor, initialState?.supervisor) || currentProject?.supervisor && !sameProcessRecord(currentProject.supervisor, project?.supervisor) || Object.entries(currentState?.collectors ?? {}).some(([platform, record]) => !sameProcessRecord(record, initialState?.collectors?.[platform])))) {
+		if (Boolean(currentState?.supervisor && !(0, process_identity_exports.sameProcessRecord)(currentState.supervisor, initialState?.supervisor) || currentProject?.supervisor && !(0, process_identity_exports.sameProcessRecord)(currentProject.supervisor, project?.supervisor) || Object.entries(currentState?.collectors ?? {}).some(([platform, record]) => !(0, process_identity_exports.sameProcessRecord)(record, initialState?.collectors?.[platform])))) {
 			supervisorHeld = true;
 			skippedMetro = "A replacement process appeared during cleanup; its ownership records are retained";
 		}

package/dist/{reload-CWpXoOgN.mjs → reload-ByTqg6ZI.mjs}

@@ -1,12 +1,12 @@
-import { L as deviceSlotPlatforms, R as parseDeviceSlotKey, f as getProject } from "./config-CcefMY2Q.mjs";
-import { f as readWorkspaceLaunches } from "./state-B3XA2wp2.mjs";
-import { a as findProjectRoot } from "./project-fKmuIaMI.mjs";
-import { i as resolveProjectMetro } from "./metro-CORqXyTL.mjs";
-import { l as phaseLine } from "./command-output-8wHMEde0.mjs";
-import { N as resolveOwnedAvdSerial } from "./android-hMj83VpN.mjs";
-import { u as androidAppProcess, y as iosAppProcess } from "./app-install-DIp9riNx.mjs";
+import { F as deviceSlotPlatforms, I as parseDeviceSlotKey, f as getProject } from "./config-6vdGngKa.mjs";
+import { a as findProjectRoot } from "./project-CBFCwnN5.mjs";
+import { d as readWorkspaceLaunches } from "./state-CDbvmZdt.mjs";
+import { i as resolveProjectMetro } from "./metro-DFLmaVz8.mjs";
+import { l as phaseLine } from "./command-output-BuIb_ZOI.mjs";
+import { N as resolveOwnedAvdSerial } from "./android-BkM4qTaN.mjs";
+import { u as androidAppProcess, y as iosAppProcess } from "./app-install--PAocWvq.mjs";
 import { x as resolveOwnedIosSim } from "./ios-Deh5js5V.mjs";
-import { n as nativeRunCommand } from "./slot-launch-CZklomj6.mjs";
+import { n as nativeRunCommand } from "./slot-launch-DeKen9e5.mjs";
 import chalk from "chalk";
 import { WebSocket } from "ws";
 //#region src/engine/reload.ts

package/dist/rolldown-runtime-BsOwBuO_.mjs

@@ -0,0 +1,30 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+export { __require as i, __exportAll as n, __reExport as r, __commonJSMin as t };

package/dist/{server-bare-DEzPZLvf.mjs → server-bare-Buk-k8tI.mjs}

@@ -1,13 +1,10 @@
-import { p as readWorkspaceState } from "./state-B3XA2wp2.mjs";
+import { i as __require, t as __commonJSMin } from "./rolldown-runtime-BsOwBuO_.mjs";
+import { r as readWorkspaceState } from "./workspace-state-Do1e2mOH.mjs";
 import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
-import { C as projectMetroSharedCache } from "./settings-DEJf6_kJ.mjs";
+import { C as projectMetroSharedCache } from "./settings-DwfltIXQ.mjs";
 import { a as metroStoreRoot, o as registerMetroStore, t as appendCacheStore } from "./metro-store-CDDZHtPl.mjs";
 import { createRequire } from "node:module";
 import { dirname, isAbsolute, join, relative, sep } from "node:path";
-//#region \0rolldown/runtime.js
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
-//#endregion
 //#region shim/bundle-response.cjs
 var require_bundle_response = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { randomUUID } = __require("node:crypto");

package/dist/{server-expo-DizT4OMk.mjs → server-expo-D4P7iTvf.mjs}

@@ -1,10 +1,10 @@
 import { t as getExecutor } from "./exec-CyylIdq9.mjs";
 import { r as createNdjsonWriter } from "./ndjson-BZwI1NBv.mjs";
-import { p as readWorkspaceState } from "./state-B3XA2wp2.mjs";
-import { l as resolvePackageJson } from "./project-fKmuIaMI.mjs";
+import { r as readWorkspaceState } from "./workspace-state-Do1e2mOH.mjs";
+import { l as resolvePackageJson } from "./project-CBFCwnN5.mjs";
 import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
 import { n as stripAnsi, t as createLineReader } from "./process-output-C7IlIzd7.mjs";
-import { C as projectMetroSharedCache } from "./settings-DEJf6_kJ.mjs";
+import { C as projectMetroSharedCache } from "./settings-DwfltIXQ.mjs";
 import { a as metroStoreRoot, i as metroStoreConfirmedRoot, n as expoMetroConfigPath, o as registerMetroStore, r as expoMetroStoreEnv } from "./metro-store-CDDZHtPl.mjs";
 import { accessSync, constants, existsSync, readFileSync } from "node:fs";
 import { dirname, join, parse } from "node:path";

package/dist/server-expo-Dho5Raiw.mjs

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

package/dist/{settings-DEJf6_kJ.mjs → settings-DwfltIXQ.mjs}

@@ -1,5 +1,5 @@
-import { d as getConfigPath, g as loadConfig, m as getRepoSettings, p as getProjectSettings } from "./config-CcefMY2Q.mjs";
-import { g as repoRoot, s as gitCommonDir } from "./worktree-Eq6TLH8N.mjs";
+import { d as getConfigPath, g as loadConfig, m as getRepoSettings, p as getProjectSettings } from "./config-6vdGngKa.mjs";
+import { _ as repoRoot, s as gitCommonDir } from "./worktree-DWNx4tUg.mjs";
 import { createHash } from "node:crypto";
 import { isAbsolute } from "node:path";
 import { existsSync, readFileSync, realpathSync, statSync } from "fs";