stim 1.19.0 → 1.20.0

package/dist/{doctor-watchman-wZhyTdp4.mjs → doctor-watchman-CB4NnVZm.mjs}

@@ -1,9 +1,9 @@
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
-import { E as upsertProject, d as getConfigDir, p as getProject } from "./config-DC5jEtd1.mjs";
-import { f as appProjectProblem } from "./project-B5eQ1USs.mjs";
-import { lt as listWorktrees, mt as repoRoot } from "./settings-CxgngUZk.mjs";
-import { o as runWatchman, r as parseWatchRoots } from "./watchman-BL1IdOtq.mjs";
-import { t as compareStimVersions } from "./stim-installations-DbmUjsLv.mjs";
+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
@@ -12,17 +12,17 @@ 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";
-const PLATFORMS = ["ios", "android"];
-function recordDoctorRun(projectRoot, platform, version, now = /* @__PURE__ */ new Date()) {
+function recordDoctorRun(projectRoot, platform, version, now = /* @__PURE__ */ new Date(), platforms) {
 	const run = {
 		at: now.toISOString(),
 		version
 	};
 	try {
-		if (appProjectProblem(projectRoot)) return;
+		const targets = platforms ?? projectRegistry.selectDoctor(projectRoot, platform).platforms;
+		if (targets.length === 0) return;
 		upsertProject(projectRoot, (existing) => {
 			const doctorRuns = { ...existing.doctorRuns };
-			for (const target of platform ? [platform] : PLATFORMS) doctorRuns[target] = run;
+			for (const target of targets) doctorRuns[target] = run;
 			return { doctorRuns };
 		});
 	} catch {}
@@ -102,12 +102,13 @@ function renderGuideStatus({ running, doctor, latest }) {
 }
 async function guideStatus({ projectRoot, running, now = /* @__PURE__ */ new Date(), fetch: fetchImpl = fetch }) {
 	const doctor = [];
-	if (projectRoot && !appProjectProblem(projectRoot)) {
+	if (projectRoot) {
+		const platforms = projectRegistry.selectDoctor(projectRoot).platforms;
 		let runs = null;
 		try {
 			runs = getProject(projectRoot)?.doctorRuns ?? {};
 		} catch {}
-		if (runs) for (const platform of PLATFORMS) {
+		if (runs) for (const platform of platforms) {
 			const reason = doctorDueReason(runs[platform], running, now);
 			if (reason) doctor.push({
 				platform,

package/dist/{simslim-D9LkJxIO.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-i8GDPwq9.mjs";
-import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { d as getConfigDir } from "./config-DC5jEtd1.mjs";
-import { g as releaseBuildLock, m as acquireBuildLock } from "./device-lease-Cu7PtQpZ.mjs";
-import { f as resolveEasCliBin } from "./remote-cache-N3hAEaAL.mjs";
-import { s as readInstalledEasCliVersion, v as easCliSupport, y as easCliUpgradeRemedy } from "./device-remote-B5GiUifk.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-DbmUjsLv.mjs → eas-session-ledger-DZlC-Fq3.mjs}

@@ -1,6 +1,8 @@
-import { t as getExecutor } from "./exec-i8GDPwq9.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--v5HGOU0.mjs → error-diagnostics-Du7I_GuY.mjs}

@@ -1,18 +1,18 @@
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
-import { v as launchErrorPreview } from "./command-output-Bt8ygHE7.mjs";
-import { R as deviceSlotKey, p as getProject, z as deviceSlotPlatforms } from "./config-DC5jEtd1.mjs";
-import { r as readWorkspaceState$1, w as withDirLock } from "./workspace-state-CR9X86xJ.mjs";
-import { A as readWorkspaceLaunches } from "./project-B5eQ1USs.mjs";
-import { u as resolveProjectMetro } from "./metro-DI2AjPF_.mjs";
-import { a as parseLease, n as fileLeaseIo, t as deviceLeasePath } from "./device-lease-Cu7PtQpZ.mjs";
-import { o as androidHome, u as androidToolCwd } from "./android-BdQC6zs1.mjs";
-import { r as deviceConsoleLevel } from "./ios-device-CrW8aMb5.mjs";
-import { n as parseLogcatLine, t as androidClockOffset } from "./android-DE5g_5gv.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."

package/dist/errors-DzkMYh8Q.mjs

@@ -0,0 +1,205 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { ANDROID_COMPILER_CACHE_CHOICES, ANDROID_PCH_CHOICES } from "@stim-cli/core/state";
+import { fileURLToPath } from "node:url";
+import { METRO_NAMED_CACHE_LAYOUT, metroCacheRoot, registerCache, sharedStoreRoot, tagSharedStore } from "@stim-cli/core";
+import { createHash } from "node:crypto";
+//#region src/optimizations.ts
+function compilerCacheFallbackMessage({ fallback, compilerCache, file = null }) {
+	const origin = fallback.fromEnvironment ? "the environment" : file;
+	const backend = compilerCache === "none" ? "Android builds use no compiler cache, because optimizations.android.compilerCache is \"none\"." : "Android builds fall back to ccache when it is available.";
+	return `${fallback.key}${origin ? ` in ${origin}` : ""} ${fallback.reason}. ${backend}`;
+}
+function optimizationBuildProfile(platform, options) {
+	const selected = platform === "ios" ? {
+		...options.ios,
+		swiftCompilationCache: options.ios.swiftCompilationCache ?? false
+	} : { pch: options.android.pch };
+	const defaults = platform === "ios" ? {
+		compilationCache: true,
+		swiftCompilationCache: false,
+		prefixMapping: true
+	} : { pch: "auto" };
+	if (JSON.stringify(selected) === JSON.stringify(defaults)) return void 0;
+	return `opt-${createHash("sha256").update(JSON.stringify(selected)).digest("hex").slice(0, 16)}`;
+}
+function resolveOptimizations(settings = {}, env = process.env) {
+	function choice(path, choices, fallback) {
+		const raw = optimizationValue(settings, path);
+		if (raw === void 0) return fallback;
+		if (typeof raw !== "string" || !choices.includes(raw)) throw new Error(`Invalid optimizations.${path}. Expected ${choices.join(", ")}.`);
+		return raw;
+	}
+	const compiler = choice("android.compilerCache", ANDROID_COMPILER_CACHE_CHOICES, "auto");
+	const fromEnvironment = Boolean(env.STIM_ANDROID_CAS_TOOLCHAIN);
+	const manifest = env.STIM_ANDROID_CAS_TOOLCHAIN || optimizationValue(settings, "android.casToolchain");
+	let fallback = null;
+	let toolchain = null;
+	if (manifest !== void 0) {
+		if (typeof manifest === "string" && isAbsolute(manifest) && !/[\r\n\0]/.test(manifest)) toolchain = manifest;
+		else fallback = {
+			key: fromEnvironment ? "STIM_ANDROID_CAS_TOOLCHAIN" : "optimizations.android.casToolchain",
+			reason: `is ${JSON.stringify(manifest)}, which is not an absolute path to a toolchain JSON manifest`,
+			fromEnvironment,
+			manifest: null
+		};
+	}
+	let compilerCache = compiler === "auto" ? toolchain ? "cas" : "ccache" : compiler;
+	if (compilerCache === "cas" && !toolchain) {
+		fallback ??= {
+			key: "optimizations.android.compilerCache",
+			reason: "is \"cas\", but no optimizations.android.casToolchain or STIM_ANDROID_CAS_TOOLCHAIN names the toolchain manifest",
+			fromEnvironment: false,
+			manifest: null
+		};
+		compilerCache = "ccache";
+	}
+	return {
+		buildCache: optimizationBoolean(settings, "buildCache"),
+		remoteBuildCache: optimizationBoolean(settings, "remoteBuildCache"),
+		releaseBundleSwap: optimizationBoolean(settings, "releaseBundleSwap"),
+		metroSharedCache: optimizationBoolean(settings, "metroSharedCache"),
+		metroWarmup: optimizationBoolean(settings, "metroWarmup"),
+		ios: {
+			compilationCache: optimizationBoolean(settings, "ios.compilationCache"),
+			swiftCompilationCache: optimizationValue(settings, "ios.swiftCompilationCache") === void 0 ? null : optimizationBoolean(settings, "ios.swiftCompilationCache"),
+			prefixMapping: optimizationBoolean(settings, "ios.prefixMapping")
+		},
+		android: {
+			compilerCache,
+			casToolchain: toolchain,
+			compilerCacheFallback: fallback,
+			pch: choice("android.pch", ANDROID_PCH_CHOICES, "auto"),
+			gradleBuildCache: optimizationBoolean(settings, "android.gradleBuildCache"),
+			targetAbiOnly: optimizationBoolean(settings, "android.targetAbiOnly")
+		}
+	};
+}
+function artifactCachePolicy(options, reuse, release) {
+	return {
+		read: reuse && options.buildCache && (!release || options.releaseBundleSwap),
+		write: options.buildCache,
+		remote: options.buildCache && options.remoteBuildCache
+	};
+}
+function optimizationValue(settings, path) {
+	let node = settings;
+	for (const key of ["optimizations", ...path.split(".")]) {
+		if (node === void 0) return void 0;
+		if (!node || typeof node !== "object" || Array.isArray(node)) throw new Error("Invalid optimizations setting. Expected nested objects.");
+		node = node[key];
+	}
+	return node;
+}
+function optimizationBoolean(settings, path, fallback = true) {
+	const raw = optimizationValue(settings, path);
+	if (raw === void 0) return fallback;
+	if (typeof raw !== "boolean") throw new Error(`Invalid optimizations.${path}. Expected true or false.`);
+	return raw;
+}
+function resolveMetroSharedCache(settings) {
+	return optimizationBoolean(settings, "metroSharedCache");
+}
+//#endregion
+//#region src/supervisor/metro-store.ts
+function metroStoreName(root) {
+	try {
+		const name = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"))?.name;
+		if (typeof name === "string" && name.trim() !== "") return name;
+	} catch {}
+	return "app";
+}
+function metroStoreRoot(root) {
+	return metroCacheRoot(metroStoreName(root));
+}
+function registerMetroStore(storeRoot) {
+	const parent = resolve(metroCacheRoot());
+	const dir = resolve(storeRoot);
+	registerCache({
+		dir,
+		name: "Metro transform cache",
+		prune: "entries",
+		entriesDepth: 2,
+		layout: METRO_NAMED_CACHE_LAYOUT,
+		note: "shared Metro transforms, installed by stim start; no eviction of its own",
+		replaces: dir === parent ? [] : [{
+			dir: parent,
+			name: "Metro transform cache",
+			prune: "entries",
+			entriesDepth: 2,
+			layout: null
+		}]
+	});
+}
+function hasStoreAt(stores, storeRoot) {
+	if (!Array.isArray(stores)) return false;
+	return stores.some((s) => sharedStoreRoot(s) === storeRoot);
+}
+function appendCacheStore(config, { storeRoot, FileStore }) {
+	if (!config || typeof config !== "object") return {
+		added: false,
+		storeRoot,
+		reason: "no config to add it to"
+	};
+	const stores = config.cacheStores;
+	if (typeof stores === "function") {
+		const original = stores;
+		config.cacheStores = (cache) => {
+			const resolved = original(cache);
+			return (Array.isArray(resolved) ? resolved : []).concat([tagSharedStore(new FileStore({ root: storeRoot }), storeRoot)]);
+		};
+		return {
+			added: true,
+			storeRoot
+		};
+	}
+	if (hasStoreAt(stores, storeRoot)) return {
+		added: false,
+		storeRoot,
+		reason: "a store already points at it"
+	};
+	config.cacheStores = [...Array.isArray(stores) ? stores : [], tagSharedStore(new FileStore({ root: storeRoot }), storeRoot)];
+	return {
+		added: true,
+		storeRoot
+	};
+}
+const EXPO_ADAPTER_FILE = "expo-metro-config.cjs";
+function expoMetroConfigPath(fromUrl = import.meta.url) {
+	const here = dirname(fileURLToPath(fromUrl));
+	for (const rel of ["../shim", "../../shim"]) {
+		const candidate = resolve(here, rel, EXPO_ADAPTER_FILE);
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+const STORE_OK_PREFIX = "stim-metro-store: sharing Metro transforms through ";
+function metroStoreConfirmedRoot(line) {
+	if (!line.startsWith(STORE_OK_PREFIX)) return null;
+	const root = line.slice(51).trim();
+	return root === "" ? null : root;
+}
+function expoMetroStoreEnv({ root, storeRoot, adapterPath, existingOverride }) {
+	return {
+		EXPO_OVERRIDE_METRO_CONFIG: adapterPath,
+		STIM_METRO_STORE: storeRoot,
+		STIM_PROJECT_ROOT: root,
+		...existingOverride ? { STIM_EXPO_METRO_CONFIG: existingOverride } : {}
+	};
+}
+//#endregion
+//#region src/supervisor/errors.ts
+function supervisorError(code, message, remedy) {
+	const err = new Error(message);
+	err.code = code;
+	if (remedy) err.remedy = remedy;
+	return err;
+}
+function describeError(err) {
+	if (!err) return "unknown error";
+	const e = err;
+	const message = e.message || String(err);
+	return `${e.code ? `${e.code}: ` : ""}${message}${e.remedy ? ` Remedy: ${e.remedy}` : ""}`;
+}
+//#endregion
+export { expoMetroStoreEnv as a, registerMetroStore as c, optimizationBuildProfile as d, resolveMetroSharedCache as f, expoMetroConfigPath as i, artifactCachePolicy as l, supervisorError as n, metroStoreConfirmedRoot as o, resolveOptimizations as p, appendCacheStore as r, metroStoreRoot as s, describeError as t, compilerCacheFallbackMessage as u };

package/dist/{exec-i8GDPwq9.mjs → exec-B81Qodjn.mjs}

@@ -12,6 +12,28 @@ function nameTimeout(error, command, timeoutMs) {
 	if (error?.code === "ETIMEDOUT" && error instanceof Error) error.message = `Command timed out after ${timeoutMs}ms: ${command}`;
 	return error;
 }
+const WINDOWS_BATCH_FILE = /\.(?:bat|cmd)$/i;
+const BATCH_UNSAFE_ARGUMENT = /["\r\n]/;
+function isUnsafeBatchSpawn(target, args, platform = process.platform) {
+	return platform === "win32" && WINDOWS_BATCH_FILE.test(target) && args.some((arg) => BATCH_UNSAFE_ARGUMENT.test(arg));
+}
+function refuseUnsafeBatchArguments(file, args) {
+	if (process.platform !== "win32") return;
+	const target = which.sync(file, { nothrow: true }) ?? file;
+	if (isUnsafeBatchSpawn(target, args)) throw new Error(`Refusing to run ${basename(target)}: an argument contains a character cmd.exe could misinterpret (a double quote or a line break).`);
+}
+function redactError(error, values) {
+	const secrets = values?.filter(Boolean) ?? [];
+	if (secrets.length === 0 || !error || typeof error !== "object") return error;
+	const scrub = (text) => secrets.reduce((acc, secret) => acc.split(secret).join("***"), text);
+	const fields = error;
+	for (const key of Object.getOwnPropertyNames(error)) {
+		const value = fields[key];
+		if (typeof value === "string") fields[key] = scrub(value);
+		else if (Array.isArray(value)) fields[key] = value.map((item) => typeof item === "string" ? scrub(item) : item);
+	}
+	return error;
+}
 const defaultExecutor = {
 	run(cmd, { timeoutMs, killSignal, cwd, env } = {}) {
 		const opts = {
@@ -36,16 +58,17 @@ const defaultExecutor = {
 			throw nameTimeout(error, cmd, timeoutMs);
 		}
 	},
-	runFile(file, args = [], { timeoutMs, killSignal, cwd, env, omitEnv, input, untrimmed, rejectStderr } = {}) {
+	runFile(file, args = [], { timeoutMs, killSignal, cwd, env, omitEnv, input, untrimmed, rejectStderr, detachedSilent, redact } = {}) {
 		const opts = {
 			encoding: "utf-8",
-			stdio: [
+			stdio: detachedSilent ? "ignore" : [
 				"pipe",
 				"pipe",
 				"pipe"
 			],
 			maxBuffer: MAX_BUFFER
 		};
+		if (detachedSilent) opts.detached = true;
 		if (timeoutMs) opts.timeout = timeoutMs;
 		if (killSignal) opts.killSignal = killSignal;
 		if (cwd) opts.cwd = cwd;
@@ -58,19 +81,25 @@ const defaultExecutor = {
 			for (const key of omitEnv ?? []) delete childEnv[key];
 			opts.env = childEnv;
 		}
+		refuseUnsafeBatchArguments(file, args);
 		const result = spawn.sync(file, args, opts);
-		if (result.error) throw nameTimeout(Object.assign(result.error, result), [file, ...args].join(" "), timeoutMs);
+		if (result.error) throw redactError(nameTimeout(Object.assign(result.error, result), [file, ...args].join(" "), timeoutMs), redact);
 		if (result.status !== 0 || rejectStderr && String(result.stderr ?? "").trim()) {
 			const stderr = String(result.stderr ?? "");
 			const message = `Command failed: ${[file, ...args].join(" ")}${stderr ? `\n${stderr}` : ""}`;
-			throw Object.assign(new Error(message), result);
+			throw redactError(Object.assign(new Error(message), result), redact);
 		}
+		if (detachedSilent) return "";
 		return untrimmed ? String(result.stdout) : String(result.stdout).trim();
 	},
-	runFileAsync(file, args = [], { timeoutMs, killSignal, cwd, env, omitEnv, rejectStderr, onSpawn } = {}) {
+	runFileAsync(file, args = [], { timeoutMs, killSignal, cwd, env, omitEnv, rejectStderr, onSpawn, detachedSilent, redact } = {}) {
 		const command = [file, ...args].join(" ");
 		return new Promise((resolve, reject) => {
-			const opts = { stdio: [
+			refuseUnsafeBatchArguments(file, args);
+			const opts = detachedSilent ? {
+				stdio: "ignore",
+				detached: true
+			} : { stdio: [
 				"ignore",
 				"pipe",
 				"pipe"
@@ -103,7 +132,7 @@ const defaultExecutor = {
 			child.stderr?.on("data", (chunk) => stderr.push(chunk));
 			child.on("error", (error) => {
 				clearTimeout(timer);
-				reject(error);
+				reject(redactError(error, redact));
 			});
 			child.on("close", (status, signal) => {
 				clearTimeout(timer);
@@ -115,9 +144,9 @@ const defaultExecutor = {
 					stdout: out,
 					stderr: err
 				};
-				if (timedOut) reject(nameTimeout(Object.assign(new Error(command), result, { code: "ETIMEDOUT" }), command, timeoutMs));
-				else if (status !== 0 || rejectStderr && err.trim()) reject(Object.assign(/* @__PURE__ */ new Error(`Command failed: ${command}${err ? `\n${err}` : ""}`), result));
-				else resolve(out.trim());
+				if (timedOut) reject(redactError(nameTimeout(Object.assign(new Error(command), result, { code: "ETIMEDOUT" }), command, timeoutMs), redact));
+				else if (status !== 0 || rejectStderr && err.trim()) reject(redactError(Object.assign(/* @__PURE__ */ new Error(`Command failed: ${command}${err ? `\n${err}` : ""}`), result), redact));
+				else resolve(detachedSilent ? "" : out.trim());
 			});
 		});
 	},
@@ -136,6 +165,7 @@ const defaultExecutor = {
 		}
 	},
 	spawn(cmd, args = [], opts = {}) {
+		refuseUnsafeBatchArguments(cmd, args);
 		return spawn(cmd, args, opts);
 	},
 	findExecutable(name) {