@gitkraken/core-gitlens 0.16.3 → 0.16.5

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

@@ -69,26 +69,13 @@ function parseAheadBehindField(field) {
 function toRefPatterns(refs) {
 	return sum(refs, (r) => r.length + 1) < 15e3 ? [...refs] : void 0;
 }
-/**
-* Joins the read `key` names against `records` (a cached ref list) in `memo`, or starts it with `read`. An answer is
-* kept as long as that list is: a ref write replaces the list, along with the refs and reflog the answer came from.
-* `undefined`, when git couldn't say, isn't kept
-*/
-async function shareBaseMoveRead(memo, records, key, read) {
-	let reads = memo.get(records);
-	if (reads == null) {
-		reads = /* @__PURE__ */ new Map();
-		memo.set(records, reads);
-	}
-	let pending = reads.get(key);
-	if (pending == null) {
-		pending = read();
-		reads.set(key, pending);
-	}
-	const answer = await pending;
-	if (answer === void 0 && reads.get(key) === pending) reads.delete(key);
-	return answer;
-}
+/** The stored keys a merge target is read from: the user's pick, the detected target and its legacy key, and the recorded base */
+const storedMergeKeys = [
+	"gk-merge-target-user",
+	"gk-merge-target",
+	"gk-target-base",
+	"gk-merge-base"
+];
 var BranchesGitSubProvider = class {
 	context;
 	git;
@@ -97,20 +84,22 @@ 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, what its reflog reaches (else `false`), by `<ref>\0<oldSha>\0<newSha>`, for
-	* each cached ref list it was read against. A fetch moves one base under every worktree at once, so they share the
-	* one check, joining it while it runs
+	* For a base that moved only forward, what its reflog reaches (else `false`), by `<commonPath>\0<ref>`, then by the
+	* tip it moved from. A fetch moves one base under every worktree at once, so they share the one check, joining it
+	* while it runs. The reads hold for the tip the ref moved to, the reflog they read, stamped by its file's size and
+	* mtime (else by the cached ref list, through what it derives so the list itself isn't held, when there's no file
+	* to stamp), and the replace refs, which change what's reachable; a change to any of them starts the ref over. Every
+	* move appends to the reflog, so a ref moved away and back to the same tip between reads doesn't find the answer
+	* taken before
 	*/
-	baseMovedForward = /* @__PURE__ */ new WeakMap();
+	baseMovedForward = new LruMap(64);
 	/**
 	* For a base that moved, the count of the commits its new tip lacks for each local branch a worktree has checked
-	* out, by tip sha, keyed by that new tip alone for each cached ref list it was read against (which also fixes the
-	* branches counted). The counts don't depend on the ref or where it moved from, so each worktree the move reached
-	* finds its HEAD's count in the one read, even one whose previous answer was taken at another old tip. Only the
-	* checked-out branches are counted: the shared walk runs until every counted branch meets the new tip, so an
-	* unrelated old or orphan branch no worktree uses would make it deeper than any worktree's own count
+	* out, by tip sha, by `<commonPath>\0<newTip>`, with the replace refs it was counted under and the tips it counted.
+	* The counts don't depend on the ref or where it moved from, so each worktree the move reached finds its HEAD's
+	* count in the one read, even one whose previous answer was taken at another old tip
 	*/
-	aheadOfMovedBase = /* @__PURE__ */ new WeakMap();
+	aheadOfMovedBase = new LruMap(64);
 	/**
 	* 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
@@ -124,6 +113,11 @@ var BranchesGitSubProvider = class {
 	* it once
 	*/
 	_branchCreatedFrom = new LruMap(1024);
+	/**
+	* The branch HEAD was on when each `commonPath\0branch` was first checked out, as git wrote it, for a branch
+	* created from `HEAD`; only found ones, since a later checkout can write one
+	*/
+	_branchCheckedOutFrom = 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);
 	/**
@@ -361,28 +355,17 @@ var BranchesGitSubProvider = class {
 			};
 		};
 		try {
-			let mergeTarget;
-			mergeTarget = await this.getStoredMergeTargetBranchName(repoPath, ref, priorityOpts, cancellation);
-			if (mergeTarget == null && options?.associatedPullRequest != null) {
-				const pr = await options.associatedPullRequest;
-				if (pr?.refs?.base != null) {
-					const branch = await this.getBranch(repoPath, ref, void 0, cancellation);
-					if (branch == null) return void 0;
-					const { remote: remoteName } = await resolveBranchRemote(this.provider, repoPath, branch, cancellation);
-					if (remoteName != null) {
-						const prTarget = `${remoteName}/${pr.refs.base.branch}`;
-						const { missing } = await this.provider.refs.getSymbolicReferenceNameOrMissing(repoPath, prTarget, priorityOpts, cancellation);
-						if (!missing) {
-							mergeTarget = prTarget;
-							if (pr.stack == null) this.storeMergeTargetBranchName(repoPath, ref, prTarget, { skipInvalidation: ["branchOverviews"] });
-						}
-					}
-				}
-			}
-			mergeTarget ??= await this.getBaseBranchName(repoPath, ref, priorityOpts, cancellation);
-			mergeTarget ??= await this.getDefaultBranchName(repoPath, void 0, priorityOpts, cancellation);
-			if (mergeTarget == null) return void 0;
-			const resolvedTarget = mergeTarget;
+			const associatedPullRequest = options?.associatedPullRequest;
+			const target = await this.getMergeTarget(repoPath, ref, {
+				getAssociatedPullRequest: associatedPullRequest != null ? () => associatedPullRequest : void 0,
+				inferBase: true,
+				defaultBranch: "remote",
+				getFallbackDefaultBranch: options?.getFallbackDefaultBranch,
+				keepSelfAtTip: true,
+				priority
+			}, cancellation);
+			if (target == null) return void 0;
+			const resolvedTarget = target.ref;
 			return await this.cache.getBranchOverview(repoPath, `${ref}|${resolvedTarget}`, (_commonPath, _cacheable, signal) => fetchBody(resolvedTarget, signal ?? cancellation), { cancellation });
 		} catch (ex) {
 			scope?.error(ex);
@@ -1067,75 +1050,63 @@ var BranchesGitSubProvider = class {
 					update = mergeBase != null;
 				}
 				if (mergeBase != null) {
-					const branch = await this.provider.refs.getSymbolicReferenceName(commonPath, mergeBase, priorityOpts);
-					if (branch != null) {
-						if (update) this.storeBaseBranchName(commonPath, ref, branch, { skipInvalidation: ["branchOverviews", "baseBranchName"] });
-						return branch;
+					const { name, missing } = await this.provider.refs.getSymbolicReferenceNameOrMissing(commonPath, mergeBase, priorityOpts, signal);
+					if (!missing) {
+						if (!name) {
+							cacheable.invalidate();
+							return mergeBase;
+						}
+						if (update) this.storeBaseBranchName(commonPath, ref, name, { skipInvalidation: ["branchOverviews", "baseBranchName"] });
+						return name;
 					}
 				}
 			} catch {}
-			const reflog = await this.getBaseBranchFromReflog(commonPath, ref, {
-				upstream: true,
-				priority
-			}, signal);
-			if (reflog.branch != null) {
-				this.storeBaseBranchName(commonPath, ref, reflog.branch, { skipInvalidation: ["branchOverviews", "baseBranchName"] });
-				return reflog.branch;
-			}
+			const reflog = await this.getBaseBranchFromReflog(repoPath, commonPath, ref, priority, signal);
+			if (reflog.branch != null) return reflog.branch;
 			if (reflog.failed) cacheable.invalidate();
 		}, cancellation);
 	}
 	/**
-	* `failed` separates "the reflog ran and had no answer" from "the read never happened" — the caller
-	* caches the former forever and must not cache the latter.
+	* The branch `ref` was created from, else the branch HEAD was on when it was first checked out, each as its
+	* upstream when it has one. `failed` separates "the reflog ran and had no answer" from "the read never happened" —
+	* the caller caches the former forever and must not cache the latter.
 	*/
-	async getBaseBranchFromReflog(repoPath, ref, options, cancellation) {
-		const priority = options?.priority;
+	async getBaseBranchFromReflog(repoPath, commonPath, ref, priority, cancellation) {
 		const priorityOpts = priority != null ? { priority } : void 0;
 		try {
-			const createdFrom = await this.getReflogCreatedFrom(repoPath, ref, priority, cancellation);
+			const createdFrom = await this.getReflogCreatedFrom(commonPath, ref, priority, cancellation);
 			if (createdFrom == null) return {
 				branch: void 0,
 				failed: false
 			};
 			if (createdFrom !== "HEAD") {
-				if (options?.upstream) {
-					const upstream = await this.getUpstreamName(repoPath, createdFrom, priorityOpts, cancellation);
-					if (upstream) return {
-						branch: upstream,
-						failed: false
-					};
-				}
-				const name = await this.provider.refs.getSymbolicReferenceName(repoPath, createdFrom, priorityOpts);
+				const upstream = await this.getUpstreamName(commonPath, createdFrom, priorityOpts, cancellation);
+				if (upstream) return {
+					branch: upstream,
+					failed: false
+				};
+				const name = await this.provider.refs.getSymbolicReferenceName(commonPath, createdFrom, priorityOpts);
 				if (name) return {
 					branch: name,
 					failed: false
 				};
 			}
-			const entries = await this.provider.refs.getReflogEntries(repoPath, "HEAD", {
-				grep: `checkout: moving from .* to ${ref.replace("refs/heads/", "")}`,
-				priority
-			}, cancellation);
-			if (!entries.length) return {
+			const branch = ref.replace(/^refs\/heads\//, "");
+			const source = await this.getCheckoutSource(await this.getCheckoutPath(repoPath, branch, cancellation), branch, priority, cancellation);
+			if (source == null) return {
 				branch: void 0,
 				failed: false
 			};
-			const match = entries.at(-1).message.match(/checkout: moving from ([^\s]+)\s/);
-			if (match?.length === 2) {
-				let name = match[1];
-				if (options?.upstream) {
-					const upstream = await this.getUpstreamName(repoPath, name, priorityOpts, cancellation);
-					if (upstream) return {
-						branch: upstream,
-						failed: false
-					};
-				}
-				name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
-				if (name) return {
-					branch: name,
-					failed: false
-				};
-			}
+			const upstream = await this.getUpstreamName(commonPath, source, priorityOpts, cancellation);
+			if (upstream) return {
+				branch: upstream,
+				failed: false
+			};
+			const name = await this.provider.refs.getSymbolicReferenceName(commonPath, source, priorityOpts);
+			if (name) return {
+				branch: name,
+				failed: false
+			};
 		} catch (ex) {
 			if (isCancellationError(ex)) throw ex;
 			const msg = ex?.toString() ?? "";
@@ -1168,12 +1139,36 @@ var BranchesGitSubProvider = class {
 		return entries[0].message.match(/branch: Created from (.*)$/)?.[1];
 	}
 	/**
-	* The branch `branch` was created from, as a base for {@link getAheadOfBaseInOrder}: the name its own reflog
-	* gives, when that is a local or remote-tracking branch in the cached ref list and not `branch` itself or its
-	* copy on a remote (`git switch <branch>` creates it from `<remote>/<branch>`). Never the checkout history in
-	* HEAD's reflog, which on a long-lived checkout names whatever was checked out last.
+	* The worktree `branch` is checked out in, whose HEAD reflog holds its checkouts; else the main worktree, never the
+	* caller's, since every worktree of the repository shares the answer
 	*/
-	async getCreatedFromTarget(repoPath, branch, cancellation) {
+	async getCheckoutPath(repoPath, branch, cancellation) {
+		const worktreePath = findRefRecord(await this.provider.refs.getRefs(repoPath, cancellation), `refs/heads/${branch}`)?.worktreePath;
+		return worktreePath ? normalizePath(worktreePath) : this.cache.getCommonPath(repoPath);
+	}
+	/**
+	* The branch HEAD was on when `branch` was first checked out at `repoPath` (the oldest `checkout: moving from
+	* <name> to <branch>` in its HEAD reflog), as git wrote it. `undefined` when there is no such entry. Rejects when the
+	* reflog can't be read.
+	*/
+	async getCheckoutSource(repoPath, branch, priority, cancellation) {
+		const entries = await this.provider.refs.getReflogEntries(repoPath, "HEAD", {
+			grep: `checkout: moving from .* to ${toReflogGrepLiteral(branch)}$`,
+			priority
+		}, cancellation);
+		for (let i = entries.length - 1; i >= 0; i--) {
+			const match = /^checkout: moving from (\S+) to (.+)$/.exec(entries[i].message);
+			if (match?.[2] === branch) return match[1];
+		}
+	}
+	/**
+	* The branch `branch` was created from, as a base for {@link resolveBase}: the name its own reflog gives, when that
+	* is a local or remote-tracking branch in the cached ref list and not `branch` itself or its copy on a remote
+	* (`git switch <branch>` creates it from `<remote>/<branch>`). Never the checkout history in HEAD's reflog, which
+	* on a long-lived checkout names whatever was checked out last. `fromHead` when the reflog says it was created
+	* from `HEAD`.
+	*/
+	async getCreatedFromTarget(repoPath, branch, reads, cancellation) {
 		const key = this.getBranchActivityKey(repoPath, branch);
 		let name;
 		if (this._branchCreatedFrom.has(key)) name = this._branchCreatedFrom.get(key);
@@ -1183,20 +1178,73 @@ var BranchesGitSubProvider = class {
 				name = await this.getReflogCreatedFrom(repoPath, `refs/heads/${branch}`, void 0, cancellation);
 			} catch (ex) {
 				if (isCancellationError(ex)) throw ex;
-				return;
+				reads.pinnable = false;
+				return {
+					name: void 0,
+					fromHead: false
+				};
 			}
 			if (cancellation?.aborted) throw new CancellationError();
 			if (this._branchCreatedFromGenerations.get(key) === generation) this._branchCreatedFrom.set(key, name);
 		}
+		if (name === "HEAD") return {
+			name: void 0,
+			fromHead: true
+		};
+		return {
+			name: await this.getListedBaseName(repoPath, name, branch, reads, cancellation),
+			fromHead: false
+		};
+	}
+	/**
+	* For a branch its reflog says was created from `HEAD`, the branch HEAD was on when it was first checked out (see
+	* {@link getCheckoutSource}), read in the worktree it is checked out in, else the main worktree, and kept as a base
+	* like {@link getCreatedFromTarget}'s. Remembered once found, as the created-from name is; a reflog with no such
+	* entry yet marks the answer for eviction on the next checkout, which may write one.
+	*/
+	async getInferredCreatedFrom(repoPath, branch, reads, cancellation) {
+		const key = this.getBranchActivityKey(repoPath, branch);
+		let source = this._branchCheckedOutFrom.get(key);
+		if (source == null) {
+			const generation = this._branchCreatedFromGenerations.get(key);
+			try {
+				source = await this.getCheckoutSource(await this.getCheckoutPath(repoPath, branch, cancellation), branch, reads.priority, cancellation);
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				reads.pinnable = false;
+				return;
+			}
+			if (cancellation?.aborted) throw new CancellationError();
+			if (source == null) {
+				reads.evictOnCheckout = true;
+				return;
+			}
+			if (this._branchCreatedFromGenerations.get(key) === generation) this._branchCheckedOutFrom.set(key, source);
+		}
+		return this.getListedBaseName(repoPath, source, branch, reads, cancellation);
+	}
+	/**
+	* `name` as a base for `branch`: only a local or remote-tracking branch in the cached ref list — a sha, a tag or a
+	* revision expression (`main~2`) names no `refs/heads/` or `refs/remotes/` ref — and not `branch` itself or its
+	* copy on a remote.
+	*/
+	async getListedBaseName(repoPath, name, branch, reads, cancellation) {
 		if (!name || name === "HEAD" || name.startsWith("-")) return void 0;
 		const records = await this.provider.refs.getRefs(repoPath, cancellation);
 		const fullNames = name.startsWith("refs/heads/") || name.startsWith("refs/remotes/") ? [name] : [`refs/heads/${name}`, `refs/remotes/${name}`];
 		let listed = false;
-		for (const fullName of fullNames) if (await this.getRefTip(repoPath, records, fullName, cancellation) != null) {
-			listed = true;
-			break;
+		for (const fullName of fullNames) {
+			reads.tipRefs.add(fullName);
+			if (await this.getRefTip(repoPath, records, fullName, cancellation) != null) {
+				listed = true;
+				break;
+			}
 		}
 		if (!listed) return void 0;
+		if (fullNames.length === 1 && records.length) {
+			const short = name.slice(name.startsWith("refs/heads/") ? 11 : 13);
+			if (resolveRefRecord(records, short)?.name === name) name = short;
+		}
 		if (await this.isSelfRef(repoPath, name, branch, cancellation)) return void 0;
 		return name;
 	}
@@ -1247,14 +1295,30 @@ var BranchesGitSubProvider = class {
 	}
 	async getAheadOfBase(repoPath, branch, options, cancellation) {
 		if (branch != null && isDetachedHead(branch)) branch = void 0;
-		const dependsOn = new Set(branch != null ? [`refs/heads/${branch}`] : []);
-		const preferredTarget = options?.preferredTarget?.trim() || void 0;
-		if (preferredTarget == null) return this.getAheadOfBaseInOrder(repoPath, branch, options?.skipUserTarget, dependsOn, cancellation);
-		let target = await this.getNearestForkTarget(repoPath, branch, preferredTarget, dependsOn, cancellation);
-		if (target != null && branch != null && await this.isSelfAtHead(repoPath, target.ref, branch, cancellation)) target = void 0;
-		if (cancellation?.aborted) throw new CancellationError();
-		if (target != null) return this.measureAheadOfBase(repoPath, target, "preferred", dependsOn, cancellation);
-		return this.getAheadOfBaseInOrder(repoPath, branch, options?.skipUserTarget, dependsOn, cancellation);
+		const reads = createBaseReads("HEAD", branch != null ? [`refs/heads/${branch}`] : [], void 0);
+		const { dependsOn } = reads;
+		const resolved = await this.resolveBase(repoPath, branch, branch, false, options, reads, cancellation);
+		if (resolved.kind === "upstream") return withDefaultBranch(await this.measureAheadOfSelfUpstream(repoPath, resolved.upstream, reads, cancellation), reads.localDefault);
+		if (resolved.kind === "none") {
+			let unborn = false;
+			if (branch != null) try {
+				unborn = findRefTip(await this.provider.refs.getRefs(repoPath, cancellation), `refs/heads/${branch}`) == null && await this.isUnbornHead(repoPath, cancellation);
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+			}
+			return withDefaultBranch({
+				base: void 0,
+				reason: unborn ? "unborn" : "none",
+				dependsOn: [...dependsOn]
+			}, reads.localDefault);
+		}
+		if (resolved.tier !== "preferred" && branch != null && await this.isSelfAtTip(repoPath, resolved.target.ref, branch, reads, cancellation)) return withDefaultBranch({
+			base: void 0,
+			reason: "self",
+			dependsOn: [...dependsOn]
+		}, reads.localDefault);
+		const tier = resolved.tier;
+		return withDefaultBranch(await this.measureAheadOfBase(repoPath, resolved.target, tier, dependsOn, cancellation), reads.localDefault);
 	}
 	async getAheadOfBaseAfterBaseMove(repoPath, branch, previous, moved, cancellation) {
 		const { head, base } = previous;
@@ -1291,7 +1355,7 @@ var BranchesGitSubProvider = class {
 			if (cancellation?.aborted) throw new CancellationError();
 			if (!movedForward) return void 0;
 			const { offHistory, logged } = movedForward;
-			const aheadOfNewTip = (await this.getAheadOfMovedBase(repoPath, records, newTip))?.get(head);
+			const aheadOfNewTip = await this.getAheadOfMovedBase(repoPath, records, newTip, head);
 			if (cancellation?.aborted) throw new CancellationError();
 			if (aheadOfNewTip != null && aheadOfNewTip !== base.ahead) return void 0;
 			const forkPoint = base.forkPoint;
@@ -1347,7 +1411,56 @@ var BranchesGitSubProvider = class {
 	* or git can't say.
 	*/
 	async getMovedForward(repoPath, records, ref, oldTip, newTip) {
-		return await shareBaseMoveRead(this.baseMovedForward, records, `${ref}\0${oldTip}\0${newTip}`, () => this.readMovedForward(this.cache.getCommonPath(repoPath), ref, oldTip, newTip)) || void 0;
+		const commonPath = this.cache.getCommonPath(repoPath);
+		const key = `${commonPath}\0${ref}`;
+		const inputs = getBaseMoveReadInputs(records);
+		const reflog = await this.getReflogStamp(repoPath, ref) ?? inputs;
+		const { replaced } = inputs;
+		let slot = this.baseMovedForward.get(key);
+		if (slot == null || slot.newTip !== newTip || slot.reflog !== reflog || slot.replaced !== replaced) {
+			slot = {
+				newTip,
+				reflog,
+				replaced,
+				reads: /* @__PURE__ */ new Map()
+			};
+			this.baseMovedForward.set(key, slot);
+		} else this.baseMovedForward.touch(key);
+		const { reads } = slot;
+		let pending = reads.get(oldTip);
+		if (pending == null) {
+			pending = this.readMovedForward(commonPath, ref, oldTip, newTip);
+			reads.set(oldTip, pending);
+		}
+		const movedForward = await pending;
+		if (movedForward === void 0 && reads.get(oldTip) === pending) reads.delete(oldTip);
+		return movedForward || void 0;
+	}
+	/**
+	* A stamp of `ref`'s reflog file in the common git directory, by its size and mtime; `undefined` when there's no
+	* file to stat (a reftable repository, or a ref without a reflog)
+	*/
+	async getReflogStamp(repoPath, ref) {
+		try {
+			const gitDir = await this.provider.config.getGitDir(repoPath);
+			const stat = await this.context.fs.stat(joinUriPath(gitDir.commonUri ?? gitDir.uri, "logs", ref));
+			return stat != null ? `${stat.size}\0${stat.mtime}` : void 0;
+		} catch {
+			return;
+		}
+	}
+	/**
+	* A stamp of the common git directory's `shallow` file, by its size and mtime; `null` when the repository isn't
+	* shallow, `undefined` when that can't be read
+	*/
+	async getShallowStamp(repoPath) {
+		try {
+			const gitDir = await this.provider.config.getGitDir(repoPath);
+			const stat = await this.context.fs.stat(joinUriPath(gitDir.commonUri ?? gitDir.uri, "shallow"));
+			return stat != null ? `${stat.size}\0${stat.mtime}` : null;
+		} catch {
+			return;
+		}
 	}
 	/**
 	* Reads {@link getMovedForward} from git, in `commonPath`, which holds the refs, their reflogs and the objects for
@@ -1401,31 +1514,43 @@ var BranchesGitSubProvider = class {
 		}
 	}
 	/**
-	* For a base moved to `newTip`, read against `records` (the cached ref list), the count of the commits `newTip`
-	* lacks for each local branch a worktree has checked out, by tip sha, so a detached HEAD at one of those tips finds
-	* its count too. Only those branches are counted: the one walk runs until every counted branch meets `newTip`, so an
-	* unrelated old or orphan branch would make it deeper than any worktree's own count, and a HEAD at a commit no
-	* checked-out branch points at isn't in the answer. The branches derive from `records`, which the read is kept
-	* per, so `newTip` alone keys it. `undefined` when git can't count them in one pass (before 2.41), there is no
-	* checked-out branch or `records` can't tell which are, or git couldn't say.
+	* For a base moved to `newTip`, the count of the commits `newTip` lacks for `head`, from one count of each local
+	* branch a worktree has checked out in `records` (the cached ref list), by tip sha, so a detached HEAD at one of
+	* those tips finds its count too. Only those branches are counted: the one walk runs until every counted branch
+	* meets `newTip`, so an unrelated old or orphan branch would make it deeper than any worktree's own count. Which
+	* branches it counts only bounds that walk, since a commit's count past `newTip` doesn't depend on what else is
+	* counted, so a read that counted `head` answers it for a later list (one with a branch created at `newTip` since,
+	* say) while the replace refs match; a `head` it didn't count starts a read over the current list's checked-out
+	* branches. `undefined` when no checked-out branch is at `head` or `records` can't tell which are checked out, git
+	* can't count them in one pass (before 2.41), or git couldn't say.
 	*/
-	getAheadOfMovedBase(repoPath, records, newTip) {
-		return shareBaseMoveRead(this.aheadOfMovedBase, records, newTip, () => this.readAheadOfMovedBase(this.cache.getCommonPath(repoPath), records, newTip));
+	async getAheadOfMovedBase(repoPath, records, newTip, head) {
+		const { checkedOut, checkedOutTips, replaced } = getBaseMoveReadInputs(records);
+		if (!checkedOut?.size || !checkedOutTips.has(head)) return void 0;
+		const commonPath = this.cache.getCommonPath(repoPath);
+		const key = `${commonPath}\0${newTip}`;
+		let slot = this.aheadOfMovedBase.get(key);
+		if (slot == null || slot.replaced !== replaced || !slot.tips.has(head)) {
+			slot = {
+				replaced,
+				tips: checkedOutTips,
+				read: this.readAheadOfMovedBase(commonPath, checkedOut, newTip)
+			};
+			this.aheadOfMovedBase.set(key, slot);
+		} else this.aheadOfMovedBase.touch(key);
+		const { read } = slot;
+		const aheadByTip = await read;
+		if (aheadByTip === void 0 && this.aheadOfMovedBase.get(key)?.read === read) this.aheadOfMovedBase.delete(key);
+		return aheadByTip?.get(head);
 	}
 	/**
-	* Reads {@link getAheadOfMovedBase} from git, in `commonPath`, which holds every worktree's branches. Not bound to
-	* one caller's cancellation, since every worktree the move reached rides this one read.
+	* Reads {@link getAheadOfMovedBase} for the `checkedOut` branches from git, in `commonPath`, which holds every
+	* worktree's branches. Not bound to one caller's cancellation, since every worktree the move reached rides this one
+	* read.
 	*/
-	async readAheadOfMovedBase(commonPath, records, newTip) {
+	async readAheadOfMovedBase(commonPath, checkedOut, newTip) {
 		try {
 			if (!await this.git.supports("git:for-each-ref:ahead-behind")) return void 0;
-			const checkedOut = /* @__PURE__ */ new Set();
-			for (const record of records) {
-				if (!record.name.startsWith("refs/heads/")) continue;
-				if (record.worktreePath == null) return void 0;
-				if (record.worktreePath) checkedOut.add(record.name);
-			}
-			if (!checkedOut.size) return void 0;
 			const patterns = toRefPatterns(checkedOut) ?? ["refs/heads"];
 			const result = await this.git.run({
 				cwd: commonPath,
@@ -1448,60 +1573,376 @@ var BranchesGitSubProvider = class {
 			return;
 		}
 	}
+	async getMergeTarget(repoPath, branch, options, cancellation) {
+		if (!branch || isDetachedHead(branch)) return void 0;
+		const cacheKey = getMergeTargetCacheKey(branch, options);
+		let resolved = false;
+		const factory = async (_commonPath, cacheable, signal) => {
+			resolved = true;
+			const { entry, pinnable } = await this.resolveMergeTarget(repoPath, branch, options, signal ?? cancellation);
+			if (!pinnable) cacheable.invalidate();
+			return entry;
+		};
+		let entry = await this.cache.getMergeTarget(repoPath, cacheKey, factory, cancellation);
+		if (!resolved && !await this.isMergeTargetCurrent(repoPath, branch, entry, options, cancellation)) {
+			this.cache.deleteMergeTarget(repoPath, cacheKey, entry);
+			entry = await this.cache.getMergeTarget(repoPath, cacheKey, factory, cancellation);
+		}
+		if (cancellation?.aborted) throw new CancellationError();
+		return entry.selfAtTip && !options?.keepSelfAtTip ? void 0 : entry.result;
+	}
 	/**
-	* Resolves the base from the recorded candidates, then the branch it was created from or the default branch, for
-	* {@link getAheadOfBase}
+	* Where {@link getMergeTarget} measures `branch` from: its local branch's ref, or — for a remote-tracking branch given
+	* by its short name (`origin/feature`) — that ref, with `selfName` its name on the remote
 	*/
-	async getAheadOfBaseInOrder(repoPath, branch, skipUserTarget, dependsOn, cancellation) {
+	async getMergeTargetSource(repoPath, branch, records, cancellation) {
+		if (findRefRecord(records, `refs/heads/${branch}`) != null || findRefRecord(records, `refs/remotes/${branch}`) == null) return {
+			from: `refs/heads/${branch}`,
+			selfName: branch,
+			remoteBranch: false
+		};
+		const split = splitRemoteBranchName(branch, await this.getRemoteNames(repoPath, cancellation));
+		return {
+			from: `refs/remotes/${branch}`,
+			selfName: split?.[1] ?? branch,
+			remoteBranch: true
+		};
+	}
+	/** Resolves {@link getMergeTarget}'s answer with what it was read from; `pinnable` is false when it can't be confirmed later */
+	async resolveMergeTarget(repoPath, branch, options, cancellation) {
+		const [records, configKey, shallow] = await Promise.all([
+			this.provider.refs.getRefs(repoPath, cancellation),
+			tolerateRead(() => this.getAheadOfBaseConfigKey(repoPath, cancellation)),
+			this.getShallowStamp(repoPath)
+		]);
+		const { replaced } = getBaseMoveReadInputs(records);
+		const { from, selfName, remoteBranch } = await this.getMergeTargetSource(repoPath, branch, records, cancellation);
+		if (records.length && getListedTip(records, from) == null) return {
+			entry: {
+				result: void 0,
+				selfAtTip: false,
+				tips: [[from, void 0], [`refs/remotes/${branch}`, void 0]],
+				replaced,
+				shallow: shallow ?? null,
+				configKey,
+				stored: void 0,
+				evictOnCheckout: false
+			},
+			pinnable: configKey != null && shallow !== void 0
+		};
+		const reads = createBaseReads(from, [from], options?.priority);
+		reads.pinnable = records.length !== 0 && configKey != null && shallow !== void 0;
+		const resolved = await this.resolveBase(repoPath, branch, selfName, remoteBranch, options, reads, cancellation);
+		let result;
+		let selfAtTip = false;
+		if (resolved.kind === "upstream") {
+			const upstream = resolved.upstream;
+			if (upstream != null) {
+				selfAtTip = upstream.sha === await this.getRefTip(repoPath, records, from, cancellation);
+				result = {
+					ref: upstream.ref,
+					forkPoint: selfAtTip ? upstream.sha : await this.getForkPoint(repoPath, upstream.ref, reads, cancellation),
+					tier: "upstream"
+				};
+			}
+		} else if (resolved.kind === "target") {
+			result = {
+				ref: resolved.target.ref,
+				forkPoint: resolved.target.forkPoint,
+				tier: resolved.tier
+			};
+			selfAtTip = resolved.tier !== "preferred" && await this.isSelfAtTip(repoPath, result.ref, selfName, reads, cancellation);
+		}
+		if (cancellation?.aborted) throw new CancellationError();
+		const tips = [];
+		for (const ref of /* @__PURE__ */ new Set([...reads.dependsOn, ...reads.tipRefs])) tips.push([ref, getListedTip(records, ref)]);
+		return {
+			entry: {
+				result,
+				selfAtTip,
+				tips,
+				replaced,
+				shallow: shallow ?? null,
+				configKey,
+				stored: reads.stored,
+				pullRequest: reads.pullRequest,
+				localDefault: reads.localDefault,
+				remoteDefault: reads.remoteDefault,
+				fallbackDefault: reads.fallbackDefault,
+				evictOnCheckout: reads.evictOnCheckout
+			},
+			pinnable: reads.pinnable
+		};
+	}
+	/** Whether everything `entry` was read from still reads the same; while nothing changed, every read here is cached */
+	async isMergeTargetCurrent(repoPath, branch, entry, options, cancellation) {
+		const records = await this.provider.refs.getRefs(repoPath, cancellation);
+		if (!records.length) return false;
+		for (const [ref, tip] of entry.tips) if (getListedTip(records, ref) !== tip) return false;
+		if (getBaseMoveReadInputs(records).replaced !== entry.replaced) return false;
+		if (entry.shallow != null && await this.getShallowStamp(repoPath) !== entry.shallow) return false;
+		if (await tolerateRead(() => this.getAheadOfBaseConfigKey(repoPath, cancellation)) !== entry.configKey) return false;
+		if (entry.stored != null) {
+			if ((await this.readStoredMergeKeys(repoPath, branch, options?.inferBase, void 0)).some((value, i) => value !== entry.stored[i])) return false;
+		}
+		if (entry.localDefault !== void 0) {
+			if ((await this.getLocalDefaultBranchName(repoPath, /* @__PURE__ */ new Set(), cancellation) ?? null) !== entry.localDefault) return false;
+		}
+		if (entry.remoteDefault != null) {
+			const cached = this.cache.peekDefaultBranchName(repoPath, entry.remoteDefault.remote);
+			if (cached == null) return false;
+			if ((await tolerateRead(() => cached) ?? null) !== entry.remoteDefault.name) return false;
+		}
+		if (entry.fallbackDefault !== void 0) {
+			if ((((await tolerateRead(options?.getFallbackDefaultBranch))?.trim() || void 0) ?? null) !== entry.fallbackDefault) return false;
+		}
+		if (entry.pullRequest !== void 0) {
+			const getAssociatedPullRequest = options?.getAssociatedPullRequest;
+			if (getAssociatedPullRequest == null) return false;
+			if (((await this.getPullRequestBaseCandidate(repoPath, branch, getAssociatedPullRequest, void 0, cancellation))?.ref ?? null) !== entry.pullRequest) return false;
+		}
+		return true;
+	}
+	/**
+	* The base `branch` is measured against from `reads.from`, in {@link getMergeTarget}'s order; `getAheadOfBase`'s
+	* options never reach the pull request, the reflog guess or the remote. `selfName` is the name a self check
+	* compares with: `branch`, or a remote-tracking branch's name on its remote, which has no stored targets, reflog or
+	* upstream of its own. A `'preferred'` target is already known not to be the branch itself at `from`'s commit; any
+	* other target isn't checked here.
+	*/
+	async resolveBase(repoPath, branch, selfName, remoteBranch, options, reads, cancellation) {
+		const preferredTarget = options?.preferredTarget?.trim() || void 0;
+		if (preferredTarget != null) {
+			let target = await this.getNearestForkTarget(repoPath, branch, preferredTarget, reads, cancellation);
+			if (target != null && selfName != null && await this.isSelfAtTip(repoPath, target.ref, selfName, reads, cancellation)) target = void 0;
+			if (cancellation?.aborted) throw new CancellationError();
+			if (target != null) return {
+				kind: "target",
+				target,
+				tier: "preferred"
+			};
+		}
 		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) {
-				tier = candidate.tier;
-				break;
-			}
+		if (branch != null) {
+			const stored = await this.getStoredBaseTarget(repoPath, branch, remoteBranch, options, reads, cancellation);
+			if (stored != null) ({target, tier} = stored);
 		}
 		if (target == null) {
-			const defaultBranch = await this.getLocalDefaultBranchName(repoPath, 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;
+			const defaultBranch = await this.getDefaultBranchForBase(repoPath, options, reads, cancellation);
+			if (branch != null && defaultBranch === branch) {
+				if (remoteBranch) {
+					addRefDependencies(reads.dependsOn, branch);
+					const records = await this.provider.refs.getRefs(repoPath, cancellation);
+					const tip = await this.getRefTip(repoPath, records, reads.from, cancellation);
+					if (cancellation?.aborted) throw new CancellationError();
+					return tip != null ? {
+						kind: "target",
+						target: {
+							ref: branch,
+							forkPoint: tip
+						},
+						tier: "default"
+					} : { kind: "none" };
+				}
+				return {
+					kind: "upstream",
+					upstream: await this.getSelfUpstreamTarget(repoPath, branch, reads, cancellation)
+				};
+			}
+			const createdFrom = branch != null && !remoteBranch ? await this.getCreatedFromSource(repoPath, branch, options, reads, cancellation) : void 0;
 			if (createdFrom != null) {
-				const created = await this.getCreatedFromForkTarget(repoPath, branch, createdFrom, defaultBranch, dependsOn, cancellation);
+				const created = await this.getCreatedFromForkTarget(repoPath, branch, createdFrom, defaultBranch, reads, cancellation);
 				if (created != null) ({target, tier} = created);
-			} else target = await this.getUpstreamNearestForkTarget(repoPath, branch, defaultBranch, dependsOn, cancellation);
+			} else target = await this.getUpstreamNearestForkTarget(repoPath, branch, defaultBranch, reads, cancellation);
 		}
 		if (cancellation?.aborted) throw new CancellationError();
-		if (target == null) {
-			let unborn = false;
-			if (branch != null) try {
-				unborn = findRefTip(await this.provider.refs.getRefs(repoPath, cancellation), `refs/heads/${branch}`) == null && await this.isUnbornHead(repoPath, cancellation);
+		return target != null ? {
+			kind: "target",
+			target,
+			tier
+		} : { kind: "none" };
+	}
+	/**
+	* The first usable stored candidate, most trusted first: the user's merge target (unless `skipUserTarget`), the
+	* detected one, the pull request's base (`getAssociatedPullRequest`, read only when neither is usable), then the
+	* recorded base — only its stored value (and with `inferBase`, VS Code's), never `getBaseBranchName`'s reflog
+	* guess, which on a long-lived checkout names whatever branch was last checked out from. A remote-tracking branch
+	* has no stored keys of its own, so only its pull request's base is tried, and never recorded.
+	*/
+	async getStoredBaseTarget(repoPath, branch, remoteBranch, options, reads, cancellation) {
+		let stored = [];
+		if (!remoteBranch) {
+			stored = await this.readStoredMergeKeys(repoPath, branch, options?.inferBase, reads);
+			reads.stored = stored;
+		}
+		const [user, detected, legacyDetected, recorded, vscodeRecorded] = stored;
+		const tried = /* @__PURE__ */ new Set();
+		const measure = async (candidate) => {
+			candidate = candidate?.trim();
+			if (!candidate || tried.has(candidate)) return void 0;
+			tried.add(candidate);
+			return this.getNearestForkTarget(repoPath, branch, candidate, reads, cancellation);
+		};
+		let target;
+		if (!options?.skipUserTarget) {
+			target = await measure(user);
+			if (target != null) return {
+				target,
+				tier: "user"
+			};
+		}
+		target = await measure(detected ?? legacyDetected);
+		if (target != null) return {
+			target,
+			tier: "detected"
+		};
+		if (options?.getAssociatedPullRequest != null) {
+			const pr = await this.getPullRequestBaseCandidate(repoPath, branch, options.getAssociatedPullRequest, reads, cancellation);
+			target = await measure(pr?.ref);
+			if (pr != null && target != null) {
+				if (pr.stacked || remoteBranch) reads.pullRequest = pr.ref;
+				else {
+					this.storeMergeTargetBranchName(repoPath, branch, pr.ref, { skipInvalidation: ["branchOverviews"] });
+					reads.pinnable = false;
+				}
+				return {
+					target,
+					tier: "pr"
+				};
+			}
+			reads.pullRequest = pr?.ref ?? null;
+		}
+		target = await measure(recorded);
+		if (target != null) return {
+			target,
+			tier: "recorded"
+		};
+		if (!recorded?.trim() && vscodeRecorded?.trim()) {
+			target = await measure(vscodeRecorded);
+			if (target != null) {
+				this.storeBaseBranchName(repoPath, branch, vscodeRecorded.trim(), { skipInvalidation: ["branchOverviews", "baseBranchName"] });
+				reads.pinnable = false;
+				return {
+					target,
+					tier: "recorded"
+				};
+			}
+		}
+	}
+	/**
+	* The branch's stored merge keys as read, in {@link storedMergeKeys} order, then VS Code's recorded base when
+	* `inferBase`. A failed read is absent, and leaves `reads`' answer unpinned.
+	*/
+	readStoredMergeKeys(repoPath, branch, inferBase, reads) {
+		const read = async (get) => {
+			try {
+				return await get();
 			} catch (ex) {
 				if (isCancellationError(ex)) throw ex;
+				if (reads != null) reads.pinnable = false;
+				return;
 			}
-			return withDefaultBranch({
-				base: void 0,
-				reason: unborn ? "unborn" : "none",
-				dependsOn: [...dependsOn]
-			}, resolvedDefault);
+		};
+		return Promise.all([...storedMergeKeys.map((key) => read(() => this.provider.config.getGkConfig(repoPath, `branch.${branch}.${key}`))), inferBase ? read(() => this.provider.config.getConfig(repoPath, `branch.${branch}.vscode-merge-base`)) : void 0]);
+	}
+	/**
+	* The pull request's base as a candidate on the branch's remote; `undefined` when there is none, the branch has no
+	* remote, or either can't be read (which leaves `reads`' answer unpinned)
+	*/
+	async getPullRequestBaseCandidate(repoPath, branch, getAssociatedPullRequest, reads, cancellation) {
+		try {
+			const pr = await getAssociatedPullRequest();
+			const base = pr?.refs?.base?.branch?.trim();
+			if (!base) return void 0;
+			const ref = await this.getBranch(repoPath, branch, void 0, cancellation);
+			if (ref == null) return void 0;
+			const { remote } = await resolveBranchRemote(this.provider, repoPath, ref, cancellation);
+			if (remote == null) return void 0;
+			return {
+				ref: `${remote}/${base}`,
+				stacked: pr?.stack != null
+			};
+		} catch (ex) {
+			if (isCancellationError(ex) && (cancellation?.aborted ?? true)) throw ex;
+			if (reads != null) reads.pinnable = false;
+			return;
 		}
-		if (branch != null && await this.isSelfAtHead(repoPath, target.ref, branch, cancellation)) return withDefaultBranch({
-			base: void 0,
-			reason: "self",
-			dependsOn: [...dependsOn]
-		}, resolvedDefault);
-		return withDefaultBranch(await this.measureAheadOfBase(repoPath, target, tier, dependsOn, cancellation), resolvedDefault);
+	}
+	/**
+	* The default branch for {@link resolveBase}: {@link getLocalDefaultBranchName}; when that names none, with
+	* `defaultBranch: 'remote'`, the default the first of those remotes reports; then `getFallbackDefaultBranch`. A
+	* remote-qualified answer is taken as its local branch when there is one
+	*/
+	async getDefaultBranchForBase(repoPath, options, reads, cancellation) {
+		let name = await this.getLocalDefaultBranchName(repoPath, reads.dependsOn, cancellation);
+		reads.localDefault = name ?? null;
+		if (name != null) return name;
+		if (options?.defaultBranch === "remote") {
+			const [remote] = await this.getPreferredRemotes(repoPath, cancellation);
+			if (remote != null) {
+				let symref;
+				try {
+					symref = await this.getDefaultBranchName(repoPath, remote, reads.priority != null ? { priority: reads.priority } : void 0, cancellation);
+				} catch (ex) {
+					if (isCancellationError(ex)) throw ex;
+					reads.pinnable = false;
+				}
+				reads.remoteDefault = {
+					remote,
+					name: symref ?? null
+				};
+				const local = symref?.startsWith(`${remote}/`) ? symref.slice(remote.length + 1) : void 0;
+				if (symref && local) name = await this.preferListedLocalBranch(repoPath, symref, local, reads, cancellation);
+			}
+		}
+		if (name == null && options?.getFallbackDefaultBranch != null) {
+			let fallback;
+			try {
+				fallback = (await options.getFallbackDefaultBranch())?.trim() || void 0;
+			} catch (ex) {
+				if (isCancellationError(ex) && (cancellation?.aborted ?? true)) throw ex;
+				reads.pinnable = false;
+			}
+			reads.fallbackDefault = fallback ?? null;
+			name = fallback;
+			const local = fallback != null ? splitRemoteBranchName(fallback, await this.getRemoteNames(repoPath, cancellation))?.[1] : void 0;
+			if (fallback != null && local) name = await this.preferListedLocalBranch(repoPath, fallback, local, reads, cancellation);
+		}
+		return name;
+	}
+	/** `local` when the cached ref list names that branch (depended on either way), else `remoteName` */
+	async preferListedLocalBranch(repoPath, remoteName, local, reads, cancellation) {
+		addRefDependencies(reads.dependsOn, local);
+		const records = await this.provider.refs.getRefs(repoPath, cancellation);
+		return await this.getRefTip(repoPath, records, local, cancellation) != null ? local : remoteName;
+	}
+	/**
+	* The branch `branch` was created from (tier `'created'`); with `inferBase`, for one created from `HEAD`, the
+	* branch HEAD was on when it was first checked out (tier `'inferred'`)
+	*/
+	async getCreatedFromSource(repoPath, branch, options, reads, cancellation) {
+		const createdFrom = await this.getCreatedFromTarget(repoPath, branch, reads, cancellation);
+		if (createdFrom.name != null) return {
+			name: createdFrom.name,
+			tier: "created"
+		};
+		if (!createdFrom.fromHead || !options?.inferBase) return void 0;
+		const inferred = await this.getInferredCreatedFrom(repoPath, branch, reads, cancellation);
+		return inferred != null ? {
+			name: inferred,
+			tier: "inferred"
+		} : void 0;
 	}
 	/**
 	* The base for a branch created from `createdFrom`: that branch, unless the default branch forked strictly nearer
 	* HEAD, as it does once `createdFrom` merged into it and the branch was rebased onto it. A stacked branch's
 	* unmerged parent forked nearer, and stays its base. `undefined` when neither is usable.
 	*/
-	async getCreatedFromForkTarget(repoPath, branch, createdFrom, defaultBranch, dependsOn, cancellation) {
-		const skipDefault = defaultBranch == null || createdFrom === defaultBranch || createdFrom === `refs/heads/${defaultBranch}` || createdFrom === `refs/remotes/${defaultBranch}`;
-		const [created, fallback] = await Promise.all([this.getUpstreamNearestForkTarget(repoPath, branch, createdFrom, dependsOn, cancellation), skipDefault ? void 0 : this.getUpstreamNearestForkTarget(repoPath, branch, defaultBranch, dependsOn, cancellation)]);
+	async getCreatedFromForkTarget(repoPath, branch, createdFrom, defaultBranch, reads, cancellation) {
+		const { name } = createdFrom;
+		const skipDefault = defaultBranch == null || name === defaultBranch || name === `refs/heads/${defaultBranch}` || name === `refs/remotes/${defaultBranch}`;
+		const [created, fallback] = await Promise.all([this.getUpstreamNearestForkTarget(repoPath, branch, name, reads, cancellation), skipDefault ? void 0 : this.getUpstreamNearestForkTarget(repoPath, branch, defaultBranch, reads, cancellation)]);
 		if (created == null) return fallback != null ? {
 			target: fallback,
 			tier: "default"
@@ -1512,7 +1953,7 @@ var BranchesGitSubProvider = class {
 		};
 		return {
 			target: created,
-			tier: "created"
+			tier: createdFrom.tier
 		};
 	}
 	/** Counts HEAD's commits past `target` for {@link getAheadOfBase} */
@@ -1538,8 +1979,8 @@ var BranchesGitSubProvider = class {
 		};
 	}
 	/** Counts the default branch's own commits past its upstream (see {@link getSelfUpstreamTarget}) for {@link getAheadOfBase} */
-	async measureAheadOfSelfUpstream(repoPath, branch, dependsOn, cancellation) {
-		const upstream = await this.getSelfUpstreamTarget(repoPath, branch, dependsOn, cancellation);
+	async measureAheadOfSelfUpstream(repoPath, upstream, reads, cancellation) {
+		const { dependsOn } = reads;
 		if (cancellation?.aborted) throw new CancellationError();
 		if (upstream == null) return {
 			base: void 0,
@@ -1557,7 +1998,7 @@ var BranchesGitSubProvider = class {
 			reason: "self",
 			dependsOn: [...dependsOn]
 		};
-		const forkPoint = counts.left === 0 ? upstream.sha : await this.getForkPoint(repoPath, upstream.ref, cancellation);
+		const forkPoint = counts.left === 0 ? upstream.sha : await this.getForkPoint(repoPath, upstream.ref, reads, cancellation);
 		if (cancellation?.aborted) throw new CancellationError();
 		return {
 			base: {
@@ -1747,42 +2188,28 @@ var BranchesGitSubProvider = class {
 			return [];
 		}
 	}
-	/** Whether `ref` names `branch` itself (see {@link isSelfRef}) and sits at HEAD's commit; tips are read only after the name matched */
-	async isSelfAtHead(repoPath, ref, branch, cancellation) {
-		if (!await this.isSelfRef(repoPath, ref, branch, cancellation)) return false;
-		const [refSha, headSha] = await Promise.all([this.provider.refs.validateReference(repoPath, ref, void 0, cancellation), this.provider.refs.validateReference(repoPath, "HEAD", void 0, cancellation)]);
-		return refSha != null && refSha === headSha;
-	}
 	/**
-	* The bases recorded against a branch, most trusted first: the user's merge target, the detected one, then the
-	* base a launch recorded. Only the stored value of the latter — `getBaseBranchName` would fall back to a reflog
-	* guess, which on a long-lived checkout names whatever branch was last checked out from. A failed read is absent.
+	* Whether `ref` names `selfName` itself (see {@link isSelfRef}) and sits at `reads.from`'s commit; tips are read
+	* only after the name matched. HEAD's commit is asked of git, a branch's read from the cached ref list
 	*/
-	async getRecordedBaseCandidates(repoPath, branch, skipUserTarget) {
-		const tolerate = async (read) => {
-			try {
-				return (await read())?.trim() || void 0;
-			} catch (ex) {
-				if (isCancellationError(ex)) throw ex;
-				return;
-			}
-		};
-		const reads = await Promise.all([
-			skipUserTarget ? void 0 : tolerate(() => this.getStoredUserMergeTargetBranchName(repoPath, branch)),
-			tolerate(() => this.getStoredDetectedMergeTargetBranchName(repoPath, branch)),
-			tolerate(() => this.provider.config.getGkConfig(repoPath, `branch.${branch}.gk-merge-base`))
-		]);
-		const tiers = [
-			"user",
-			"detected",
-			"recorded"
-		];
-		const candidates = [];
-		for (const [i, ref] of reads.entries()) if (ref && !candidates.some((c) => c.ref === ref)) candidates.push({
-			ref,
-			tier: tiers[i]
-		});
-		return candidates;
+	async isSelfAtTip(repoPath, ref, selfName, reads, cancellation) {
+		if (!await this.isSelfRef(repoPath, ref, selfName, cancellation)) return false;
+		if (reads.from === "HEAD") {
+			const [refSha, headSha] = await Promise.all([this.provider.refs.validateReference(repoPath, ref, void 0, cancellation), this.provider.refs.validateReference(repoPath, "HEAD", void 0, cancellation)]);
+			return refSha != null && refSha === headSha;
+		}
+		const records = await this.provider.refs.getRefs(repoPath, cancellation);
+		const [refSha, fromSha] = await Promise.all([this.getRefTip(repoPath, records, ref, cancellation), this.getRefTip(repoPath, records, reads.from, cancellation)]);
+		return refSha != null && refSha === fromSha;
+	}
+	/** The remotes a default branch is read from, in order: `upstream`, `origin`, then the first remote */
+	async getPreferredRemotes(repoPath, cancellation) {
+		const remotes = await this.getRemoteNames(repoPath, cancellation);
+		return [...new Set([
+			remotes.find((r) => r === "upstream"),
+			remotes.find((r) => r === "origin"),
+			remotes.at(0)
+		].filter((r) => r != null))];
 	}
 	/**
 	* The repo's default branch from local refs only, never the network: the `HEAD` symref of the `upstream` remote,
@@ -1796,12 +2223,7 @@ var BranchesGitSubProvider = class {
 			records ??= await this.provider.refs.getRefs(repoPath, cancellation);
 			return await this.getRefTip(repoPath, records, ref, cancellation) != null;
 		};
-		const remotes = await this.getRemoteNames(repoPath, cancellation);
-		const preferred = new Set([
-			remotes.find((r) => r === "upstream"),
-			remotes.find((r) => r === "origin"),
-			remotes.at(0)
-		].filter((r) => r != null));
+		const preferred = await this.getPreferredRemotes(repoPath, cancellation);
 		for (const remote of preferred) {
 			dependsOn.add(`refs/remotes/${remote}/HEAD`);
 			const symref = await this.getDefaultBranchName(repoPath, remote, { local: true }, cancellation);
@@ -1840,7 +2262,7 @@ var BranchesGitSubProvider = class {
 	* remote and ref lists; `undefined` when there is no `upstream` remote, it lacks the branch, or the base is that
 	* ref itself.
 	*/
-	async getUpstreamContender(repoPath, base, dependsOn, cancellation) {
+	async getUpstreamContender(repoPath, base, reads, cancellation) {
 		if (!base) return void 0;
 		const remotes = await this.getRemoteNames(repoPath, cancellation);
 		if (!remotes.includes("upstream")) return void 0;
@@ -1857,33 +2279,37 @@ var BranchesGitSubProvider = class {
 		}
 		const contender = `upstream/${name}`;
 		const remoteRef = `refs/remotes/${contender}`;
-		if (contender === base || remoteRef === base || findRefTip(records, remoteRef) == null) return void 0;
-		dependsOn.add(remoteRef);
+		if (contender === base || remoteRef === base) return void 0;
+		if (findRefTip(records, remoteRef) == null) {
+			reads.tipRefs.add(remoteRef);
+			return;
+		}
+		reads.dependsOn.add(remoteRef);
 		return contender;
 	}
 	/** {@link getNearestForkTarget} with the `upstream` remote's copy of `candidate` as its contender */
-	async getUpstreamNearestForkTarget(repoPath, branch, candidate, dependsOn, cancellation) {
-		return this.getNearestForkTarget(repoPath, branch, candidate, dependsOn, cancellation, { contender: await this.getUpstreamContender(repoPath, candidate, dependsOn, cancellation) });
+	async getUpstreamNearestForkTarget(repoPath, branch, candidate, reads, cancellation) {
+		return this.getNearestForkTarget(repoPath, branch, candidate, reads, cancellation, { contender: await this.getUpstreamContender(repoPath, candidate, reads, cancellation) });
 	}
 	/**
-	* A candidate base as the ref HEAD is measured against: the candidate or its tracking ref, whichever forked
-	* nearer HEAD, so a stale local base defers to its upstream while one carrying unpushed work wins over it. A
+	* A candidate base as the ref `reads.from` is measured against: the candidate or its tracking ref, whichever forked
+	* nearer, so a stale local base defers to its upstream while one carrying unpushed work wins over it. A
 	* `contender` other than the tracking ref is taken only when it forked strictly nearer than both, so a tie keeps
-	* the candidate's own pick. A candidate none forks from is used as-is if it names a commit. `undefined` when the
-	* candidate is unusable.
+	* the candidate's own pick. A candidate none forks from is used as-is unless git confirms it names no ref: one the
+	* cached ref list names is kept, and so is one whose check fails. `undefined` when the candidate is unusable.
 	*/
-	async getNearestForkTarget(repoPath, branch, candidate, dependsOn, cancellation, options) {
+	async getNearestForkTarget(repoPath, branch, candidate, reads, cancellation, options) {
 		if (!candidate || candidate.startsWith("-")) return void 0;
 		if (candidate === branch || candidate === `refs/heads/${branch}`) return void 0;
-		addRefDependencies(dependsOn, candidate);
+		addRefDependencies(reads.dependsOn, candidate);
 		const upstreamName = this.getUpstreamName(repoPath, candidate, void 0, cancellation);
 		const getUpstreamFork = async () => {
 			const upstream = await upstreamName;
 			if (!upstream || upstream.startsWith("-")) return void 0;
-			addRefDependencies(dependsOn, upstream);
+			addRefDependencies(reads.dependsOn, upstream);
 			return {
 				ref: upstream,
-				mergeBase: await this.getForkPoint(repoPath, upstream, cancellation)
+				mergeBase: await this.getForkPoint(repoPath, upstream, reads, cancellation)
 			};
 		};
 		const contender = options?.contender;
@@ -1896,10 +2322,15 @@ var BranchesGitSubProvider = class {
 				const upstream = await upstreamName;
 				if (upstream && tip === findRefTip(records, upstream)) return void 0;
 			}
-			return this.getForkPoint(repoPath, contender, cancellation);
+			return this.getForkPoint(repoPath, contender, reads, cancellation);
+		};
+		const candidateReads = {
+			from: reads.from,
+			priority: reads.priority,
+			pinnable: true
 		};
 		const [candidateMergeBase, upstreamFork, contenderMergeBase] = await Promise.all([
-			this.getForkPoint(repoPath, candidate, cancellation),
+			this.getForkPoint(repoPath, candidate, candidateReads, cancellation),
 			getUpstreamFork(),
 			getContenderMergeBase()
 		]);
@@ -1918,18 +2349,33 @@ var BranchesGitSubProvider = class {
 			ref: contender,
 			mergeBase: contenderMergeBase
 		};
-		if (nearest != null) return {
-			ref: nearest.ref,
-			forkPoint: nearest.mergeBase
-		};
-		return await this.provider.refs.validateReference(repoPath, candidate, void 0, cancellation) ? {
+		if (nearest != null) {
+			if (!candidateReads.pinnable) reads.pinnable = false;
+			return {
+				ref: nearest.ref,
+				forkPoint: nearest.mergeBase
+			};
+		}
+		const records = await this.provider.refs.getRefs(repoPath, cancellation);
+		if (records.length && findRefTip(records, candidate) != null) {
+			if (!candidateReads.pinnable) reads.pinnable = false;
+			return {
+				ref: candidate,
+				forkPoint: void 0
+			};
+		}
+		const { missing } = await this.provider.refs.getSymbolicReferenceNameOrMissing(repoPath, candidate, reads.priority != null ? { priority: reads.priority } : void 0, cancellation);
+		if (missing) return void 0;
+		reads.pinnable = false;
+		return {
 			ref: candidate,
 			forkPoint: void 0
-		} : void 0;
+		};
 	}
 	/**
 	* `<name>@{u}`, without asking git when the cached ref list shows `name` can't have one: a failed lookup isn't
-	* cached, so asking it of a remote-tracking ref (`origin/main`, the usual default) re-spawns on every read.
+	* cached, so asking it of a remote-tracking ref (`origin/main`, the usual default) re-spawns on every read. The
+	* list's own upstream isn't used: a config-only change (`git branch -u`) doesn't refresh it.
 	*/
 	async getUpstreamName(repoPath, name, options, cancellation) {
 		if (!mayHaveUpstream(await this.provider.refs.getRefs(repoPath, cancellation), name)) return void 0;
@@ -1940,7 +2386,8 @@ var BranchesGitSubProvider = class {
 	* when an `upstream` remote has it, else `<branch>@{u}`. Read from the cached ref and branch lists; only a
 	* `<branch>` that isn't checked out spawns, for its `@{u}`. `undefined` when there is neither, or its ref is gone.
 	*/
-	async getSelfUpstreamTarget(repoPath, branch, dependsOn, cancellation) {
+	async getSelfUpstreamTarget(repoPath, branch, reads, cancellation) {
+		const { dependsOn } = reads;
 		const records = await this.provider.refs.getRefs(repoPath, cancellation);
 		let upstream;
 		if ((await this.getRemoteNames(repoPath, cancellation)).includes("upstream")) {
@@ -1976,9 +2423,36 @@ var BranchesGitSubProvider = class {
 		if (records.length) return findRefTip(records, name);
 		return this.provider.refs.validateReference(repoPath, name, void 0, cancellation);
 	}
-	/** The merge base of HEAD and `ref`, preferring git's fork-point reading of `ref`'s reflog when it has one */
-	async getForkPoint(repoPath, ref, cancellation) {
-		return await this.provider.refs.getMergeBase(repoPath, ref, "HEAD", { forkPoint: true }, cancellation) ?? this.provider.refs.getMergeBase(repoPath, "HEAD", ref, void 0, cancellation);
+	/** Where `reads.from` forked from `ref`: git's fork-point reading of `ref`'s reflog when it has one, else their merge base */
+	async getForkPoint(repoPath, ref, reads, cancellation) {
+		return await this.readMergeBase(repoPath, ref, reads.from, true, reads, cancellation) ?? this.readMergeBase(repoPath, reads.from, ref, false, reads, cancellation);
+	}
+	/**
+	* `getMergeBase`, sharing its cached and in-flight reads, but telling git's exit 1 (no common ancestor, or no fork
+	* point) from a read that failed. Both answer `undefined`; a failed one also clears `reads.pinnable`.
+	*/
+	async readMergeBase(repoPath, ref1, ref2, forkPoint, reads, cancellation) {
+		try {
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				errors: "throw",
+				expectedExitCodes: [1],
+				caching: {
+					cache: this.cache.gitResults,
+					options: { accessTTL: 3e5 }
+				},
+				...reads.priority != null ? { priority: reads.priority } : void 0
+			}, "merge-base", forkPoint ? "--fork-point" : void 0, ref1, ref2);
+			if (result.completion.status === "exited") {
+				if (result.exitCode === 1) return void 0;
+				const sha = result.stdout.split("\n")[0].trim();
+				if (sha) return sha;
+			}
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+		}
+		reads.pinnable = false;
 	}
 	/**
 	* The stored merge target — the user's pick, else the one detected from its PR — skipping any whose branch git
@@ -2025,6 +2499,7 @@ var BranchesGitSubProvider = class {
 	forgetBranchCreatedFrom(repoPath, name) {
 		const key = this.getBranchActivityKey(repoPath, name);
 		this._branchCreatedFrom.delete(key);
+		this._branchCheckedOutFrom.delete(key);
 		this._branchCreatedFromGenerations.set(key, (this._branchCreatedFromGenerations.get(key) ?? 0) + 1);
 	}
 	/** Forgets this process's throttle marks for `name`, so its next activity re-reads the stored stamps */
@@ -2169,32 +2644,66 @@ var BranchesGitSubProvider = class {
 		this.context.hooks?.repository?.onChanged?.(repoPath, ["starred"]);
 	}
 };
-__decorate([debug()], BranchesGitSubProvider.prototype, "getBranch", null);
-__decorate([debug({ args: (repoPath) => ({ repoPath }) })], BranchesGitSubProvider.prototype, "getBranches", null);
-__decorate([debug()], BranchesGitSubProvider.prototype, "getBranchContributionsOverview", null);
-__decorate([debug()], BranchesGitSubProvider.prototype, "getBranchesWithCommits", null);
-__decorate([debug()], BranchesGitSubProvider.prototype, "getCurrentBranchReference", null);
-__decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getDefaultBranchName", null);
+__decorate([debug({ quiet: true })], BranchesGitSubProvider.prototype, "getBranch", null);
+__decorate([debug({
+	quiet: true,
+	args: (repoPath) => ({ repoPath })
+})], BranchesGitSubProvider.prototype, "getBranches", null);
+__decorate([debug({ quiet: true })], BranchesGitSubProvider.prototype, "getBranchContributionsOverview", null);
+__decorate([debug({ quiet: true })], BranchesGitSubProvider.prototype, "getBranchesWithCommits", null);
+__decorate([debug({ quiet: true })], BranchesGitSubProvider.prototype, "getCurrentBranchReference", null);
+__decorate([debug({
+	quiet: true,
+	exit: true
+})], BranchesGitSubProvider.prototype, "getDefaultBranchName", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "setRemoteHeadIfMissing", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "createBranch", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "deleteLocalBranch", null);
 __decorate([debug()], BranchesGitSubProvider.prototype, "deleteRemoteBranch", null);
-__decorate([debug()], BranchesGitSubProvider.prototype, "getBranchMergedStatus", null);
-__decorate([debug()], BranchesGitSubProvider.prototype, "getLocalBranchByUpstream", null);
-__decorate([trace({ exit: true })], BranchesGitSubProvider.prototype, "getPushTarget", null);
-__decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialApplyConflicts", null);
-__decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialMergeConflicts", null);
-__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);
-__decorate([trace({ exit: true })], BranchesGitSubProvider.prototype, "getStoredDetectedMergeTargetBranchName", null);
-__decorate([trace()], BranchesGitSubProvider.prototype, "getStoredUserMergeTargetBranchName", null);
+__decorate([debug({ quiet: true })], BranchesGitSubProvider.prototype, "getBranchMergedStatus", null);
+__decorate([debug({ quiet: true })], BranchesGitSubProvider.prototype, "getLocalBranchByUpstream", null);
+__decorate([trace({
+	quiet: true,
+	exit: true
+})], BranchesGitSubProvider.prototype, "getPushTarget", null);
+__decorate([debug({ quiet: true })], BranchesGitSubProvider.prototype, "getPotentialApplyConflicts", null);
+__decorate([debug({ quiet: true })], BranchesGitSubProvider.prototype, "getPotentialMergeConflicts", null);
+__decorate([debug({ quiet: true })], BranchesGitSubProvider.prototype, "getPotentialStashReapplyConflicts", null);
+__decorate([debug({
+	quiet: true,
+	exit: true
+})], BranchesGitSubProvider.prototype, "getBaseBranchName", null);
+__decorate([trace({ quiet: true })], BranchesGitSubProvider.prototype, "getAheadOfBaseConfigKey", null);
+__decorate([trace({ quiet: true })], BranchesGitSubProvider.prototype, "getAheadOfBaseConfigEntries", null);
+__decorate([debug({
+	quiet: true,
+	exit: true
+})], BranchesGitSubProvider.prototype, "getAheadOfBase", null);
+__decorate([debug({
+	quiet: true,
+	exit: true
+})], BranchesGitSubProvider.prototype, "getAheadOfBaseAfterBaseMove", null);
+__decorate([debug({
+	quiet: true,
+	exit: true
+})], BranchesGitSubProvider.prototype, "getMergeTarget", null);
+__decorate([debug({
+	quiet: true,
+	exit: true
+})], BranchesGitSubProvider.prototype, "getAheadBehindCounts", null);
+__decorate([debug({
+	quiet: true,
+	exit: true
+})], BranchesGitSubProvider.prototype, "getMergedBranches", null);
+__decorate([debug({
+	quiet: true,
+	exit: true
+})], BranchesGitSubProvider.prototype, "getStoredMergeTargetBranchName", null);
+__decorate([trace({
+	quiet: true,
+	exit: true
+})], BranchesGitSubProvider.prototype, "getStoredDetectedMergeTargetBranchName", null);
+__decorate([trace({ quiet: true })], BranchesGitSubProvider.prototype, "getStoredUserMergeTargetBranchName", null);
 __decorate([trace()], BranchesGitSubProvider.prototype, "onCurrentBranchAccessed", null);
 __decorate([trace()], BranchesGitSubProvider.prototype, "onCurrentBranchModified", null);
 __decorate([trace()], BranchesGitSubProvider.prototype, "onCurrentBranchAgentActivity", null);
@@ -2260,15 +2769,46 @@ function getRefRecordsByName(records) {
 	}
 	return byName;
 }
+/** Each ref list's {@link BaseMoveReadInputs}: every worktree a base move reached derives them from the same cached list */
+const baseMoveReadInputs = /* @__PURE__ */ new WeakMap();
+function getBaseMoveReadInputs(records) {
+	let inputs = baseMoveReadInputs.get(records);
+	if (inputs != null) return inputs;
+	let checkedOut = /* @__PURE__ */ new Set();
+	const checkedOutTips = /* @__PURE__ */ new Set();
+	const replaced = [];
+	for (const record of records) {
+		if (record.name.startsWith("refs/replace/")) {
+			replaced.push(`${record.name}\0${record.objectname}`);
+			continue;
+		}
+		if (checkedOut == null || !record.name.startsWith("refs/heads/")) continue;
+		if (record.worktreePath == null) {
+			checkedOut = void 0;
+			checkedOutTips.clear();
+			continue;
+		}
+		if (record.worktreePath) {
+			checkedOut.add(record.name);
+			checkedOutTips.add(record.objectname);
+		}
+	}
+	inputs = {
+		checkedOut,
+		checkedOutTips,
+		replaced: replaced.sort().join("\n")
+	};
+	baseMoveReadInputs.set(records, inputs);
+	return inputs;
+}
 /** The record for the full ref name `fullName` in `records`, the cached ref list; no short-name resolution */
 function findRefRecord(records, fullName) {
 	return getRefRecordsByName(records).get(fullName);
 }
 function toPushTargetRef(records, ref) {
-	const record = findRefRecord(records, ref);
 	return {
 		ref,
-		sha: record != null ? record.peeledObjectname || record.objectname : void 0
+		sha: getListedTip(records, ref)
 	};
 }
 /**
@@ -2335,6 +2875,48 @@ function addRefDependencies(dependsOn, name) {
 	dependsOn.add(`refs/heads/${name}`);
 	dependsOn.add(`refs/remotes/${name}`);
 }
+function createBaseReads(from, dependsOn, priority) {
+	return {
+		from,
+		priority,
+		dependsOn: new Set(dependsOn),
+		tipRefs: /* @__PURE__ */ new Set(),
+		pinnable: true,
+		evictOnCheckout: false
+	};
+}
+/**
+* Keys a merge target by `branch` and every option that shapes the answer. `keepSelfAtTip` is applied to the cached
+* answer instead, and `priority` doesn't change it
+*/
+function getMergeTargetCacheKey(branch, options) {
+	return `${branch}\0${[
+		options?.skipUserTarget ? "u" : "",
+		options?.getAssociatedPullRequest != null ? "p" : "",
+		options?.inferBase ? "i" : "",
+		options?.defaultBranch === "remote" ? "r" : "",
+		options?.getFallbackDefaultBranch != null ? "f" : ""
+	].join("")}\0${options?.preferredTarget?.trim() ?? ""}`;
+}
+/** `read`'s answer, with a failure read as none; cancellation still rejects */
+async function tolerateRead(read) {
+	if (read == null) return void 0;
+	try {
+		return await read();
+	} catch (ex) {
+		if (isCancellationError(ex)) throw ex;
+		return;
+	}
+}
+/** `value` as a literal in `getReflogEntries`' `grep`, a basic regular expression */
+function toReflogGrepLiteral(value) {
+	return value.replace(/[\\.*[\]^$]/g, "\\$&");
+}
+/** The tip of the full ref name `fullName` in `records`, the cached ref list; `undefined` when it isn't listed */
+function getListedTip(records, fullName) {
+	const record = findRefRecord(records, fullName);
+	return record != null ? record.peeledObjectname || record.objectname : void 0;
+}
 //#endregion
 export { BranchesGitSubProvider };