stim 1.18.0 → 1.20.0

package/dist/doctor-watchman-CB4NnVZm.mjs

@@ -0,0 +1,260 @@
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { E as upsertProject, d as getConfigDir, p as getProject } from "./config-D0LhTY3S.mjs";
+import { Et as repoRoot, xt as listWorktrees } from "./settings-Bbztm4oV.mjs";
+import { d as projectRegistry } from "./project-B8_duAzW.mjs";
+import { o as runWatchman, r as parseWatchRoots } from "./watchman-CQl51YZu.mjs";
+import { o as compareStimVersions } from "./eas-session-ledger-DZlC-Fq3.mjs";
+import { mkdirSync, readFileSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
+//#region src/guide-status.ts
+const DAY_MS = 864e5;
+const DOCTOR_STALE_MS = 7 * DAY_MS;
+const UPDATE_CHECK_INTERVAL_MS = DAY_MS;
+const UPDATE_CHECK_TIMEOUT_MS = 2e3;
+const LATEST_URL = "https://registry.npmjs.org/stim/latest";
+function recordDoctorRun(projectRoot, platform, version, now = /* @__PURE__ */ new Date(), platforms) {
+	const run = {
+		at: now.toISOString(),
+		version
+	};
+	try {
+		const targets = platforms ?? projectRegistry.selectDoctor(projectRoot, platform).platforms;
+		if (targets.length === 0) return;
+		upsertProject(projectRoot, (existing) => {
+			const doctorRuns = { ...existing.doctorRuns };
+			for (const target of targets) doctorRuns[target] = run;
+			return { doctorRuns };
+		});
+	} catch {}
+}
+function doctorDueReason(record, running, now) {
+	const at = record ? Date.parse(record.at) : NaN;
+	if (!record || Number.isNaN(at)) return "never run";
+	if (record.version !== running) return `last run with stim ${record.version}`;
+	const age = now.getTime() - at;
+	if (age > DOCTOR_STALE_MS) return `last run ${Math.floor(age / DAY_MS)} days ago`;
+	return null;
+}
+function updateCacheFile() {
+	return join(getConfigDir(), "update-check.json");
+}
+function readUpdateCache() {
+	try {
+		const parsed = JSON.parse(readFileSync(updateCacheFile(), "utf-8"));
+		if (typeof parsed?.checkedAt !== "string") return null;
+		return {
+			checkedAt: parsed.checkedAt,
+			latest: typeof parsed.latest === "string" ? parsed.latest : null
+		};
+	} catch {
+		return null;
+	}
+}
+function writeUpdateCache(cache) {
+	const target = updateCacheFile();
+	const tmp = `${target}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	try {
+		mkdirSync(getConfigDir(), { recursive: true });
+		writeFileSync(tmp, `${JSON.stringify(cache)}\n`);
+		renameSync(tmp, target);
+	} catch {
+		try {
+			unlinkSync(tmp);
+		} catch {}
+	}
+}
+async function fetchLatest(fetchImpl) {
+	const res = await fetchImpl(LATEST_URL, { signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS) });
+	if (!res.ok) return null;
+	const body = await res.json();
+	return typeof body.version === "string" ? body.version : null;
+}
+async function checkForUpdate(running, { now = /* @__PURE__ */ new Date(), fetch: fetchImpl = fetch } = {}) {
+	if (process.env.STIM_NO_UPDATE_CHECK) return null;
+	const cached = readUpdateCache();
+	const checkedAt = cached ? Date.parse(cached.checkedAt) : NaN;
+	let latest = cached?.latest ?? null;
+	if (Number.isNaN(checkedAt) || now.getTime() - checkedAt > UPDATE_CHECK_INTERVAL_MS) {
+		try {
+			latest = await fetchLatest(fetchImpl);
+		} catch {
+			latest = null;
+		}
+		writeUpdateCache({
+			checkedAt: now.toISOString(),
+			latest
+		});
+	}
+	if (!latest) return null;
+	const comparison = compareStimVersions(latest, running);
+	return comparison !== null && comparison > 0 ? latest : null;
+}
+function renderGuideStatus({ running, doctor, latest }) {
+	const lines = [];
+	if (doctor.length) {
+		const named = doctor.map((due) => `${due.platform} (${due.reason})`).join(" and ");
+		const command = doctor.length === 1 ? `stim doctor --platform ${doctor[0]?.platform}` : "stim doctor";
+		lines.push(`  Doctor is due for ${named}.`, `  Run before native work:  ${command}`);
+	}
+	if (latest) lines.push(`  stim ${latest} is available (running ${running}):  npm install -g stim@latest`);
+	if (!lines.length) return null;
+	return ["STATUS", ...lines].join("\n");
+}
+async function guideStatus({ projectRoot, running, now = /* @__PURE__ */ new Date(), fetch: fetchImpl = fetch }) {
+	const doctor = [];
+	if (projectRoot) {
+		const platforms = projectRegistry.selectDoctor(projectRoot).platforms;
+		let runs = null;
+		try {
+			runs = getProject(projectRoot)?.doctorRuns ?? {};
+		} catch {}
+		if (runs) for (const platform of platforms) {
+			const reason = doctorDueReason(runs[platform], running, now);
+			if (reason) doctor.push({
+				platform,
+				reason
+			});
+		}
+	}
+	return renderGuideStatus({
+		running,
+		doctor,
+		latest: await checkForUpdate(running, {
+			now,
+			fetch: fetchImpl
+		})
+	});
+}
+//#endregion
+//#region src/diagnostics/doctor-watchman.ts
+const WATCHMAN_NESTED_WORKTREES = "watchman-nested-worktrees";
+function isPlainObject(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function ignoreDirsOf(config) {
+	if (config.kind !== "object" || !Array.isArray(config.value.ignore_dirs)) return [];
+	return config.value.ignore_dirs.filter((entry) => typeof entry === "string");
+}
+function covered(path, ignoreDirs) {
+	return ignoreDirs.some((entry) => path === entry || path.startsWith(`${entry}/`));
+}
+/**
+* Watchman joins each ignore_dirs entry to the root without normalizing it, so `.worktrees/` or `./.worktrees`
+* ignores nothing; only an entry spelled exactly as the relative path, or as one of its ancestors, covers it.
+*/
+function nestedWorktreeIgnores(checkout, worktrees, ignoreDirs, holdsSource) {
+	const nested = worktrees.map((path) => relative(checkout, path)).filter((rel) => rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel)).map((rel) => rel.split(sep).join("/")).filter((rel) => !covered(rel, ignoreDirs)).toSorted();
+	const parents = new Set(nested.map((rel) => dirname(rel)));
+	const [parent] = parents;
+	return {
+		nested,
+		add: parents.size === 1 && parent !== void 0 && parent !== "." && !holdsSource(parent) ? [parent] : nested
+	};
+}
+function mergeIgnoreDirs(config, add) {
+	if (config.kind === "invalid") return { refusal: config.reason };
+	const existing = config.kind === "object" ? config.value : {};
+	if ("ignore_dirs" in existing && !Array.isArray(existing.ignore_dirs)) return { refusal: "holds an ignore_dirs that is not an array" };
+	const current = Array.isArray(existing.ignore_dirs) ? existing.ignore_dirs : [];
+	return { value: {
+		...existing,
+		ignore_dirs: [.../* @__PURE__ */ new Set([...current, ...add])]
+	} };
+}
+function readWatchmanConfig(path) {
+	let raw;
+	try {
+		raw = readFileSync(path, "utf-8");
+	} catch (error) {
+		const code = error.code;
+		return code === "ENOENT" ? { kind: "absent" } : {
+			kind: "invalid",
+			reason: `cannot be read (${code})`
+		};
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		parsed = null;
+	}
+	return isPlainObject(parsed) ? {
+		kind: "object",
+		value: parsed
+	} : {
+		kind: "invalid",
+		reason: "is not a JSON object"
+	};
+}
+function canonical(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return null;
+	}
+}
+function inspectNestedWorktrees(projectRoot) {
+	const worktrees = listWorktrees(repoRoot(projectRoot) ?? projectRoot).filter((entry) => !entry.prunable && !entry.bare).flatMap((entry) => canonical(entry.path) ?? []);
+	return worktrees.flatMap((checkout) => {
+		const configPath = join(checkout, ".watchmanconfig");
+		const config = readWatchmanConfig(configPath);
+		const { nested, add } = nestedWorktreeIgnores(checkout, worktrees, ignoreDirsOf(config), (dir) => Boolean(getExecutor().runFileQuiet("git", [
+			"-C",
+			checkout,
+			"ls-files",
+			"--",
+			dir
+		]) ?? true));
+		return nested.length > 0 ? [{
+			checkout,
+			configPath,
+			config,
+			nested,
+			add
+		}] : [];
+	});
+}
+async function watchedCheckouts(checkouts, watchman = runWatchman) {
+	if (checkouts.length === 0) return /* @__PURE__ */ new Set();
+	try {
+		const roots = parseWatchRoots(await watchman(["watch-list"], 5e3)) ?? [];
+		const canonicalRoots = new Set(roots.map((root) => canonical(root) ?? root));
+		return new Set(checkouts.filter((checkout) => canonicalRoots.has(checkout)));
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+function list(items) {
+	return items.map((item) => `\`${item}\``).join(", ");
+}
+function nestedWorktreeFinding(entry, watched) {
+	const count = entry.nested.length;
+	const now = watched ? ` Watchman watches ${entry.checkout} now; \`watchman watch-del ${entry.checkout}\` and a watchman restart free that memory.` : "";
+	const merge = mergeIgnoreDirs(entry.config, entry.add);
+	const fix = "refusal" in merge ? `${entry.configPath} ${merge.refusal}, so Stim will not edit it. Add ${list(entry.add)} to its ignore_dirs by hand, then commit it.` : `Run \`stim doctor --fix\` to add ${list(entry.add)} to ignore_dirs in ${entry.configPath}, then commit that file. Watchman reads it only when it adds a root, so an existing root needs \`watchman watch-del ${entry.checkout}\` before the ignore applies.`;
+	return {
+		code: WATCHMAN_NESTED_WORKTREES,
+		level: "cost",
+		title: `${count} linked worktree${count === 1 ? " sits" : "s sit"} inside a checkout that Watchman would crawl`,
+		detail: `${list(entry.nested)} ${count === 1 ? "is" : "are"} inside ${entry.checkout}, and its .watchmanconfig does not ignore them. A Watchman root at that checkout, as Jest or a Metro started there registers, crawls every worktree's files, node_modules and build output, which grows the shared daemon's memory and its recrawls.${now}`,
+		fix
+	};
+}
+function writeIgnoreDirs(entry) {
+	const merge = mergeIgnoreDirs(entry.config, entry.add);
+	if ("refusal" in merge) return {
+		status: "refused",
+		reason: `${entry.configPath} ${merge.refusal}`
+	};
+	const tmp = `${entry.configPath}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	try {
+		writeFileSync(tmp, `${JSON.stringify(merge.value, null, 2)}\n`);
+		renameSync(tmp, entry.configPath);
+	} catch (error) {
+		rmSync(tmp, { force: true });
+		throw error;
+	}
+	return { status: entry.config.kind === "absent" ? "created" : "updated" };
+}
+//#endregion
+export { writeIgnoreDirs as a, watchedCheckouts as i, inspectNestedWorktrees as n, guideStatus as o, nestedWorktreeFinding as r, recordDoctorRun as s, WATCHMAN_NESTED_WORKTREES as t };

package/dist/{simslim-EHBQ2R4G.mjs → eas-build-Dw_ec2Km.mjs}

@@ -1,12 +1,9 @@
-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 { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { d as getConfigDir } from "./config-CgYMahz7.mjs";
-import { g as releaseBuildLock, m as acquireBuildLock } from "./device-lease-Co-EwifR.mjs";
-import { f as resolveEasCliBin } from "./remote-cache-BGg7aGIZ.mjs";
-import { _ as easCliSupport, s as readInstalledEasCliVersion, v as easCliUpgradeRemedy } from "./device-remote-tHbd1fKy.mjs";
+import { n as ownership_claim_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { g as releaseBuildLock, m as acquireBuildLock } from "./device-lease-DHOBXGgS.mjs";
+import { f as resolveEasCliBin } from "./remote-cache-Bsts6f6Y.mjs";
+import { g as easCliUpgradeRemedy, h as easCliSupport, s as readInstalledEasCliVersion } from "./device-remote-Bmg42063.mjs";
 import { existsSync, realpathSync, statSync } from "node:fs";
-import { join } from "node:path";
 import { createHash } from "node:crypto";
 //#region src/engine/eas-build.ts
 const MIN_EAS_CLI_BUILD_DOWNLOAD_VERSION = "18.9.0";
@@ -228,147 +225,4 @@ async function resolveEasDevelopmentBuild(args) {
 	}
 }
 //#endregion
-//#region src/engine/simslim.ts
-async function reconcileSimSlim({ udid, profile, previouslyManaged = false, out = () => {}, spawn, timeoutMs = 72e4, cleanupMs = 1e4 }) {
-	if (!profile && !previouslyManaged) return {
-		managed: false,
-		profile: null
-	};
-	const action = profile ? "on" : "off";
-	const args = profile ? [
-		"on",
-		udid,
-		"--profile",
-		profile
-	] : ["off", udid];
-	const lines = [];
-	const onLine = (raw) => {
-		const line = stripAnsi(raw).trim();
-		if (!line) return;
-		lines.push(line);
-		if (lines.length > 20) lines.shift();
-		out(`SimSlim: ${line}`);
-	};
-	const stdout = createLineReader(onLine);
-	const stderr = createLineReader(onLine);
-	const root = join(getConfigDir(), "simslim-locks", `${encodeURIComponent(udid.toLowerCase())}.lock`);
-	const label = `SimSlim for ${udid}`;
-	const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
-		root,
-		mode: "exclusive",
-		label
-	});
-	if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
-	const claim = attempt.acquired;
-	if (!claim) throw new ownership_claim_exports.ClaimRefusedError({
-		root,
-		claimPath: attempt.held?.path ?? root,
-		label,
-		reason: "another SimSlim operation is still using this simulator"
-	});
-	let child;
-	let result;
-	let identity;
-	let cancellation;
-	const stopGroup = () => {
-		if (child?.pid !== void 0 && identity && (0, process_identity_exports.inspectProcessIdentity)(identity) === "same") try {
-			process.kill(-child.pid, "SIGKILL");
-		} catch {}
-	};
-	const cancel = (signal) => {
-		cancellation ??= signal;
-		stopGroup();
-	};
-	const onInterrupt = () => cancel("SIGINT");
-	const onTerminate = () => cancel("SIGTERM");
-	const groupAlive = () => child?.pid !== void 0 && (0, ownership_claim_exports.processGroupAlive)(child.pid);
-	const settled = () => result !== void 0 && !groupAlive();
-	const waitUntil = async (deadline, cancellable = false) => {
-		while (!settled() && Date.now() < deadline) {
-			if (cancellable && cancellation) break;
-			await new Promise((resolve) => setTimeout(resolve, Math.min(50, deadline - Date.now())));
-		}
-		return settled();
-	};
-	process.on("SIGINT", onInterrupt);
-	process.on("SIGTERM", onTerminate);
-	process.on("exit", stopGroup);
-	try {
-		(0, ownership_claim_exports.markClaimChildPending)(claim);
-		try {
-			child = (spawn ?? ((cmd, childArgs, opts) => getExecutor().spawn(cmd, childArgs, opts)))("simslim", args, {
-				stdio: [
-					"ignore",
-					"pipe",
-					"pipe"
-				],
-				detached: true
-			});
-		} catch (error) {
-			throw simslimLaunchError(error);
-		}
-		child.stdout?.on("data", (chunk) => stdout.push(chunk));
-		child.stderr?.on("data", (chunk) => stderr.push(chunk));
-		waitForChild(child).then((value) => {
-			result = value;
-		});
-		if (child.pid !== void 0) {
-			const captured = (0, process_identity_exports.captureProcessIdentity)(child.pid);
-			if (captured.ok) {
-				identity = {
-					pid: child.pid,
-					processToken: captured.token
-				};
-				try {
-					(0, ownership_claim_exports.setClaimChild)(claim, identity);
-				} catch {}
-			}
-		}
-		const completed = await waitUntil(Date.now() + timeoutMs, true);
-		if (cancellation || !completed) {
-			stopGroup();
-			const stopped = await waitUntil(Date.now() + cleanupMs);
-			const detail = lines.length ? ` ${lines.join(" | ")}` : "";
-			const recovery = stopped ? "Its process group has stopped. Retry stim ios to reconcile the retained simulator settings." : `Its process group could not be confirmed stopped. The claim remains at ${claim.path}. Inspect the SimSlim process group ${child.pid ?? "unknown"} before retrying. Only when nothing is using it, remove the claim: ${(0, ownership_claim_exports.claimRemoveCommand)(claim.path)}`;
-			const message = `SimSlim ${action} ${cancellation ? `interrupted by ${cancellation}` : `exceeded ${Math.round(timeoutMs / 1e3)}s`}. ${recovery}${detail}`;
-			if (cancellation) out(message);
-			throw Object.assign(new Error(message), { code: cancellation ? "EINTR" : "ETIMEDOUT" });
-		}
-	} finally {
-		if (!child || settled()) (0, ownership_claim_exports.releaseClaim)(claim);
-		else {
-			child.stdout?.destroy?.();
-			child.stderr?.destroy?.();
-			child.unref();
-		}
-		process.off("SIGINT", onInterrupt);
-		process.off("SIGTERM", onTerminate);
-		process.off("exit", stopGroup);
-		if (cancellation) process.exit(cancellation === "SIGINT" ? 130 : 143);
-	}
-	stdout.flush();
-	stderr.flush();
-	if (result?.error) throw simslimLaunchError(result.error);
-	if (result?.code !== 0) {
-		const detail = lines.length ? ` ${lines.join(" | ")}` : "";
-		throw new Error(`SimSlim ${action} failed with exit code ${result?.code ?? "unknown"}.${detail}`);
-	}
-	return {
-		managed: Boolean(profile),
-		profile: profile ?? null
-	};
-}
-function simslimLaunchError(error) {
-	const cause = error;
-	if (cause?.code === "ENOENT") return new Error("SimSlim is configured but the `simslim` command is not installed. Run `brew install mobai-app/tap/simslim`.", { cause });
-	return new Error(`Could not start SimSlim: ${String(cause?.message || cause)}`, { cause });
-}
-function simslimIsOnPath() {
-	try {
-		return Boolean(getExecutor().findExecutable("simslim"));
-	} catch {
-		return false;
-	}
-}
-//#endregion
-export { isEasBuildFailure as a, easDeviceBuildRemedy as i, simslimIsOnPath as n, planEasDevelopmentBuild as o, MIN_EAS_CLI_BUILD_DOWNLOAD_VERSION as r, resolveEasDevelopmentBuild as s, reconcileSimSlim as t };
+export { resolveEasDevelopmentBuild as a, planEasDevelopmentBuild as i, easDeviceBuildRemedy as n, isEasBuildFailure as r, MIN_EAS_CLI_BUILD_DOWNLOAD_VERSION as t };

package/dist/{stim-installations-aR_WsNOA.mjs → eas-session-ledger-DZlC-Fq3.mjs}

@@ -1,6 +1,8 @@
-import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
-import { accessSync, constants, realpathSync, statSync } from "node:fs";
-import { delimiter, join, resolve } from "node:path";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { D as withDirLock } from "./workspace-state-CSIFuuDa.mjs";
+import { accessSync, constants, existsSync, mkdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { easMachineStateRoot, easMachineStateRoot as easMachineStateRoot$1, easSessionLedgerFile, easSessionLedgerLock, readEasSessionLedger, readEasSessionLedger as readEasSessionLedger$1, validEasSessionClaim } from "@stim-cli/core/state";
 //#region src/diagnostics/stim-installations.ts
 const VERSION_OUTPUT_LIMIT = 4096;
 function parsedVersion(version) {
@@ -149,4 +151,55 @@ async function inspectStimVersions(runningVersion, { pathValue = process.env.PAT
 	return analyzeStimVersions(runningVersion, canonicalPath(runningPath), installations);
 }
 //#endregion
-export { inspectStimVersions as n, compareStimVersions as t };
+//#region src/engine/eas-machine-root-guard-env.ts
+const EAS_TEST_GUARD_ROOT_ENV = "STIM_TEST_GUARD_REAL_EAS_ROOT";
+//#endregion
+//#region src/engine/eas-session-ledger.ts
+function assertEasMachineRootWritable(root) {
+	const guardedRoot = process.env[EAS_TEST_GUARD_ROOT_ENV];
+	if (!guardedRoot || resolve(root) !== resolve(guardedRoot)) return;
+	throw new Error(`Refusing to write the real EAS machine root ${root} from a test process. Pass a temporary ledgerRoot, machineRoot, or easLedgerRoot, or point HOME (and USERPROFILE on Windows) at a temporary directory.`);
+}
+function writeLedger(root, ledger) {
+	mkdirSync(root, { recursive: true });
+	const file = easSessionLedgerFile(root);
+	const tmp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(ledger, null, 2)}\n`);
+	try {
+		renameSync(tmp, file);
+	} catch (error) {
+		rmSync(tmp, { force: true });
+		throw error;
+	}
+}
+function recordEasSessionClaim(claim, root = easMachineStateRoot()) {
+	assertEasMachineRootWritable(root);
+	const normalized = validEasSessionClaim(claim.sessionId, claim);
+	if (!normalized) throw new Error(`Invalid EAS session claim for ${claim.sessionId}.`);
+	withDirLock(easSessionLedgerLock(root), () => {
+		const current = readEasSessionLedger(root);
+		if (!current.safe) throw new Error(current.notice ?? "EAS ownership ledger is unreadable.");
+		current.claims.set(normalized.sessionId, normalized);
+		writeLedger(root, {
+			version: 1,
+			claims: Object.fromEntries(current.claims)
+		});
+	}, { ensureParent: () => mkdirSync(dirname(easSessionLedgerLock(root)), { recursive: true }) });
+}
+function removeEasSessionClaim(sessionId, root = easMachineStateRoot()) {
+	const file = easSessionLedgerFile(root);
+	if (!existsSync(file)) return false;
+	assertEasMachineRootWritable(root);
+	return withDirLock(easSessionLedgerLock(root), () => {
+		const current = readEasSessionLedger(root);
+		if (!current.safe) return false;
+		if (!current.claims.delete(sessionId)) return false;
+		writeLedger(root, {
+			version: 1,
+			claims: Object.fromEntries(current.claims)
+		});
+		return true;
+	});
+}
+//#endregion
+export { removeEasSessionClaim as a, recordEasSessionClaim as i, easMachineStateRoot$1 as n, compareStimVersions as o, readEasSessionLedger$1 as r, inspectStimVersions as s, assertEasMachineRootWritable as t };

