stim 0.0.0 → 1.0.0

package/dist/metro-store-COLl1pOk.mjs

@@ -0,0 +1,1249 @@
+import { t as getExecutor } from "./exec-bsN9MJXb.mjs";
+import { d as getProjectSettings, f as getRepoSettings, l as getConfigDir, m as loadConfig } from "./config-7kmtuhO2.mjs";
+import { accessSync, chmodSync, constants, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { chmodSync as chmodSync$1, existsSync as existsSync$1, lstatSync as lstatSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, realpathSync as realpathSync$1, statSync as statSync$1, utimesSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+import { METRO_NAMED_CACHE_LAYOUT, metroCacheRoot, registerCache, sharedStoreRoot, tagSharedStore } from "@stim-cli/core";
+import { tmpdir } from "node:os";
+import { basename as basename$1, dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "node:path";
+import { createHash } from "node:crypto";
+import { fileURLToPath } from "node:url";
+//#region src/temporary.ts
+function existingPath(path) {
+	const missing = [];
+	let current = resolve$1(path);
+	while (!lstatSync(current, { throwIfNoEntry: false })) {
+		missing.unshift(basename$1(current));
+		current = dirname$1(current);
+	}
+	const existing = realpathSync(current);
+	return {
+		existing,
+		resolved: join$1(existing, ...missing)
+	};
+}
+function filesystemDevice(path) {
+	return statSync(existingPath(path).existing).dev;
+}
+function outsideWorkingTree(path) {
+	let current = path;
+	while (true) {
+		if (lstatSync(join$1(current, ".git"), { throwIfNoEntry: false })) return false;
+		const parent = dirname$1(current);
+		if (parent === current) return true;
+		current = parent;
+	}
+}
+function temporaryRoot(near) {
+	const reference = existingPath(near);
+	const insideReference = (path) => {
+		const rel = relative$1(reference.resolved, path);
+		return rel === "" || rel !== ".." && !rel.startsWith(`..${sep$1}`) && !isAbsolute$1(rel);
+	};
+	const override = process.env.STIM_TMPDIR ?? loadConfig()?.tempDir;
+	if (override !== void 0) {
+		if (typeof override !== "string" || !isAbsolute$1(override)) throw new Error("STIM_TMPDIR / tempDir must be an absolute directory path.");
+		const { existing, resolved } = existingPath(override);
+		if (!statSync(existing).isDirectory() || !outsideWorkingTree(existing)) throw new Error(`Temporary directory ${override} must be outside Git working trees.`);
+		if (insideReference(resolved)) throw new Error(`Temporary directory ${override} must not be inside ${near}.`);
+		accessSync(existing, constants.W_OK);
+		return resolved;
+	}
+	const { existing } = reference;
+	const device = statSync(existing).dev;
+	const candidates = [tmpdir()];
+	let current = existing === reference.resolved || !statSync(existing).isDirectory() ? dirname$1(existing) : existing;
+	while (statSync(current).dev === device) {
+		candidates.push(current);
+		const parent = dirname$1(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	for (const candidate of candidates) try {
+		const path = realpathSync(candidate);
+		if (statSync(path).dev !== device || insideReference(path) || !outsideWorkingTree(path)) continue;
+		accessSync(path, constants.W_OK);
+		return path;
+	} catch {}
+	throw new Error(`No writable temporary directory on the filesystem containing ${near}. Set STIM_TMPDIR or tempDir in ${join$1(getConfigDir(), "config.json")} to a directory outside Git working trees.`);
+}
+function makeTemporaryDirectory(near, prefix) {
+	const root = temporaryRoot(near);
+	mkdirSync(root, {
+		recursive: true,
+		mode: 448
+	});
+	return mkdtempSync(join$1(root, prefix));
+}
+function removeTemporaryEntry(path) {
+	const stat = lstatSync(path, { throwIfNoEntry: false });
+	if (stat?.isDirectory()) {
+		chmodSync(path, stat.mode | 448);
+		for (const entry of readdirSync(path, { withFileTypes: true })) if (entry.isDirectory()) removeTemporaryEntry(join$1(path, entry.name));
+	}
+	rmSync(path, {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
+//#region src/worktree.ts
+const CARRY_SKIP_BASENAMES = /* @__PURE__ */ new Set([".DerivedData"]);
+function isCarrySkipped(rel) {
+	return /(^|\/)android\/build\/generated\/autolinking(\/|$)/.test(rel) || String(rel).split("/").some((seg) => CARRY_SKIP_BASENAMES.has(seg));
+}
+function gitCommonDir(cwd) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-common-dir"
+	]);
+	return out ? out.trim() : null;
+}
+function isMainWorkingTree(path) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		path,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-dir",
+		"--git-common-dir"
+	]);
+	if (!out) return false;
+	const [gitDir, commonDir] = out.trim().split("\n").map((line) => line.trim());
+	return Boolean(gitDir) && gitDir === commonDir;
+}
+function repoRoot(cwd) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"rev-parse",
+		"--show-toplevel"
+	]);
+	return out ? out.trim() : null;
+}
+function warmWorktreePaths(cwd) {
+	const currentRoot = repoRoot(cwd);
+	if (!currentRoot) throw new Error("Not a git repository.");
+	const target = realpathSync$1(currentRoot);
+	if (isMainWorkingTree(target)) throw new Error("Run stim worktree warm from a linked worktree, not the main checkout.");
+	const entries = listWorktrees(target);
+	const current = entries.find((entry) => canonicalPath(entry.path) === target);
+	const main = entries.find((entry) => isMainWorkingTree(entry.path));
+	if (!current || !main) throw new Error("Could not identify the linked worktree and its main checkout.");
+	const root = realpathSync$1(main.path);
+	const sourceRoot = repoRoot(root);
+	const sourceCommon = gitCommonDir(root);
+	const targetCommon = gitCommonDir(target);
+	if (root === target || !sourceRoot || realpathSync$1(sourceRoot) !== root || !sourceCommon || !targetCommon || realpathSync$1(sourceCommon) !== realpathSync$1(targetCommon)) throw new Error("Could not verify that the main checkout belongs to this linked worktree.");
+	return {
+		root,
+		target,
+		common: realpathSync$1(targetCommon)
+	};
+}
+function matchesInclude(path, patterns) {
+	for (const pattern of patterns || []) {
+		const rooted = pattern.startsWith("/");
+		const escaped = (rooted ? pattern.slice(1) : pattern).replace(/[.+^${}()|[\]\\?]/g, "\\$&").replace(/\*\*\//g, "::GLOBSTAR::").replace(/\*/g, "[^/]+").replace(/::GLOBSTAR::/g, "(?:.*/)?").replace(/\\\?/g, "[^/]");
+		if (new RegExp(`${rooted ? "^" : "(^|/)"}${escaped}$`).test(path)) return true;
+	}
+	return false;
+}
+function readWorktreeExclude(root) {
+	return readPatternFile(join(root, ".worktreeexclude"));
+}
+function readPatternFile(p) {
+	if (!existsSync$1(p)) return null;
+	return readFileSync$1(p, "utf-8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+}
+function canonicalPath(path) {
+	try {
+		return realpathSync$1(path);
+	} catch {
+		return resolve(path);
+	}
+}
+function nestedWorktreePaths(root) {
+	const source = canonicalPath(root);
+	const paths = /* @__PURE__ */ new Set();
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		root,
+		"worktree",
+		"list",
+		"--porcelain"
+	]);
+	if (out === null) throw new Error("Could not list Git worktrees. Refusing to carry ignored files.");
+	for (const entry of parseWorktrees(out)) {
+		const rel = relative(source, canonicalPath(entry.path));
+		if (!rel || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) continue;
+		paths.add(rel.split(sep).join("/"));
+	}
+	return [...paths];
+}
+function overlapsNestedWorktree(rel, nestedPaths) {
+	const path = String(rel).replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
+	return nestedPaths.some((nested) => path === nested || path.startsWith(`${nested}/`) || nested.startsWith(`${path}/`));
+}
+function listTrackedPaths(dir) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		dir,
+		"ls-files",
+		"-z"
+	]);
+	if (out === null) return null;
+	return out.split("\0").filter(Boolean);
+}
+function trackedGuard(dir) {
+	const paths = listTrackedPaths(dir);
+	if (paths === null) return {
+		known: false,
+		covers: () => false
+	};
+	const entries = new Set(paths);
+	const covered = new Set(paths);
+	for (const p of paths) for (let i = p.indexOf("/"); i !== -1; i = p.indexOf("/", i + 1)) covered.add(p.slice(0, i));
+	return {
+		known: true,
+		covers: (rel) => {
+			if (covered.has(rel)) return true;
+			for (let i = rel.indexOf("/"); i !== -1; i = rel.indexOf("/", i + 1)) if (entries.has(rel.slice(0, i))) return true;
+			return false;
+		}
+	};
+}
+function listGitignoredEntries(root) {
+	const args = [
+		"-C",
+		root,
+		"ls-files",
+		"--others",
+		"--ignored",
+		"--exclude-standard",
+		"--directory",
+		"--no-empty-directory",
+		"-z"
+	];
+	const out = getExecutor().runFile("git", args);
+	if (!out) return [];
+	return out.split("\0").filter(Boolean).map((e) => e.endsWith("/") ? e.slice(0, -1) : e);
+}
+function listCarryableIgnoredEntries(root, patterns) {
+	const nested = nestedWorktreePaths(root);
+	return listGitignoredEntries(root).filter((rel) => !isCarrySkipped(rel) && !overlapsNestedWorktree(rel, nested) && !matchesInclude(rel, patterns));
+}
+function missingDestinationReason(target, rel) {
+	const parts = rel.split("/");
+	for (let i = 1; i < parts.length; i++) {
+		const parent = parts.slice(0, i).join("/");
+		const stat = lstatSync$1(join(target, parent), { throwIfNoEntry: false });
+		if (stat?.isSymbolicLink()) return `symlink ancestor: ${parent}`;
+		if (stat && !stat.isDirectory()) return `non-directory ancestor: ${parent}`;
+	}
+	return lstatSync$1(join(target, rel), { throwIfNoEntry: false }) ? "exists" : null;
+}
+function removeCopiedExclusions(path, rel) {
+	const entries = readdirSync$1(path, { withFileTypes: true });
+	const excluded = entries.filter((entry) => isCarrySkipped(`${rel}/${entry.name}`));
+	if (excluded.length > 0) {
+		const stat = lstatSync$1(path);
+		chmodSync$1(path, stat.mode | 448);
+		try {
+			for (const entry of excluded) removeTemporaryEntry(join(path, entry.name));
+		} finally {
+			utimesSync(path, stat.atime, stat.mtime);
+			chmodSync$1(path, stat.mode);
+		}
+	}
+	for (const entry of entries) {
+		const child = `${rel}/${entry.name}`;
+		if (entry.isDirectory() && !isCarrySkipped(child)) removeCopiedExclusions(join(path, entry.name), child);
+	}
+}
+function cloneIgnoredEntries({ root, target, patterns }) {
+	const copied = [];
+	const skipped = [];
+	const failed = [];
+	let cloned = true;
+	const guard = trackedGuard(target);
+	if (!guard.known) throw new Error("Could not list the destination's tracked files.");
+	const nested = nestedWorktreePaths(target);
+	for (const rel of listCarryableIgnoredEntries(root, patterns)) {
+		const from = join(root, rel);
+		const to = join(target, rel);
+		try {
+			const reason = guard.covers(rel) ? "tracked" : overlapsNestedWorktree(rel, nested) ? "nested worktree" : missingDestinationReason(target, rel);
+			if (reason) {
+				skipped.push({
+					file: rel,
+					reason
+				});
+				continue;
+			}
+			mkdirSync$1(dirname(to), { recursive: true });
+			try {
+				getExecutor().runFile("cp", [
+					"-Rc",
+					from,
+					to
+				]);
+			} catch {
+				removeTemporaryEntry(to);
+				getExecutor().runFile("cp", [
+					"-R",
+					from,
+					to
+				]);
+				cloned = false;
+			}
+			if (lstatSync$1(to).isDirectory()) removeCopiedExclusions(to, rel);
+			copied.push(rel);
+		} catch (e) {
+			failed.push({
+				file: rel,
+				error: String(e?.message || e)
+			});
+		}
+	}
+	return {
+		copied,
+		skipped,
+		failed,
+		cloned
+	};
+}
+function podsOutOfSync(target, copiedEntries, { read = readFileSync$1 } = {}) {
+	const problems = [];
+	for (const rel of copiedEntries || []) {
+		if (rel !== "Pods" && !rel.endsWith("/Pods")) continue;
+		const iosDir = rel === "Pods" ? "" : rel.slice(0, -5);
+		const manifest = join(target, rel, "Manifest.lock");
+		const podfileLock = join(target, iosDir, "Podfile.lock");
+		if (!existsSync$1(manifest)) continue;
+		if (!existsSync$1(podfileLock)) {
+			problems.push({
+				dir: iosDir || ".",
+				reason: "missing"
+			});
+			continue;
+		}
+		try {
+			if (read(manifest, "utf-8") !== read(podfileLock, "utf-8")) problems.push({
+				dir: iosDir || ".",
+				reason: "mismatch"
+			});
+		} catch {}
+	}
+	return problems;
+}
+const LOCKFILE_NAMES = [
+	"package-lock.json",
+	"yarn.lock",
+	"pnpm-lock.yaml",
+	"bun.lock",
+	"bun.lockb"
+];
+function depsOutOfSync(root, target, copiedEntries, { read = readFileSync$1 } = {}) {
+	const problems = [];
+	for (const rel of copiedEntries || []) {
+		if (rel !== "node_modules" && !rel.endsWith("/node_modules")) continue;
+		const dir = rel === "node_modules" ? "" : rel.slice(0, -13);
+		for (const name of LOCKFILE_NAMES) {
+			const source = join(root, dir, name);
+			const branch = join(target, dir, name);
+			if (!existsSync$1(source) || !existsSync$1(branch)) continue;
+			try {
+				if (read(source, "utf-8") !== read(branch, "utf-8")) problems.push({
+					dir: dir || ".",
+					lockfile: name
+				});
+			} catch {}
+			break;
+		}
+	}
+	return problems;
+}
+const FINGERPRINT_INPUT_FILES = [
+	"app.json",
+	"app.config.ts",
+	"app.config.js",
+	"app.config.mjs",
+	"package.json"
+];
+function dirtyFingerprintFiles(root) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		root,
+		"status",
+		"--porcelain",
+		"--",
+		...FINGERPRINT_INPUT_FILES
+	]);
+	if (out === null || out.trim() === "") return [];
+	return out.split("\n").map((line) => normalizePorcelainLine(line.trimEnd())).filter((line) => line !== "").map((line) => line.slice(3).trim()).filter((path) => path !== "");
+}
+function hasUncommittedWork(dir) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		dir,
+		"status",
+		"--porcelain"
+	]);
+	if (out === null) return null;
+	return out.trim().length > 0;
+}
+function dirtyPaths(dir, { limit = 10 } = {}) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		dir,
+		"status",
+		"--porcelain"
+	]);
+	if (out === null) return [];
+	return out.split("\n").map((l) => normalizePorcelainLine(l.trimEnd())).filter(Boolean).slice(0, limit);
+}
+function normalizePorcelainLine(line) {
+	if (line === "" || line[2] === " ") return line;
+	return ` ${line}`;
+}
+function restoreFile(dir, file) {
+	return getExecutor().runFileQuiet("git", [
+		"-C",
+		dir,
+		"checkout",
+		"--",
+		file
+	]) !== null;
+}
+function isPodInstallChurn(paths) {
+	if (!paths || paths.length === 0) return false;
+	return paths.every((line) => /(?:^|\/)(?:Podfile\.lock|project\.pbxproj)$/.test(line.slice(3).trim()));
+}
+const SAFE_BRANCH_NAME = /^[A-Za-z0-9._/-]+$/;
+function unpushedCommits(dir) {
+	const exec = getExecutor();
+	const branch = exec.runFileQuiet("git", [
+		"-C",
+		dir,
+		"symbolic-ref",
+		"--quiet",
+		"--short",
+		"HEAD"
+	]);
+	const own = branch === null ? "" : branch.trim();
+	const protection = own && SAFE_BRANCH_NAME.test(own) ? [
+		"--remotes",
+		`--exclude=${own}`,
+		"--branches"
+	] : ["--remotes"];
+	if (!own && exec.runFileQuiet("git", [
+		"-C",
+		dir,
+		"rev-parse",
+		"--abbrev-ref",
+		"HEAD"
+	]) === "HEAD") protection.push("--branches");
+	const out = exec.runFileQuiet("git", [
+		"-C",
+		dir,
+		"log",
+		"--oneline",
+		"HEAD",
+		"--not",
+		...protection
+	]);
+	if (out === null) return null;
+	return out.split("\n").map((l) => l.trim()).filter(Boolean);
+}
+function hasRemote(dir) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		dir,
+		"remote"
+	]);
+	return Boolean(out && out.trim().length > 0);
+}
+function branchExists(cwd, branch) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		`refs/heads/${branch}`
+	]);
+	return Boolean(out);
+}
+function resolveFullRef(cwd, ref) {
+	try {
+		const out = getExecutor().runFile("git", [
+			"-C",
+			cwd,
+			"rev-parse",
+			"--verify",
+			"--quiet",
+			"--end-of-options",
+			`${ref}^{commit}`
+		]);
+		return out && out.trim() ? out.trim() : null;
+	} catch {
+		return null;
+	}
+}
+function removeWorktree(path, { force = false } = {}) {
+	const args = [
+		"-C",
+		path,
+		"worktree",
+		"remove",
+		...force ? ["--force"] : [],
+		"--",
+		path
+	];
+	getExecutor().runFile("git", args);
+}
+function deleteBranch(cwd, branch, expectedSha) {
+	if (!SAFE_BRANCH_NAME.test(branch) || branch.startsWith("-")) throw new Error(`Refusing branch ${JSON.stringify(branch)}: it is not a safe local branch name.`);
+	getExecutor().runFile("git", [
+		"-C",
+		cwd,
+		"update-ref",
+		"-d",
+		`refs/heads/${branch}`,
+		expectedSha
+	]);
+}
+function parseWorktrees(out) {
+	const entries = [];
+	let current = {};
+	for (const line of out.split("\n")) if (line.startsWith("worktree ")) {
+		if (current.path) entries.push(current);
+		current = { path: line.slice(9) };
+	} else if (line.startsWith("branch ")) current.branch = line.slice(7).replace("refs/heads/", "");
+	if (current.path) entries.push(current);
+	return entries;
+}
+function listWorktrees(cwd) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"worktree",
+		"list",
+		"--porcelain"
+	]);
+	return out ? parseWorktrees(out) : [];
+}
+//#endregion
+//#region src/optimizations.ts
+const OPTIMIZATION_SHAPES = {
+	optimizations: "object",
+	"optimizations.buildCache": "boolean",
+	"optimizations.remoteBuildCache": "boolean",
+	"optimizations.releaseBundleSwap": "boolean",
+	"optimizations.metroSharedCache": "boolean",
+	"optimizations.ios": "object",
+	"optimizations.ios.compilationCache": "boolean",
+	"optimizations.ios.swiftCompilationCache": "boolean",
+	"optimizations.ios.prefixMapping": "boolean",
+	"optimizations.android": "object",
+	"optimizations.android.compilerCache": "string",
+	"optimizations.android.casToolchain": "path",
+	"optimizations.android.pch": "string",
+	"optimizations.android.gradleBuildCache": "boolean",
+	"optimizations.android.targetAbiOnly": "boolean"
+};
+function optimizationBuildProfile(platform, options) {
+	const selected = platform === "ios" ? options.ios : { 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", [
+		"auto",
+		"ccache",
+		"cas",
+		"none"
+	], "auto");
+	const manifest = env.STIM_ANDROID_CAS_TOOLCHAIN || optimizationValue(settings, "android.casToolchain");
+	if (manifest !== void 0 && (typeof manifest !== "string" || !isAbsolute$1(manifest) || /[\r\n\0]/.test(manifest))) throw new Error("Invalid Android CAS toolchain. Expected an absolute path to the toolchain JSON manifest.");
+	const compilerCache = compiler === "auto" ? manifest ? "cas" : "ccache" : compiler;
+	if (compilerCache === "cas" && !manifest) throw new Error("optimizations.android.compilerCache=cas requires optimizations.android.casToolchain or STIM_ANDROID_CAS_TOOLCHAIN.");
+	return {
+		buildCache: optimizationBoolean(settings, "buildCache"),
+		remoteBuildCache: optimizationBoolean(settings, "remoteBuildCache"),
+		releaseBundleSwap: optimizationBoolean(settings, "releaseBundleSwap"),
+		metroSharedCache: optimizationBoolean(settings, "metroSharedCache"),
+		ios: {
+			compilationCache: optimizationBoolean(settings, "ios.compilationCache"),
+			swiftCompilationCache: optimizationBoolean(settings, "ios.swiftCompilationCache", false),
+			prefixMapping: optimizationBoolean(settings, "ios.prefixMapping")
+		},
+		android: {
+			compilerCache,
+			casToolchain: manifest ?? null,
+			pch: choice("android.pch", [
+				"auto",
+				"on",
+				"off"
+			], "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/engine/metro-reach.ts
+const TUNNEL_MODES = [
+	"auto",
+	"off",
+	"expo",
+	"cloudflared",
+	"ngrok"
+];
+const PUBLIC_METRO_ENV = "STIM_METRO_PUBLIC_URL";
+const MANAGED_PROVIDERS = ["ngrok", "cloudflared"];
+const NAMED = {
+	cloudflared: "`cloudflared` (brew install cloudflared)",
+	ngrok: "`ngrok` (brew install ngrok, then `ngrok config add-authtoken <token>`)"
+};
+function planMetroReach({ mode, metroPort, publicUrl = null, isExpo, available = [] }) {
+	const named = publicUrl?.trim().replace(/\/+$/, "") || null;
+	if (mode === "off") return {
+		origin: `http://localhost:${metroPort}`,
+		gate: false
+	};
+	if (named) return {
+		origin: named,
+		gate: true
+	};
+	if (mode === "expo") {
+		if (!isExpo) return {
+			failed: "metro.tunnel is \"expo\", but this workspace does not run an Expo dev server.",
+			remedy: "Use \"auto\" to let stim start a tunnel, or \"off\" if the device shares this machine."
+		};
+		return { expoTunnel: true };
+	}
+	if (mode === "cloudflared" || mode === "ngrok") {
+		if (!available.includes(mode)) return {
+			failed: `metro.tunnel is "${mode}", but ${mode} is not on PATH.`,
+			remedy: `Install ${NAMED[mode] ?? mode}, or set metro.tunnel to "auto".`
+		};
+		return { start: mode };
+	}
+	const provider = available[0];
+	if (provider) return { start: provider };
+	return {
+		failed: `A remote device cannot reach this workspace's Metro on port ${metroPort}, and no tunnel is available to give it one.`,
+		remedy: `Install ${NAMED.ngrok} or ${NAMED.cloudflared} and Stim will manage the tunnel for you. If you already have one, set metro.publicUrl to its URL. If the device shares this machine (a local \`agent-device proxy\`), set metro.tunnel to "off".`
+	};
+}
+function detectProviders(onPath) {
+	return MANAGED_PROVIDERS.filter((p) => onPath(p));
+}
+//#endregion
+//#region src/settings.ts
+function isPlainObject(v) {
+	return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function mergeSettingsLayers(layers) {
+	const out = {};
+	for (const layer of layers) {
+		if (!isPlainObject(layer)) continue;
+		for (const [key, value] of Object.entries(layer)) if (isPlainObject(value) && isPlainObject(out[key])) out[key] = mergeSettingsLayers([out[key], value]);
+		else if (!(key in out)) out[key] = value;
+	}
+	return out;
+}
+const SETTING_SHAPE_RULES = {
+	boolean: {
+		expected: "true or false",
+		accepts: (value) => typeof value === "boolean"
+	},
+	string: {
+		expected: "a string",
+		accepts: (value) => typeof value === "string"
+	},
+	path: {
+		expected: "a string path",
+		accepts: (value) => typeof value === "string"
+	},
+	strings: {
+		expected: "an array of strings",
+		accepts: (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string")
+	},
+	number: {
+		expected: "a number",
+		accepts: (value) => typeof value === "number"
+	},
+	object: {
+		expected: "an object",
+		accepts: isPlainObject
+	}
+};
+const SETTING_SHAPES = {
+	...OPTIMIZATION_SHAPES,
+	"ios.deviceType": "string",
+	"ios.runtime": "string",
+	"ios.configuration": "string",
+	"ios.remote": "string",
+	"ios.simslimProfile": "path",
+	"ios.signingIdentity": "string",
+	"ios.signingIdentitySha1": "string",
+	"ios.lanHost": "string",
+	"android.systemImage": "string",
+	"android.dataPartitionSizeGb": "number",
+	"android.avdConfigFile": "path",
+	"android.avdConfig": "object",
+	"android.variant": "string",
+	"android.keystore": "path",
+	"android.keystorePassword": "string",
+	"android.remote": "string",
+	"metro.tunnel": "string",
+	"metro.ngrokUrl": "string",
+	"metro.publicUrl": "string",
+	"worktree.exclude": "strings",
+	"cache.provider": "string",
+	"cache.options": "object",
+	caches: "strings"
+};
+const KNOWN_SETTINGS = new Set(Object.keys(SETTING_SHAPES));
+function settingValueAt(settings, path) {
+	let node = settings;
+	for (const segment of path.split(".")) {
+		if (!isPlainObject(node)) return void 0;
+		node = node[segment];
+	}
+	return node;
+}
+function settingShapeErrors(settings) {
+	const errors = [];
+	for (const [path, shape] of Object.entries(SETTING_SHAPES)) {
+		const value = settingValueAt(settings, path);
+		if (value === void 0) continue;
+		const rule = SETTING_SHAPE_RULES[shape];
+		if (rule.accepts(value)) continue;
+		errors.push(`Invalid ${path} setting ${JSON.stringify(value)}. Expected ${rule.expected}.`);
+	}
+	return errors;
+}
+const SETTING_SHAPE_REMEDY = "Run `stim guide settings` for the shape each setting takes.";
+const MAX_ANDROID_DATA_PARTITION_SIZE_GB = 16384;
+function validateAndroidDataPartitionSizeGb(raw) {
+	if (typeof raw !== "number" || !Number.isSafeInteger(raw) || raw < 6 || raw > 16384) throw new Error(`Invalid android.dataPartitionSizeGb setting ${JSON.stringify(raw)}. Expected an integer from 6 through ${MAX_ANDROID_DATA_PARTITION_SIZE_GB} GiB.`);
+	return raw;
+}
+function androidDataPartitionSizeBytes(sizeGb) {
+	return validateAndroidDataPartitionSizeGb(sizeGb) * 1024 ** 3;
+}
+function androidDataPartitionSizeGbRaw(settings) {
+	if (!isPlainObject(settings) || !isPlainObject(settings.android)) return void 0;
+	return settings.android.dataPartitionSizeGb;
+}
+function androidDataPartitionSizeGbSetting(settings) {
+	const raw = androidDataPartitionSizeGbRaw(settings);
+	if (raw === void 0) return 8;
+	return validateAndroidDataPartitionSizeGb(raw);
+}
+function androidDataPartitionSizeGbSettingError(settings) {
+	try {
+		androidDataPartitionSizeGbSetting(settings);
+		return null;
+	} catch (error) {
+		return String(error?.message || error);
+	}
+}
+function yesNoAvdValue(value) {
+	if (value === true || value === "true" || value === "yes") return "yes";
+	if (value === false || value === "false" || value === "no") return "no";
+	throw new Error("expected true, false, \"yes\", or \"no\"");
+}
+function boundedIntegerAvdRule(min, max, unit) {
+	return {
+		help: `integer ${min}-${max}${unit ? ` ${unit}` : ""}`,
+		parse: (value) => {
+			const parsed = typeof value === "number" ? value : typeof value === "string" && /^(0|[1-9]\d*)$/.test(value) ? Number(value) : NaN;
+			if (!Number.isSafeInteger(parsed) || parsed < min || parsed > max) throw new Error(`expected an integer from ${min} through ${max}${unit ? ` ${unit}` : ""}`);
+			return String(parsed);
+		}
+	};
+}
+function enumAvdRule(values) {
+	return {
+		help: values.join("|"),
+		parse: (value) => {
+			if (typeof value !== "string" || !values.includes(value)) throw new Error(`expected one of: ${values.join(", ")}`);
+			return value;
+		}
+	};
+}
+const ANDROID_AVD_CONFIG_RULES = {
+	"hw.cpu.ncore": boundedIntegerAvdRule(1, 64),
+	"hw.gpu.mode": enumAvdRule([
+		"auto",
+		"host",
+		"software",
+		"lavapipe",
+		"swiftshader",
+		"swangle"
+	]),
+	"hw.initialOrientation": enumAvdRule(["portrait", "landscape"]),
+	"hw.lcd.density": boundedIntegerAvdRule(72, 1e3, "dpi"),
+	"hw.lcd.vsync": boundedIntegerAvdRule(1, 1e3, "Hz"),
+	"hw.ramSize": boundedIntegerAvdRule(1536, 8192, "MB"),
+	"hw.screen": enumAvdRule([
+		"no-touch",
+		"touch",
+		"multi-touch"
+	]),
+	"runtime.network.latency": enumAvdRule([
+		"none",
+		"gsm",
+		"hscsd",
+		"gprs",
+		"edge",
+		"umts",
+		"hsdpa",
+		"lte",
+		"evdo",
+		"5g"
+	]),
+	"runtime.network.speed": enumAvdRule([
+		"gsm",
+		"hscsd",
+		"gprs",
+		"edge",
+		"umts",
+		"hsdpa",
+		"lte",
+		"evdo",
+		"5g",
+		"full"
+	]),
+	"vm.heapSize": boundedIntegerAvdRule(16, 4096, "MB")
+};
+const YES_NO_AVD_RULE = {
+	help: "true|false|yes|no",
+	parse: yesNoAvdValue
+};
+for (const key of [
+	"hw.accelerometer",
+	"hw.accelerometer_uncalibrated",
+	"hw.audioInput",
+	"hw.audioOutput",
+	"hw.battery",
+	"hw.dPad",
+	"hw.gps",
+	"hw.gpu.enabled",
+	"hw.gyroscope",
+	"hw.keyboard",
+	"hw.mainKeys",
+	"hw.rotaryInput",
+	"hw.trackBall",
+	"showDeviceFrame"
+]) ANDROID_AVD_CONFIG_RULES[key] = YES_NO_AVD_RULE;
+const ANDROID_AVD_CONFIG_KEYS = Object.freeze(Object.keys(ANDROID_AVD_CONFIG_RULES).toSorted());
+const ANDROID_AVD_CONFIG_HELP = Object.freeze(ANDROID_AVD_CONFIG_KEYS.map((key) => `${key}: ${ANDROID_AVD_CONFIG_RULES[key].help}`));
+function isSafeAndroidAvdConfigKey(key) {
+	return Object.hasOwn(ANDROID_AVD_CONFIG_RULES, key);
+}
+function normalizedAndroidAvdConfigEntry(key, value) {
+	if (typeof key !== "string" || key !== key.trim() || !isSafeAndroidAvdConfigKey(key)) throw new Error(`Unsupported android.avdConfig key ${JSON.stringify(key)}. Use a documented safe hardware override; identity, path, storage, image, snapshot, and boot-lifecycle keys are protected.`);
+	if (typeof value === "string" && /[\r\n\0]/.test(value)) throw new Error(`Invalid android.avdConfig value for ${key}: expected one line.`);
+	try {
+		return [key, ANDROID_AVD_CONFIG_RULES[key].parse(value)];
+	} catch (error) {
+		throw new Error(`Invalid android.avdConfig value for ${key}: ${String(error?.message || error)}.`, { cause: error });
+	}
+}
+function parseAndroidAvdConfigIni(contents) {
+	const entries = {};
+	const lines = contents.replace(/^\uFEFF/, "").split(/\r?\n/);
+	for (let index = 0; index < lines.length; index++) {
+		const line = String(lines[index] ?? "").trim();
+		if (!line || line.startsWith("#") || line.startsWith(";")) continue;
+		const separator = line.indexOf("=");
+		if (separator <= 0) throw new Error(`Invalid android.avdConfigFile line ${index + 1}: expected key=value.`);
+		const [key, value] = normalizedAndroidAvdConfigEntry(line.slice(0, separator), line.slice(separator + 1).trim());
+		if (Object.hasOwn(entries, key)) throw new Error(`Invalid android.avdConfigFile line ${index + 1}: duplicate key ${key}.`);
+		entries[key] = value;
+	}
+	return entries;
+}
+function pathEscapesRoot(root, path) {
+	const child = relative(root, path);
+	return child === ".." || child.startsWith(`..${sep}`) || isAbsolute(child);
+}
+function androidAvdConfigSetting(settings, settingsRoot) {
+	if (!isPlainObject(settings) || !isPlainObject(settings.android)) return {};
+	const android = settings.android;
+	let entries = {};
+	if ("avdConfigFile" in android) {
+		if (typeof android.avdConfigFile !== "string" || !android.avdConfigFile.trim() || android.avdConfigFile !== android.avdConfigFile.trim() || /[\r\n\0]/.test(android.avdConfigFile) || isAbsolute(android.avdConfigFile)) throw new Error("Invalid android.avdConfigFile setting. Expected a relative file path inside the app directory.");
+		try {
+			const root = realpathSync$1(settingsRoot);
+			const candidate = resolve(root, android.avdConfigFile);
+			if (pathEscapesRoot(root, candidate)) throw new Error("path escapes the settings root");
+			const path = realpathSync$1(candidate);
+			if (pathEscapesRoot(root, path)) throw new Error("symlink target escapes the settings root");
+			const stat = statSync$1(path);
+			if (!stat.isFile()) throw new Error("path is not a regular file");
+			if (stat.size > 65536) throw new Error("file exceeds 64 KiB");
+			const contents = readFileSync$1(path, "utf8");
+			if (Buffer.byteLength(contents) > 65536) throw new Error("file exceeds 64 KiB");
+			entries = parseAndroidAvdConfigIni(contents);
+		} catch (error) {
+			throw new Error(`Could not read valid android.avdConfigFile ${android.avdConfigFile}: ${String(error?.message || error)}`, { cause: error });
+		}
+	}
+	if ("avdConfig" in android) {
+		if (!isPlainObject(android.avdConfig)) throw new Error("Invalid android.avdConfig setting. Expected an object of native AVD key/value pairs.");
+		for (const [key, value] of Object.entries(android.avdConfig)) {
+			const [normalizedKey, normalizedValue] = normalizedAndroidAvdConfigEntry(key, value);
+			entries[normalizedKey] = normalizedValue;
+		}
+	}
+	return entries;
+}
+function androidAvdConfigSettingError(settings, projectPath) {
+	try {
+		androidAvdConfigSetting(settings, projectPath);
+		return null;
+	} catch (error) {
+		return String(error?.message || error);
+	}
+}
+function iosSimSlimProfileSetting(settings, settingsRoot) {
+	if (!isPlainObject(settings) || !isPlainObject(settings.ios) || !("simslimProfile" in settings.ios)) return null;
+	const value = settings.ios.simslimProfile;
+	if (typeof value !== "string" || !value.trim() || value !== value.trim() || /[\r\n\0]/.test(value) || isAbsolute(value)) throw new Error("Invalid ios.simslimProfile setting. Expected a relative JSON file path inside the app directory.");
+	try {
+		const root = realpathSync$1(settingsRoot);
+		const candidate = resolve(root, value);
+		if (pathEscapesRoot(root, candidate)) throw new Error("path escapes the settings root");
+		const path = realpathSync$1(candidate);
+		if (pathEscapesRoot(root, path)) throw new Error("symlink target escapes the settings root");
+		const stat = statSync$1(path);
+		if (!stat.isFile()) throw new Error("path is not a regular file");
+		if (stat.size > 65536) throw new Error("file exceeds 64 KiB");
+		return path;
+	} catch (error) {
+		throw new Error(`Could not read ios.simslimProfile ${value}: ${String(error?.message || error)}`, { cause: error });
+	}
+}
+function iosString(settings, key) {
+	if (!isPlainObject(settings) || !isPlainObject(settings.ios)) return void 0;
+	return settings.ios[key];
+}
+function iosSigningIdentitySetting(settings) {
+	const raw = iosString(settings, "signingIdentity");
+	return typeof raw === "string" && raw.trim() !== "" ? raw.trim() : null;
+}
+function iosSigningIdentitySettingError(settings) {
+	const raw = iosString(settings, "signingIdentity");
+	if (raw === void 0) return null;
+	if (typeof raw !== "string" || raw.trim() === "" || /[\r\n\0]/.test(raw)) return `Invalid ios.signingIdentity setting ${JSON.stringify(raw)}. Expected the identity name \`security find-identity -v -p codesigning\` prints, such as "Apple Development: Jane (TEAMID5678)".`;
+	return null;
+}
+const SIGNING_IDENTITY_SHA1 = /^[0-9A-Fa-f]{40}$/;
+function iosSigningIdentitySha1Setting(settings) {
+	const raw = iosString(settings, "signingIdentitySha1");
+	return typeof raw === "string" && SIGNING_IDENTITY_SHA1.test(raw.trim()) ? raw.trim().toUpperCase() : null;
+}
+function iosSigningIdentitySha1SettingError(settings) {
+	const raw = iosString(settings, "signingIdentitySha1");
+	if (raw === void 0) return null;
+	if (typeof raw !== "string" || !SIGNING_IDENTITY_SHA1.test(raw.trim())) return `Invalid ios.signingIdentitySha1 setting ${JSON.stringify(raw)}. Expected the 40-character hex SHA-1 hash \`security find-identity -v -p codesigning\` prints beside the identity name.`;
+	return null;
+}
+const LAN_HOST = /^(?!-)[A-Za-z0-9-]+(?:\.(?!-)[A-Za-z0-9-]+)*$/;
+function iosLanHostSetting(settings) {
+	const raw = iosString(settings, "lanHost");
+	return typeof raw === "string" && LAN_HOST.test(raw.trim()) ? raw.trim() : null;
+}
+function iosLanHostSettingError(settings) {
+	const raw = iosString(settings, "lanHost");
+	if (raw === void 0) return null;
+	if (typeof raw !== "string" || !LAN_HOST.test(raw.trim())) return `Invalid ios.lanHost setting ${JSON.stringify(raw)}. Expected a bare address or hostname the phone can reach, such as "192.168.1.42" -- never a URL, a scheme, or a port.`;
+	return null;
+}
+function unknownSettingKeys(settings, prefix = "") {
+	if (!isPlainObject(settings)) return [];
+	const unknown = [];
+	for (const [key, value] of Object.entries(settings)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		if (KNOWN_SETTINGS.has(path) && ![...KNOWN_SETTINGS].some((k) => k.startsWith(`${path}.`))) continue;
+		if (isPlainObject(value) && [...KNOWN_SETTINGS].some((k) => k.startsWith(`${path}.`))) {
+			unknown.push(...unknownSettingKeys(value, path));
+			continue;
+		}
+		unknown.push(path);
+	}
+	return unknown;
+}
+function readCommittedSettings(directory) {
+	if (!directory) return {};
+	const p = join(directory, ".stim.json");
+	if (!existsSync$1(p)) return {};
+	try {
+		const parsed = JSON.parse(readFileSync$1(p, "utf-8"));
+		return isPlainObject(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function resolveSettings({ projectPath, gitCommonDir, repoRoot }) {
+	const machine = loadConfig();
+	return mergeSettingsLayers([
+		projectPath ? getProjectSettings(projectPath) : null,
+		gitCommonDir ? getRepoSettings(gitCommonDir) : null,
+		readCommittedSettings(projectPath ?? repoRoot),
+		machine?.optimizations === void 0 ? null : { optimizations: machine.optimizations }
+	]);
+}
+function settingsForProject(root) {
+	return resolveSettings({
+		projectPath: root,
+		gitCommonDir: gitCommonDir(root),
+		repoRoot: repoRoot(root) ?? root
+	});
+}
+function projectOptimizations(root) {
+	return resolveOptimizations(settingsForProject(root));
+}
+function projectMetroSharedCache(root) {
+	return resolveMetroSharedCache(settingsForProject(root));
+}
+function cacheBlock(layer) {
+	if (!isPlainObject(layer) || !isPlainObject(layer.cache)) return null;
+	return layer.cache;
+}
+function resolveCacheProviderConfig({ projectPath, gitCommonDir, repoRoot }) {
+	const layers = [
+		{
+			settings: projectPath ? getProjectSettings(projectPath) : {},
+			baseDir: projectPath ?? null
+		},
+		{
+			settings: gitCommonDir ? getRepoSettings(gitCommonDir) : {},
+			baseDir: repoRoot ?? projectPath ?? null
+		},
+		{
+			settings: readCommittedSettings(projectPath),
+			baseDir: projectPath ?? null
+		}
+	];
+	let provider = null;
+	let baseDir = null;
+	for (const layer of layers) {
+		const reference = cacheBlock(layer.settings)?.provider;
+		if (typeof reference !== "string" || reference.trim() === "" || layer.baseDir === null) continue;
+		provider = reference.trim();
+		baseDir = layer.baseDir;
+		break;
+	}
+	if (provider === null || baseDir === null) return null;
+	const options = mergeSettingsLayers(layers.map((layer) => {
+		const block = cacheBlock(layer.settings)?.options;
+		return isPlainObject(block) ? block : null;
+	}));
+	return {
+		provider,
+		options,
+		baseDir
+	};
+}
+function cacheProviderSettingError(settings) {
+	const block = settings.cache;
+	if (!isPlainObject(block)) return block === void 0 ? null : `Invalid cache setting ${JSON.stringify(block)}. Expected an object with provider and options.`;
+	if ("provider" in block && (typeof block.provider !== "string" || block.provider.trim() === "")) return `Invalid cache.provider setting ${JSON.stringify(block.provider)}. Expected a module path or package name.`;
+	if ("options" in block && !isPlainObject(block.options)) return `Invalid cache.options setting ${JSON.stringify(block.options)}. Expected an object.`;
+	return null;
+}
+const REMOTE_DEVICE_BACKENDS = ["proxy", "eas"];
+function remoteIosSetting(settings) {
+	return remoteSetting(settings, "ios");
+}
+function remoteAndroidSetting(settings) {
+	return remoteSetting(settings, "android");
+}
+function remoteSetting(settings, platform) {
+	const block = settings[platform];
+	if (!isPlainObject(block)) return null;
+	const remote = block.remote;
+	return typeof remote === "string" && REMOTE_DEVICE_BACKENDS.includes(remote) ? remote : null;
+}
+function remoteDeviceSettingError(settings) {
+	for (const platform of ["ios", "android"]) {
+		const block = settings[platform];
+		if (!isPlainObject(block) || !("remote" in block)) continue;
+		if (remoteSetting(settings, platform) === null) return `Invalid ${platform}.remote setting ${JSON.stringify(block.remote)}. Expected one of: ${REMOTE_DEVICE_BACKENDS.join(", ")}.`;
+	}
+	return null;
+}
+function tunnelModeSetting(settings) {
+	const block = settings.metro;
+	if (typeof block !== "object" || block === null) return null;
+	const mode = block.tunnel;
+	return typeof mode === "string" && TUNNEL_MODES.includes(mode) ? mode : null;
+}
+function metroTunnelSettingError(settings) {
+	const block = settings.metro;
+	if (!isPlainObject(block)) return null;
+	if ("tunnel" in block) {
+		const mode = block.tunnel;
+		if (typeof mode !== "string" || !TUNNEL_MODES.includes(mode)) return `Invalid metro.tunnel setting ${JSON.stringify(mode)}. Expected one of: ${TUNNEL_MODES.join(", ")}.`;
+	}
+	if (!("ngrokUrl" in block)) return null;
+	if (block.tunnel !== "ngrok") return "metro.ngrokUrl requires metro.tunnel to be \"ngrok\".";
+	if (normalizedHttpsUrl(block.ngrokUrl) === null) return "metro.ngrokUrl must be a valid HTTPS URL.";
+	return null;
+}
+function publicUrlSetting(settings) {
+	const block = settings.metro;
+	if (typeof block !== "object" || block === null) return null;
+	const url = block.publicUrl;
+	return typeof url === "string" && url.trim() ? url : null;
+}
+function ngrokUrlSetting(settings) {
+	const block = settings.metro;
+	if (typeof block !== "object" || block === null) return null;
+	if (block.tunnel !== "ngrok") return null;
+	return normalizedHttpsUrl(block.ngrokUrl);
+}
+function normalizedHttpsUrl(raw) {
+	if (typeof raw !== "string" || !raw.trim()) return null;
+	try {
+		return new URL(raw.trim()).protocol === "https:" ? raw.trim().replace(/\/+$/, "") : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/supervisor/metro-store.ts
+function metroStoreName(root) {
+	try {
+		const name = JSON.parse(readFileSync(join$1(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$1(metroCacheRoot());
+	const dir = resolve$1(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$1(fileURLToPath(fromUrl));
+	for (const rel of ["../shim", "../../shim"]) {
+		const candidate = resolve$1(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
+export { listWorktrees as $, remoteIosSetting as A, optimizationBuildProfile as B, metroTunnelSettingError as C, publicUrlSetting as D, projectOptimizations as E, unknownSettingKeys as F, depsOutOfSync as G, branchExists as H, PUBLIC_METRO_ENV as I, gitCommonDir as J, dirtyFingerprintFiles as K, detectProviders as L, resolveSettings as M, settingShapeErrors as N, remoteAndroidSetting as O, tunnelModeSetting as P, isPodInstallChurn as Q, planMetroReach as R, iosSimSlimProfileSetting as S, projectMetroSharedCache as T, cloneIgnoredEntries as U, resolveOptimizations as V, deleteBranch as W, hasUncommittedWork as X, hasRemote as Y, isMainWorkingTree as Z, iosLanHostSettingError as _, metroStoreRoot as a, restoreFile as at, iosSigningIdentitySha1Setting as b, REMOTE_DEVICE_BACKENDS as c, filesystemDevice as ct, androidAvdConfigSettingError as d, temporaryRoot as dt, podsOutOfSync as et, androidDataPartitionSizeBytes as f, iosLanHostSetting as g, cacheProviderSettingError as h, metroStoreConfirmedRoot as i, resolveFullRef as it, resolveCacheProviderConfig as j, remoteDeviceSettingError as k, SETTING_SHAPE_REMEDY as l, makeTemporaryDirectory as lt, androidDataPartitionSizeGbSettingError as m, expoMetroConfigPath as n, removeWorktree as nt, registerMetroStore as o, unpushedCommits as ot, androidDataPartitionSizeGbSetting as p, dirtyPaths as q, expoMetroStoreEnv as r, repoRoot as rt, ANDROID_AVD_CONFIG_HELP as s, warmWorktreePaths as st, appendCacheStore as t, readWorktreeExclude as tt, androidAvdConfigSetting as u, removeTemporaryEntry as ut, iosSigningIdentitySetting as v, ngrokUrlSetting as w, iosSigningIdentitySha1SettingError as x, iosSigningIdentitySettingError as y, artifactCachePolicy as z };