stim 1.18.0 → 1.20.0

package/dist/{metro-Dh8T4Ytd.mjs → metro-D_j9sN-B.mjs}

@@ -1,12 +1,198 @@
 import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
-import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
-import { M as isOnMountedVolume, N as listMountedVolumes, _ as loadConfig, n as allMetroPorts, r as claimMetroPort, x as releaseMetroPort } from "./config-CgYMahz7.mjs";
-import { r as readWorkspaceState } from "./workspace-state-C59dqG-Z.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { M as isOnMountedVolume, N as listMountedVolumes, _ as loadConfig, n as allMetroPorts, r as claimMetroPort, x as releaseMetroPort } from "./config-D0LhTY3S.mjs";
+import { r as readWorkspaceState } from "./workspace-state-CSIFuuDa.mjs";
 import { sep } from "path";
 import { existsSync, readlinkSync, realpathSync } from "fs";
+import { readFile } from "node:fs/promises";
 import { request } from "http";
-import { connect } from "net";
+import { connect } from "node:net";
+//#region src/listening-ports.ts
+/**
+* Returns occupied TCP ports across local interfaces. Rejects if listener inspection fails.
+*/
+async function readListeningPorts(platform = process.platform) {
+	switch (platform) {
+		case "darwin": return parseDarwinPorts(await readNetstat("/usr/sbin/netstat", [
+			"-anL",
+			"-p",
+			"tcp"
+		]));
+		case "linux": return parseLinuxPorts(await Promise.all([readFile("/proc/net/tcp", "utf8"), readFile("/proc/net/tcp6", "utf8").catch((error) => {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
+			throw error;
+		})]));
+		case "win32": return parseWindowsPorts(await readNetstat("netstat", ["-an"]));
+		default: throw new Error(`TCP listener inspection is not supported on ${platform}.`);
+	}
+}
+const DARWIN_TITLE = "Current listen queue sizes (qlen/incqlen/maxqlen)";
+const DARWIN_COLUMNS = /^Listen\s+Local Address$/;
+const DARWIN_TABLE_CHANGE = /^Some tcp sockets may have been (?:created|deleted|created or deleted)\.?$/;
+const DARWIN_LISTENER = /^\d+\/\d+\/\d+\s+\S+\.(?<port>\d+)$/;
+function parseDarwinPorts(output) {
+	const ports = /* @__PURE__ */ new Set();
+	let title = false;
+	let columns = false;
+	for (const raw of output.split("\n")) {
+		const line = raw.trim();
+		if (line === DARWIN_TITLE) title = true;
+		else if (DARWIN_COLUMNS.test(line)) columns = true;
+		if (!line || line === DARWIN_TITLE || DARWIN_COLUMNS.test(line) || DARWIN_TABLE_CHANGE.test(line)) continue;
+		const listener = DARWIN_LISTENER.exec(line)?.groups;
+		if (!listener) throw new Error("Cannot parse the TCP listen table from netstat.");
+		addPort(ports, Number(listener.port));
+	}
+	if (!title || !columns) throw new Error("netstat printed no TCP listen table.");
+	return ports;
+}
+const LINUX_COLUMNS = /^\s*sl\s+local_address\s+rem(?:ote)?_address\s+st\s/;
+const LINUX_TCP_STATE = /^[0-9A-F]{2}$/i;
+const LINUX_LOCAL_ADDRESS = /^(?:[0-9A-F]{8}|[0-9A-F]{32}):(?<port>[0-9A-F]{4})$/i;
+const LINUX_LISTEN_STATE = "0A";
+function parseLinuxPorts(tables) {
+	const ports = /* @__PURE__ */ new Set();
+	for (const table of tables) {
+		if (table === null) continue;
+		const [header, ...rows] = table.trim().split("\n");
+		if (!header || !LINUX_COLUMNS.test(header)) throw new Error("Cannot parse the TCP socket table from /proc/net.");
+		for (const raw of rows) {
+			const line = raw.trim();
+			if (!line) continue;
+			const [, localAddress, , state] = line.split(/\s+/);
+			if (!state || !LINUX_TCP_STATE.test(state)) throw new Error("Invalid TCP state in /proc/net.");
+			if (state.toUpperCase() !== LINUX_LISTEN_STATE) continue;
+			const listener = localAddress && LINUX_LOCAL_ADDRESS.exec(localAddress)?.groups;
+			if (!listener) throw new Error("Invalid TCP listener in /proc/net.");
+			addPort(ports, Number(`0x${listener.port}`));
+		}
+	}
+	return ports;
+}
+const WINDOWS_COLUMNS = /^Proto\s/;
+const WINDOWS_TCP_ROW = /^TCP\s+\S*:(?<localPort>\d+)\s+\S*:(?<remotePort>\d+)\s+\S/;
+function parseWindowsPorts(output) {
+	const ports = /* @__PURE__ */ new Set();
+	let table = false;
+	for (const raw of output.split("\n")) {
+		const line = raw.trim();
+		if (WINDOWS_COLUMNS.test(line)) table = true;
+		const [protocol] = line.split(/\s+/, 1);
+		if (protocol !== "TCP") continue;
+		table = true;
+		const connection = WINDOWS_TCP_ROW.exec(line)?.groups;
+		if (!connection) throw new Error("Cannot parse the TCP connection table from netstat.");
+		if (Number(connection.remotePort) === 0) addPort(ports, Number(connection.localPort));
+	}
+	if (!table) throw new Error("netstat printed no TCP connection table.");
+	return ports;
+}
+function readNetstat(file, args) {
+	return getExecutor().runFileAsync(file, args, {
+		timeoutMs: 5e3,
+		rejectStderr: true,
+		env: { LC_ALL: "C" }
+	});
+}
+function addPort(ports, port) {
+	if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("Invalid TCP listener port.");
+	ports.add(port);
+}
+function addressPort(address) {
+	const colon = String(address ?? "").lastIndexOf(":");
+	return colon < 0 ? NaN : Number(String(address).slice(colon + 1));
+}
+function parseLsofListeners(out) {
+	const byPort = /* @__PURE__ */ new Map();
+	let pid = null;
+	for (const line of String(out ?? "").split("\n")) if (line.startsWith("p")) pid = parseInt(line.slice(1), 10);
+	else if (line.startsWith("n") && pid !== null && Number.isFinite(pid)) {
+		const port = addressPort(line.slice(1));
+		const pids = byPort.get(port) ?? [];
+		if (!pids.includes(pid)) pids.push(pid);
+		byPort.set(port, pids);
+	}
+	return byPort;
+}
+const PORT_INSPECTION_REMEDY = "Allow Stim to run netstat or lsof, or to connect to 127.0.0.1 and ::1, then retry. A metro.port pin skips the scan for Metro.";
+var PortInspectionError = class extends Error {
+	code = "STIM_PORT_INSPECTION_FAILED";
+	reason;
+	constructor(reason) {
+		super(`${reason} ${PORT_INSPECTION_REMEDY}`);
+		this.reason = reason;
+	}
+};
+/**
+* Returns the TCP ports lsof lists as listening, or null when lsof cannot list them.
+*/
+async function readLsofListeningPorts() {
+	try {
+		const out = await getExecutor().runFileAsync("lsof", [
+			"-nP",
+			"-iTCP",
+			"-sTCP:LISTEN",
+			"-Fpn"
+		], { timeoutMs: 5e3 });
+		return new Set([...parseLsofListeners(out).keys()].filter(Number.isInteger));
+	} catch (error) {
+		const result = error;
+		if (result.status === 1 && !String(result.stdout ?? "").trim() && !String(result.stderr ?? "").trim()) return /* @__PURE__ */ new Set();
+		return null;
+	}
+}
+const IPV6_UNAVAILABLE = /* @__PURE__ */ new Set([
+	"EADDRNOTAVAIL",
+	"EAFNOSUPPORT",
+	"ENETUNREACH"
+]);
+/**
+* Connects to a loopback port: `taken` when something accepts or the connect hangs, `free` when
+* it is refused or IPv6 is unavailable, `unknown` for any other connect error.
+*/
+function probeLoopback(port, host, timeoutMs = 400) {
+	return new Promise((resolve) => {
+		const socket = connect({
+			port,
+			host
+		});
+		const done = (answer) => {
+			socket.removeAllListeners();
+			socket.destroy();
+			resolve(answer);
+		};
+		socket.setTimeout(timeoutMs);
+		socket.once("connect", () => done("taken"));
+		socket.once("timeout", () => done("taken"));
+		socket.once("error", (error) => {
+			const refused = error.code === "ECONNREFUSED" || host === "::1" && IPV6_UNAVAILABLE.has(error.code ?? "");
+			done(refused ? "free" : "unknown");
+		});
+	});
+}
+//#endregion
 //#region src/ports.ts