package/dist/{error-diagnostics-BRXOqDzG.mjs → error-diagnostics-Du7I_GuY.mjs}

@@ -1,18 +1,18 @@
-import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
-import { v as launchErrorPreview } from "./command-output-CBtzyIgF.mjs";
-import { R as deviceSlotKey, p as getProject, z as deviceSlotPlatforms } from "./config-CgYMahz7.mjs";
-import { l as resolveProjectMetro } from "./metro-Dh8T4Ytd.mjs";
-import { r as readWorkspaceState$1, w as withDirLock } from "./workspace-state-C59dqG-Z.mjs";
-import { Kt as readWorkspaceLaunches } from "./budget-DIhL2BKx.mjs";
-import { a as parseLease, n as fileLeaseIo, t as deviceLeasePath } from "./device-lease-Co-EwifR.mjs";
-import { o as androidHome, u as androidToolCwd } from "./android-DC3ZLuw0.mjs";
-import { r as deviceConsoleLevel } from "./ios-device-Bn7jWDB1.mjs";
-import { n as parseLogcatLine, t as androidClockOffset } from "./android-CBwCNicO.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { R as deviceSlotKey, p as getProject, z as deviceSlotPlatforms } from "./config-D0LhTY3S.mjs";
+import { a as parseLease, n as fileLeaseIo, t as deviceLeasePath } from "./device-lease-DHOBXGgS.mjs";
+import { D as withDirLock, r as readWorkspaceState$1 } from "./workspace-state-CSIFuuDa.mjs";
+import { v as launchErrorPreview } from "./command-output-BjPN99ZB.mjs";
+import { F as readWorkspaceLaunches } from "./project-B8_duAzW.mjs";
+import { o as androidHome, u as androidToolCwd } from "./android-BsYNR81W.mjs";
+import { u as resolveProjectMetro } from "./metro-D_j9sN-B.mjs";
+import { r as deviceConsoleLevel } from "./ios-device-B1B14xND.mjs";
+import { n as parseLogcatLine, t as androidClockOffset } from "./android-CK3fpEyZ.mjs";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve, sep } from "node:path";
 import { NATIVE_CRASH_LOG_PREFIX, attachExpoErrorContext, readLogRecords, readLogTimeline } from "@stim-cli/core/state";
