stim 1.18.0 → 1.19.0

package/dist/{settings-CQyMElEP.mjs → settings-CxgngUZk.mjs}

@@ -1,9 +1,12 @@
-import { _ as loadConfig$1, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-CgYMahz7.mjs";
-import { s as gitCommonDir, y as repoRoot } from "./worktree-CsKYexJM.mjs";
-import { isAbsolute } from "node:path";
-import { isAbsolute as isAbsolute$1, join as join$1, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { _ as loadConfig$1, d as getConfigDir, f as getConfigPath$1, h as getRepoSettings, m as getProjectSettings } from "./config-DC5jEtd1.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, relative as relative$1, resolve as resolve$1, sep as sep$1 } from "path";
 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 { existsSync, readFileSync, realpathSync, statSync } from "fs";
+import { tmpdir } from "node:os";
+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 { createHash } from "node:crypto";
 //#region src/optimizations.ts
 function compilerCacheFallbackMessage({ fallback, compilerCache, file = null }) {
@@ -102,6 +105,750 @@ function resolveMetroSharedCache(settings) {
 	return optimizationBoolean(settings, "metroSharedCache");
 }
 //#endregion
+//#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"];
@@ -347,15 +1094,15 @@ function androidAvdConfigSetting(settings, settingsRoot) {
 	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(settingsRoot);
+			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(candidate);
+			const path = realpathSync$1(candidate);
 			if (pathEscapesRoot(root, path)) throw new Error("symlink target escapes the settings root");
-			const stat = statSync(path);
+			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(path, "utf8");
+			const contents = readFileSync$1(path, "utf8");
 			if (Buffer.byteLength(contents) > 65536) throw new Error("file exceeds 64 KiB");
 			entries = parseAndroidAvdConfigIni(contents);
 		} catch (error) {
@@ -384,12 +1131,12 @@ function iosSimSlimProfileSetting(settings, settingsRoot) {
 	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(settingsRoot);
+		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(candidate);
+		const path = realpathSync$1(candidate);
 		if (pathEscapesRoot(root, path)) throw new Error("symlink target escapes the settings root");
-		const stat = statSync(path);
+		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;
@@ -451,9 +1198,9 @@ function unknownSettingKeys(settings, prefix = "") {
 function readCommittedSettings(directory) {
 	if (!directory) return {};
 	const p = join$1(directory, ".stim.json");
-	if (!existsSync(p)) return {};
+	if (!existsSync$1(p)) return {};
 	try {
-		const parsed = JSON.parse(readFileSync(p, "utf-8"));
+		const parsed = JSON.parse(readFileSync$1(p, "utf-8"));
 		return isPlainObject(parsed) ? parsed : {};
 	} catch {
 		return {};
@@ -588,9 +1335,11 @@ function cacheProviderSettingError(settings) {
 	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
@@ -603,6 +1352,9 @@ 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;
@@ -698,4 +1450,4 @@ function webSettings(settings) {
 	};
 }
 //#endregion
-export { publicUrlSetting as A, settingValueAt as B, metroWarmupUrlSetting as C, projectMaintenancePinned as D, projectDeviceReclaimIdleMinutes as E, resolveSettings as F, PUBLIC_METRO_ENV as G, tunnelModeSetting as H, settingFile as I, resolveTailscaleBinary as J, detectProviders as K, settingOrigin as L, remoteAndroidSetting as M, remoteIosSetting as N, projectMetroSharedCache as O, resolveCacheProviderConfig as P, resolveOptimizations as Q, settingOriginScope as R, metroTunnelSettingError as S, parseIosRemote as T, unknownSettingKeys as U, settingsLayers as V, webSettings as W, compilerCacheFallbackMessage as X, artifactCachePolicy as Y, optimizationBuildProfile as Z, iosSigningIdentitySha1SettingError as _, androidAvdConfigSetting as a, metroIdleStopMinutesSetting as b, androidDataPartitionSizeGbSetting as c, deviceIdleShutdownMinutesSetting as d, iosLanHostSetting as f, iosSigningIdentitySha1Setting as g, iosSigningIdentitySettingError as h, SETTING_SHAPE_REMEDY as i, readCommittedSettings as j, projectOptimizations as k, androidDataPartitionSizeGbSettingError as l, iosSigningIdentitySetting as m, PATH_SETTINGS as n, androidAvdConfigSettingError as o, iosLanHostSettingError as p, planMetroReach as q, SETTINGS_WITH_RESOLVE_TIME_FALLBACK as r, androidDataPartitionSizeBytes as s, ANDROID_AVD_CONFIG_HELP as t, cacheProviderSettingError as u, iosSimSlimProfileSetting as v, ngrokUrlSetting as w, metroPortSetting as x, mergeSettingsLayers as y, settingShapeErrors as z };
+export { depsOutOfSync as $, publicUrlSetting as A, settingShapeErrors as B, metroWarmupUrlSetting as C, removeTemporaryEntry as Ct, projectMaintenancePinned as D, optimizationBuildProfile as Dt, projectDeviceReclaimIdleMinutes as E, compilerCacheFallbackMessage as Et, resolveCacheProviderConfig as F, webSettings as G, settingsLayers as H, resolveSettings as I, planMetroReach as J, PUBLIC_METRO_ENV as K, settingFile as L, remoteAndroidSetting as M, remoteEasFallbackSetting as N, projectMetroSharedCache as O, resolveOptimizations as Ot, remoteIosSetting as P, deleteBranch as Q, settingOrigin as R, metroTunnelSettingError as S, makeTemporaryDirectory as St, parseIosRemote as T, artifactCachePolicy as Tt, tunnelModeSetting as U, settingValueAt as V, unknownSettingKeys as W, branchExists as X, resolveTailscaleBinary as Y, cloneIgnoredEntries as Z, iosSigningIdentitySha1SettingError as _, restoreFile as _t, androidAvdConfigSetting as a, hasRemote as at, metroIdleStopMinutesSetting as b, warmWorktreePaths as bt, androidDataPartitionSizeGbSetting as c, linkedWorktreesOnDisk as ct, deviceIdleShutdownMinutesSetting as d, podsOutOfSync as dt, dirtyFingerprintFiles as et, iosLanHostSetting as f, readWorktreeExclude as ft, iosSigningIdentitySha1Setting as g, resolveSourceCheckout as gt, iosSigningIdentitySettingError as h, resolveFullRef as ht, SETTING_SHAPE_REMEDY as i, hasPopulatedSubmodules as it, readCommittedSettings as j, projectOptimizations as k, androidDataPartitionSizeGbSettingError as l, listWorktrees as lt, iosSigningIdentitySetting as m, repoRoot as mt, PATH_SETTINGS as n, gitCommonDir as nt, androidAvdConfigSettingError as o, hasUncommittedWork as ot, iosLanHostSettingError as p, removeWorktree as pt, detectProviders as q, SETTINGS_WITH_RESOLVE_TIME_FALLBACK as r, gitCommonDirOnDisk as rt, androidDataPartitionSizeBytes as s, isPodInstallChurn as st, ANDROID_AVD_CONFIG_HELP as t, dirtyPaths as tt, cacheProviderSettingError as u, locallyKnownUpstream as ut, iosSimSlimProfileSetting as v, sourceCheckoutOf as vt, ngrokUrlSetting as w, temporaryRoot as wt, metroPortSetting as x, filesystemDevice as xt, mergeSettingsLayers as y, unpushedCommits as yt, settingOriginScope as z };