stim 1.13.0 → 1.15.0

package/dist/pull-requests.d.mts

@@ -0,0 +1,120 @@
+//#region src/workspace/pull-request.d.ts
+interface GhPullRequest {
+  number: number;
+  state: string;
+  url: string;
+  headRefOid: string;
+  mergedAt: string | null;
+  closedAt: string | null;
+  isCrossRepository?: boolean;
+  isDraft?: boolean;
+  headRepository?: {
+    name?: string | null;
+  } | null;
+  headRepositoryOwner?: {
+    login?: string | null;
+  } | null;
+  title?: string;
+  reviewDecision?: string | null;
+  commits?: {
+    nodes?: {
+      commit?: {
+        statusCheckRollup?: GhCheckRollup | null;
+      };
+    }[];
+  };
+}
+interface GhStateCount {
+  state: string;
+  count: number;
+}
+interface GhCheckRollup {
+  contexts?: {
+    checkRunCountsByState?: GhStateCount[];
+    statusContextCountsByState?: GhStateCount[];
+  };
+}
+interface CheckCounts {
+  passing: number;
+  failing: number;
+  pending: number;
+}
+/**
+ * The pull request whose head branch is the worktree's branch and whose commits include the worktree's HEAD.
+ * `containsHead` is false when the pull request's head is an ancestor of HEAD: HEAD has commits the pull request
+ * never had. `endedAt` is when it was merged or closed, in epoch milliseconds, and null while it is open.
+ */
+interface PullRequestFact {
+  number: number;
+  state: "open" | "merged" | "closed";
+  draft: boolean;
+  url: string;
+  head: string;
+  containsHead: boolean;
+  endedAt: number | null;
+  /** Present when the lookup asked for detail. */
+  title?: string;
+  reviewDecision?: "approved" | "changes-requested" | "review-required" | null;
+  checks?: CheckCounts | null;
+}
+/** Sums a head commit's check runs and commit statuses by outcome; null when the commit has no checks. */
+declare function checkCounts(rollup: GhCheckRollup | null | undefined): CheckCounts | null;
+type PullRequestLookup = {
+  pullRequest: PullRequestFact | null;
+} | {
+  unavailable: string;
+};
+/**
+ * Picks the pull request that describes `head` among those `gh pr list --head <branch>` returned. One whose head is
+ * `head` wins, then one whose head contains `head`, then one whose head `head` contains. An open one wins a tier,
+ * then the newest. A pull request unrelated to `head` is from an earlier use of the branch name and is ignored. A
+ * cross-repository pull request is kept only when its head repository is one of `ownRepos` (this checkout's own git
+ * remotes, lowercased "owner/name"); otherwise it only shares the branch name with a stranger's fork and is ignored.
+ * `isAncestor(a, b)` answers whether commit `a` is an ancestor of commit `b`, and false when git cannot tell.
+ */
+declare function selectPullRequest(pulls: readonly GhPullRequest[], head: string, isAncestor: (ancestor: string, descendant: string) => boolean, ownRepos?: ReadonlySet<string>): PullRequestFact | null;
+/**
+ * "owner/name", lowercased, parsed out of a git remote URL, or null when it doesn't match: https, `ssh://`, or
+ * scp-like (`[user@]host:owner/name`, which also covers an `~/.ssh/config` host alias in place of `user@host`).
+ */
+declare function parseRemoteRepo(url: string): string | null;
+/**
+ * Asks GitHub, through `gh`, which pull requests have `branch` as their head, run from `cwd` so `gh` picks the
+ * repository from its remotes. Each call is one fixed `gh pr list` invocation. Once `gh` is missing, signed out or
+ * times out, every later lookup through the same function answers `unavailable` without running it again.
+ */
+declare function pullRequestLookup(): (cwd: string, branch: string, head: string) => PullRequestLookup;
+/** A worktree whose pull request {@link pullRequestLookups} looks up: its path, branch and HEAD commit. */
+interface PullRequestQuery {
+  cwd: string;
+  branch: string;
+  head: string;
+}
+/**
+ * {@link pullRequestLookup} for every branch of one repository in one fixed `gh api graphql` call run from `repo`,
+ * which asks for the same 20 newest pull requests of each head branch that `gh pr list --head` returns. `gh` fills
+ * `{owner}` and `{repo}` from the remotes of `repo`; branch names travel as variables. Once `gh` is missing, signed
+ * out or times out, every later call through the same function answers `unavailable` without running it again.
+ * With `detail`, it also asks for each pull request's title, review decision and head commit check counts.
+ */
+declare function pullRequestLookups({ detail }?: {
+  detail?: boolean;
+}): (repo: string, queries: readonly PullRequestQuery[]) => Promise<PullRequestLookup[]>;
+/** The merged or closed pull request whose commits include HEAD, which makes the worktree removable. */
+declare function endedPullRequest(lookup: PullRequestLookup | null): PullRequestFact | null;
+/** "PR #123 merged", for reports. */
+declare function describePullRequest(pr: Pick<PullRequestFact, "number" | "state">): string;
+/** A linked worktree whose pull request {@link worktreePullRequests} looks up. */
+interface WorktreeBranch {
+  path: string;
+  branch: string;
+  repository: string;
+}
+/**
+ * Looks up the pull request of each worktree's branch and HEAD, with one {@link pullRequestLookups} call per
+ * repository. The map holds null for a worktree without one, and leaves out a worktree whose HEAD git cannot read
+ * or whose lookup was unavailable.
+ */
+declare function worktreePullRequests(): (worktrees: readonly WorktreeBranch[]) => Promise<Map<string, PullRequestFact | null>>;
+//#endregion
+export { CheckCounts, GhCheckRollup, GhPullRequest, PullRequestFact, PullRequestLookup, PullRequestQuery, WorktreeBranch, checkCounts, describePullRequest, endedPullRequest, parseRemoteRepo, pullRequestLookup, pullRequestLookups, selectPullRequest, worktreePullRequests };

