stim 1.14.0 → 1.16.0

package/dist/settings-oTSkkNrM.mjs

@@ -0,0 +1,1439 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { _ as loadConfig$1, d as getConfigDir, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-D0DbpZtM.mjs";
+import { createHash } from "node:crypto";
+import { accessSync, chmodSync, constants, lstatSync, mkdirSync, mkdtempSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+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 as utimesSync$1 } from "fs";
+import { 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 "path";
+import { buildCacheRoot } from "@stim-cli/core";
+import { ANDROID_COMPILER_CACHE_CHOICES, ANDROID_PCH_CHOICES, REMOTE_DEVICE_BACKENDS, SETTINGS, SETTING_GROUPS, TUNNEL_MODES, WEB_VIEWPORTS, acceptsShape, coerceSettingText, expectedShape, isLayeredSetting, settingDefinition, settingValueError } from "@stim-cli/core/state";
+import { tmpdir } from "node:os";
+//#region src/temporary.ts
+function existingPath(path) {
+	const missing = [];
+	let current = resolve(path);
+	while (!lstatSync(current, { throwIfNoEntry: false })) {
+		missing.unshift(basename(current));
+		current = dirname(current);
+	}
+	const existing = realpathSync(current);
+	return {
+		existing,
+		resolved: join(existing, ...missing)
+	};
+}
+function filesystemDevice(path) {
+	return statSync(existingPath(path).existing).dev;
+}
+function outsideWorkingTree(path) {
+	let current = path;
+	while (true) {
+		if (lstatSync(join(current, ".git"), { throwIfNoEntry: false })) return false;
+		const parent = dirname(current);
+		if (parent === current) return true;
+		current = parent;
+	}
+}
+function inside(parent, path) {
+	const rel = relative(parent, path);
+	return rel === "" || rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+function temporaryRoot(near) {
+	const reference = existingPath(near);
+	const insideReference = (path) => inside(reference.resolved, path);
+	const override = process.env.STIM_TMPDIR ?? loadConfig$1()?.tempDir;
+	if (override !== void 0) {
+		if (typeof override !== "string" || !isAbsolute(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 cache = existingPath(buildCacheRoot()).resolved;
+	const device = statSync(existing).dev;
+	const candidates = [tmpdir()];
+	let current = existing === reference.resolved || !statSync(existing).isDirectory() ? dirname(existing) : existing;
+	while (statSync(current).dev === device) {
+		candidates.push(current);
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	for (const candidate of candidates) try {
+		const path = realpathSync(candidate);
+		if (statSync(path).dev !== device || insideReference(path) || inside(cache, 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(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(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(path, entry.name));
+	}
+	rmSync(path, {
+		recursive: true,
+		force: true
+	});
+}
+//#endregion
+//#region src/workspace/worktree.ts
+const CARRY_SKIP_BASENAMES = /* @__PURE__ */ new Set([
+	".DerivedData",
+	".DS_Store",
+	".idea",
+	".jj"
+]);
+function isCarrySkipped(rel) {
+	return /(^|\/)android\/build\/generated\/autolinking(\/|$)/.test(rel) || String(rel).split("/").some((seg) => CARRY_SKIP_BASENAMES.has(seg));
+}
+function nativePath(path) {
+	return sep$1 === "/" ? path : path.replaceAll("/", sep$1);
+}
+function gitCommonDir(cwd) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"rev-parse",
+		"--path-format=absolute",
+		"--git-common-dir"
+	]);
+	return out ? nativePath(out.trim()) : null;
+}
+function repoRoot(cwd) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"rev-parse",
+		"--show-toplevel"
+	]);
+	return out ? nativePath(out.trim()) : null;
+}
+function locallyKnownUpstream(projectRoot) {
+	try {
+		const name = getExecutor().runFile("git", [
+			"-C",
+			projectRoot,
+			"rev-parse",
+			"--abbrev-ref",
+			"--symbolic-full-name",
+			"@{upstream}"
+		], { timeoutMs: 5e3 });
+		const counts = getExecutor().runFile("git", [
+			"-C",
+			projectRoot,
+			"rev-list",
+			"--left-right",
+			"--count",
+			"HEAD...@{upstream}"
+		], { timeoutMs: 5e3 }).trim().split(/\s+/).map(Number);
+		const ahead = counts[0] ?? NaN;
+		const behind = counts[1] ?? NaN;
+		if (!name || !Number.isInteger(ahead) || !Number.isInteger(behind)) return null;
+		return {
+			name,
+			ahead,
+			behind
+		};
+	} catch {
+		return null;
+	}
+}
+function warmWorktreePaths(cwd) {
+	const currentRoot = repoRoot(cwd);
+	if (!currentRoot) throw new Error("Not a git repository.");
+	const target = realpathSync$1(currentRoot);
+	const source = resolveSourceCheckout(target);
+	if ("refusal" in source) throw new Error(source.refusal);
+	if (!source.entries.find((entry) => canonicalPath(entry.path) === target)) throw new Error("Could not identify the linked worktree and its source checkout.");
+	const root = realpathSync$1(source.path);
+	if (root === target) throw new Error("Run stim worktree warm from a linked worktree, not the source checkout.");
+	const sourceRoot = repoRoot(root);
+	const sourceCommon = gitCommonDir(root);
+	const targetCommon = gitCommonDir(target);
+	if (!sourceRoot || realpathSync$1(sourceRoot) !== root || !sourceCommon || !targetCommon || realpathSync$1(sourceCommon) !== realpathSync$1(targetCommon)) throw new Error("Could not verify that the source 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$1(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$1(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$1(source, canonicalPath(entry.path));
+		if (!rel || rel === ".." || rel.startsWith(`..${sep$1}`) || isAbsolute$1(rel)) continue;
+		paths.add(rel.split(sep$1).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$1(target, parent), { throwIfNoEntry: false });
+		if (stat?.isSymbolicLink()) return `symlink ancestor: ${parent}`;
+		if (stat && !stat.isDirectory()) return `non-directory ancestor: ${parent}`;
+	}
+	return lstatSync$1(join$1(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$1(path, entry.name));
+		} finally {
+			utimesSync$1(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$1(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$1(root, rel);
+		const to = join$1(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$1(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$1(target, rel, "Manifest.lock");
+		const podfileLock = join$1(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 = [
+	"pnpm-lock.yaml",
+	"yarn.lock",
+	"bun.lock",
+	"bun.lockb",
+	"package-lock.json"
+];
+function npmInstallMatches(wanted, installed) {
+	if (!wanted.packages || !installed.packages) return null;
+	for (const [key, entry] of Object.entries(wanted.packages)) {
+		if (!key.includes("node_modules/") || entry.link) continue;
+		const present = installed.packages[key];
+		if (!present && (entry.optional || entry.devOptional)) continue;
+		if (present?.version !== entry.version) return false;
+	}
+	return true;
+}
+function lastYamlDocument(text) {
+	return (text.split(/^---$/m).at(-1) ?? "").trim();
+}
+function yarnClassicInstallMatches(lockfile, integrity) {
+	if (!integrity.lockfileEntries) return null;
+	const wanted = [...lockfile.matchAll(/^ {2}resolved "([^"]+)"$/gm)].flatMap((m) => m[1] ?? []);
+	if (wanted.length === 0) return null;
+	const installed = new Set(Object.values(integrity.lockfileEntries));
+	return wanted.every((url) => installed.has(url));
+}
+function yarnBerryInstallMatches(lockfile, state) {
+	const installed = new Set([...state.matchAll(/^"?([^\s"#][^"]*?)"?:$/gm)].flatMap((m) => m[1]?.replace(/@virtual:[^#]+#/, "@") ?? []));
+	let entries = 0;
+	for (const entry of lockfile.split(/\n(?=\S)/)) {
+		const resolution = /^ {2}resolution: "([^"]+)"$/m.exec(entry)?.[1];
+		if (!resolution) continue;
+		entries += 1;
+		if (installed.has(resolution) || /^ {2}conditions: /m.test(entry)) continue;
+		return false;
+	}
+	return entries === 0 ? null : true;
+}
+function installedMatchesLockfile(dir, lockfile, { read = readFileSync$1 } = {}) {
+	const text = (rel) => {
+		try {
+			return read(join$1(dir, rel), "utf-8").replaceAll("\r\n", "\n");
+		} catch {
+			return null;
+		}
+	};
+	const wanted = text(lockfile);
+	if (wanted === null) return null;
+	try {
+		if (lockfile === "package-lock.json") {
+			const installed = text("node_modules/.package-lock.json");
+			return installed === null ? null : npmInstallMatches(JSON.parse(wanted), JSON.parse(installed));
+		}
+		if (lockfile === "pnpm-lock.yaml") {
+			const installed = text("node_modules/.pnpm/lock.yaml");
+			return installed === null ? null : lastYamlDocument(wanted) === lastYamlDocument(installed);
+		}
+		if (lockfile === "yarn.lock") {
+			if (/^__metadata:$/m.test(wanted)) {
+				const berry = text("node_modules/.yarn-state.yml");
+				return berry === null ? null : yarnBerryInstallMatches(wanted, berry);
+			}
+			const classic = text("node_modules/.yarn-integrity");
+			return classic === null ? null : yarnClassicInstallMatches(wanted, JSON.parse(classic));
+		}
+	} catch {}
+	return null;
+}
+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);
+		const name = LOCKFILE_NAMES.find((candidate) => existsSync$1(join$1(target, dir, candidate)));
+		if (!name) continue;
+		const installed = installedMatchesLockfile(join$1(target, dir), name, { read });
+		if (installed === false) {
+			problems.push({
+				dir: dir || ".",
+				lockfile: name,
+				reason: "installed"
+			});
+			continue;
+		}
+		const source = join$1(root, dir, name);
+		if (installed === true || !existsSync$1(source)) continue;
+		try {
+			if (read(source, "utf-8") !== read(join$1(target, dir, name), "utf-8")) problems.push({
+				dir: dir || ".",
+				lockfile: name,
+				reason: "lockfile"
+			});
+		} catch {}
+	}
+	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", [
+		"--no-optional-locks",
+		"-C",
+		dir,
+		"status",
+		"--porcelain"
+	]);
+	if (out === null) return null;
+	return out.trim().length > 0;
+}
+function dirtyPaths(dir, { limit = 10 } = {}) {
+	const out = getExecutor().runFileQuiet("git", [
+		"--no-optional-locks",
+		"-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, { from, force = false, platform = process.platform }) {
+	const args = [
+		...platform === "win32" ? ["-c", "core.longpaths=true"] : [],
+		"-C",
+		from,
+		"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: nativePath(line.slice(9)) };
+	} else if (line.startsWith("branch ")) current.branch = line.slice(7).replace("refs/heads/", "");
+	else if (line === "prunable" || line.startsWith("prunable ")) current.prunable = true;
+	else if (line === "locked" || line.startsWith("locked ")) current.locked = true;
+	else if (line === "bare") current.bare = true;
+	if (current.path) entries.push(current);
+	return entries;
+}
+function hasPopulatedSubmodules(worktree) {
+	const modules = getExecutor().runFileQuiet("git", [
+		"-C",
+		worktree,
+		"rev-parse",
+		"--git-path",
+		"modules"
+	]);
+	if (modules && existsSync$1(resolve$1(worktree, nativePath(modules)))) return true;
+	return (getExecutor().runFileQuiet("git", [
+		"-C",
+		worktree,
+		"ls-files",
+		"--stage",
+		"-z"
+	]) ?? "").split("\0").some((line) => line.startsWith("160000 ") && existsSync$1(join$1(worktree, line.slice(line.indexOf("	") + 1), ".git")));
+}
+function listWorktrees(cwd) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		cwd,
+		"worktree",
+		"list",
+		"--porcelain"
+	]);
+	return out ? parseWorktrees(out) : [];
+}
+function branchOf(head) {
+	return head.startsWith("ref: refs/heads/") ? head.slice(16) : void 0;
+}
+/**
+* The linked worktrees recorded under a git common dir, read from `worktrees/<id>/gitdir` and `HEAD` without running
+* git or touching the worktree directories, sorted by path. The worktree with the branch the common dir's own `HEAD`
+* names (the main checkout's branch, or a bare repository's source checkout) is left out.
+*/
+function linkedWorktreesOnDisk(commonDir) {
+	const admin = join$1(commonDir, "worktrees");
+	let ids;
+	let sourceBranch;
+	try {
+		ids = readdirSync$1(admin);
+		sourceBranch = branchOf(readFileSync$1(join$1(commonDir, "HEAD"), "utf-8").trim());
+	} catch {
+		return [];
+	}
+	return ids.flatMap((id) => {
+		try {
+			const gitdir = readFileSync$1(join$1(admin, id, "gitdir"), "utf-8").trim();
+			const branch = branchOf(readFileSync$1(join$1(admin, id, "HEAD"), "utf-8").trim());
+			if (branch && branch === sourceBranch) return [];
+			const path = dirname$1(resolve$1(admin, id, nativePath(gitdir)));
+			return [branch ? {
+				path,
+				branch
+			} : { path }];
+		} catch {
+			return [];
+		}
+	}).toSorted((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+/**
+* The git common dir of the repository containing `start`, read from `.git` and `commondir` files without running
+* git. Returns null when `start` is missing, unreadable, or not inside a repository.
+*/
+function gitCommonDirOnDisk(start) {
+	try {
+		for (let dir = realpathSync$1.native(start);; dir = dirname$1(dir)) {
+			const dotGit = join$1(dir, ".git");
+			if (existsSync$1(dotGit)) {
+				if (statSync$1(dotGit).isDirectory()) return realpathSync$1.native(dotGit);
+				const gitdir = /^gitdir: (.+)$/m.exec(readFileSync$1(dotGit, "utf-8"))?.[1]?.trim();
+				if (!gitdir) return null;
+				const linked = resolve$1(dir, gitdir);
+				const commondir = join$1(linked, "commondir");
+				return realpathSync$1.native(existsSync$1(commondir) ? resolve$1(linked, readFileSync$1(commondir, "utf-8").trim()) : linked);
+			}
+			if (dirname$1(dir) === dir) return null;
+		}
+	} catch {
+		return null;
+	}
+}
+function selectSourceCheckout(entries, bareHead) {
+	const first = entries[0];
+	if (!first) return { refusal: "Git lists no worktrees for this repository." };
+	if (!first.bare) return { path: first.path };
+	const bare = first.path;
+	const checkouts = entries.filter((entry) => !entry.bare && !entry.prunable);
+	const listed = checkouts.map((entry) => `${entry.branch ?? "detached"} (${entry.path})`).join(", ") || "none";
+	const pointHead = `  git -C ${bare} symbolic-ref HEAD refs/heads/<branch>`;
+	if (!bareHead) return { refusal: `The bare repository at ${bare} has a detached HEAD, so Stim cannot tell which worktree is the source checkout. Point HEAD at the source branch, then retry:\n${pointHead}\nChecked-out branches: ${listed}` };
+	const matches = checkouts.filter((entry) => entry.branch === bareHead);
+	const [only] = matches;
+	if (only && matches.length === 1) return { path: only.path };
+	if (!only) {
+		const stale = entries.find((entry) => entry.prunable && entry.branch === bareHead);
+		const beside = checkouts[0] ? dirname$1(checkouts[0].path) : bare;
+		return { refusal: `The bare repository at ${bare} points HEAD at ${bareHead}, but no worktree has ${bareHead} checked out, so Stim has no source checkout to copy from. ${stale ? `Its worktree at ${stale.path} is missing. Recreate it, then retry:\n  git -C ${bare} worktree prune\n  git -C ${bare} worktree add ${stale.path} ${bareHead}\n` : `Create one, then retry:\n  git -C ${bare} worktree add ${join$1(beside, bareHead)} ${bareHead}\n`}Or point HEAD at a branch that is checked out (${listed}):\n${pointHead}` };
+	}
+	return { refusal: `The bare repository at ${bare} points HEAD at ${bareHead}, which is checked out in more than one worktree: ${matches.map((entry) => entry.path).join(", ")}. Remove the extra worktrees, or point HEAD at a branch checked out once, then retry:\n${pointHead}` };
+}
+function bareHeadBranch(bare) {
+	const out = getExecutor().runFileQuiet("git", [
+		"-C",
+		bare,
+		"symbolic-ref",
+		"--quiet",
+		"HEAD"
+	])?.trim();
+	return out?.startsWith("refs/heads/") ? out.slice(11) : null;
+}
+function sourceCheckoutOf(entries) {
+	const first = entries[0];
+	return selectSourceCheckout(entries, first?.bare ? bareHeadBranch(first.path) : null);
+}
+function resolveSourceCheckout(cwd) {
+	const entries = listWorktrees(cwd);
+	return {
+		entries,
+		...sourceCheckoutOf(entries)
+	};
+}
+//#endregion
+//#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/engine/metro-reach.ts
+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>`)",
+	tailscale: "Tailscale and sign in to your tailnet"
+};
+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" || mode === "tailscale") {
+		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.find((candidate) => candidate !== "tailscale");
+	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 resolveTailscaleBinary(findExecutable) {
+	return findExecutable("tailscale") ?? findExecutable("/Applications/Tailscale.app/Contents/MacOS/Tailscale");
+}
+function detectProviders(onPath, mode = "auto") {
+	if (mode === "tailscale") return resolveTailscaleBinary((bin) => onPath(bin) ? bin : null) ? ["tailscale"] : [];
+	return MANAGED_PROVIDERS.filter((p) => onPath(p));
+}
+//#endregion
+//#region src/workspace/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 LAYERED_SETTINGS = SETTINGS.filter(isLayeredSetting);
+const KNOWN_SETTINGS = /* @__PURE__ */ new Set([...LAYERED_SETTINGS.map((setting) => setting.key), ...SETTING_GROUPS]);
+const BOUNDS_CHECKED_WHEN_USED = /* @__PURE__ */ new Set(["android.dataPartitionSizeGb"]);
+const SETTINGS_WITH_RESOLVE_TIME_FALLBACK = /* @__PURE__ */ new Set(["optimizations.android.casToolchain"]);
+const PATH_SETTINGS = Object.freeze(LAYERED_SETTINGS.filter((setting) => setting.type.kind === "path").map((setting) => setting.key));
+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 group of SETTING_GROUPS) {
+		const value = settingValueAt(settings, group);
+		if (value === void 0 || isPlainObject(value)) continue;
+		errors.push(`Invalid ${group} setting ${JSON.stringify(value)}. Expected an object.`);
+	}
+	for (const setting of LAYERED_SETTINGS) {
+		if (SETTINGS_WITH_RESOLVE_TIME_FALLBACK.has(setting.key)) continue;
+		const value = settingValueAt(settings, setting.key);
+		if (value === void 0) continue;
+		const expected = setting.key === "ios.remote" || setting.type.kind === "number" && !BOUNDS_CHECKED_WHEN_USED.has(setting.key) ? settingValueError(setting, value) : acceptsShape(setting, value) ? null : expectedShape(setting.type);
+		if (expected) errors.push(`Invalid ${setting.key} setting ${JSON.stringify(value)}. Expected ${expected}.`);
+	}
+	return errors;
+}
+const SETTING_SHAPE_REMEDY = "Run `stim guide settings` for the shape each setting takes.";
+const MIN_ANDROID_DATA_PARTITION_SIZE_GB = 6;
+const DEFAULT_ANDROID_DATA_PARTITION_SIZE_GB = 8;
+const MAX_ANDROID_DATA_PARTITION_SIZE_GB = 16384;
+function validateAndroidDataPartitionSizeGb(raw) {
+	if (typeof raw !== "number" || !Number.isSafeInteger(raw) || raw < MIN_ANDROID_DATA_PARTITION_SIZE_GB || raw > MAX_ANDROID_DATA_PARTITION_SIZE_GB) throw new Error(`Invalid android.dataPartitionSizeGb setting ${JSON.stringify(raw)}. Expected an integer from ${MIN_ANDROID_DATA_PARTITION_SIZE_GB} 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 DEFAULT_ANDROID_DATA_PARTITION_SIZE_GB;
+	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$1(root, path);
+	return child === ".." || child.startsWith(`..${sep$1}`) || isAbsolute$1(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$1(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$1(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$1(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$1(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 (path === "$schema") continue;
+		if (KNOWN_SETTINGS.has(path) && (!isPlainObject(value) || ![...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$1(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 setSettingValueAt(settings, path, value) {
+	const segments = path.split(".");
+	let node = settings;
+	for (const segment of segments.slice(0, -1)) {
+		const next = node[segment];
+		if (!isPlainObject(next)) node[segment] = {};
+		node = node[segment];
+	}
+	node[segments[segments.length - 1]] = value;
+}
+const MACHINE_READABLE_SETTINGS = SETTINGS.filter((setting) => isLayeredSetting(setting) && setting.scopes.includes("machine") && !setting.key.startsWith("optimizations."));
+function machineLayerSettings(machine) {
+	const settings = {};
+	const optimizations = settingValueAt(machine, "optimizations");
+	if (optimizations !== void 0) settings.optimizations = optimizations;
+	for (const setting of MACHINE_READABLE_SETTINGS) {
+		const value = settingValueAt(machine, setting.key);
+		if (value !== void 0) setSettingValueAt(settings, setting.key, value);
+	}
+	return Object.keys(settings).length > 0 ? settings : null;
+}
+function settingsLayers({ projectPath, gitCommonDir, repoRoot }) {
+	const machine = loadConfig$1();
+	const machineFile = getConfigPath$1();
+	const committedDir = projectPath ?? repoRoot;
+	const machineSettings = machineLayerSettings(machine);
+	return [
+		projectPath ? {
+			scope: "workspace",
+			file: `${machineFile} (projects["${projectPath}"].settings)`,
+			settings: getProjectSettings(projectPath)
+		} : null,
+		gitCommonDir ? {
+			scope: "repo",
+			file: `${machineFile} (repos["${gitCommonDir}"].settings)`,
+			settings: getRepoSettings(gitCommonDir)
+		} : null,
+		committedDir ? {
+			scope: "committed",
+			file: join$1(committedDir, ".stim.json"),
+			settings: readCommittedSettings(committedDir)
+		} : null,
+		machineSettings ? {
+			scope: "machine",
+			file: machineFile,
+			settings: machineSettings
+		} : null
+	].filter((layer) => layer !== null);
+}
+function settingOrigin(layers, dottedKey) {
+	for (const layer of layers) {
+		const value = settingValueAt(layer.settings, dottedKey);
+		if (value !== void 0) return {
+			file: layer.file,
+			value
+		};
+	}
+	return null;
+}
+/** The layer a resolved setting's value came from, or null when no layer set it (a default or a flag). */
+function settingOriginScope(layers, dottedKey) {
+	for (const layer of layers) if (settingValueAt(layer.settings, dottedKey) !== void 0) return layer.scope;
+	return null;
+}
+function settingFile(context, dottedKey) {
+	return settingOrigin(settingsLayers(context), dottedKey)?.file ?? null;
+}
+function resolveSettings(context) {
+	return mergeSettingsLayers(settingsLayers(context).map((layer) => layer.settings));
+}
+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
+		}
+	];
+	const references = layers.map((layer) => {
+		const reference = cacheBlock(layer.settings)?.provider;
+		return typeof reference === "string" && reference.trim() !== "" ? reference.trim() : null;
+	});
+	const selected = layers.findIndex((layer, index) => references[index] !== null && layer.baseDir !== null);
+	if (selected === -1) return null;
+	const provider = references[selected];
+	const baseDir = layers[selected].baseDir;
+	return {
+		provider,
+		options: mergeSettingsLayers(layers.map((layer, index) => {
+			const namesProvider = references[index] === provider && layer.baseDir === baseDir;
+			const overridesAbove = index < selected && references[index] === null;
+			if (!namesProvider && !overridesAbove) return null;
+			const block = cacheBlock(layer.settings)?.options;
+			return isPlainObject(block) ? block : null;
+		})),
+		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;
+}
+function parseIosRemote(remote) {
+	const selected = remote.trim();
+	const reserved = selected.toLowerCase();
+	return REMOTE_DEVICE_BACKENDS.includes(reserved) ? {
+		kind: "backend",
+		backend: reserved
+	} : {
+		kind: "machine",
+		machine: reserved === "auto" ? "auto" : selected
+	};
+}
+function remoteIosSetting(settings) {
+	const ios = settings.ios;
+	return isPlainObject(ios) && typeof ios.remote === "string" ? parseIosRemote(ios.remote) : null;
+}
+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 minutesSetting(settings, block, name) {
+	const parent = settings[block];
+	const value = isPlainObject(parent) ? parent[name] : void 0;
+	const setting = settingDefinition(`${block}.${name}`);
+	return setting && value !== void 0 && settingValueError(setting, value) === null ? value : Number(setting?.default);
+}
+function metroIdleStopMinutesSetting(settings) {
+	return minutesSetting(settings, "metro", "idleStopMinutes");
+}
+function deviceIdleShutdownMinutesSetting(settings) {
+	return minutesSetting(settings, "devices", "idleShutdownMinutes");
+}
+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) || !("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 metroPortSetting(projectPath, env = process.env) {
+	const setting = settingDefinition("metro.port");
+	const fromEnv = env.STIM_METRO_PORT?.trim();
+	const value = fromEnv ? coerceSettingText(setting, fromEnv) : settingValueAt(settingsForProject(projectPath), "metro.port");
+	if (value === void 0) return {
+		port: null,
+		error: null
+	};
+	const problem = settingValueError(setting, value);
+	if (problem === null) return {
+		port: value,
+		error: null
+	};
+	return {
+		port: null,
+		error: `Invalid ${fromEnv ? `STIM_METRO_PORT value ${JSON.stringify(env.STIM_METRO_PORT)}` : `metro.port setting ${JSON.stringify(value)}`}. Expected ${problem}.`
+	};
+}
+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 metroWarmupUrlSetting(settings, platform) {
+	const value = settingValueAt(settings, `metro.warmupUrl.${platform}`);
+	return typeof value === "string" ? value : 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;
+	}
+}
+function webSettings(settings) {
+	const url = settingValueAt(settings, "web.url");
+	const viewport = settingValueAt(settings, "web.viewport");
+	return {
+		url: typeof url === "string" ? url : null,
+		ignoreCertificateErrors: settingValueAt(settings, "web.ignoreCertificateErrors") === true,
+		viewport: WEB_VIEWPORTS.includes(viewport) ? viewport : "desktop"
+	};
+}
+//#endregion
+export { cloneIgnoredEntries as $, readCommittedSettings as A, settingsLayers as B, metroTunnelSettingError as C, filesystemDevice as Ct, projectMetroSharedCache as D, parseIosRemote as E, temporaryRoot as Et, settingFile as F, detectProviders as G, unknownSettingKeys as H, settingOrigin as I, artifactCachePolicy as J, planMetroReach as K, settingOriginScope as L, remoteIosSetting as M, resolveCacheProviderConfig as N, projectOptimizations as O, resolveSettings as P, branchExists as Q, settingShapeErrors as R, metroPortSetting as S, warmWorktreePaths as St, ngrokUrlSetting as T, removeTemporaryEntry as Tt, webSettings as U, tunnelModeSetting as V, PUBLIC_METRO_ENV as W, optimizationBuildProfile as X, compilerCacheFallbackMessage as Y, resolveOptimizations as Z, iosSigningIdentitySha1Setting as _, resolveFullRef as _t, SETTING_SHAPE_REMEDY as a, gitCommonDirOnDisk as at, mergeSettingsLayers as b, sourceCheckoutOf as bt, androidDataPartitionSizeBytes as c, hasUncommittedWork as ct, cacheProviderSettingError as d, listWorktrees as dt, deleteBranch as et, deviceIdleShutdownMinutesSetting as f, locallyKnownUpstream as ft, iosSigningIdentitySettingError as g, repoRoot as gt, iosSigningIdentitySetting as h, removeWorktree as ht, SETTINGS_WITH_RESOLVE_TIME_FALLBACK as i, gitCommonDir as it, remoteAndroidSetting as j, publicUrlSetting as k, androidDataPartitionSizeGbSetting as l, isPodInstallChurn as lt, iosLanHostSettingError as m, readWorktreeExclude as mt, PATH_SETTINGS as n, dirtyFingerprintFiles as nt, androidAvdConfigSetting as o, hasPopulatedSubmodules as ot, iosLanHostSetting as p, podsOutOfSync as pt, resolveTailscaleBinary as q, REMOTE_DEVICE_BACKENDS as r, dirtyPaths as rt, androidAvdConfigSettingError as s, hasRemote as st, ANDROID_AVD_CONFIG_HELP as t, depsOutOfSync as tt, androidDataPartitionSizeGbSettingError as u, linkedWorktreesOnDisk as ut, iosSigningIdentitySha1SettingError as v, resolveSourceCheckout as vt, metroWarmupUrlSetting as w, makeTemporaryDirectory as wt, metroIdleStopMinutesSetting as x, unpushedCommits as xt, iosSimSlimProfileSetting as y, restoreFile as yt, settingValueAt as z };