-import { homedir } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
+import { homedir } from "node:os";
 //#region src/diagnostics/diagnostic-store.ts
 /** Publishes an immutable diagnostic snapshot atomically; existing evidence wins. */
 function writeDiagnosticOnce(path, content) {
@@ -617,7 +617,12 @@ async function errorDiagnostics(input, { root, logsDir, port, allowRequest = fal
 			"bundle_response_started",
 			"bundle_response_finished",
 			"bundle_response_failed"
-		].includes(String(event.event)) || ["expo_stdout", "expo_stderr"].includes(String(event.event)) && /\bBundl(?:ing|ed)\b/.test(event.msg ?? "")) && Number(event.ts) > Number(record.ts) && (!event.platform || !record.platform || event.platform === record.platform))) {
+		].includes(String(event.event)) || [
+			"expo_stdout",
+			"expo_stderr",
+			"command_stdout",
+			"command_stderr"
+		].includes(String(event.event)) && /\bBundl(?:ing|ed)\b/.test(event.msg ?? "")) && Number(event.ts) > Number(record.ts) && (!event.platform || !record.platform || event.platform === record.platform))) {
 			rendered[index] = {
 				...record,
 				symbolicationNote: "Metro rebuilt after this error; captured coordinates retained rather than mapping against a different bundle."