package/dist/pull-requests.mjs

@@ -0,0 +1,2 @@
+import { a as pullRequestLookup, c as worktreePullRequests, i as parseRemoteRepo, n as describePullRequest, o as pullRequestLookups, r as endedPullRequest, s as selectPullRequest, t as checkCounts } from "./pull-request-pxnDCQzn.mjs";
+export { checkCounts, describePullRequest, endedPullRequest, parseRemoteRepo, pullRequestLookup, pullRequestLookups, selectPullRequest, worktreePullRequests };

package/dist/recordings-GEXp4iBT.mjs

@@ -0,0 +1,37 @@
+import { c as gitCommonDirOnDisk } from "./worktree-C0c5Udwa.mjs";
+import { existsSync, rmSync } from "node:fs";
+import { loadConfig, recordingEnabled, workspaceRecordingsDir } from "@stim-cli/core/state";
+//#region src/workspace/recordings.ts
+/** `recording.enabled` for one registered workspace, from `STIM_RECORDING` and its workspace, repo and machine layers. */
+function workspaceRecordingEnabled(path, project, config, env) {
+	const repo = gitCommonDirOnDisk(path);
+	return recordingEnabled(env, [
+		project.settings,
+		repo ? config?.repos?.[repo]?.settings : void 0,
+		config
+	]);
+}
+/** Every registered workspace's `recording.enabled` from the settings files alone, without `STIM_RECORDING`. */
+function recordingLayers() {
+	const config = loadConfig();
+	return new Map(Object.entries(config?.projects ?? {}).map(([path, project]) => [path, workspaceRecordingEnabled(path, project, config, {})]));
+}
+/**
+* Deletes the recordings of every workspace a settings write turned off, comparing the settings files before
+* (`before`, from {@link recordingLayers}) and after it, and returns those workspaces. stim-server stops
+* recording them once `stim status` shows the change.
+*/
+function deleteTurnedOffRecordings(before) {
+	return [...recordingLayers()].flatMap(([path, enabled]) => {
+		if (enabled || before.get(path) === false) return [];
+		const dir = workspaceRecordingsDir(path);
+		if (!existsSync(dir)) return [];
+		rmSync(dir, {
+			recursive: true,
+			force: true
+		});
+		return [path];
+	});
+}
+//#endregion
+export { recordingLayers as n, workspaceRecordingEnabled as r, deleteTurnedOffRecordings as t };

