stim 1.18.0 → 1.20.0

package/dist/settings-Bbztm4oV.mjs

@@ -0,0 +1,1503 @@
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { _ as loadConfig$1, d as getConfigDir, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-D0LhTY3S.mjs";
+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 { dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, normalize, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
+import { REMOTE_DEVICE_BACKENDS, SETTINGS, SETTING_GROUPS, TUNNEL_MODES, WEB_VIEWPORTS, acceptsShape, coerceSettingText, expectedShape, isLayeredSetting, settingDefinition, settingValueError } from "@stim-cli/core/state";
+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 { buildCacheRoot } from "@stim-cli/core";
+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/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 (key === "__proto__") continue;
+			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.key === "android.remote" || setting.key === "android.deviceProfile" || 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 realpathInside(root, path) {
+	const base = realpathSync$1(root);
+	const real = realpathSync$1(resolve$1(base, path));
+	if (pathEscapesRoot(base, real)) throw new Error(`it resolves outside ${base}`);
+	return real;
+}
+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 iosProjectDirSetting(settings, appRoot) {
+	const value = iosString(settings, "projectPath");
+	if (value === void 0 || typeof value === "string" && normalize(value).replace(/[\\/]+$/, "") === "ios") return {
+		dir: join$1(appRoot, "ios"),
+		relative: "ios",
+		custom: false
+	};
+	if (typeof value !== "string" || !value.trim() || value !== value.trim() || /[\r\n\0]/.test(value) || isAbsolute$1(value)) throw new Error("Invalid ios.projectPath setting. Expected a directory path relative to the app directory.");
+	try {
+		const root = realpathSync$1(appRoot);
+		const candidate = resolve$1(root, value);
+		if (pathEscapesRoot(root, candidate)) throw new Error("path escapes the app directory");
+		const dir = realpathSync$1(candidate);
+		if (pathEscapesRoot(root, dir)) throw new Error("symlink target escapes the app directory");
+		if (!statSync$1(dir).isDirectory()) throw new Error("path is not a directory");
+		if (!readdirSync$1(dir).some((name) => name.endsWith(".xcworkspace") || name.endsWith(".xcodeproj"))) throw new Error("it holds no .xcworkspace or .xcodeproj");
+		return {
+			dir,
+			relative: relative$1(root, dir) || ".",
+			custom: true
+		};
+	} catch (error) {
+		throw new Error(`Could not use ios.projectPath ${value}: ${String(error?.message || error)}`, { cause: error });
+	}
+}
+function iosProjectDirSettingError(settings, appRoot) {
+	try {
+		iosProjectDirSetting(settings, appRoot);
+		return null;
+	} catch (error) {
+		return String(error?.message || error);
+	}
+}
+const INVALID_IOS_PROJECT_DIR = "\0invalid ios.projectPath";
+const DEFAULT_ANDROID_GRADLE_ROOT = "android";
+const DEFAULT_ANDROID_MODULE = ":app";
+const ANDROID_MODULE = /^(:(?!\.\.?(?::|$))[A-Za-z0-9._-]+)+$/;
+function androidString(settings, key) {
+	if (!isPlainObject(settings) || !isPlainObject(settings.android)) return void 0;
+	return settings.android[key];
+}
+function hasGradleScript(dir, name) {
+	return existsSync$1(join$1(dir, `${name}.gradle`)) || existsSync$1(join$1(dir, `${name}.gradle.kts`));
+}
+function androidLayoutSetting(settings, appRoot, bound) {
+	const rootValue = androidString(settings, "gradleRoot");
+	const moduleValue = androidString(settings, "module");
+	if (!(rootValue !== void 0 && rootValue !== "android" || moduleValue !== void 0 && moduleValue !== ":app")) {
+		const gradleRoot = join$1(appRoot, DEFAULT_ANDROID_GRADLE_ROOT);
+		return {
+			gradleRoot,
+			gradleRootRelative: DEFAULT_ANDROID_GRADLE_ROOT,
+			module: DEFAULT_ANDROID_MODULE,
+			moduleDir: join$1(gradleRoot, "app"),
+			custom: false
+		};
+	}
+	const rawRoot = rootValue ?? "android";
+	if (typeof rawRoot !== "string" || !rawRoot.trim() || rawRoot !== rawRoot.trim() || /[\r\n\0]/.test(rawRoot) || isAbsolute$1(rawRoot)) throw new Error("Invalid android.gradleRoot setting. Expected a directory path relative to the app directory.");
+	const module = moduleValue ?? ":app";
+	if (typeof module !== "string" || !ANDROID_MODULE.test(module)) throw new Error(`Invalid android.module setting ${JSON.stringify(module)}. Expected a Gradle project path such as :app.`);
+	try {
+		const app = realpathSync$1(appRoot);
+		const limit = realpathSync$1(bound);
+		const gradleRoot = realpathSync$1(resolve$1(app, rawRoot));
+		if (pathEscapesRoot(limit, gradleRoot)) throw new Error(`it resolves outside ${limit}`);
+		if (!statSync$1(gradleRoot).isDirectory()) throw new Error("it is not a directory");
+		if (!hasGradleScript(gradleRoot, "settings")) throw new Error("it holds no settings.gradle or settings.gradle.kts");
+		const mapped = join$1(gradleRoot, ...module.split(":").filter(Boolean));
+		if (!hasGradleScript(mapped, "build")) throw new Error(`module ${module} has no build.gradle or build.gradle.kts at ${mapped}`);
+		const moduleDir = realpathSync$1(mapped);
+		if (pathEscapesRoot(limit, moduleDir)) throw new Error(`module ${module} resolves outside ${limit}`);
+		return {
+			gradleRoot,
+			gradleRootRelative: relative$1(app, gradleRoot).split(sep$1).join("/") || ".",
+			module,
+			moduleDir,
+			custom: true
+		};
+	} catch (error) {
+		throw new Error(`Could not use android.gradleRoot ${rawRoot}: ${String(error?.message || error)}`, { cause: error });
+	}
+}
+function androidLayoutSettingError(settings, appRoot, bound) {
+	try {
+		androidLayoutSetting(settings, appRoot, bound);
+		return null;
+	} catch (error) {
+		return String(error?.message || error);
+	}
+}
+const INVALID_ANDROID_GRADLE_ROOT = "\0invalid android.gradleRoot";
+function defaultAndroidLayout(appRoot) {
+	return androidLayoutSetting({}, appRoot, appRoot);
+}
+function resolveAndroidLayout(settings, root, bound) {
+	if (settings === null) return defaultAndroidLayout(root);
+	try {
+		return androidLayoutSetting(settings, root, bound);
+	} catch {
+		const gradleRoot = join$1(root, INVALID_ANDROID_GRADLE_ROOT);
+		return {
+			gradleRoot,
+			gradleRootRelative: INVALID_ANDROID_GRADLE_ROOT,
+			module: DEFAULT_ANDROID_MODULE,
+			moduleDir: join$1(gradleRoot, "app"),
+			custom: true
+		};
+	}
+}
+function resolveIosProjectDir(settings, root) {
+	if (settings === null) return {
+		dir: join$1(root, "ios"),
+		relative: "ios",
+		custom: false
+	};
+	try {
+		return iosProjectDirSetting(settings, root);
+	} catch {
+		return {
+			dir: join$1(root, INVALID_IOS_PROJECT_DIR),
+			relative: INVALID_IOS_PROJECT_DIR,
+			custom: true
+		};
+	}
+}
+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 projectSettingsContext(root, git = {
+	gitCommonDir,
+	repoRoot
+}) {
+	return {
+		projectPath: root,
+		gitCommonDir: git.gitCommonDir(root),
+		repoRoot: git.repoRoot(root)
+	};
+}
+function resolveProjectSettings(root) {
+	const context = projectSettingsContext(root);
+	return {
+		context,
+		settings: resolveSettings(context)
+	};
+}
+const METRO_COMMAND_PORT = "{port}";
+function metroCommandSetting(settings) {
+	const value = settingValueAt(settings, "metro.command");
+	if (!Array.isArray(value) || !value.every((arg) => typeof arg === "string")) return null;
+	return typeof value[0] === "string" && value[0].trim() !== "" ? value : null;
+}
+function metroCommandSettingError(settings) {
+	if (settingValueAt(settings, "metro.command") === void 0) return null;
+	const command = metroCommandSetting(settings);
+	if (!command) return "metro.command must be a non-empty array of strings whose first entry is the program to run.";
+	if (!command.some((arg) => arg.includes("{port}"))) return `metro.command must pass ${METRO_COMMAND_PORT} so the dev server listens on this workspace's reserved port.`;
+	return null;
+}
+function runnableMetroCommand(settings) {
+	return metroCommandSettingError(settings) ? null : metroCommandSetting(settings);
+}
+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;
+}
+/** The remote target `remote` names, or null for `local`, which runs on this Mac whatever a lower layer sets. */
+function parseIosRemote(remote) {
+	const selected = remote.trim();
+	const reserved = selected.toLowerCase();
+	if (reserved === "local") return null;
+	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 remoteEasFallbackSetting(settings) {
+	return settingValueAt(settings, "remote.easFallback") === true;
+}
+function remoteAndroidSetting(settings) {
+	const android = settings.android;
+	return isPlainObject(android) && typeof android.remote === "string" ? parseIosRemote(android.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 deviceReclaimIdleMinutesSetting(settings) {
+	return minutesSetting(settings, "devices", "reclaimIdleMinutes");
+}
+function maintenanceKeepSetting(settings) {
+	const value = settingValueAt(settings, "maintenance.keep");
+	return value !== void 0 && value !== false;
+}
+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) || block.ngrokUrl === void 0) 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(settings, env = process.env) {
+	const setting = settingDefinition("metro.port");
+	const fromEnv = env.STIM_METRO_PORT?.trim();
+	const value = fromEnv ? coerceSettingText(setting, fromEnv) : settingValueAt(settings, "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 { settingValueAt as $, metroIdleStopMinutesSetting as A, sourceCheckoutOf as At, remoteAndroidSetting as B, iosSigningIdentitySha1Setting as C, podsOutOfSync as Ct, mergeSettingsLayers as D, resolveFullRef as Dt, maintenanceKeepSetting as E, repoRoot as Et, parseIosRemote as F, removeTemporaryEntry as Ft, resolveIosProjectDir as G, remoteIosSetting as H, projectSettingsContext as I, temporaryRoot as It, runnableMetroCommand as J, resolveProjectSettings as K, publicUrlSetting as L, metroTunnelSettingError as M, warmWorktreePaths as Mt, metroWarmupUrlSetting as N, filesystemDevice as Nt, metroCommandSetting as O, resolveSourceCheckout as Ot, ngrokUrlSetting as P, makeTemporaryDirectory as Pt, settingShapeErrors as Q, readCommittedSettings as R, iosSigningIdentitySettingError as S, locallyKnownUpstream as St, iosSimSlimProfileSetting as T, removeWorktree as Tt, resolveAndroidLayout as U, remoteEasFallbackSetting as V, resolveCacheProviderConfig as W, settingOrigin as X, settingFile as Y, settingOriginScope as Z, iosLanHostSetting as _, hasRemote as _t, SETTING_SHAPE_REMEDY as a, detectProviders as at, iosProjectDirSettingError as b, linkedWorktreesOnDisk as bt, androidDataPartitionSizeBytes as c, branchExists as ct, androidLayoutSetting as d, depsOutOfSync as dt, settingsLayers as et, androidLayoutSettingError as f, dirtyFingerprintFiles as ft, deviceReclaimIdleMinutesSetting as g, hasPopulatedSubmodules as gt, deviceIdleShutdownMinutesSetting as h, gitCommonDirOnDisk as ht, SETTINGS_WITH_RESOLVE_TIME_FALLBACK as i, PUBLIC_METRO_ENV as it, metroPortSetting as j, unpushedCommits as jt, metroCommandSettingError as k, restoreFile as kt, androidDataPartitionSizeGbSetting as l, cloneIgnoredEntries as lt, defaultAndroidLayout as m, gitCommonDir as mt, METRO_COMMAND_PORT as n, unknownSettingKeys as nt, androidAvdConfigSetting as o, planMetroReach as ot, cacheProviderSettingError as p, dirtyPaths as pt, resolveSettings as q, PATH_SETTINGS as r, webSettings as rt, androidAvdConfigSettingError as s, resolveTailscaleBinary as st, ANDROID_AVD_CONFIG_HELP as t, tunnelModeSetting as tt, androidDataPartitionSizeGbSettingError as u, deleteBranch as ut, iosLanHostSettingError as v, hasUncommittedWork as vt, iosSigningIdentitySha1SettingError as w, readWorktreeExclude as wt, iosSigningIdentitySetting as x, listWorktrees as xt, iosProjectDirSetting as y, isPodInstallChurn as yt, realpathInside as z };