stim 1.17.2 → 1.18.0

package/dist/worktree-CsKYexJM.mjs

@@ -0,0 +1,753 @@
+import { t as getExecutor } from "./exec-DWhCZDGm.mjs";
+import { _ as loadConfig, d as getConfigDir } from "./config-CgYMahz7.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 { 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";
+//#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()?.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
+export { sourceCheckoutOf as C, makeTemporaryDirectory as D, filesystemDevice as E, removeTemporaryEntry as O, restoreFile as S, warmWorktreePaths as T, readWorktreeExclude as _, dirtyFingerprintFiles as a, resolveFullRef as b, gitCommonDirOnDisk as c, hasUncommittedWork as d, isPodInstallChurn as f, podsOutOfSync as g, locallyKnownUpstream as h, depsOutOfSync as i, temporaryRoot as k, hasPopulatedSubmodules as l, listWorktrees as m, cloneIgnoredEntries as n, dirtyPaths as o, linkedWorktreesOnDisk as p, deleteBranch as r, gitCommonDir as s, branchExists as t, hasRemote as u, removeWorktree as v, unpushedCommits as w, resolveSourceCheckout as x, repoRoot as y };