package/dist/{reload-C-cV5yy_.mjs → reload-ChPiwvot.mjs}

@@ -1,14 +1,15 @@
-import { B as deviceSlotPlatforms, V as parseDeviceSlotKey, p as getProject } from "./config-0jCcMM0E.mjs";
-import { c as resolveProjectMetro, g as recordWorkspaceUse } from "./metro-BPeY1YMh.mjs";
-import { i as findCommandWorkspace } from "./project-DGeclhvO.mjs";
-import { f as readWorkspaceLaunches } from "./state-DwAU2_-D.mjs";
-import { f as refuseNoProject, l as phaseLine } from "./command-output-BIL7rlX7.mjs";
-import { q as resolveOwnedAvdSerial } from "./android-qx_31wJo.mjs";
-import { a as readWebRecord, l as webFacts, r as cdpEndpoint } from "./state-l1pYwOre.mjs";
-import { S as resolveOwnedIosSim } from "./ios-CmEzZiOj.mjs";
-import { h as iosAppProcess, o as androidAppProcess } from "./app-install-CDFY2nUL.mjs";
-import { n as nativeRunCommand } from "./slot-launch-BIWEW-wI.mjs";
-import { n as sendToOwnedPage, t as liveWebRecord } from "./page-BTu7I60K.mjs";
+import { B as parseDeviceSlotKey, p as getProject, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
+import { i as recordWorkspaceUse } from "./workspace-state-CL2V2Ons.mjs";
+import { i as findCommandWorkspace } from "./project-CV3tDFHl.mjs";
+import { f as readWorkspaceLaunches } from "./state-CaeaHbDA.mjs";
+import { f as refuseNoProject, l as phaseLine } from "./command-output-CliHHn7a.mjs";
+import { J as resolveOwnedAvdSerial } from "./android-Db2eEMaf.mjs";
+import { l as resolveProjectMetro } from "./metro-Di8EN2Tb.mjs";
+import { o as readWebRecord, r as cdpEndpoint, u as webFacts } from "./state-DFm77wRn.mjs";
+import { w as resolveOwnedIosSim } from "./ios-3CtCRhwr.mjs";
+import { p as ensureMetroReverse, s as androidAppProcess, v as iosAppProcess } from "./app-install-CAAplXAt.mjs";
+import { n as nativeRunCommand } from "./slot-launch-BY0BrOLh.mjs";
+import { n as sendToOwnedPage, t as liveWebRecord } from "./page-QF_Ke10s.mjs";
 import chalk from "chalk";
 import { WebSocket } from "ws";
 //#region src/engine/reload.ts
@@ -31,7 +32,11 @@ function peerMatches(query, role, appId) {
 	if (role === "ios") return query.get("role")?.toLowerCase() === "ios";
 	return query.get("app") === appId;
 }
-function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS }) {
+/**
+* Asks Metro for its peers and reloads the ones matching `role` and `appId`. With `peersOnly`, it sends nothing and
+* only reports the outcome a reload would have, so a caller can wait for the app to connect.
+*/
+function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS, peersOnly = false }) {
 	const roleName = ROLE_NAMES[role];
 	return new Promise((resolve) => {
 		const requestId = `stim-reload-${process.pid}-${Date.now()}`;
@@ -72,6 +77,15 @@ function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS })
 					const query = peerQuery(metadata);
 					return query ? peerMatches(query, role, appId) : false;
 				});