+/**
+* Creates one lazy listener snapshot for an allocation attempt; discard the probe before retrying.
+* When the native TCP table cannot be read, each port is checked with an lsof listener scan and
+* loopback connects instead. Rejects with `PortInspectionError` only when none of them can answer.
+*/
+function createPortProbe() {
+	let snapshot;
+	let lsof;
+	return async (port) => {
+		const listening = await (snapshot ??= readListeningPorts().catch((error) => error instanceof Error ? error : new Error(String(error))));
+		if (!(listening instanceof Error)) return !listening.has(port);
+		const [listed, ipv4, ipv6] = await Promise.all([
+			lsof ??= readLsofListeningPorts(),
+			probeLoopback(port, "127.0.0.1"),
+			probeLoopback(port, "::1")
+		]);
+		if (listed?.has(port) || ipv4 === "taken" || ipv6 === "taken") return false;
+		if (listed || ipv4 === "free" && ipv6 === "free") return true;
+		throw new PortInspectionError(`Cannot tell whether TCP port ${port} is free: the TCP listener table failed (${listening.message.replace(/\s+/g, " ").trim()}), lsof could not list listeners, and a loopback connect failed.`);
+	};
+}
 function isMetroRunning(port) {
 	return new Promise((resolve) => {
 		const req = request({
@@ -29,25 +215,8 @@ function isMetroRunning(port) {
 		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) {
+async function computeNextPort(isFree = createPortProbe()) {
 	const taken = new Set(allMetroPorts());
 	for (let port = FIRST_PORT; port < 8282; port++) {
 		if (taken.has(port)) continue;
@@ -73,7 +242,7 @@ async function findReclaimablePort(excludeProjectPath, probe = isMetroRunning, {
 	for (const c of candidates) if (!await probe(c.port)) return c;
 	return null;
 }
-async function allocatePort(projectPath, probe = isMetroRunning, isFree = isPortFree) {
+async function allocatePort(projectPath, probe = isMetroRunning, isFree = createPortProbe()) {
 	const reclaim = await findReclaimablePort(projectPath, probe);
 	if (reclaim && await isFree(reclaim.port)) {
 		releaseMetroPort(reclaim.ownerPath, reclaim.port);
@@ -82,7 +251,7 @@ async function allocatePort(projectPath, probe = isMetroRunning, isFree = isPort
 	return computeNextPort(isFree);
 }
 const RESERVE_ATTEMPTS = 5;
-async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree = isPortFree, pinned = null) {
+async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree, 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.`);
@@ -116,10 +285,6 @@ function parseLsofPids(out) {
 	if (!out) return [];
 	return String(out).split("\n").map((s) => parseInt(s.trim(), 10)).filter((n) => Number.isFinite(n));
 }
-function addressPort(address) {
-	const colon = String(address ?? "").lastIndexOf(":");
-	return colon < 0 ? NaN : Number(String(address).slice(colon + 1));
-}
 function parseNetstatPids(out, port) {
 	const pids = [];
 	for (const line of String(out ?? "").split("\n")) {
@@ -132,7 +297,12 @@ function parseNetstatPids(out, port) {
 	return pids;
 }
 function listeningPids(port, platform = process.platform) {
-	const pids = parseLsofPids(getExecutor().runQuiet(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`));
+	const pids = parseLsofPids(getExecutor().runFileQuiet("lsof", [
+		"-nP",
+		`-iTCP:${port}`,
+		"-sTCP:LISTEN",
+		"-t"
+	]));
 	if (pids.length > 0 || platform !== "win32") return pids;
 	return parseNetstatPids(getExecutor().runQuiet("netstat -ano"), port);
 }
@@ -147,18 +317,6 @@ function parseLsofCwd(out) {
 function lsofOutput(args) {
 	return getExecutor().runFileAsync("lsof", args).catch((error) => typeof error?.stdout === "string" ? error.stdout : null);
 }
-function parseLsofListeners(out) {
-	const byPort = /* @__PURE__ */ new Map();
-	let pid = null;
-	for (const line of String(out ?? "").split("\n")) if (line.startsWith("p")) pid = parseInt(line.slice(1), 10);
-	else if (line.startsWith("n") && pid !== null && Number.isFinite(pid)) {
-		const port = addressPort(line.slice(1));
-		const pids = byPort.get(port) ?? [];
-		if (!pids.includes(pid)) pids.push(pid);
-		byPort.set(port, pids);
-	}
-	return byPort;
-}
 /**
 * `listeningPids` for several ports with one lsof call. A port lsof could not be asked about is
 * missing from the map.
@@ -218,7 +376,14 @@ 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`));
+	return parseLsofCwd(getExecutor().runFileQuiet("lsof", [
+		"-a",
+		"-p",
+		String(pid),
+		"-d",
+		"cwd",
+		"-Fn"
+	]));
 }
 function canonicalPath(path) {
 	try {
@@ -286,6 +451,7 @@ async function resolveProjectMetro(port, projectPath, { probe = isMetroRunning,
 * always forceful.
 */
 function signalProcessTree(pid, signal = "SIGTERM", { group = false, platform = process.platform } = {}) {
+	if (!Number.isSafeInteger(pid) || pid <= 1) throw new Error(`Refusing to signal pid ${pid}.`);
 	if (platform !== "win32") return process.kill(group ? -pid : pid, signal);
 	return getExecutor().runFileQuiet("taskkill", [
 		"/PID",
@@ -306,4 +472,4 @@ function killMetroTree(leader, processToken) {
 	}
 }
 //#endregion
-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 };
+export { listeningPidsByPort as a, processCwd as c, signalProcessTree as d, createPortProbe as f, PortInspectionError as g, PORT_INSPECTION_REMEDY as h, listeningPids as i, processCwds as l, reserveMetroPort as m, isInsideProject as n, parseNetstatPids as o, isMetroRunning as p, killMetroTree as r, pidExists as s, NOT_OURS_FOREIGN_CWD as t, resolveProjectMetro as u };

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

@@ -1,6 +1,6 @@
 import { t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
-import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-C59dqG-Z.mjs";
-import { w as realIo } from "./client-DzhapoMB.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-CSIFuuDa.mjs";
+import { l as realIo } from "./tailnet-CoJUb2tB.mjs";
 import { HOSTED_METRO_REQUESTS_KEY, findPeer, hostedMetroGateways, hostedMetroRequests, isJsonObject, parseMachine } from "@stim-cli/core/state";
 import { randomBytes, randomUUID } from "node:crypto";
 import { isIP } from "node:net";

package/dist/miss-reason-BPAzZS0r.mjs

@@ -0,0 +1,238 @@
+import { ht as gitCommonDirOnDisk } from "./settings-Bbztm4oV.mjs";
+import { C as diffFingerprintSources, I as storedSources } from "./device-lease-DHOBXGgS.mjs";
+import { m as sharedBuildCache } from "./workspace-state-CSIFuuDa.mjs";
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { LAST_BUILD_KEYS, loadConfig, readWorkspaceState } from "@stim-cli/core/state";
+import * as expoFingerprint from "@expo/fingerprint";
+//#region src/cache/miss-reason.ts
+const MISS_CHANGE_CAP = 20;
+function recordedBuilds(state, platform) {
+	const builds = [];
+	for (const value of [state?.[LAST_BUILD_KEYS[platform]], state?.lastBuild]) {
+		const record = value;
+		if (record?.platform !== platform) continue;
+		const startedAt = typeof record.startedAt === "string" ? record.startedAt : "";
+		if (typeof record.fingerprint === "string" && typeof record.cacheKey === "string") builds.push({
+			fingerprint: record.fingerprint,
+			cacheKey: record.cacheKey,
+			startedAt
+		});
+		const carried = record.missReason?.baseline;
+		if (typeof carried?.fingerprint === "string" && typeof carried.cacheKey === "string") builds.push({
+			fingerprint: carried.fingerprint,
+			cacheKey: carried.cacheKey,
+			startedAt
+		});
+	}
+	return builds;
+}
+function projectIdentity(root) {
+	let real;
+	try {
+		real = realpathSync.native(root);
+	} catch {
+		return null;
+	}
+	for (let dir = real;; dir = dirname(dir)) {
+		if (existsSync(join(dir, ".git"))) {
+			const common = gitCommonDirOnDisk(dir);
+			return common ? `${common}\n${relative(dir, real)}` : null;
+		}
+		if (dirname(dir) === dir) return null;
+	}
+}
+function findMissBaseline(root, platform, { readState = readWorkspaceState, projectRoots = () => Object.keys(loadConfig()?.projects ?? {}), identity = projectIdentity, sourcesOf = (p, key) => storedSources(p, key, sharedBuildCache()) } = {}) {
+	for (const build of recordedBuilds(readState(root), platform)) {
+		const sources = sourcesOf(platform, build.cacheKey);
+		if (sources) return {
+			fingerprint: build.fingerprint,
+			cacheKey: build.cacheKey,
+			sources,
+			from: "workspace"
+		};
+	}
+	const project = identity(root);
+	if (!project) return null;
+	const others = [];
+	for (const other of projectRoots()) {
+		if (other === root || identity(other) !== project) continue;
+		others.push(...recordedBuilds(readState(other), platform));
+	}
+	for (const build of others.toSorted((a, b) => (Date.parse(b.startedAt) || 0) - (Date.parse(a.startedAt) || 0))) {
+		const sources = sourcesOf(platform, build.cacheKey);
+		if (sources) return {
+			fingerprint: build.fingerprint,
+			cacheKey: build.cacheKey,
+			sources,
+			from: "project"
+		};
+	}
+	return null;
+}
+const CATEGORY_RANK = {
+	"native-dependency": 0,
+	"app-config": 1,
+	"config-plugin": 2,
+	package: 3,
+	"native-dir": 4,
+	file: 5,
+	"app-asset": 6,
+	other: 7,
+	"package-scripts": 8,
+	autolinking: 9
+};
+function packageIn(path) {
+	return [...path.matchAll(/(?:^|\/)node_modules\/((?:@[^/]+\/)?[^/]+)/g)].at(-1)?.[1] ?? null;
+}
+function describeChange({ name, change, reasons }) {
+	const pkg = packageIn(name);
+	if (name === "expoConfig" || reasons.includes("expoConfig")) return {
+		category: "app-config",
+		label: "app config changed"
+	};
+	if (pkg && reasons.some((reason) => /^(expo|rncore)Autolinking(Ios|Android)?$/.test(reason))) return {
+		category: "native-dependency",
+		label: `native dependency ${change}: ${pkg}`
+	};
+	if (pkg && reasons.includes("expoConfigPlugins")) return {
+		category: "config-plugin",
+		label: `config plugin ${change}: ${pkg}`
+	};
+	if (/^(expoAutolinkingConfig|rncoreAutolinkingConfig)(:|$)/.test(name)) return {
+		category: "autolinking",
+		label: "autolinking config changed"
+	};
+	if (name.startsWith("package:")) return {
+		category: "package",
+		label: `${name.slice(8)} ${change}`
+	};
+	if (name === "packageJson:scripts") return {
+		category: "package-scripts",
+		label: "package.json scripts changed"
+	};
+	if (reasons.includes("expoConfigExternalFile")) return {
+		category: "app-asset",
+		label: `app asset ${change}: ${name}`
+	};
+	if (reasons.includes("bareNativeDir")) return {
+		category: "native-dir",
+		label: `${name}/ ${change}`
+	};
+	if (reasons.length || name.includes("/") || name.includes(".")) return {
+		category: "file",
+		label: `${name} ${change}`
+	};
+	return {
+		category: "other",
+		label: `${name} ${change}`
+	};
+}
+function rekeyPrefix(rekeyedBy) {
+	return rekeyedBy.length ? `${rekeyedBy.join(" and ")} changed native inputs; ` : "";
+}
+function missReasonFromChanges({ changes, baseline, rekeyedBy = [] }) {
+	const prefix = rekeyPrefix(rekeyedBy);
+	if (!baseline) return {
+		kind: "no-baseline",
+		summary: `${prefix}no earlier build of this project in the cache to compare with`,
+		changes: [],
+		changeCount: 0,
+		baseline: null,
+		rekeyedBy
+	};
+	if (!changes.length) return {
+		kind: "same-sources",
+		summary: `${prefix}native inputs match the last build; no cached app for this configuration or target`,
+		changes: [],
+		changeCount: 0,
+		baseline,
+		rekeyedBy
+	};
+	const described = changes.map((change, index) => ({
+		change,
+		index,
+		...describeChange(change)
+	})).toSorted((a, b) => CATEGORY_RANK[a.category] - CATEGORY_RANK[b.category] || a.index - b.index);
+	const dependencyMoved = described.some((entry) => entry.category === "native-dependency");
+	const labels = [...new Set(described.filter((entry) => !(dependencyMoved && entry.category === "autolinking")).map((entry) => entry.label))];
+	const more = labels.length > 1 ? ` (+${labels.length - 1} more)` : "";
+	return {
+		kind: "changed",
+		summary: `${prefix}${labels[0]}${more}`,
+		changes: described.slice(0, MISS_CHANGE_CAP).map(({ change, category }) => ({
+			source: change.name,
+			change: change.change,
+			category
+		})),
+		changeCount: changes.length,
+		baseline,
+		rekeyedBy
+	};
+}
+function explainBuildMiss({ root, platform, current, rekeyedBy = [], baselineDeps, differ = expoFingerprint.diffFingerprints }) {
+	const baseline = findMissBaseline(root, platform, baselineDeps);
+	const changes = baseline ? diffFingerprintSources({
+		previous: baseline.sources,
+		previousHash: baseline.fingerprint,
+		current,
+		differ
+	}) : [];
+	return {
+		reason: missReasonFromChanges({
+			changes,
+			baseline: baseline ? {
+				fingerprint: baseline.fingerprint,
+				cacheKey: baseline.cacheKey,
+				from: baseline.from
+			} : null,
+			rekeyedBy
+		}),
+		changedNames: changes.map((change) => change.name),
+		previousHash: baseline?.fingerprint ?? null
+	};
+}
+function predictBuildMiss({ root, platform, current, prebuild }) {
+	const { reason } = explainBuildMiss({
+		root,
+		platform,
+		current
+	});
+	const baseline = reason.baseline && {
+		fingerprint: reason.baseline.fingerprint,
+		from: reason.baseline.from
+	};
+	if (!prebuild || !baseline) return {
+		...reason,
+		baseline
+	};
+	const dir = platform === "ios" ? "ios/" : "android/";
+	return {
+		...reason,
+		kind: "prebuild-pending",
+		summary: `${reason.summary} (before prebuild ${prebuild}s ${dir})`,
+		baseline
+	};
+}
+function skippedMissReason(summary) {
+	return {
+		kind: "cache-skipped",
+		summary,
+		changes: [],
+		changeCount: 0,
+		baseline: null,
+		rekeyedBy: []
+	};
+}
+function fingerprintErrorMissReason(message) {
+	return {
+		kind: "fingerprint-error",
+		summary: `fingerprinting failed: ${message}`,
+		changes: [],
+		changeCount: 0,
+		baseline: null,
+		rekeyedBy: []
+	};
+}
+//#endregion
+export { skippedMissReason as i, fingerprintErrorMissReason as n, predictBuildMiss as r, explainBuildMiss as t };

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

@@ -1,7 +1,7 @@
 import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
-import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
-import { C as saveConfig, D as withConfigLock, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-CgYMahz7.mjs";
-import { f as isPortFree, i as listeningPids, u as signalProcessTree } from "./metro-Dh8T4Ytd.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { C as saveConfig, D as withConfigLock, _ as loadConfig, c as ensureConfig, d as getConfigDir, p as getProject } from "./config-D0LhTY3S.mjs";
+import { d as signalProcessTree, f as createPortProbe, o as parseNetstatPids } from "./metro-D_j9sN-B.mjs";
 import { n as declareSpawnsOn, o as stopDeclaringSpawnsOn } from "./spawn-claims-Kqiifsk2.mjs";
 import { realpathSync } from "node:fs";
 import { join } from "node:path";
@@ -69,7 +69,14 @@ function validatePortLabel(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, platform) {
-	if (platform === "win32") return listeningPids(port, platform);
+	if (platform === "win32") {
+		const out = getExecutor().runFile("netstat", ["-ano"], {
+			timeoutMs: 5e3,
+			rejectStderr: true
+		});
+		if (!/^\s*(?:Proto|TCP)\s/m.test(out)) throw new Error("netstat printed no TCP connection table.");
+		return parseNetstatPids(out, port);
+	}
 	let out;
 	try {
 		out = getExecutor().runFile("lsof", [
@@ -126,7 +133,7 @@ function releaseBrowserPort(projectPath, port) {
 		saveConfig(cfg);
 	}));
 }
-async function allocateNamedPort(projectPath, label, { isFree = async (port) => await isPortFree(port) && portListeners(port, process.platform).length === 0 }) {
+async function allocateNamedPort(projectPath, label, { isFree = createPortProbe() }) {
 	const root = realpathSync(projectPath);
 	return withPortsLock(async () => {
 		const existing = getProject(root)?.ports;