@dev.fast/whiteboard 0.3.4 → 0.3.5-preview.20261021.131

package/dist/{src-BMPuxWv4.js → src-DtfSndqS.js}

@@ -684,22 +684,182 @@ var import_lib = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((export
 	}
 	module.exports = gitUrlParse;
 })))(), 1);
+/** A quick query: a ref, a config value, a status. */
+const QUICK_TIMEOUT_MS = 3e4;
+/** A read that grows with the repository or a file in it, or a jj call. */
+const LARGE_READ_TIMEOUT_MS = 3e5;
+/** Talking to a remote. */
+const NETWORK_TIMEOUT_MS = 6e5;
+const NETWORK_COMMANDS = /* @__PURE__ */ new Set([
+	"fetch",
+	"clone",
+	"pull",
+	"push",
+	"ls-remote"
+]);
+const LARGE_READS = /* @__PURE__ */ new Set([
+	"archive",
+	"blame",
+	"cat-file",
+	"diff",
+	"diff-tree",
+	"format-patch",
+	"grep",
+	"log",
+	"ls-files",
+	"ls-tree",
+	"rev-list",
+	"show"
+]);
+const VALUED_OPTIONS = [
+	"-C",
+	"-c",
+	"--git-dir",
+	"--work-tree",
+	"-R"
+];
+/** The subcommand's index; `args.length` if none. */
+function subcommandIndex(args) {
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (VALUED_OPTIONS.includes(arg)) i++;
+		else if (!arg.startsWith("-")) return i;
+	}
+	return args.length;
+}
+function talksToRemote(args) {
+	const command = args[subcommandIndex(args)];
+	return command !== void 0 && NETWORK_COMMANDS.has(command);
+}
+const namesRepository = (args) => args.slice(0, subcommandIndex(args)).some((arg) => arg === "-C" || arg === "--git-dir");
+/** How long a call may run when its caller doesn't say. */
+function defaultVcsTimeout(tool, args) {
+	if (talksToRemote(args)) return NETWORK_TIMEOUT_MS;
+	const command = args[subcommandIndex(args)];
+	if (tool === "jj" || command && LARGE_READS.has(command)) return LARGE_READ_TIMEOUT_MS;
+	return QUICK_TIMEOUT_MS;
+}
+const COMMIT_ID = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
+/** Thrown before anything runs when an operand could be misread. */
+var VcsOperandError = class extends Error {};
+function refused(kind, value) {
+	throw new VcsOperandError(`Refusing ${kind} ${JSON.stringify(value)}.`);
+}
+/** Whether a value could be read as an option, or carries a control
+* character or a line break. */
+const unsafe = (value) => !value || value.startsWith("-") || /[\0-\x1f\x7f]/.test(value);
+const unsafeRef = (value) => unsafe(value) || /[\s:~^?*[\\]|\.\.|@\{/.test(value);
+function checkRefSide(value) {
+	if (!COMMIT_ID.test(value) && unsafeRef(value)) refused("ref", value);
+}
+/** Operands are objects; flags written in the code are strings. */
+const isOperand = (arg) => Object(arg) === arg;
+/** The arguments as the process gets them: operands checked, so none can
+* be read as an option, and paths after `--`. (`--end-of-options` would say
+* the same to git, but older gits refuse it in some commands.) */
+function renderVcsArgs(args) {
+	const out = [];
+	let paths = false;
+	for (const arg of args) {
+		if (!isOperand(arg)) {
+			if (arg === "--") paths = true;
+			out.push(arg);
+			continue;
+		}
+		if ("path" in arg) {
+			if (!arg.path || /\0/.test(arg.path)) refused("path", arg.path);
+			if (!paths) {
+				out.push("--");
+				paths = true;
+			}
+			out.push(arg.path);
+			continue;
+		}
+		let rendered;
+		if ("commit" in arg) {
+			if (!COMMIT_ID.test(arg.commit)) refused("commit", arg.commit);
+			rendered = arg.commit;
+		} else if ("rev" in arg) {
+			if (unsafe(arg.rev)) refused("revision", arg.rev);
+			rendered = arg.rev;
+		} else if ("ref" in arg) {
+			if (unsafeRef(arg.ref)) refused("ref", arg.ref);
+			rendered = arg.ref;
+		} else if ("refspec" in arg) {
+			checkRefSide(arg.refspec.from);
+			checkRefSide(arg.refspec.to);
+			rendered = `${arg.refspec.force ? "+" : ""}${arg.refspec.from}:${arg.refspec.to}`;
+		} else if ("remote" in arg) {
+			if (unsafe(arg.remote) || /\s/.test(arg.remote)) refused("remote", arg.remote);
+			rendered = arg.remote;
+		} else {
+			if (unsafe(arg.value)) refused("value", arg.value);
+			rendered = arg.value;
+		}
+		out.push(rendered);
+	}
+	return out;
+}
+const LOCAL_GIT_ENV_KEYS = [
+	"GIT_ALTERNATE_OBJECT_DIRECTORIES",
+	"GIT_COMMON_DIR",
+	"GIT_CONFIG",
+	"GIT_CONFIG_COUNT",
+	"GIT_CONFIG_PARAMETERS",
+	"GIT_DIR",
+	"GIT_GRAFT_FILE",
+	"GIT_IMPLICIT_WORK_TREE",
+	"GIT_INDEX_FILE",
+	"GIT_INTERNAL_SUPER_PREFIX",
+	"GIT_NO_REPLACE_OBJECTS",
+	"GIT_OBJECT_DIRECTORY",
+	"GIT_PREFIX",
+	"GIT_QUARANTINE_PATH",
+	"GIT_REPLACE_REF_BASE",
+	"GIT_SHALLOW_FILE",
+	"GIT_WORK_TREE"
+];
+/** The process environment without the variables that would redirect git
+* to another repository's objects, index or work tree. */
+function localGitEnvironment() {
+	const env = { ...process.env };
+	for (const key of LOCAL_GIT_ENV_KEYS) delete env[key];
+	return env;
+}
+/** The environment a version-control process runs with. A git call that
+* names its repository (`-C`, `--git-dir`) and brings no environment of its
+* own drops the variables that would redirect it to another. */
+function vcsEnvironment(tool, args, env) {
+	const next = { ...env ?? (tool === "git" && namesRepository(args) ? localGitEnvironment() : process.env) };
+	if (!talksToRemote(args)) next.GIT_NO_LAZY_FETCH = "1";
+	next.GIT_TERMINAL_PROMPT = "0";
+	next.GH_PROMPT_DISABLED = "1";
+	return next;
+}
 let observer = null;
 function setLocalVcsCommandObserver(next) {
 	observer = next;
 }
 const execFilePromise = promisify(execFile);
-async function execFileAsync(file, args, options = {}) {
+async function runVcs(tool, vcsArgs, { input, ...options } = {}) {
+	const args = renderVcsArgs(vcsArgs);
 	const finish = observer?.start({
-		file,
+		tool,
 		args,
 		cwd: options.cwd === void 0 ? void 0 : String(options.cwd)
 	});
 	try {
-		const result = await execFilePromise(file, args, {
+		const running = execFilePromise(tool, args, {
 			...options,
+			env: vcsEnvironment(tool, args, options.env),
+			timeout: options.timeout ?? defaultVcsTimeout(tool, args),
 			encoding: options.encoding ?? "utf8"
 		});
+		if (input !== void 0) {
+			running.child.stdin?.on("error", () => {});
+			running.child.stdin?.end(input);
+		}
+		const result = await running;
 		finish?.({ ok: true });
 		return {
 			stdout: String(result.stdout),
@@ -710,14 +870,19 @@ async function execFileAsync(file, args, options = {}) {
 		throw error;
 	}
 }
-function execFileSyncObserved(file, args, options) {
+function runVcsSync(tool, vcsArgs, options) {
+	const args = renderVcsArgs(vcsArgs);
 	const finish = observer?.start({
-		file,
+		tool,
 		args,
 		cwd: options.cwd === void 0 ? void 0 : String(options.cwd)
 	});
 	try {
-		const output = execFileSync(file, args, options);
+		const output = execFileSync(tool, args, {
+			...options,
+			env: vcsEnvironment(tool, args, options.env),
+			timeout: options.timeout ?? defaultVcsTimeout(tool, args)
+		});
 		finish?.({ ok: true });
 		return String(output);
 	} catch (error) {
@@ -726,14 +891,18 @@ function execFileSyncObserved(file, args, options) {
 	}
 }
 /** Long-lived child; the observer sees one spawn, completed once the process is up. */
-function spawnObserved(file, args, options) {
+function spawnObserved(tool, vcsArgs, options) {
+	const args = renderVcsArgs(vcsArgs);
 	const finish = observer?.start({
-		file,
+		tool,
 		args,
 		cwd: options.cwd === void 0 ? void 0 : String(options.cwd)
 	});
 	try {
-		const child = spawn(file, args, options);
+		const child = spawn(tool, args, {
+			...options,
+			env: vcsEnvironment(tool, args, options.env)
+		});
 		let finished = false;
 		const complete = (ok) => {
 			if (finished) return;
@@ -1013,25 +1182,6 @@ function normalizeEntry(entry) {
 }
 //#endregion
 //#region ../local-vcs/src/vcs.ts
-const LOCAL_GIT_ENV_KEYS = [
-	"GIT_ALTERNATE_OBJECT_DIRECTORIES",
-	"GIT_COMMON_DIR",
-	"GIT_CONFIG",
-	"GIT_CONFIG_COUNT",
-	"GIT_CONFIG_PARAMETERS",
-	"GIT_DIR",
-	"GIT_GRAFT_FILE",
-	"GIT_IMPLICIT_WORK_TREE",
-	"GIT_INDEX_FILE",
-	"GIT_INTERNAL_SUPER_PREFIX",
-	"GIT_NO_REPLACE_OBJECTS",
-	"GIT_OBJECT_DIRECTORY",
-	"GIT_PREFIX",
-	"GIT_QUARANTINE_PATH",
-	"GIT_REPLACE_REF_BASE",
-	"GIT_SHALLOW_FILE",
-	"GIT_WORK_TREE"
-];
 /** Neither git nor jj could be started, so no folder can be recognized as a repository. */
 var LocalVcsToolsMissingError = class extends Error {
 	constructor() {
@@ -1139,29 +1289,6 @@ async function resolveRepoContext(rootPath) {
 		githubSlug: (resolvedOriginUrl ? parseGitRemoteSlug(resolvedOriginUrl) : null) ?? (originUrl ? parseGitRemoteSlug(originUrl) : null)
 	};
 }
-function resolveRepoContextSync(rootPath) {
-	const commonDir = gitCommonDirSync(path.resolve(rootPath));
-	if (!commonDir) return null;
-	const originUrl = commandOutputSync("git", [
-		"--git-dir",
-		commonDir,
-		"config",
-		"--get",
-		"remote.origin.url"
-	]) || null;
-	const resolvedOriginUrl = commandOutputSync("git", [
-		"--git-dir",
-		commonDir,
-		"remote",
-		"get-url",
-		"origin"
-	]) || null;
-	return {
-		commonDir,
-		originUrl,
-		githubSlug: (resolvedOriginUrl ? parseGitRemoteSlug(resolvedOriginUrl) : null) ?? (originUrl ? parseGitRemoteSlug(originUrl) : null)
-	};
-}
 /** git argv for the object store: a jj workspace reads through its backing store. */
 async function objectStoreArgs(input) {
 	if (input.kind === "git") return ["-C", input.rootPath];
@@ -1185,10 +1312,19 @@ async function gitArgs(rootPath, args) {
 		...args
 	];
 }
+/** A timed-out child said nothing, so report the kill. */
+function failure(cause) {
+	const error = cause;
+	return {
+		ok: false,
+		stdout: error.stdout ?? "",
+		stderr: error.stderr || (error.killed ? `git timed out and was killed (${error.signal ?? "SIGTERM"})` : String(error))
+	};
+}
 /** Run git against the repo's shared git dir, optionally tolerating failure. */
 async function git(rootPath, args, options = {}) {
 	try {
-		const { stdout, stderr } = await execFileAsync("git", await gitArgs(rootPath, args), {
+		const { stdout, stderr } = await runVcs("git", await gitArgs(rootPath, args), {
 			maxBuffer: 67108864,
 			signal: options.signal
 		});
@@ -1198,14 +1334,7 @@ async function git(rootPath, args, options = {}) {
 			stderr
 		};
 	} catch (error) {
-		if (options.allowFailure) {
-			const err = error;
-			return {
-				ok: false,
-				stdout: err.stdout ?? "",
-				stderr: err.stderr ?? String(error)
-			};
-		}
+		if (options.allowFailure) return failure(error);
 		throw error;
 	}
 }
@@ -1216,7 +1345,7 @@ async function git(rootPath, args, options = {}) {
 */
 async function gitAt(cwd, args, options = {}) {
 	try {
-		const { stdout, stderr } = await execFileAsync("git", [
+		const { stdout, stderr } = await runVcs("git", [
 			"-C",
 			cwd,
 			...args
@@ -1232,14 +1361,7 @@ async function gitAt(cwd, args, options = {}) {
 			stderr
 		};
 	} catch (error) {
-		if (options.allowFailure) {
-			const err = error;
-			return {
-				ok: false,
-				stdout: err.stdout ?? "",
-				stderr: err.stderr ?? String(error)
-			};
-		}
+		if (options.allowFailure) return failure(error);
 		throw error;
 	}
 }
@@ -1256,17 +1378,19 @@ function createLocalVcs(kind, rootPath) {
 			headRef,
 			kind
 		}),
-		listTrackedFiles: (revision) => Promise.resolve(listTrackedFilesForKind({
+		listTrackedFiles: (revision) => listTrackedFilesOf({
 			rootPath,
-			ref: revision,
 			kind
-		})),
-		readFileAtRef: (ref, relativePath) => Promise.resolve(readFileAtRevisionForKind({
-			rootPath,
-			ref,
-			relativePath,
-			kind
-		})?.source ?? null),
+		}, revision),
+		readFileAtRef: async (ref, relativePath) => {
+			const commit = await resolveRevisionCommitByPreference(rootPath, ref, kind);
+			return commit ? readFileAtCommit({
+				rootPath,
+				kind,
+				commit,
+				relativePath
+			}) : null;
+		},
 		diff: (input) => diffForKind({
 			rootPath,
 			baseRef: input.base,
@@ -1302,10 +1426,10 @@ function createLocalVcs(kind, rootPath) {
 async function jjRevisionIsConflicted(rootPath, revision) {
 	if ((await detectLocalVcs(rootPath))?.kind !== "jj") return null;
 	try {
-		const { stdout } = await execFileAsync("jj", [
+		const { stdout } = await runVcs("jj", [
 			"log",
 			"-r",
-			revision,
+			{ rev: revision },
 			"--no-graph",
 			"-T",
 			"if(conflict, \"true\", \"false\")",
@@ -1355,61 +1479,67 @@ async function mergeBaseForKind(input) {
 	const commit = await mergeBaseByPreference(input.rootPath, input.baseRef, input.headRef, input.kind);
 	return commit ? { commit } : null;
 }
-async function listTrackedFilesAtCommit(input) {
-	if (input.kind === "jj") {
-		const output = await commandOutput("jj", [
+async function listTrackedFilesOf(vcs, ref) {
+	const run = (command, args) => commandOutput(command, args, { cwd: vcs.rootPath }).catch(() => null);
+	if (vcs.kind === "jj") {
+		const args = [
 			"-R",
-			input.rootPath,
+			vcs.rootPath,
 			"file",
 			"list",
-			"--ignore-working-copy",
-			"-r",
-			input.commit
-		], { cwd: input.rootPath }).catch(() => null);
+			"--ignore-working-copy"
+		];
+		if (ref) args.push("-r", { rev: ref });
+		const output = await run("jj", args);
 		if (output !== null) return splitLines(output);
-		if (!await canUseGitFallback(input.rootPath, input.kind)) return [];
+		const gitRoot = await run("git", [
+			"-C",
+			vcs.rootPath,
+			"rev-parse",
+			"--show-toplevel"
+		]);
+		if (gitRoot === null || canonicalPath(gitRoot) !== canonicalPath(vcs.rootPath)) return [];
 	}
-	const output = await commandOutput("git", [
+	const output = await run("git", ref ? [
 		"-C",
-		input.rootPath,
+		vcs.rootPath,
 		"ls-tree",
 		"-r",
 		"-z",
 		"--name-only",
-		input.commit
-	], { cwd: input.rootPath }).catch(() => null);
+		{ rev: ref }
+	] : [
+		"-C",
+		vcs.rootPath,
+		"ls-files",
+		"-z"
+	]);
 	return output === null ? [] : output.split("\0").filter(Boolean);
 }
-function listTrackedFilesForKind(input) {
+async function listTrackedFilesAtCommit(input) {
 	if (input.kind === "jj") {
-		const args = [
+		const output = await commandOutput("jj", [
 			"-R",
 			input.rootPath,
 			"file",
 			"list",
-			"--ignore-working-copy"
-		];
-		if (input.ref) args.push("-r", input.ref);
-		const output = commandOutputSync("jj", args, { cwd: input.rootPath });
+			"--ignore-working-copy",
+			"-r",
+			{ rev: input.commit }
+		], { cwd: input.rootPath }).catch(() => null);
 		if (output !== null) return splitLines(output);
-		if (!canUseGitFallbackSync(input.rootPath, input.kind)) return [];
+		if (!await canUseGitFallback(input.rootPath, input.kind)) return [];
 	}
-	const output = input.ref ? commandOutputSync("git", [
+	const output = await commandOutput("git", [
 		"-C",
 		input.rootPath,
 		"ls-tree",
 		"-r",
 		"-z",
 		"--name-only",
-		input.ref
-	], { cwd: input.rootPath }) : commandOutputSync("git", [
-		"-C",
-		input.rootPath,
-		"ls-files",
-		"-z"
-	], { cwd: input.rootPath });
-	if (output === null) return [];
-	return output.split("\0").filter(Boolean);
+		{ rev: input.commit }
+	], { cwd: input.rootPath }).catch(() => null);
+	return output === null ? [] : output.split("\0").filter(Boolean);
 }
 /**
 * Read a blob at a resolved commit through the caller's batch reader.
@@ -1442,7 +1572,7 @@ async function readJjFileAtCommit(input) {
 		"file",
 		"show",
 		"-r",
-		input.commit,
+		{ rev: input.commit },
 		"--ignore-working-copy",
 		"--",
 		toJjRootFilePattern(input.relativePath)
@@ -1467,9 +1597,6 @@ async function jjCommitIsConflicted(reader, commit) {
 	known.set(commit, probe);
 	return probe;
 }
-function readFileAtRevisionForKind(input) {
-	return input.kind === "jj" ? readJjFileAtRevisionSync(input) ?? (canUseGitFallbackSync(input.rootPath, input.kind) ? readGitFileAtRevisionSync(input) : null) : readGitFileAtRevisionSync(input) ?? readJjFileAtRevisionSync(input);
-}
 async function diff(input) {
 	const vcs = await knownOrDetectedVcs(input.rootPath, input.kind);
 	if (!vcs) throw new Error(`No Git or jj repository found for ${input.rootPath}.`);
@@ -1518,7 +1645,7 @@ async function withWorkingTreeIndex(input, read) {
 			env.GIT_WORK_TREE = input.rootPath;
 		}
 		await fs.promises.mkdir(path.join(scratch, "objects"));
-		const git = (args) => execFileAsync("git", [
+		const git = (args) => runVcs("git", [
 			"-c",
 			"core.splitIndex=false",
 			"-C",
@@ -1530,7 +1657,7 @@ async function withWorkingTreeIndex(input, read) {
 			maxBuffer: 33554432
 		});
 		if (input.kind === "git") {
-			const index = (await execFileAsync("git", [
+			const index = (await runVcs("git", [
 				"-C",
 				input.rootPath,
 				"rev-parse",
@@ -1600,7 +1727,7 @@ async function listCommitRange(input) {
 	const vcs = await knownOrDetectedVcs(input.rootPath, input.kind);
 	if (!vcs) throw new Error(`No Git or jj repository found for ${input.rootPath}.`);
 	try {
-		const { stdout } = await execFileAsync("git", [
+		const { stdout } = await runVcs("git", [
 			"-C",
 			vcs.rootPath,
 			"log",
@@ -1608,7 +1735,7 @@ async function listCommitRange(input) {
 			"--format=%H%x00%P%x00%an%x00%aI%x00%s%x00",
 			"--numstat",
 			"-z",
-			`${input.baseRef}..${input.headRef}`
+			{ rev: `${input.baseRef}..${input.headRef}` }
 		], {
 			cwd: vcs.rootPath,
 			maxBuffer: 26214400
@@ -1668,7 +1795,7 @@ async function readJjCommitRange(rootPath, baseRef, headRef) {
 		"log",
 		"--no-graph",
 		"-r",
-		`::${headRef} ~ ::${baseRef}`,
+		{ rev: `::${headRef} ~ ::${baseRef}` },
 		"-T",
 		"commit_id ++ \"\\0\" ++ parents.map(|p| p.commit_id()).join(\" \") ++ \"\\0\" ++ author.name() ++ \"\\0\" ++ author.timestamp().format(\"%+\") ++ \"\\0\" ++ description.first_line() ++ \"\\0\"",
 		"--ignore-working-copy"
@@ -1718,8 +1845,8 @@ async function diffFileSummariesTrees(input) {
 	});
 }
 async function diffForKind(input) {
-	if (input.kind === "jj") return readJjDiff(input).catch((cause) => {
-		if (!canUseGitFallbackSync(input.rootPath, input.kind)) throw cause;
+	if (input.kind === "jj") return readJjDiff(input).catch(async (cause) => {
+		if (!await canUseGitFallback(input.rootPath, input.kind)) throw cause;
 		return readGitDiff(input);
 	});
 	return readGitDiff(input).catch(() => readJjDiff(input));
@@ -1732,7 +1859,7 @@ async function diffFileSummariesForKind(input) {
 	};
 	let summaries;
 	if (input.kind === "jj") {
-		if (canUseGitFallbackSync(input.rootPath, input.kind)) try {
+		if (await canUseGitFallback(input.rootPath, input.kind)) try {
 			summaries = await readGitDiffFileSummaries(unfilteredInput);
 			return filterDiffFileSummaries(summaries, requestedPaths);
 		} catch {}
@@ -1743,8 +1870,8 @@ async function diffFileSummariesForKind(input) {
 	return filterDiffFileSummaries(summaries, requestedPaths);
 }
 async function diffNameStatusForKind(input) {
-	if (input.kind === "jj") return readJjDiffNameStatus(input).catch((cause) => {
-		if (!canUseGitFallbackSync(input.rootPath, input.kind)) throw cause;
+	if (input.kind === "jj") return readJjDiffNameStatus(input).catch(async (cause) => {
+		if (!await canUseGitFallback(input.rootPath, input.kind)) throw cause;
 		return readGitDiffNameStatus(input);
 	});
 	return readGitDiffNameStatus(input).catch(() => readJjDiffNameStatus(input));
@@ -1841,7 +1968,7 @@ function toNameStatusEntries(summary) {
 	}))].sort((left, right) => left.path.localeCompare(right.path));
 }
 async function readGitDiffNameStatus(input) {
-	const refRange = input.mergeBase === false ? [input.baseRef, input.headRef] : [`${input.baseRef}...${input.headRef}`];
+	const refRange = input.mergeBase === false ? [{ rev: input.baseRef }, { rev: input.headRef }] : [{ rev: `${input.baseRef}...${input.headRef}` }];
 	return parseGitDiffNameStatus(await commandOutput("git", [
 		"-C",
 		input.rootPath,
@@ -1862,9 +1989,9 @@ async function readJjDiffNameStatus(input) {
 		"diff",
 		"--summary",
 		"--from",
-		input.baseRef,
+		{ rev: input.baseRef },
 		"--to",
-		input.headRef,
+		{ rev: input.headRef },
 		"--ignore-working-copy"
 	], {
 		cwd: input.rootPath,
@@ -1893,12 +2020,12 @@ async function defaultBranchCandidates(rootPath) {
 async function resolveRevisionCommitByPreference(rootPath, revision, preferred) {
 	const primary = preferred === "jj" ? resolveJjRevisionCommit : resolveGitRevisionCommit;
 	const secondary = preferred === "jj" ? resolveGitRevisionCommit : resolveJjRevisionCommit;
-	return await primary(rootPath, revision).catch(() => null) ?? (canUseGitFallbackSync(rootPath, preferred) ? await secondary(rootPath, revision).catch(() => null) : null);
+	return await primary(rootPath, revision).catch(() => null) ?? (await canUseGitFallback(rootPath, preferred) ? await secondary(rootPath, revision).catch(() => null) : null);
 }
 async function mergeBaseByPreference(rootPath, baseRef, headRef, preferred) {
 	const primary = preferred === "jj" ? resolveJjMergeBase : resolveGitMergeBase;
 	const secondary = preferred === "jj" ? resolveGitMergeBase : resolveJjMergeBase;
-	return await primary(rootPath, baseRef, headRef).catch(() => null) ?? (canUseGitFallbackSync(rootPath, preferred) ? await secondary(rootPath, baseRef, headRef).catch(() => null) : null);
+	return await primary(rootPath, baseRef, headRef).catch(() => null) ?? (await canUseGitFallback(rootPath, preferred) ? await secondary(rootPath, baseRef, headRef).catch(() => null) : null);
 }
 async function resolveGitRevisionCommit(rootPath, revision) {
 	return commandOutput("git", [
@@ -1906,16 +2033,7 @@ async function resolveGitRevisionCommit(rootPath, revision) {
 		rootPath,
 		"rev-parse",
 		"--verify",
-		`${revision}^{commit}`
-	]);
-}
-function resolveGitRevisionCommitSync(rootPath, revision) {
-	return commandOutputSync("git", [
-		"-C",
-		rootPath,
-		"rev-parse",
-		"--verify",
-		`${revision}^{commit}`
+		{ rev: `${revision}^{commit}` }
 	]);
 }
 async function resolveJjRevisionCommit(rootPath, revision) {
@@ -1925,26 +2043,12 @@ async function resolveJjRevisionCommit(rootPath, revision) {
 		"log",
 		"--no-graph",
 		"-r",
-		revision,
+		{ rev: revision },
 		"-T",
 		"commit_id ++ \"\\n\"",
 		"--ignore-working-copy"
 	], { cwd: rootPath }), revision);
 }
-function resolveJjRevisionCommitSync(rootPath, revision) {
-	const output = commandOutputSync("jj", [
-		"-R",
-		rootPath,
-		"log",
-		"--no-graph",
-		"-r",
-		revision,
-		"-T",
-		"commit_id ++ \"\\n\"",
-		"--ignore-working-copy"
-	], { cwd: rootPath });
-	return output ? oneResolvedCommit(output, revision) : null;
-}
 function oneResolvedCommit(output, revision) {
 	const commits = output.split("\n").filter(Boolean);
 	if (commits.length !== 1 || !/^[0-9a-f]{40}$/.test(commits[0])) throw new Error(`Revision ${revision} does not resolve to one Git commit.`);
@@ -1955,8 +2059,8 @@ async function resolveGitMergeBase(rootPath, baseRef, headRef) {
 		"-C",
 		rootPath,
 		"merge-base",
-		baseRef,
-		headRef
+		{ rev: baseRef },
+		{ rev: headRef }
 	]);
 }
 async function resolveJjMergeBase(rootPath, baseRef, headRef) {
@@ -1966,56 +2070,16 @@ async function resolveJjMergeBase(rootPath, baseRef, headRef) {
 		"log",
 		"--no-graph",
 		"-r",
-		`heads(::${baseRef} & ::${headRef})`,
+		{ rev: `heads(::${baseRef} & ::${headRef})` },
 		"-T",
 		"commit_id ++ \"\n\"",
 		"--ignore-working-copy"
 	], { cwd: rootPath }))[0] ?? null;
 }
-function readGitFileAtRevisionSync(input) {
-	const commit = resolveGitRevisionCommitSync(input.rootPath, input.ref);
-	if (!commit) return null;
-	const source = commandOutputSync("git", [
-		"-C",
-		input.rootPath,
-		"show",
-		`${commit}:${input.relativePath}`
-	], {
-		maxBuffer: 10485760,
-		trim: false
-	});
-	return source === null ? null : {
-		commit,
-		source
-	};
-}
-function readJjFileAtRevisionSync(input) {
-	const commit = resolveJjRevisionCommitSync(input.rootPath, input.ref);
-	if (!commit) return null;
-	const source = commandOutputSync("jj", [
-		"-R",
-		input.rootPath,
-		"file",
-		"show",
-		"-r",
-		input.ref,
-		"--ignore-working-copy",
-		"--",
-		toJjRootFilePattern(input.relativePath)
-	], {
-		cwd: input.rootPath,
-		maxBuffer: 10485760,
-		trim: false
-	});
-	return source === null ? null : {
-		commit,
-		source
-	};
-}
 async function readGitDiff(input) {
 	const paths = input.literalPaths ? input.paths ?? [] : normalizeDiffPaths(input.paths);
-	const diffRefs = input.headRef ? input.mergeBase === false ? [input.baseRef, input.headRef] : [`${input.baseRef}...${input.headRef}`] : [input.baseRef];
-	const { stdout } = await execFileAsync("git", [
+	const diffRefs = input.headRef ? input.mergeBase === false ? [{ rev: input.baseRef }, { rev: input.headRef }] : [{ rev: `${input.baseRef}...${input.headRef}` }] : [{ rev: input.baseRef }];
+	const { stdout } = await runVcs("git", [
 		...input.literalPaths ? ["--literal-pathspecs"] : [],
 		"-C",
 		input.rootPath,
@@ -2038,8 +2102,8 @@ async function readGitDiff(input) {
 }
 async function readGitDiffFileSummaries(input) {
 	const paths = normalizeDiffPaths(input.paths);
-	const diffRefs = input.headRef ? input.mergeBase === false ? [input.baseRef, input.headRef] : [`${input.baseRef}...${input.headRef}`] : [input.baseRef];
-	const { stdout } = await execFileAsync("git", [
+	const diffRefs = input.headRef ? input.mergeBase === false ? [{ rev: input.baseRef }, { rev: input.headRef }] : [{ rev: `${input.baseRef}...${input.headRef}` }] : [{ rev: input.baseRef }];
+	const { stdout } = await runVcs("git", [
 		"-C",
 		input.rootPath,
 		"diff",
@@ -2062,7 +2126,7 @@ async function readGitDiffFileSummaries(input) {
 }
 async function readJjDiff(input) {
 	const paths = input.literalPaths ? input.paths ?? [] : normalizeDiffPaths(input.paths);
-	const { stdout } = await execFileAsync("jj", [
+	const { stdout } = await runVcs("jj", [
 		"-R",
 		input.rootPath,
 		"--color",
@@ -2266,16 +2330,6 @@ async function canUseGitFallback(rootPath, preferred) {
 	], { cwd: rootPath }).catch(() => null);
 	return gitRoot !== null && canonicalPath(gitRoot) === canonicalPath(rootPath);
 }
-function canUseGitFallbackSync(rootPath, preferred) {
-	if (preferred !== "jj") return true;
-	const gitRoot = commandOutputSync("git", [
-		"-C",
-		rootPath,
-		"rev-parse",
-		"--show-toplevel"
-	], { cwd: rootPath });
-	return gitRoot !== null && canonicalPath(gitRoot) === canonicalPath(rootPath);
-}
 function isInsideDirectory(filePath, directoryPath) {
 	const relative = path.relative(canonicalPath(directoryPath), canonicalPath(filePath));
 	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
@@ -2294,18 +2348,16 @@ function commandOutputSync(command, args, options = {}) {
 	return runCommandOutputSync(command, args, options);
 }
 function runCommandOutput(command, args, options) {
-	return execFileAsync(command, args, {
+	return runVcs(command, args, {
 		cwd: options.cwd,
-		env: commandEnvironment(command, args),
 		maxBuffer: options.maxBuffer
 	}).then(({ stdout }) => options.trim === false ? stdout : stdout.trim());
 }
 function runCommandOutputSync(command, args, options) {
 	try {
-		const output = execFileSyncObserved(command, args, {
+		const output = runVcsSync(command, args, {
 			cwd: options.cwd,
 			encoding: "utf8",
-			env: commandEnvironment(command, args),
 			maxBuffer: options.maxBuffer,
 			stdio: [
 				"ignore",
@@ -2318,16 +2370,6 @@ function runCommandOutputSync(command, args, options) {
 		return null;
 	}
 }
-function commandEnvironment(command, args) {
-	if (command !== "git" || args[0] !== "-C" && args[0] !== "--git-dir") return;
-	return localGitEnvironment();
-}
-/** Drop per-repository git env vars that would redirect an explicit object store. */
-function localGitEnvironment() {
-	const env = { ...process.env };
-	for (const key of LOCAL_GIT_ENV_KEYS) delete env[key];
-	return env;
-}
 //#endregion
 //#region ../../node_modules/graceful-fs/polyfills.js
 var require_polyfills = /* @__PURE__ */ __commonJSMin(((exports, module) => {
@@ -3678,4 +3720,4 @@ var require_adapter = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports.checkSync = checkSync;
 })))();
 //#endregion
-export { setLocalVcsCommandObserver as C, __toESM as E, splitGitPatchFiles as S, __require as T, parseGitRemote as _, diff as a, resolveRepoContextSync as b, diffFileSummariesWorkingTree as c, git as d, gitAt as f, listTrackedFilesAtCommit as g, listCommitRange as h, detectLocalVcs as i, diffTrees as l, jjRevisionIsConflicted as m, createBlobBatchReader as n, diffFileSummaries as o, gitCommonDir as p, defaultBranch as r, diffFileSummariesTrees as s, LocalVcsToolsMissingError as t, diffWorkingTree as u, readFileAtCommit as v, __commonJSMin as w, resolveRevision as x, resolveRepoContext as y };
+export { renderVcsArgs as C, __commonJSMin as D, setLocalVcsCommandObserver as E, __require as O, splitGitPatchFiles as S, runVcsSync as T, listTrackedFilesAtCommit as _, diff as a, resolveRepoContext as b, diffFileSummariesWorkingTree as c, git as d, gitAt as f, listCommitRange as g, jjRevisionIsConflicted as h, detectLocalVcs as i, __toESM as k, diffTrees as l, gitCommonDirSync as m, createBlobBatchReader as n, diffFileSummaries as o, gitCommonDir as p, defaultBranch as r, diffFileSummariesTrees as s, LocalVcsToolsMissingError as t, diffWorkingTree as u, parseGitRemote as v, runVcs as w, resolveRevision as x, readFileAtCommit as y };