+				if (rolePeers.length === 0 && peersOnly) {
+					finish({
+						failed: true,
+						noPeer: true,
+						peers,
+						reason: `No ${roleName} React Native app is connected to Metro on port ${port}.`
+					});
+					return;
+				}
 				if (rolePeers.length === 0) {
 					socket.send(JSON.stringify({
 						version: 2,
@@ -86,7 +100,7 @@ function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS })
 					});
 					return;
 				}
-				for (const [id] of rolePeers) socket.send(JSON.stringify({
+				if (!peersOnly) for (const [id] of rolePeers) socket.send(JSON.stringify({
 					version: 2,
 					method: "reload",
 					target: id
@@ -98,7 +112,7 @@ function reloadThroughMetro(port, { role, appId, timeoutMs = METRO_TIMEOUT_MS })
 				});
 				return;
 			}
-			socket.send(JSON.stringify({
+			if (!peersOnly) socket.send(JSON.stringify({
 				version: 2,
 				method: "reload"
 			}));
@@ -130,8 +144,16 @@ const DEFAULT_DEPS = {
 		const facts = webFacts(readWebRecord(root));
 		return facts?.status === "unverified" ? "unverified" : liveWebRecord(facts?.record ?? null);
 	},
-	reloadPage: (record) => sendToOwnedPage(record, "Page.reload")
+	reloadPage: (record) => sendToOwnedPage(record, "Page.reload"),
+	ensureReverse: (serial, metroPort) => ensureMetroReverse({
+		serial,
+		metroPort
+	}),
+	sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
 };
+const RECONNECT_POLL_MS = 500;
+const RECONNECT_POLLS = 16;
+const RECONNECT_UNOBSERVED_MS = 2500;
 function failure(code, message, remedy) {
 	return {
 		code,
@@ -143,8 +165,9 @@ function describe(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 async function reloadBrowser(browser, metroPort, d) {
+	let pageUrl;
 	try {
-		await d.reloadPage(browser);
+		pageUrl = await d.reloadPage(browser);
 	} catch (error) {
 		return {
 			ok: false,
@@ -157,10 +180,11 @@ async function reloadBrowser(browser, metroPort, d) {
 			platform: "web",
 			deviceId: cdpEndpoint(browser.cdpPort),
 			deviceName: browser.version ?? "Chrome",
-			appId: browser.url,
+			appId: pageUrl,
 			metroPort: metroPort !== null && new URL(browser.url).port === String(metroPort) ? metroPort : null,
 			strategy: "cdp",
-			targets: 1
+			targets: 1,
+			reverseRestored: []
 		}
 	};
 }
@@ -312,10 +336,32 @@ async function runReload({ root, platform = null, deps = {} }) {
 		ok: false,
 		error: stopped
 	};
-	const reloaded = await d.reloadMetro(port, {
+	const reverseRestored = [];
+	const reverseChecked = target.platform === "android" ? live.filter((c) => c.platform === "android" && !c.record.release && c.record.metroPort === port) : [];
+	for (const candidate of reverseChecked) {
+		const serial = candidate.record.deviceId;
+		const ensured = d.ensureReverse(serial, port);
+		if (ensured.failed) return {
+			ok: false,
+			error: failure("STIM_RELOAD_FAILED", `Stim could not check or restore the adb reverse for Metro port ${port} on ${serial}: ${ensured.reason}`, `Run \`adb -s ${serial} reverse tcp:${port} tcp:${port}\`, then \`stim reload android\` again.`)
+		};
+		if (ensured.restored) reverseRestored.push(serial);
+	}
+	const request = {
 		role: target.platform,
 		appId: target.record.appId
-	});
+	};
+	const expectedPeers = reverseChecked.filter((c) => c.record.appId === target.record.appId).length;
+	for (let poll = 0; reverseRestored.length && poll < RECONNECT_POLLS; poll++) {
+		const peers = await d.reloadMetro(port, {
+			...request,
+			peersOnly: true
+		});
+		if (peers.broadcast) await d.sleep(RECONNECT_UNOBSERVED_MS);
+		if (peers.unreachable || peers.broadcast || peers.ok && peers.targets >= expectedPeers) break;
+		await d.sleep(RECONNECT_POLL_MS);
+	}
+	const reloaded = await d.reloadMetro(port, request);
 	if (!reloaded.ok) {
 		const stoppedAfterMetro = processFailure(target.platform, target.record, d, target.slot);
 		if (stoppedAfterMetro) return {
@@ -342,7 +388,8 @@ async function runReload({ root, platform = null, deps = {} }) {
 			appId: target.record.appId,
 			metroPort: port,
 			strategy,
-			targets: reloaded.targets ?? null
+			targets: reloaded.targets ?? null,
+			reverseRestored
 		}
 	};
 }
@@ -386,7 +433,8 @@ function registerReload(program, deps = {}) {
 				return;
 			}
 			const scope = facts.strategy === "metro-broadcast" ? ` This Metro cannot name its connected apps, so the reload request was broadcast to all of them and Stim cannot confirm ${facts.appId} was one. Check the expected UI on ${facts.deviceId}; if nothing changed, reload from the app's own error screen or dev menu.` : facts.targets && facts.targets > 1 ? ` ${facts.targets} devices are running this app on that Metro and the reload request addressed all of them, not only ${facts.deviceId}.` : "";
-			console.log(`Reload requested for ${facts.appId} on ${facts.deviceName} (${facts.deviceId}) via ${facts.strategy}; ${facts.platform} Metro port ${facts.metroPort}.${scope} Completion is not observed; verify the expected UI and run stim logs --errors.`);
+			const restored = facts.reverseRestored.length ? ` The adb reverse for tcp:${facts.metroPort} was missing on ${facts.reverseRestored.join(", ")}, so Stim restored it first.` : "";
+			console.log(`Reload requested for ${facts.appId} on ${facts.deviceName} (${facts.deviceId}) via ${facts.strategy}; ${facts.platform} Metro port ${facts.metroPort}.${restored}${scope} Completion is not observed; verify the expected UI and run stim logs --errors.`);
 		}
 	});
 }

package/dist/{remote-cache--aehr4Pr.mjs → remote-cache-CO2elm_b.mjs}

@@ -1,9 +1,9 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
-import { M as workspaceLogsDir } from "./metro-BPeY1YMh.mjs";
-import { f as resolvePackageJson } from "./project-DGeclhvO.mjs";
+import { C as workspaceLogsDir } from "./workspace-state-CL2V2Ons.mjs";
+import { f as resolvePackageJson } from "./project-CV3tDFHl.mjs";
 import { n as stripAnsi } from "./process-output-Fpl8PYi8.mjs";
-import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-DUCg52-K.mjs";
+import { n as expoBinFromPackage, r as expoBinPath, s as findBinUpward } from "./server-expo-DhtX6bom.mjs";
 import { createRequire } from "node:module";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";

package/dist/run-B-xqRrsg.mjs

@@ -0,0 +1,119 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
+import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
+import { i as macosRuntimeClaim, n as macosLogFile, o as updateMacosRecord, r as macosProcess } from "./state-BxCgeTQu.mjs";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
+import { readMacosRecord } from "@stim-cli/core/state";
+import { StringDecoder } from "node:string_decoder";
+//#region src/macos/run.ts
+function logLines(stream, write) {
+	const decoder = new StringDecoder("utf8");
+	let pending = "";
+	stream.on("data", (chunk) => {
+		pending += decoder.write(chunk);
+		while (pending.length > 65536 && !pending.includes("\n")) {
+			write(pending.slice(0, 65536));
+			pending = pending.slice(65536);
+		}
+		const lines = pending.split("\n");
+		pending = lines.pop() ?? "";
+		for (const line of lines) write(line.replace(/\r$/, ""));
+	});
+	stream.on("end", () => {
+		pending += decoder.end();
+		if (pending) write(pending);
+	});
+}
+async function runMacosSupervisor(root, launchId) {
+	const record = readMacosRecord(root);
+	if (!record || record.launchId !== launchId || record.build.state !== "ok") throw new Error("The macOS launch record changed before its supervisor started.");
+	const owner = macosProcess(process.pid);
+	const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+		root: macosRuntimeClaim(root),
+		mode: "exclusive",
+		label: "macOS app"
+	});
+	if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+	const claim = attempt.acquired;
+	if (!claim) throw new Error(`The macOS runtime is already held at ${attempt.held?.path ?? macosRuntimeClaim(root)}.`);
+	const writer = createNdjsonWriter(macosLogFile(root), { maxBytes: LOG_ROTATE_BYTES });
+	let app;
+	let stopping = false;
+	let spawned = false;
+	let childExited = false;
+	try {
+		if (!(0, process_identity_exports.sameProcessRecord)(readMacosRecord(root)?.supervisor, record.supervisor) || !updateMacosRecord(root, record.supervisor, { supervisor: owner })) throw new Error("The macOS launch owner changed.");
+		(0, ownership_claim_exports.markClaimChildPending)(claim);
+		const child = getExecutor().spawn(record.executable, record.arguments, {
+			cwd: root,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				NSUnbufferedIO: "YES"
+			}
+		});
+		spawned = child.pid !== void 0;
+		const ended = new Promise((resolve, reject) => {
+			child.once("error", reject);
+			child.once("close", () => {
+				childExited = true;
+				resolve();
+			});
+		});
+		if (!child.pid) {
+			await ended;
+			throw new Error("The macOS app did not start.");
+		}
+		app = macosProcess(child.pid);
+		(0, ownership_claim_exports.setClaimChild)(claim, app);
+		if (!updateMacosRecord(root, owner, { app })) {
+			if ((0, process_identity_exports.inspectProcessIdentity)(app) === "same") process.kill(app.pid, "SIGTERM");
+			throw new Error("The macOS launch owner changed.");
+		}
+		const log = (level, msg) => writer.write({
+			src: "client",
+			platform: "macos",
+			level,
+			msg
+		});
+		if (child.stdout) logLines(child.stdout, (line) => log("info", line));
+		if (child.stderr) logLines(child.stderr, (line) => log("warn", line));
+		const stop = async () => {
+			if (stopping) return;
+			stopping = true;
+			for (const signal of ["SIGTERM", "SIGKILL"]) {
+				if (!app || (0, process_identity_exports.inspectProcessIdentity)(app) !== "same") return;
+				process.kill(app.pid, signal);
+				if (await (0, process_identity_exports.waitForProcessExit)(app, 5e3)) return;
+			}
+		};
+		process.on("SIGTERM", stop);
+		process.on("SIGINT", stop);
+		log("info", `Started ${record.product} (pid ${app.pid}).`);
+		await ended;
+		process.off("SIGTERM", stop);
+		process.off("SIGINT", stop);
+		log(stopping || child.exitCode === 0 ? "info" : "error", `Exited ${record.product} (${child.exitCode ?? child.signalCode ?? "unknown"}).`);
+		updateMacosRecord(root, owner, {
+			app: void 0,
+			supervisor: void 0
+		});
+	} finally {
+		if (!spawned || childExited || app && ["gone", "different"].includes((0, process_identity_exports.inspectProcessIdentity)(app))) {
+			(0, ownership_claim_exports.clearClaimChild)(claim);
+			(0, ownership_claim_exports.releaseClaim)(claim);
+		}
+		writer.close();
+	}
+}
+if (process.argv[1]?.endsWith("/macos-run.mjs") || process.argv[1]?.endsWith("/macos/run.ts")) {
+	const [root, launchId] = process.argv.slice(2);
+	if (!root || !launchId) throw new Error("macos-run needs a workspace and launch identity.");
+	await runMacosSupervisor(root, launchId);
+}
+//#endregion
+export { runMacosSupervisor as n, logLines as t };

package/dist/{server-bare-Bq8BpSIo.mjs → server-bare-X7PUgizL.mjs}

@@ -1,20 +1,44 @@
 import { i as __require, t as __commonJSMin } from "./rolldown-runtime-BsOwBuO_.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
-import { w as projectMetroSharedCache } from "./settings-xB0Frkg6.mjs";
-import { a as metroStoreRoot, o as registerMetroStore, t as appendCacheStore } from "./metro-store-DzeWkfqW.mjs";
+import { E as projectMetroSharedCache } from "./settings-CduVcoxj.mjs";
+import { a as metroStoreRoot, o as registerMetroStore, t as appendCacheStore } from "./metro-store-CDDZHtPl.mjs";
 import { createRequire } from "node:module";
 import { isAbsolute, join, relative, sep } from "node:path";
 //#endregion
 //#region src/supervisor/server-bare.ts
 var import_bundle_response = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const { randomUUID } = __require("node:crypto");
-	function bundleResponseMiddleware(write) {
+	const LOOPBACK = /* @__PURE__ */ new Set([
+		"127.0.0.1",
+		"::1",
+		"::ffff:127.0.0.1"
+	]);
+	const PROGRESS_PART = /^\{"done":(\d+),"total":(\d+),"percent":(\d+)\}$/;
+	const PROGRESS_INTERVAL_MS = 1e3;
+	function clientPidFromLsof(output, clientPort, serverPort) {
+		const connection = new RegExp(`:${clientPort}->\\S*:${serverPort}$`);
+		let pid = null;
+		for (const line of String(output).split("\n")) if (line.startsWith("p")) pid = Number(line.slice(1));
+		else if (line.startsWith("n") && connection.test(line) && Number.isInteger(pid) && pid > 0) return pid;
+		return null;
+	}
+	function lookupClientPid(req, runLsof) {
+		const { remoteAddress, remotePort, localPort } = req.socket;
+		if (!runLsof || !LOOPBACK.has(remoteAddress)) return null;
+		return Promise.resolve().then(() => runLsof([
+			"-nP",
+			`-iTCP:${remotePort}`,
+			"-Fpn"
+		])).then((output) => clientPidFromLsof(output, remotePort, localPort)).catch(() => null);
+	}
+	function bundleResponseMiddleware(write, { runLsof } = {}) {
 		return (req, res, next) => {
 			if (req.method === "GET" && req.url === "/_stim/metro-warmup") {
 				res.end("ready");
 				return;
 			}
-			if (req.headers["x-stim-metro-warmup"] === "1") return next();
+			const prefetch = req.headers["x-stim-metro-warmup"] === "1";
 			let url;
 			try {
 				url = new URL(req.url, "http://localhost");
@@ -24,27 +48,50 @@ var import_bundle_response = (/* @__PURE__ */ __commonJSMin(((exports, module) =
 			const platform = url.searchParams.get("platform");
 			if (req.method !== "GET" || !/\.bundle\/*$/.test(url.pathname) || !["ios", "android"].includes(platform)) return next();
 			const requestId = randomUUID();
-			const emit = (event, statusCode) => {
+			const kind = prefetch ? "prefetch" : "response";
+			const clientPid = platform === "ios" && !prefetch ? lookupClientPid(req, runLsof) : null;
+			const send = (ts, stage, statusCode, pid, progress) => {
 				try {
 					write({
-						ts: Date.now(),
+						ts,
 						src: "metro",
-						level: event === "bundle_response_failed" ? "error" : "debug",
-						event,
+						level: stage === "failed" && !prefetch ? "error" : "debug",
+						event: `bundle_${kind}_${stage}`,
 						platform,
 						requestId,
-						statusCode,
-						msg: `${platform} bundle response ${event.slice(16)}`
+						...progress ?? { statusCode },
+						msg: progress ? `${platform} bundle ${progress.percent}%` : `${platform} bundle ${kind} ${stage}`,
+						...pid ? { clientPid: pid } : {}
 					});
 				} catch {}
 			};
-			emit("bundle_response_started");
+			const emit = (stage, statusCode, progress) => {
+				const ts = Date.now();
+				if (clientPid) clientPid.then((pid) => send(ts, stage, statusCode, pid, progress));
+				else send(ts, stage, statusCode, null, progress);
+			};
+			emit("started");
+			const writeChunk = res.write;
+			let progressAt = 0;
+			res.write = function(chunk, ...rest) {
+				const part = typeof chunk === "string" && chunk.length < 100 ? PROGRESS_PART.exec(chunk) : null;
+				const now = part ? Date.now() : 0;
+				if (part && now - progressAt >= PROGRESS_INTERVAL_MS) {
+					progressAt = now;
+					emit("progress", void 0, {
+						done: Number(part[1]),
+						total: Number(part[2]),
+						percent: Number(part[3])
+					});
+				}
+				return writeChunk.call(this, chunk, ...rest);
+			};
 			let ended = false;
 			const finish = (complete) => {
 				if (ended) return;
 				ended = true;
 				const success = complete && (res.statusCode === 200 || res.statusCode === 304);
-				emit(success ? "bundle_response_finished" : "bundle_response_failed", res.statusCode);
+				emit(success ? "finished" : "failed", res.statusCode);
 			};
 			res.once("finish", () => finish(true));
 			res.once("close", () => finish(false));
@@ -296,7 +343,7 @@ async function startBareServer({ root, port, logsDir, writer = null, deps = null
 	});
 	const httpServer = await metro.runServer(config, {
 		unstable_extraMiddleware: [
-			(0, import_bundle_response.bundleResponseMiddleware)((record) => writer?.write(record)),
+			(0, import_bundle_response.bundleResponseMiddleware)((record) => writer?.write(record), { runLsof: process.platform === "darwin" ? (args) => getExecutor().runFileAsync("lsof", args, { timeoutMs: 2e3 }) : void 0 }),
 			symbolicationReporterMiddleware(reporter),
 			communityMiddleware,
 			middleware

package/dist/{server-expo-DUCg52-K.mjs → server-expo-DhtX6bom.mjs}

@@ -1,13 +1,13 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
 import { r as createNdjsonWriter } from "./ndjson-CDY9IkVC.mjs";
-import { f as resolvePackageJson } from "./project-DGeclhvO.mjs";
+import { f as resolvePackageJson } from "./project-CV3tDFHl.mjs";
 import { n as supervisorError } from "./errors-B6W7FkxQ.mjs";
 import { n as stripAnsi, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { w as projectMetroSharedCache } from "./settings-xB0Frkg6.mjs";
-import { a as metroStoreRoot, i as metroStoreConfirmedRoot, n as expoMetroConfigPath, o as registerMetroStore, r as expoMetroStoreEnv } from "./metro-store-DzeWkfqW.mjs";
+import { E as projectMetroSharedCache } from "./settings-CduVcoxj.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 { LOG_ROTATE_BYTES } from "@stim-cli/core";
 import { dirname, join, parse } from "node:path";
+import { LOG_ROTATE_BYTES } from "@stim-cli/core";
 //#region src/supervisor/server-expo.ts
 function delay(ms) {
 	return new Promise((resolve) => {
@@ -120,11 +120,7 @@ function recordFromLine(line, { stream = "stdout" } = {}) {
 	if (!msg.trim()) return null;
 	if (stream === "stderr" && msg.startsWith("stim-bundle-response: ")) try {
 		const record = JSON.parse(msg.slice(22));
-		if (record.src === "metro" && [
-			"bundle_response_started",
-			"bundle_response_finished",
-			"bundle_response_failed"
-		].includes(record.event) && ["ios", "android"].includes(record.platform) && typeof record.requestId === "string" && Number.isFinite(record.ts)) return record;
+		if (record.src === "metro" && /^bundle_(response|prefetch)_(started|progress|finished|failed)$/.test(record.event) && ["ios", "android"].includes(record.platform) && typeof record.requestId === "string" && Number.isFinite(record.ts)) return record;
 	} catch {}
 	const confirmed = metroStoreConfirmedRoot(msg);
 	if (confirmed) return {

package/dist/server-expo-KJeD109I.mjs

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