@gitkraken/core-gitlens 0.15.7 → 0.16.0

package/dist/git-cli/providers/branches.d.ts

@@ -17,6 +17,13 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
   private readonly provider;
   /** Ahead/behind counts by `<baseSha>...<tipSha>` range, from the per-tip fallback; a pair of commits always counts the same */
   private readonly aheadBehindBySha;
+  /**
+   * For a base that moved only forward, the commits its reflog reaches off the new tip's history (else `false`), by
+   * `<ref>\0<oldSha>\0<newSha>`, for each cached ref list it was read against: a ref write replaces that list, along
+   * with the reflog the answer came from. `undefined` when git couldn't say, which isn't kept. A fetch moves one base
+   * under every worktree at once, so they share the one check, joining it while it runs
+   */
+  private readonly baseMovedForward;
   /**
    * When each `commonPath\0branch\0key` was last stamped by this process. Bounded: a dropped entry only costs a
    * read of the stored stamp, which still holds off a write under 5 minutes old
@@ -32,6 +39,12 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
   private readonly _branchCreatedFrom;
   /** Bumped each time a key's created-from is forgotten, so a reflog read in flight across that doesn't store it */
   private readonly _branchCreatedFromGenerations;
+  /**
+   * The repositories (by common path) whose last config listing showed config that can differ by checkout, so a linked
+   * checkout reads its own listing without first waiting on the main checkout's. Only a shortcut: a listing that shows
+   * otherwise drops the repository again
+   */
+  private readonly _configDiffersByCheckout;
   constructor(context: GitServiceContext, git: Git, cache: Cache, provider: CliGitProviderInternal);
   getBranch(repoPath: string, name?: string, options?: {
     force?: boolean;
@@ -137,10 +150,47 @@ export declare class BranchesGitSubProvider implements GitBranchesSubProvider {
    */
   private getCreatedFromTarget;
   getAheadOfBaseConfigKey(repoPath: string, cancellation?: AbortSignal): Promise<string | undefined>;
+  getAheadOfBaseConfigEntries(repoPath: string, cancellation?: AbortSignal): Promise<readonly (readonly [key: string, value: string | undefined])[] | undefined>;
+  /**
+   * A checkout's listing of the config inputs to {@link getAheadOfBase}. Every checkout of a repository shares the main
+   * checkout's, unless it shows config that can differ by checkout (see `mayConfigDifferByCheckout`); then
+   * each linked checkout reads its own, and keeps doing so until one of its own reads shows config no longer can.
+   */
+  private getAheadOfBaseConfigListing;
+  private readAheadOfBaseConfigListing;
   getAheadOfBase(repoPath: string, branch: string | undefined, options?: {
     skipUserTarget?: boolean;
     preferredTarget?: string;
   }, cancellation?: AbortSignal): Promise<AheadOfBase>;
+  getAheadOfBaseAfterBaseMove(repoPath: string, branch: string | undefined, previous: {
+    readonly head: string;
+    readonly base: NonNullable<AheadOfBase['base']>;
+    readonly dependsOn: readonly string[];
+    readonly defaultBranch?: string | null;
+  }, moved: readonly string[], cancellation?: AbortSignal): Promise<AheadOfBase | undefined>;
+  /**
+   * Whether the repository is shallow, by its common git directory's `shallow` file, which spawns nothing; `undefined`
+   * when it can't be read
+   */
+  private isShallowRepository;
+  /** Whether `ref` is a `refs/remotes/<remote>/HEAD` symref pointing at `target`, from the cached local symref */
+  private isRemoteHeadOf;
+  /**
+   * For `ref` (a full name in `records`, the cached ref list) moving from `oldTip` to `newTip`, the commits its reflog
+   * reaches off `newTip`'s history when it moved only forward: `oldTip` and every value its reflog took after it are in
+   * `newTip`'s history. `--fork-point` reads every reflog entry, so one in between that shares more of HEAD's history
+   * than `newTip` does (a branch's commit that landed and was force-pushed away) moves the fork point while the count
+   * stands; an older one off `newTip`'s history may hold such a commit too, which each worktree's count checks for.
+   * Without a reflog it reads only the tip. `undefined` when it didn't move only forward, or git can't say.
+   */
+  private getMovedForward;
+  /**
+   * Reads {@link getMovedForward} from git, in `commonPath`, which holds the refs, their reflogs and the objects for
+   * every worktree. Not bound to one caller's cancellation, since every worktree the move reached rides this one
+   * read. `false` when the ref didn't move only forward, or reaches too much history off `newTip`'s to tell;
+   * `undefined` when git couldn't say.
+   */
+  private readMovedForward;
   /**
    * Resolves the base from the recorded candidates, then the branch it was created from or the default branch, for
    * {@link getAheadOfBase}

package/dist/git-cli/providers/branches.js

@@ -6,6 +6,7 @@ import { getScopedLogger } from "../../utils/logger.scoped.js";
 import { getSettledValue, mapBounded } from "../../utils/promise.js";
 import { debug, trace } from "../../utils/decorators/log.js";
 import { getBranchId } from "../../utils/gitRefs.js";
+import { joinUriPath } from "../../utils/uri.js";
 import { normalizePath } from "../../utils/path.js";
 import { createRevisionRange, shortenRevision } from "../../git/utils/revision.utils.js";
 import { formatDetachedHeadName, getLocalBranchByUpstream, isDetachedHead, isRemoteHEAD, parseBranchMetadataGkConfigKey, parseRefName, parseUpstream, setBranchMetadataValue, splitRemoteBranchName } from "../../git/utils/branch.utils.js";
@@ -24,6 +25,7 @@ import { LruMap } from "../../utils/lruMap.js";
 import { PageableResult, emptyPagedResult } from "../../utils/paging.js";
 import { parseMergeTreeConflict } from "../parsers/mergeTreeParser.js";
 import { resolveBranchRemote } from "./branchRemote.js";
+import { isGitBooleanFalse } from "./config.js";
 //#region ../git-cli/src/providers/branches.ts
 /** Minimum time between writes to the config for last accessed/modified dates */
 const dateMetadataStaleThresholdMs = 3e5;
@@ -47,6 +49,12 @@ const branchActivityKeys = [
 	"gk-last-modified",
 	"gk-agent-last-activity"
 ];
+/**
+* The most commits a base's reflog may reach off its new tip's history for a re-measure: every worktree's count
+* excludes each of them on its command line, and more come only from a long history force-pushed away, where a full
+* read costs less
+*/
+const maxOffHistoryCommits = 64;
 var BranchesGitSubProvider = class {
 	context;
 	git;
@@ -55,6 +63,13 @@ var BranchesGitSubProvider = class {
 	/** Ahead/behind counts by `<baseSha>...<tipSha>` range, from the per-tip fallback; a pair of commits always counts the same */
 	aheadBehindBySha = new LruMap(4096);
 	/**
+	* For a base that moved only forward, the commits its reflog reaches off the new tip's history (else `false`), by
+	* `<ref>\0<oldSha>\0<newSha>`, for each cached ref list it was read against: a ref write replaces that list, along
+	* with the reflog the answer came from. `undefined` when git couldn't say, which isn't kept. A fetch moves one base
+	* under every worktree at once, so they share the one check, joining it while it runs
+	*/
+	baseMovedForward = /* @__PURE__ */ new WeakMap();
+	/**
 	* When each `commonPath\0branch\0key` was last stamped by this process. Bounded: a dropped entry only costs a
 	* read of the stored stamp, which still holds off a write under 5 minutes old
 	*/
@@ -69,6 +84,12 @@ var BranchesGitSubProvider = class {
 	_branchCreatedFrom = new LruMap(1024);
 	/** Bumped each time a key's created-from is forgotten, so a reflog read in flight across that doesn't store it */
 	_branchCreatedFromGenerations = new LruMap(1024);
+	/**
+	* The repositories (by common path) whose last config listing showed config that can differ by checkout, so a linked
+	* checkout reads its own listing without first waiting on the main checkout's. Only a shortcut: a listing that shows
+	* otherwise drops the repository again
+	*/
+	_configDiffersByCheckout = /* @__PURE__ */ new Set();
 	constructor(context, git, cache, provider) {
 		this.context = context;
 		this.git = git;
@@ -1129,20 +1150,50 @@ var BranchesGitSubProvider = class {
 		return name;
 	}
 	getAheadOfBaseConfigKey(repoPath, cancellation) {
+		return this.getAheadOfBaseConfigListing(repoPath, cancellation);
+	}
+	async getAheadOfBaseConfigEntries(repoPath, cancellation) {
+		const listing = await this.getAheadOfBaseConfigListing(repoPath, cancellation);
+		return listing != null ? parseConfigListing(listing) : void 0;
+	}
+	/**
+	* A checkout's listing of the config inputs to {@link getAheadOfBase}. Every checkout of a repository shares the main
+	* checkout's, unless it shows config that can differ by checkout (see `mayConfigDifferByCheckout`); then
+	* each linked checkout reads its own, and keeps doing so until one of its own reads shows config no longer can.
+	*/
+	getAheadOfBaseConfigListing(repoPath, cancellation) {
 		return this.cache.getAheadOfBaseConfigKey(repoPath, async (checkoutPath, cacheable, signal) => {
-			const result = await this.git.run({
-				cwd: checkoutPath,
-				cancellation: signal,
-				expectedExitCodes: [1]
-			}, "config", "--null", "--get-regexp", "^(branch\\..*\\.(remote|merge)|remote\\..*|init\\.defaultbranch)$");
-			if (signal?.aborted) throw new CancellationError();
-			if (result.completion.status !== "exited") {
-				cacheable.invalidate();
-				return;
+			const commonPath = this.cache.getCommonPath(checkoutPath);
+			const isMain = checkoutPath === commonPath;
+			if (isMain || !this._configDiffersByCheckout.has(commonPath)) {
+				const shared = await this.cache.getAheadOfBaseConfigListing(checkoutPath, (path, sharedCacheable, sharedSignal) => this.readAheadOfBaseConfigListing(path, sharedCacheable, sharedSignal), signal);
+				if (isMain) {
+					if (shared == null) cacheable.invalidate();
+					return shared;
+				}
+				if (shared != null) {
+					if (!mayConfigDifferByCheckout(shared)) return shared;
+					this._configDiffersByCheckout.add(commonPath);
+				}
 			}
-			return result.stdout;
+			const own = await this.readAheadOfBaseConfigListing(checkoutPath, cacheable, signal);
+			if (own != null && !mayConfigDifferByCheckout(own)) this._configDiffersByCheckout.delete(commonPath);
+			return own;
 		}, cancellation);
 	}
+	async readAheadOfBaseConfigListing(cwd, cacheable, cancellation) {
+		const result = await this.git.run({
+			cwd,
+			cancellation,
+			expectedExitCodes: [1]
+		}, "config", "--null", "--get-regexp", "^(branch\\..*\\.(remote|merge)|remote\\..*|init\\.defaultbranch|includeif\\..*|extensions\\.worktreeconfig)$");
+		if (cancellation?.aborted) throw new CancellationError();
+		if (result.completion.status !== "exited") {
+			cacheable.invalidate();
+			return;
+		}
+		return result.stdout;
+	}
 	async getAheadOfBase(repoPath, branch, options, cancellation) {
 		if (branch != null && isDetachedHead(branch)) branch = void 0;
 		const dependsOn = new Set(branch != null ? [`refs/heads/${branch}`] : []);
@@ -1154,6 +1205,152 @@ var BranchesGitSubProvider = class {
 		if (target != null) return this.measureAheadOfBase(repoPath, target, "preferred", dependsOn, cancellation);
 		return this.getAheadOfBaseInOrder(repoPath, branch, options?.skipUserTarget, dependsOn, cancellation);
 	}
+	async getAheadOfBaseAfterBaseMove(repoPath, branch, previous, moved, cancellation) {
+		const { head, base } = previous;
+		const oldTip = base.sha;
+		if (oldTip == null || !moved.length) return void 0;
+		if (base.tier === "preferred" || base.tier === "upstream" && base.forkPoint === oldTip) return void 0;
+		try {
+			const records = await this.provider.refs.getRefs(repoPath, cancellation);
+			const record = records.length ? resolveRefRecord(records, base.ref) : void 0;
+			if (record == null || !moved.includes(record.name)) return void 0;
+			if (isAmbiguousRefName(records, base.ref)) return void 0;
+			const newTip = record.peeledObjectname || record.objectname;
+			if (!newTip || newTip === oldTip) return void 0;
+			if (branch != null && !isDetachedHead(branch) && findRefTip(records, `refs/heads/${branch}`) !== head) return;
+			let remoteHeadMoved = false;
+			for (const ref of moved) {
+				if (ref === record.name) continue;
+				if (findRefTip(records, ref) !== newTip || !await this.isRemoteHeadOf(repoPath, ref, record.name, cancellation)) return;
+				remoteHeadMoved = true;
+			}
+			if (remoteHeadMoved && previous.defaultBranch === void 0) return void 0;
+			if (previous.defaultBranch !== void 0) {
+				const defaultBranch = await this.getLocalDefaultBranchName(repoPath, /* @__PURE__ */ new Set(), cancellation);
+				if (cancellation?.aborted) throw new CancellationError();
+				if ((defaultBranch ?? null) !== previous.defaultBranch) return void 0;
+			}
+			if (previous.dependsOn.some((r) => r.startsWith("refs/remotes/upstream/") && !r.endsWith("/HEAD"))) for (const ref of previous.dependsOn) {
+				if (ref === record.name || ref.endsWith("/HEAD")) continue;
+				const tip = findRefTip(records, ref);
+				if (tip === oldTip || tip === newTip) return void 0;
+			}
+			if (await this.isShallowRepository(repoPath) !== false) return void 0;
+			const offHistory = await this.getMovedForward(repoPath, records, record.name, oldTip, newTip);
+			if (cancellation?.aborted) throw new CancellationError();
+			if (!offHistory) return void 0;
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				errors: "ignore"
+			}, "rev-list", "--count", head, "--not", newTip, ...base.forkPoint != null ? [base.forkPoint] : [], ...offHistory, "--");
+			if (cancellation?.aborted) throw new CancellationError();
+			if (result.completion.status !== "exited" || result.exitCode !== 0) return void 0;
+			if (parseInt(result.stdout.trim(), 10) !== base.ahead) return void 0;
+			return withDefaultBranch({
+				base: {
+					...base,
+					sha: newTip
+				},
+				dependsOn: [...previous.dependsOn]
+			}, previous.defaultBranch);
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			return;
+		}
+	}
+	/**
+	* Whether the repository is shallow, by its common git directory's `shallow` file, which spawns nothing; `undefined`
+	* when it can't be read
+	*/
+	async isShallowRepository(repoPath) {
+		try {
+			const gitDir = await this.provider.config.getGitDir(repoPath);
+			return await this.context.fs.stat(joinUriPath(gitDir.commonUri ?? gitDir.uri, "shallow")) != null;
+		} catch {
+			return;
+		}
+	}
+	/** Whether `ref` is a `refs/remotes/<remote>/HEAD` symref pointing at `target`, from the cached local symref */
+	async isRemoteHeadOf(repoPath, ref, target, cancellation) {
+		if (!ref.startsWith("refs/remotes/") || !ref.endsWith("/HEAD")) return false;
+		const remote = ref.slice(13, -5);
+		if (!remote) return false;
+		const symref = await this.getDefaultBranchName(repoPath, remote, { local: true }, cancellation);
+		return symref != null && `refs/remotes/${symref}` === target;
+	}
+	/**
+	* For `ref` (a full name in `records`, the cached ref list) moving from `oldTip` to `newTip`, the commits its reflog
+	* reaches off `newTip`'s history when it moved only forward: `oldTip` and every value its reflog took after it are in
+	* `newTip`'s history. `--fork-point` reads every reflog entry, so one in between that shares more of HEAD's history
+	* than `newTip` does (a branch's commit that landed and was force-pushed away) moves the fork point while the count
+	* stands; an older one off `newTip`'s history may hold such a commit too, which each worktree's count checks for.
+	* Without a reflog it reads only the tip. `undefined` when it didn't move only forward, or git can't say.
+	*/
+	async getMovedForward(repoPath, records, ref, oldTip, newTip) {
+		let checks = this.baseMovedForward.get(records);
+		if (checks == null) {
+			checks = /* @__PURE__ */ new Map();
+			this.baseMovedForward.set(records, checks);
+		}
+		const key = `${ref}\0${oldTip}\0${newTip}`;
+		let check = checks.get(key);
+		if (check == null) {
+			check = this.readMovedForward(this.cache.getCommonPath(repoPath), ref, oldTip, newTip);
+			checks.set(key, check);
+		}
+		const offHistory = await check;
+		if (offHistory == null && checks.get(key) === check) checks.delete(key);
+		return offHistory || void 0;
+	}
+	/**
+	* Reads {@link getMovedForward} from git, in `commonPath`, which holds the refs, their reflogs and the objects for
+	* every worktree. Not bound to one caller's cancellation, since every worktree the move reached rides this one
+	* read. `false` when the ref didn't move only forward, or reaches too much history off `newTip`'s to tell;
+	* `undefined` when git couldn't say.
+	*/
+	async readMovedForward(commonPath, ref, oldTip, newTip) {
+		let since = /* @__PURE__ */ new Set([oldTip]);
+		let logged = /* @__PURE__ */ new Set([oldTip]);
+		try {
+			const entries = await this.provider.refs.getReflogEntries(commonPath, ref);
+			if (entries.length) {
+				if (entries[0].sha !== newTip) return false;
+				const oldest = entries.findLastIndex((e) => e.sha === oldTip);
+				if (oldest < 0) return false;
+				since = new Set(entries.slice(1, oldest + 1).map((e) => e.sha));
+				logged = new Set(entries.map((e) => e.sha));
+				const before = await this.git.run({
+					cwd: commonPath,
+					errors: "ignore"
+				}, "rev-parse", "--verify", `${ref}@{${entries.length}}`);
+				if (before.completion.status !== "exited") return void 0;
+				if (before.exitCode === 0) {
+					const sha = before.stdout.trim();
+					if (!sha) return void 0;
+					logged.add(sha);
+				} else if (!before.stderr?.includes(" only has ")) return;
+				else if (!await this.git.supports("git:rev-parse:reflog-oldest-old-value")) return false;
+				logged.delete(newTip);
+			}
+		} catch {
+			return;
+		}
+		try {
+			const result = await this.git.run({
+				cwd: commonPath,
+				errors: "ignore",
+				stdin: `${[...logged, `^${newTip}`].join("\n")}\n`
+			}, "rev-list", `--max-count=65`, "--stdin");
+			if (result.completion.status !== "exited" || result.exitCode !== 0) return void 0;
+			const off = result.stdout.split("\n").filter((sha) => sha.length > 0);
+			if (off.length > maxOffHistoryCommits) return false;
+			if (off.some((sha) => since.has(sha))) return false;
+			return off;
+		} catch {
+			return;
+		}
+	}
 	/**
 	* Resolves the base from the recorded candidates, then the branch it was created from or the default branch, for
 	* {@link getAheadOfBase}
@@ -1161,6 +1358,7 @@ var BranchesGitSubProvider = class {
 	async getAheadOfBaseInOrder(repoPath, branch, skipUserTarget, dependsOn, cancellation) {
 		let target;
 		let tier = "default";
+		let resolvedDefault;
 		if (branch != null) for (const candidate of await this.getRecordedBaseCandidates(repoPath, branch, skipUserTarget)) {
 			target = await this.getNearestForkTarget(repoPath, branch, candidate.ref, dependsOn, cancellation);
 			if (target != null) {
@@ -1170,7 +1368,8 @@ var BranchesGitSubProvider = class {
 		}
 		if (target == null) {
 			const defaultBranch = await this.getLocalDefaultBranchName(repoPath, dependsOn, cancellation);
-			if (branch != null && defaultBranch === branch) return this.measureAheadOfSelfUpstream(repoPath, branch, dependsOn, cancellation);
+			resolvedDefault = defaultBranch ?? null;
+			if (branch != null && defaultBranch === branch) return withDefaultBranch(await this.measureAheadOfSelfUpstream(repoPath, branch, dependsOn, cancellation), resolvedDefault);
 			const createdFrom = branch != null ? await this.getCreatedFromTarget(repoPath, branch, cancellation) : void 0;
 			if (createdFrom != null) {
 				const created = await this.getCreatedFromForkTarget(repoPath, branch, createdFrom, defaultBranch, dependsOn, cancellation);
@@ -1185,18 +1384,18 @@ var BranchesGitSubProvider = class {
 			} catch (ex) {
 				if (isCancellationError(ex)) throw ex;
 			}
-			return {
+			return withDefaultBranch({
 				base: void 0,
 				reason: unborn ? "unborn" : "none",
 				dependsOn: [...dependsOn]
-			};
+			}, resolvedDefault);
 		}
-		if (branch != null && await this.isSelfAtHead(repoPath, target.ref, branch, cancellation)) return {
+		if (branch != null && await this.isSelfAtHead(repoPath, target.ref, branch, cancellation)) return withDefaultBranch({
 			base: void 0,
 			reason: "self",
 			dependsOn: [...dependsOn]
-		};
-		return this.measureAheadOfBase(repoPath, target, tier, dependsOn, cancellation);
+		}, resolvedDefault);
+		return withDefaultBranch(await this.measureAheadOfBase(repoPath, target, tier, dependsOn, cancellation), resolvedDefault);
 	}
 	/**
 	* The base for a branch created from `createdFrom`: that branch, unless the default branch forked strictly nearer
@@ -1895,7 +2094,9 @@ __decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialMergeConfli
 __decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialStashReapplyConflicts", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getBaseBranchName", null);
 __decorate([trace()], BranchesGitSubProvider.prototype, "getAheadOfBaseConfigKey", null);
+__decorate([trace()], BranchesGitSubProvider.prototype, "getAheadOfBaseConfigEntries", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getAheadOfBase", null);
+__decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getAheadOfBaseAfterBaseMove", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getAheadBehindCounts", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getMergedBranches", null);
 __decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getStoredMergeTargetBranchName", null);
@@ -1924,18 +2125,38 @@ const refRecordsByName = /* @__PURE__ */ new WeakMap();
 * `refs/heads/` before `refs/remotes/`); annotated tags peel to their commit. `undefined` when no listed ref matches.
 */
 function findRefTip(records, name) {
+	const record = resolveRefRecord(records, name);
+	return record != null ? record.peeledObjectname || record.objectname : void 0;
+}
+/** The listed ref `name` resolves to, in {@link findRefTip}'s order */
+function resolveRefRecord(records, name) {
 	const byName = getRefRecordsByName(records);
-	for (const candidate of [
+	for (const candidate of getRefNameCandidates(name)) {
+		const record = byName.get(candidate);
+		if (record != null) return record;
+	}
+}
+/** Whether more than one listed ref answers to `name`, which git calls ambiguous and resolves in {@link findRefTip}'s order */
+function isAmbiguousRefName(records, name) {
+	const byName = getRefRecordsByName(records);
+	let found = false;
+	for (const candidate of getRefNameCandidates(name)) {
+		if (!byName.has(candidate)) continue;
+		if (found) return true;
+		found = true;
+	}
+	return false;
+}
+/** The full ref names `name` may stand for, in git's own order for a short name */
+function getRefNameCandidates(name) {
+	return [
 		name,
 		`refs/${name}`,
 		`refs/tags/${name}`,
 		`refs/heads/${name}`,
 		`refs/remotes/${name}`,
 		`refs/remotes/${name}/HEAD`
-	]) {
-		const record = byName.get(candidate);
-		if (record != null) return record.peeledObjectname || record.objectname;
-	}
+	];
 }
 function getRefRecordsByName(records) {
 	let byName = refRecordsByName.get(records);
@@ -1969,6 +2190,44 @@ function mayHaveUpstream(records, name) {
 	if (findRefTip(records, `refs/heads/${name}`) != null) return true;
 	return findRefTip(records, name) == null;
 }
+/** `answer` with the default branch its read resolved, when it consulted one (see `AheadOfBase.defaultBranch`) */
+function withDefaultBranch(answer, defaultBranch) {
+	return defaultBranch !== void 0 ? {
+		...answer,
+		defaultBranch
+	} : answer;
+}
+/** Splits `git config --null --get-regexp` output into its entries, in order; a key set without a value has none */
+function parseConfigListing(listing) {
+	const entries = [];
+	for (const entry of listing.split("\0")) {
+		if (!entry) continue;
+		const separator = entry.indexOf("\n");
+		entries.push(separator < 0 ? [entry, void 0] : [entry.substring(0, separator), entry.substring(separator + 1)]);
+	}
+	return entries;
+}
+/**
+* Whether `listing` shows config that can differ by checkout over time: `extensions.worktreeConfig` (each checkout's
+* `config.worktree`), or a conditional include that is neither `hasconfig:` nor `gitdir:`, since `onbranch:` follows
+* each checkout's HEAD and an unknown condition might follow anything. A `gitdir:` include matching only some
+* checkouts is accepted as shared: it is the common identity setup, and treating it as differing would end sharing for
+* nearly everyone. The cost is a known gap: an edit to a file only those checkouts include goes unseen there, since
+* nothing watches it, until a change the shared listing does see.
+*/
+function mayConfigDifferByCheckout(listing) {
+	for (const [key, value] of parseConfigListing(listing)) {
+		if (key === "extensions.worktreeconfig") {
+			if (value == null || !isGitBooleanFalse(value)) return true;
+			continue;
+		}
+		if (!key.startsWith("includeif.")) continue;
+		const condition = key.substring(10, key.lastIndexOf("."));
+		if (condition.startsWith("hasconfig:") || condition.startsWith("gitdir:") || condition.startsWith("gitdir/i:")) continue;
+		return true;
+	}
+	return false;
+}
 /**
 * Adds the full ref names a `.git/refs` watcher would report for `name`. A short name can't be told tag from local
 * from remote without a spawn, so it adds every form, including the tag git resolves it to first; a spurious one