@gitkraken/core-gitlens 0.2.0 → 0.3.1

package/src/git-cli/parsers/refParser.ts

@@ -1,52 +1,51 @@
 import type { FilteredGitFeatures } from '../../git/features.js';
+import type { RefRecord } from '../../git/models/reference.js';
 import { maybeStopWatch } from '../../utils/stopwatch.js';
 import { iterateByDelimiter } from '../../utils/string.js';
 import type { ExtractAll } from '../../utils/types.js';
 import type { Parser } from './logParser.js';
 
-const branchMapping = {
-	current: `%(HEAD)`, // HEAD indicator (current branch)
-	name: `%(refname)`, // Full reference name
-	upstream: `%(upstream)`, // Upstream branch, if any
-	upstreamTracking: `%(upstream:track)`, // Tracking status
-	sha: `%(objectname)`, // SHA
-	date: `%(committerdate:iso8601)`, // Date
+/**
+ * Unified `for-each-ref` mapping covering branches, remotes, and tags in a single pass.
+ * Fields inapplicable to a given ref-type come back as empty strings from git.
+ *
+ * NOTE: When adding a new field that is gated on a git feature flag, mirror the entry in
+ * `refMappingSupportsWorktreePath` (and any future variants) — both maps MUST stay aligned
+ * so callers can switch parsers based on `git.supported('git:for-each-ref')` without losing
+ * field positions.
+ */
+const refMapping = {
+	current: `%(HEAD)`,
+	name: `%(refname)`,
+	objectname: `%(objectname)`,
+	peeledObjectname: `%(*objectname)`,
+	upstream: `%(upstream)`,
+	upstreamTracking: `%(upstream:track)`,
+	committerDate: `%(committerdate:iso8601)`,
+	creatorDate: `%(creatordate:iso8601)`,
+	authorDate: `%(authordate:iso8601)`,
+	subject: `%(subject)`,
 	worktreePath: undefined,
 };
 
-const branchMappingSupportsWorktreePath = {
-	...branchMapping,
-	worktreePath: '%(worktreepath)', // Worktree path
+const refMappingSupportsWorktreePath = {
+	...refMapping,
+	worktreePath: '%(worktreepath)',
 };
 
-type BranchParser = Parser<typeof branchMapping> | Parser<typeof branchMappingSupportsWorktreePath>;
+type RefParser = Parser<RefRecord>;
 
-let _branchParser: BranchParser | undefined;
-let _branchParserWithWorktree: BranchParser | undefined;
-export function getBranchParser(supportedFeatures: FilteredGitFeatures<'git:for-each-ref'>[]): BranchParser {
+let _refParser: RefParser | undefined;
+let _refParserWithWorktree: RefParser | undefined;
+
+export function getRefParser(supportedFeatures: FilteredGitFeatures<'git:for-each-ref'>[]): RefParser {
 	if (supportedFeatures.includes('git:for-each-ref:worktreePath')) {
-		_branchParserWithWorktree ??= createRefParser(branchMappingSupportsWorktreePath);
-		return _branchParserWithWorktree;
+		_refParserWithWorktree ??= createRefParser(refMappingSupportsWorktreePath);
+		return _refParserWithWorktree;
 	}
-	_branchParser ??= createRefParser(branchMapping);
-	return _branchParser;
-}
-
-const tagMapping = {
-	name: `%(refname)`, // Full reference name
-	tagSha: `%(objectname)`, // sha of the tag
-	sha: `%(*objectname)`, // sha of the commit the tag points to, if any
-	date: `%(creatordate:iso8601)`, // date the tag was created
-	commitDate: `%(authordate:iso8601)`, // author date of the commit the tag points to
-	message: `%(subject)`, // message
-};
-
-type TagParser = Parser<typeof tagMapping>;
-let _tagParser: TagParser | undefined;
 
-export function getTagParser(): TagParser {
-	_tagParser ??= createRefParser(tagMapping);
-	return _tagParser;
+	_refParser ??= createRefParser(refMapping);
+	return _refParser;
 }
 
 const recordSep = '\x1E'; // ASCII Record Separator character

package/src/git-cli/providers/blame.ts

@@ -234,6 +234,7 @@ export class BlameGitSubProvider implements GitBlameSubProvider {
 			let blameLine = blame.lines[editorLine];
 			if (blameLine == null) {
 				if (blame.lines.length !== editorLine) return undefined;
+
 				blameLine = blame.lines[editorLine - 1];
 			}
 

package/src/git-cli/providers/branches.ts

@@ -1,4 +1,4 @@
-import type { Cache, ConflictDetectionCacheKey } from '../../git/cache.js';
+import type { Cache, ConflictDetectionCacheKey, GkConfigInvalidationTarget } from '../../git/cache.js';
 import type { GitServiceContext } from '../../git/context.js';
 import { BranchError } from '../../git/errors.js';
 import type { BranchDisposition, BranchMetadata } from '../../git/models/branch.js';
@@ -10,6 +10,7 @@ import type {
 	GitBranchesSubProvider,
 	GitBranchMergedStatus,
 } from '../../git/providers/branches.js';
+import type { GitCommandPriority } from '../../git/run.types.js';
 import {
 	formatDetachedHeadName,
 	getBranchId,
@@ -41,7 +42,6 @@ import type { GitResult } from '../exec/exec.types.js';
 import type { Git } from '../exec/git.js';
 import { getGitCommandError, gitConfigsBranch, gitConfigsLog, GitError, GitErrors, GitWarnings } from '../exec/git.js';
 import { parseMergeTreeConflict } from '../parsers/mergeTreeParser.js';
-import { getBranchParser } from '../parsers/refParser.js';
 
 /** Minimum time between writes to the config for last accessed/modified dates */
 const dateMetadataStaleThresholdMs = 5 * 60 * 1000; // 5 minutes
@@ -96,7 +96,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		const [pausedOpStatusResult, committerDateResult, defaultWorktreePathResult, metadataMapResult] =
 			await Promise.allSettled([
 				isDetachedHead(ref.name)
-					? this.provider.pausedOps?.getPausedOperationStatus(repoPath, cancellation)
+					? this.provider.pausedOps?.getPausedOperationStatus(repoPath, undefined, cancellation)
 					: undefined,
 				this.git
 					.run(
@@ -168,27 +168,22 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			// own cancellation when bypassing the cache (e.g. paging-cursor path).
 			signal ??= cancellation;
 			try {
-				const supported = await this.git.supported('git:for-each-ref');
-				const parser = getBranchParser(supported);
-
-				const [gitResult, defaultWorktreePathResult, metadataMapResult] = await Promise.allSettled([
-					this.git.run(
-						{ cwd: commonPath, cancellation: signal },
-						'for-each-ref',
-						...parser.arguments,
-						'refs/heads/',
-						'refs/remotes/',
-					),
-					this.provider.config.getDefaultWorktreePath?.(commonPath),
-					this.getBranchMetadataMap(commonPath),
-				]);
-
-				const result = getSettledValue(gitResult);
+				const [recordsResult, supportedResult, defaultWorktreePathResult, metadataMapResult] =
+					await Promise.allSettled([
+						this.provider.refs.getRefs(commonPath, signal),
+						this.git.supported('git:for-each-ref'),
+						this.provider.config.getDefaultWorktreePath?.(commonPath),
+						this.getBranchMetadataMap(commonPath),
+					]);
+
+				const records = getSettledValue(recordsResult) ?? [];
+				const supported = getSettledValue(supportedResult) ?? [];
 				const metadataMap = getSettledValue(metadataMapResult) ?? new Map<string, BranchMetadata>();
 				const defaultWorktreePath = getSettledValue(defaultWorktreePathResult);
+				const worktreePathSupported = supported.includes('git:for-each-ref:worktreePath');
 
 				// If we don't get any data, assume the repo doesn't have any commits yet so check if we have a current branch
-				if (!result?.stdout) {
+				if (!records.length) {
 					const current = await this.getCurrentBranch(
 						commonPath,
 						metadataMap,
@@ -202,25 +197,28 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 
 				const branches: GitBranch[] = [];
 
-				for (const entry of parser.parse(result.stdout)) {
+				for (const record of records) {
+					const fullName = record.name;
+					// Filter to branches and remote-tracking branches; skip tags from the unified records.
+					if (!fullName.startsWith('refs/heads/') && !fullName.startsWith('refs/remotes/')) continue;
 					// Skip HEAD refs in remote branches
-					if (isRemoteHEAD(entry.name)) continue;
+					if (isRemoteHEAD(fullName)) continue;
 
-					const upstream = parseUpstream(entry.upstream, entry.upstreamTracking);
+					const upstream = parseUpstream(record.upstream, record.upstreamTracking);
 
-					const metadata = metadataMap.get(parseRefName(entry.name).name);
-					const worktreePath = entry.worktreePath ? normalizePath(entry.worktreePath) : undefined;
+					const metadata = metadataMap.get(parseRefName(fullName).name);
+					const worktreePath = record.worktreePath ? normalizePath(record.worktreePath) : undefined;
 
 					branches.push(
 						new GitBranch(
 							commonPath,
-							entry.name,
+							fullName,
 							false, // Don't trust %(HEAD) for current as it's per-worktree -- we will set it later
-							entry.date ? new Date(entry.date) : undefined,
+							record.committerDate ? new Date(record.committerDate) : undefined,
 							metadata,
-							entry.sha,
+							record.objectname,
 							upstream,
-							supported.includes('git:for-each-ref:worktreePath')
+							worktreePathSupported
 								? worktreePath
 									? { path: worktreePath, isDefault: worktreePath === defaultWorktreePath }
 									: false
@@ -234,6 +232,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				// Pre-populate current branch cache for worktrees based on worktreePath info
 				// This eliminates the need for rev-parse calls during branch reconstruction
 				for (const branch of branches) {
+					// oxlint-disable-next-line typescript/prefer-optional-chain
 					if (branch.worktree && branch.worktree.path) {
 						const { name } = parseRefName(branch.refName);
 						const reference = createReference(name, branch.worktree.path, {
@@ -360,46 +359,23 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	async getBranchContributionsOverview(
 		repoPath: string,
 		ref: string,
-		options?: { associatedPullRequest?: Promise<{ refs?: { base?: { branch: string } } } | undefined> },
+		options?: {
+			associatedPullRequest?: Promise<{ refs?: { base?: { branch: string } } } | undefined>;
+			priority?: GitCommandPriority;
+		},
 		cancellation?: AbortSignal,
 	): Promise<BranchContributionsOverview | undefined> {
 		const scope = getScopedLogger();
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority: priority } : undefined;
 
-		const getCore = async (
-			_commonPath: string,
-			_cacheable: CacheController | undefined,
+		// Expensive body — runs only on cache miss. Closes over `mergeTarget` so the cache key
+		// (`${ref}|${mergeTarget}`) fully captures every input that affects the result.
+		const fetchBody = async (
+			mergeTarget: string,
 			signal: AbortSignal | undefined,
-			storedTarget: string | undefined,
 		): Promise<BranchContributionsOverview | undefined> => {
-			let mergeTarget: string | undefined;
-
-			// Tier 1: Stored merge target (user-set or previously detected from PR). Caller has
-			// already read this once for the cache decision; reuse rather than re-fetching.
-			if (storedTarget) {
-				const validated = await this.provider.refs.getSymbolicReferenceName(repoPath, storedTarget);
-				mergeTarget = validated || storedTarget;
-			}
-
-			// Tier 2: PR-based lookup. The branch object is only needed here (for `remoteName`),
-			// so lazy-load it on the cold path instead of paying for it on every call.
-			if (mergeTarget == null && options?.associatedPullRequest != null) {
-				const pr = await options.associatedPullRequest;
-				if (pr?.refs?.base != null) {
-					const branch = await this.getBranch(repoPath, ref, signal);
-					if (branch == null) return undefined;
-					mergeTarget = `${branch.remoteName}/${pr.refs.base.branch}`;
-					// Store for future reuse — turns the next call into a Tier 1 cache-eligible path.
-					void this.storeMergeTargetBranchName(repoPath, ref, mergeTarget);
-				}
-			}
-
-			// Tier 3: Base branch, then default branch
-			mergeTarget ??= await this.getBaseBranchName(repoPath, ref, signal);
-			mergeTarget ??= await this.getDefaultBranchName(repoPath, undefined, signal);
-
-			if (mergeTarget == null) return undefined;
-
-			const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget, undefined, signal);
+			const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget, priorityOpts, signal);
 			if (mergeBase == null) return undefined;
 
 			// Fetch the merge-base commit's dates in parallel with contributors so consumers
@@ -471,20 +447,61 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 		};
 
 		try {
-			// Pre-check Tier 1: when a stored merge target exists the result is deterministic for
-			// `ref` (Tier 2's PR resolution is short-circuited), so it's safe to cache. Otherwise
-			// the result depends on PR resolution which the cache key can't capture — bypass.
+			// Resolve `mergeTarget` through Tier 1 → Tier 2 → Tier 3. The pieces of each tier are
+			// already individually cached (`getStoredMergeTargetBranchName`, `getBaseBranchName`,
+			// `getDefaultBranchName`), so this resolution path is cheap on warm caches. Only the
+			// expensive body below (`getMergeBase` + `getContributors` w/ stats + `getCommitDates`)
+			// is wrapped by `cache.getBranchOverview`, keyed on the resolved `mergeTarget` so any
+			// caller that resolves to the same target shares; differing targets get independent
+			// slots, which is the correctness constraint that previously forced the Tier 2/3 paths
+			// to bypass the cache entirely.
+			let mergeTarget: string | undefined;
+
+			// Tier 1: Stored merge target (user-set or previously detected from PR).
 			const storedTarget = await this.getStoredMergeTargetBranchName(repoPath, ref);
-			if (storedTarget != null) {
-				return await this.cache.getBranchOverview(
+			if (storedTarget) {
+				const validated = await this.provider.refs.getSymbolicReferenceName(
 					repoPath,
-					ref,
-					(commonPath, cacheable, signal) =>
-						getCore(commonPath, cacheable, signal ?? cancellation, storedTarget),
-					{ cancellation: cancellation },
+					storedTarget,
+					priorityOpts,
+					cancellation,
 				);
+				mergeTarget = validated || storedTarget;
+			}
+
+			// Tier 2: PR-based lookup. The branch object is only needed here (for `remoteName`),
+			// so lazy-load it on the cold path instead of paying for it on every call.
+			if (mergeTarget == null && options?.associatedPullRequest != null) {
+				const pr = await options.associatedPullRequest;
+				if (pr?.refs?.base != null) {
+					const branch = await this.getBranch(repoPath, ref, cancellation);
+					if (branch == null) return undefined;
+
+					mergeTarget = `${branch.remoteName}/${pr.refs.base.branch}`;
+					// Store for future reuse — turns the next call into a Tier 1 path. Skip the
+					// `branchOverviews` invalidation that the write would otherwise trigger: we're
+					// about to populate `${ref}|${mergeTarget}` with this exact target, so evicting
+					// it would just force the next caller to redo the body. (gk-merge-target writes
+					// do not affect `baseBranchName`, so no need to skip that target.)
+					void this.storeMergeTargetBranchName(repoPath, ref, mergeTarget, {
+						skipInvalidation: ['branchOverviews'],
+					});
+				}
 			}
-			return await getCore(repoPath, undefined, cancellation, undefined);
+
+			// Tier 3: Base branch, then default branch.
+			mergeTarget ??= await this.getBaseBranchName(repoPath, ref, priorityOpts, cancellation);
+			mergeTarget ??= await this.getDefaultBranchName(repoPath, undefined, priorityOpts, cancellation);
+
+			if (mergeTarget == null) return undefined;
+
+			const resolvedTarget = mergeTarget;
+			return await this.cache.getBranchOverview(
+				repoPath,
+				`${ref}|${resolvedTarget}`,
+				(_commonPath, _cacheable, signal) => fetchBody(resolvedTarget, signal ?? cancellation),
+				{ cancellation: cancellation },
+			);
 		} catch (ex) {
 			scope?.error(ex);
 			if (isCancellationError(ex)) throw ex;
@@ -624,7 +641,12 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 							}
 
 							if (data == null) {
-								const symbolicRef = await this.getDefaultBranchName(repoPath, 'origin', signal);
+								const symbolicRef = await this.getDefaultBranchName(
+									repoPath,
+									'origin',
+									undefined,
+									signal,
+								);
 								if (symbolicRef != null) {
 									data = [
 										symbolicRef.startsWith('origin/')
@@ -705,18 +727,21 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	async getDefaultBranchName(
 		repoPath: string | undefined,
 		remote?: string,
+		options?: { priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined> {
 		if (repoPath == null) return undefined;
 
 		remote ??= 'origin';
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority: priority } : undefined;
 
 		return this.cache.getDefaultBranchName(repoPath, remote, async commonPath => {
 			let retried = false;
 			while (true) {
 				try {
 					const result = await this.git.run(
-						{ cwd: commonPath, cancellation: cancellation },
+						{ cwd: commonPath, cancellation: cancellation, ...priorityOpts },
 						'symbolic-ref',
 						'--short',
 						`refs/remotes/${remote}/HEAD`,
@@ -728,7 +753,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 							if (!retried) {
 								retried = true;
 								await this.git.run(
-									{ cwd: commonPath, cancellation: cancellation },
+									{ cwd: commonPath, cancellation: cancellation, ...priorityOpts },
 									'remote',
 									'set-head',
 									'-a',
@@ -738,7 +763,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 							}
 
 							const result = await this.git.run(
-								{ cwd: commonPath, cancellation: cancellation },
+								{ cwd: commonPath, cancellation: cancellation, ...priorityOpts },
 								'ls-remote',
 								'--symref',
 								remote,
@@ -1156,6 +1181,7 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			currentTreeOid = treeResult.stdout.trim();
 		} catch (ex) {
 			if (isCancellationError(ex)) throw ex;
+
 			scope?.error(ex, `Failed to resolve target branch '${targetBranch}'`);
 			return createConflictDetectionError('refNotFound');
 		}
@@ -1263,7 +1289,15 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	}
 
 	@debug({ exit: true })
-	getBaseBranchName(repoPath: string, ref: string, cancellation?: AbortSignal): Promise<string | undefined> {
+	getBaseBranchName(
+		repoPath: string,
+		ref: string,
+		options?: { priority?: GitCommandPriority },
+		cancellation?: AbortSignal,
+	): Promise<string | undefined> {
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority: priority } : undefined;
+
 		return this.cache.getBaseBranchName(
 			repoPath,
 			ref,
@@ -1280,19 +1314,36 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 					}
 
 					if (mergeBase != null) {
-						const branch = await this.provider.refs.getSymbolicReferenceName(commonPath, mergeBase);
+						const branch = await this.provider.refs.getSymbolicReferenceName(
+							commonPath,
+							mergeBase,
+							priorityOpts,
+						);
 						if (branch != null) {
 							if (update) {
-								void this.storeBaseBranchName(commonPath, ref, branch);
+								// Self-write: the value we're storing is exactly what this factory is
+								// returning, so any in-flight `branchOverviews` or `baseBranchName` entry
+								// being populated against this resolution should NOT be evicted.
+								void this.storeBaseBranchName(commonPath, ref, branch, {
+									skipInvalidation: ['branchOverviews', 'baseBranchName'],
+								});
 							}
 							return branch;
 						}
 					}
 				} catch {}
 
-				const branch = await this.getBaseBranchFromReflog(commonPath, ref, { upstream: true }, signal);
+				const branch = await this.getBaseBranchFromReflog(
+					commonPath,
+					ref,
+					{ upstream: true, priority: priority },
+					signal,
+				);
 				if (branch != null) {
-					void this.storeBaseBranchName(commonPath, ref, branch);
+					// Self-write: see comment on the migration path above.
+					void this.storeBaseBranchName(commonPath, ref, branch, {
+						skipInvalidation: ['branchOverviews', 'baseBranchName'],
+					});
 					return branch;
 				}
 
@@ -1305,12 +1356,15 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	private async getBaseBranchFromReflog(
 		repoPath: string,
 		ref: string,
-		options?: { upstream: true },
+		options?: { upstream: true; priority?: GitCommandPriority },
 		cancellation?: AbortSignal,
 	): Promise<string | undefined> {
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority: priority } : undefined;
+
 		try {
 			let result = await this.git.run(
-				{ cwd: repoPath, cancellation: cancellation },
+				{ cwd: repoPath, cancellation: cancellation, ...priorityOpts },
 				'reflog',
 				ref,
 				'--grep-reflog=branch: Created from *.',
@@ -1325,18 +1379,22 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 				let name: string | undefined = match[1];
 				if (name !== 'HEAD') {
 					if (options?.upstream) {
-						const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`);
+						const upstream = await this.provider.refs.getSymbolicReferenceName(
+							repoPath,
+							`${name}@{u}`,
+							priorityOpts,
+						);
 						if (upstream) return upstream;
 					}
 
-					name = await this.provider.refs.getSymbolicReferenceName(repoPath, name);
+					name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
 					if (name) return name;
 				}
 			}
 
 			// Check if branch was created from HEAD
 			result = await this.git.run(
-				{ cwd: repoPath, cancellation: cancellation },
+				{ cwd: repoPath, cancellation: cancellation, ...priorityOpts },
 				'reflog',
 				'HEAD',
 				`--grep-reflog=checkout: moving from .* to ${ref.replace('refs/heads/', '')}`,
@@ -1349,11 +1407,15 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 			if (match?.length === 2) {
 				let name: string | undefined = match[1];
 				if (options?.upstream) {
-					const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`);
+					const upstream = await this.provider.refs.getSymbolicReferenceName(
+						repoPath,
+						`${name}@{u}`,
+						priorityOpts,
+					);
 					if (upstream) return upstream;
 				}
 
-				name = await this.provider.refs.getSymbolicReferenceName(repoPath, name);
+				name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
 				if (name) return name;
 			}
 		} catch (ex) {
@@ -1469,13 +1531,23 @@ export class BranchesGitSubProvider implements GitBranchesSubProvider {
 	}
 
 	@debug()
-	async storeBaseBranchName(repoPath: string, ref: string, base: string): Promise<void> {
-		await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-base`, base);
+	async storeBaseBranchName(
+		repoPath: string,
+		ref: string,
+		base: string,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
+	): Promise<void> {
+		await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-base`, base, options);
 	}
 
 	@debug()
-	async storeMergeTargetBranchName(repoPath: string, ref: string, target: string): Promise<void> {
-		await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-target`, target);
+	async storeMergeTargetBranchName(
+		repoPath: string,
+		ref: string,
+		target: string,
+		options?: { skipInvalidation?: readonly GkConfigInvalidationTarget[] },
+	): Promise<void> {
+		await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-target`, target, options);
 	}
 
 	@debug()