@gitkraken/core-gitlens 0.11.1 → 0.13.0

package/dist/git/cache.js

@@ -6,6 +6,7 @@ import { Emitter } from "../utils/event.js";
 import { getBranchId } from "../utils/gitRefs.js";
 import { normalizePath } from "../utils/path.js";
 import { PromiseCache, PromiseMap, RepoPromiseCacheMap } from "../utils/promiseCache.js";
+import { parseBranchMetadataGkConfigKey, setBranchMetadataValue } from "./utils/branch.utils.js";
 import { createReference } from "./utils/reference.utils.js";
 import { getCommonRepositoryPath, getRepositoryOrWorktreePath } from "./utils/repository.utils.js";
 import __decorate from "../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
@@ -42,6 +43,15 @@ async function shouldEvictBlameCacheEntry(progressive) {
 * Capture group 1 is the ref name (which may itself contain `.`/`/`).
 */
 const branchOverviewGkConfigKeysRegex = /^branch\.(.+)\.(?:gk-merge-(?:base|target(?:-user)?)|gk-target-base)$/;
+/** The ref of a gkConfig key the reconcile baseline tracks, or `undefined` for any other key */
+function getReconciledGkConfigRef(key) {
+	return branchOverviewGkConfigKeysRegex.exec(key)?.[1] ?? parseBranchMetadataGkConfigKey(key)?.branch;
+}
+/** The value `cache` holds for `key`, `'pending'` while it is still being read, or `undefined` when nothing is cached */
+function getSettledOrPending(cache, key) {
+	if (!cache?.has(key)) return void 0;
+	return cache.getSettled(key) ?? "pending";
+}
 /** Compile-time enforced: adding a key to SharedCaches without listing it here is a type error */
 const sharedCacheKeys = new Set(exhaustiveArray()([
 	"baseBranchName",
@@ -128,18 +138,22 @@ var Cache = class Cache {
 	/** Monotonic per-path "close clock" — see {@link getCloseGeneration}. */
 	_closeGenerations = /* @__PURE__ */ new Map();
 	/**
-	* Per-commonPath snapshot of the merge-relevant subset of `.git/gk/config` (keys matching
-	* {@link branchOverviewGkConfigKeysRegex}), used by {@link reconcileGkConfigMap} to diff a watcher
-	* `'gkConfig'` event down to only the keys that actually changed, instead of coarsely re-deriving
-	* `baseBranchName`/`branchOverviews` on every gk write. Absent means "never observed".
+	* Per-commonPath snapshot of the subset of `.git/gk/config` that derived caches depend on — merge-relevant keys
+	* ({@link branchOverviewGkConfigKeysRegex}) and branch metadata keys ({@link parseBranchMetadataGkConfigKey}) —
+	* used by {@link reconcileGkConfigMap} to diff a watcher `'gkConfig'` event down to only the keys that actually
+	* changed, instead of coarsely re-deriving `baseBranchName`/`branchOverviews` and the branches on every gk write.
+	* Absent means "never observed".
 	*/
-	_gkConfigMergeSnapshots = /* @__PURE__ */ new Map();
+	_gkConfigSnapshots = /* @__PURE__ */ new Map();
 	_onDidChangeMergeTargets = new Emitter();
 	/**
-	* Fires when an external `.git/gk/config` write changed a branch's merge-relevant keys — never for a write that
-	* only touched other keys (activity timestamps), and never for core's own writes, which
-	* {@link recordGkConfigWrite} folds into the snapshot before the watcher reports them. Fires after the derived
-	* caches were cleared, so a listener's re-read sees the new values.
+	* Fires when a `.git/gk/config` write changed a branch's merge-relevant keys — never for a write that only touched
+	* other keys (activity timestamps). Core's own key store fires it once, as the write completes (see
+	* {@link recordGkConfigWrite}), and the watcher's later report of that write doesn't fire it again; core's own
+	* section remove and rename (a branch delete or rename) never fire it, nor do its internal saves while answering
+	* a read (nobody awaits those, and only another process's watcher reports them). Fires after the derived caches were
+	* cleared, so a listener's re-read sees the new values. A listener must not write merge keys back in response,
+	* or it loops.
 	*/
 	get onDidChangeMergeTargets() {
 		return this._onDidChangeMergeTargets.event;
@@ -166,7 +180,7 @@ var Cache = class Cache {
 		usage["cache.worktreesByCommonPath.entries.count"] = this._worktreesByCommonPath.size;
 		usage["cache.statusGenerations.entries.count"] = this._statusGenerations.size;
 		usage["cache.closeGenerations.entries.count"] = this._closeGenerations.size;
-		usage["cache.gkConfigMergeSnapshots.entries.count"] = this._gkConfigMergeSnapshots.size;
+		usage["cache.gkConfigSnapshots.entries.count"] = this._gkConfigSnapshots.size;
 		return usage;
 	}
 	get bestRemotes() {
@@ -365,7 +379,7 @@ var Cache = class Cache {
 		return this._caches.worktrees ??= new PromiseMap();
 	}
 	clearCaches(repoPath, ...types) {
-		this.clearCachesCore("share", repoPath, ...types);
+		this.clearCachesCore("share", repoPath, types);
 	}
 	/**
 	* Hard-evicts the same cache keys {@link clearCaches} would clear for `repoPath`, but a shared
@@ -375,9 +389,10 @@ var Cache = class Cache {
 	* letting an in-flight read complete and share its answer with new callers is fine.
 	*/
 	evictCaches(repoPath, ...types) {
-		this.clearCachesCore("evict", repoPath, ...types);
+		this.clearCachesCore("evict", repoPath, types);
 	}
-	clearCachesCore(inFlight, repoPath, ...types) {
+	/** `worktreeOnly` leaves the shared (commonPath-keyed) entries alone (see {@link applyRepositoryChanges}) */
+	clearCachesCore(inFlight, repoPath, types, worktreeOnly = false) {
 		const keysToClear = /* @__PURE__ */ new Set();
 		if (!types.length) {
 			for (const key of Object.keys(this._caches)) keysToClear.add(key);
@@ -467,8 +482,9 @@ var Cache = class Cache {
 			const cache = this._caches[key];
 			if (cache == null) continue;
 			if (repoPath == null) cache.clear();
-			else if (sharedCacheKeys.has(key)) this.evictShared(key, repoPath, inFlight);
-			else cache.delete(repoPath);
+			else if (sharedCacheKeys.has(key)) {
+				if (!worktreeOnly) this.evictShared(key, repoPath, inFlight);
+			} else cache.delete(repoPath);
 		}
 	}
 	/**
@@ -617,7 +633,7 @@ var Cache = class Cache {
 				if (isLastWorktree) evict(commonPath);
 			} else evict(repoPath);
 		}
-		if (isLastWorktree) this._gkConfigMergeSnapshots.delete(commonPath);
+		if (isLastWorktree) this._gkConfigSnapshots.delete(commonPath);
 		this._commonPathRegistry.delete(repoPath);
 		if (worktrees != null) {
 			worktrees.delete(repoPath);
@@ -629,7 +645,7 @@ var Cache = class Cache {
 		this._commonPathRegistry.clear();
 		this._worktreesByCommonPath.clear();
 		this._statusGenerations.clear();
-		this._gkConfigMergeSnapshots.clear();
+		this._gkConfigSnapshots.clear();
 		this._gkConfigReconciler = void 0;
 		this._caches = createEmptyCaches();
 	}
@@ -647,8 +663,13 @@ var Cache = class Cache {
 	* `'gkConfig'` change, returning the cache types it cleared. `inFlight` is as {@link clearCaches}
 	* (`'share'`) vs {@link evictCaches} (`'evict'`). `'unknown'` and `'closed'` map to nothing here: the
 	* watcher unregisters the path on them, and an announced write resets everything instead.
+	*
+	* `options.worktreeOnly` clears only `repoPath`'s own entries and status clock, leaving the shared
+	* (commonPath-keyed) ones alone — for a sibling worktree once the change was applied to the worktree it ran in,
+	* which already cleared them for every worktree of the repository.
 	*/
-	applyRepositoryChanges(repoPath, changes, inFlight) {
+	applyRepositoryChanges(repoPath, changes, inFlight, options) {
+		const worktreeOnly = options?.worktreeOnly ?? false;
 		const changesSet = new Set(changes);
 		const hasAny = (...c) => c.some((ch) => changesSet.has(ch));
 		if (hasAny("index", "head", "heads", "remotes", "ignores", "config")) this.incrementStatusGeneration(repoPath);
@@ -673,7 +694,7 @@ var Cache = class Cache {
 			types.add("worktrees");
 		}
 		if (hasAny("ignores")) types.add("gitignore");
-		if (hasAny("gkConfig")) this.handleGkConfigChanged(repoPath);
+		if (hasAny("gkConfig") && !worktreeOnly) this.handleGkConfigChanged(repoPath);
 		if (hasAny("lastFetched")) types.add("lastFetched");
 		if (hasAny("remoteProviders")) types.add("providers");
 		if (hasAny("cherryPick", "merge", "rebase", "revert", "pausedOp")) {
@@ -683,7 +704,7 @@ var Cache = class Cache {
 		if (hasAny("stash")) types.add("stashes");
 		if (hasAny("tags")) types.add("tags");
 		if (hasAny("worktrees")) types.add("worktrees");
-		if (types.size) this.clearCachesCore(inFlight, repoPath, ...types);
+		if (types.size) this.clearCachesCore(inFlight, repoPath, [...types], worktreeOnly);
 		return [...types];
 	}
 	/**
@@ -701,14 +722,18 @@ var Cache = class Cache {
 			this.clearGkConfigCoarsely(repoPath);
 			return;
 		}
-		const priorSnapshot = this._gkConfigMergeSnapshots.get(commonPath);
+		const priorSnapshot = this._gkConfigSnapshots.get(commonPath);
 		Promise.resolve(this._gkConfigReconciler(repoPath, priorSnapshot)).then((outcome) => {
 			if (outcome === "failed") this.clearGkConfigCoarsely(repoPath);
 		}, () => this.clearGkConfigCoarsely(repoPath));
 	}
-	/** The coarse fallback: every derived merge cache is cleared, so any branch's merge targets may have changed */
+	/**
+	* The coarse fallback: every derived merge cache and the branches are cleared, so any branch's merge targets or
+	* metadata may have changed. Evicting the branches even when only merge keys changed is the price of not knowing.
+	*/
 	clearGkConfigCoarsely(repoPath) {
 		this.clearCaches(repoPath, "gkConfig");
+		this.deleteBranchMetadata(repoPath);
 		this._onDidChangeMergeTargets.fire({
 			repoPath: this.getCommonPath(repoPath),
 			refs: void 0
@@ -718,9 +743,17 @@ var Cache = class Cache {
 	deleteGkConfigMap(repoPath) {
 		this._caches.gkConfigMap?.delete(this.getCommonPath(repoPath));
 	}
-	/** The merge-relevant gk config snapshot currently serving as the reconcile baseline. */
-	getGkConfigMergeSnapshot(repoPath) {
-		return this._gkConfigMergeSnapshots.get(this.getCommonPath(repoPath));
+	/**
+	* Whether a write of `key` must first read the gk config to seed the reconcile snapshot: without one,
+	* {@link recordGkConfigWrite} can't tell whether the write changed anything, and the watcher's reconcile of it
+	* would report every branch as changed.
+	*/
+	needsGkConfigSnapshot(repoPath, key) {
+		return getReconciledGkConfigRef(key) != null && !this._gkConfigSnapshots.has(this.getCommonPath(repoPath));
+	}
+	/** The gk config snapshot currently serving as the reconcile baseline. */
+	getGkConfigSnapshot(repoPath) {
+		return this._gkConfigSnapshots.get(this.getCommonPath(repoPath));
 	}
 	getBranches(repoPath, factory, mapper, cancellation) {
 		const commonPath = this.getCommonPath(repoPath);
@@ -767,20 +800,20 @@ var Cache = class Cache {
 	* per-namespace gk lookups are served from it in-memory (see `getGkConfigMap` in the CLI config
 	* sub-provider). Invalidated by `deleteGkConfig` (write) and, on a watcher `'gkConfig'` event, by
 	* `handleGkConfigChanged` (reconciled precisely when a reconciler is registered, or the coarse
-	* clear otherwise). The first fresh read seeds the merge-relevant snapshot used by
+	* clear otherwise). The first fresh read seeds the snapshot used by
 	* `reconcileGkConfigMap`; later refreshes of that snapshot are owned by the reconcile itself.
 	*/
 	getGkConfigMap(repoPath, factory) {
 		return this.getSharedSimple(this.gkConfigMap, repoPath, async (commonPath, cacheable) => {
 			const map = await factory(cacheable);
-			if (!this._gkConfigMergeSnapshots.has(commonPath)) this._gkConfigMergeSnapshots.set(commonPath, this.extractMergeRelevantGkConfig(map));
+			if (!this._gkConfigSnapshots.has(commonPath)) this._gkConfigSnapshots.set(commonPath, this.extractReconciledGkConfig(map));
 			return map;
 		});
 	}
-	/** Extracts the subset of a gk config map whose keys participate in the `branchOverviews`/`baseBranchName` lineage. */
-	extractMergeRelevantGkConfig(map) {
+	/** Extracts the subset of a gk config map that the reconcile baseline tracks (see {@link _gkConfigSnapshots}). */
+	extractReconciledGkConfig(map) {
 		const subset = /* @__PURE__ */ new Map();
-		for (const [key, value] of map) if (branchOverviewGkConfigKeysRegex.test(key)) subset.set(key, value);
+		for (const [key, value] of map) if (getReconciledGkConfigRef(key) != null) subset.set(key, value);
 		return subset;
 	}
 	/**
@@ -800,36 +833,44 @@ var Cache = class Cache {
 		this.cascadeGkConfigKeyChange(commonPath, key, options?.skipInvalidation);
 	}
 	/**
-	* Keeps the merge-relevant gk config snapshot in sync with OUR OWN writes, so the next
-	* watcher-triggered `reconcileGkConfigMap` diffs a self-write as unchanged rather than as an
-	* external change (which would otherwise defeat `skipInvalidation`). No-ops for keys outside the
-	* merge-relevant subset, and if no snapshot exists yet for this repo — nothing to keep in sync;
-	* the next real read (`getGkConfigMap`) populates one from scratch.
+	* Keeps the gk config snapshot in sync with OUR OWN writes, so the next watcher-triggered
+	* `reconcileGkConfigMap` diffs a self-write as unchanged rather than as an external change (which would
+	* otherwise defeat `skipInvalidation`, or evict the branches a second time after a branch-activity stamp),
+	* and fires {@link onDidChangeMergeTargets} naming the key's branch when a merge-relevant value differs from
+	* the snapshot's, unless `announce` is `false` (an internal save while answering a read, which nobody awaits;
+	* only another process's watcher reports it). No-ops for keys the snapshot doesn't track, and if no snapshot exists yet for this repo
+	* (the writer seeds one first; see {@link needsGkConfigSnapshot}).
 	*/
-	recordGkConfigWrite(repoPath, key, value) {
-		if (!branchOverviewGkConfigKeysRegex.test(key)) return;
+	recordGkConfigWrite(repoPath, key, value, options) {
+		const ref = getReconciledGkConfigRef(key);
+		if (ref == null) return;
 		const commonPath = this.getCommonPath(repoPath);
-		const snapshot = this._gkConfigMergeSnapshots.get(commonPath);
-		if (snapshot == null) return;
+		const snapshot = this._gkConfigSnapshots.get(commonPath);
+		if (snapshot == null || snapshot.get(key) === value) return;
 		const next = new Map(snapshot);
 		if (value == null) next.delete(key);
 		else next.set(key, value);
-		this._gkConfigMergeSnapshots.set(commonPath, next);
+		this._gkConfigSnapshots.set(commonPath, next);
+		if (options?.announce === false || !branchOverviewGkConfigKeysRegex.test(key)) return;
+		this._onDidChangeMergeTargets.fire({
+			repoPath: commonPath,
+			refs: /* @__PURE__ */ new Set([ref])
+		});
 	}
 	/**
 	* {@link recordGkConfigWrite} for a whole `branch.<ref>` section: our own `--remove-section` (a branch delete) or
 	* `--rename-section` (a branch rename, to `renamedTo`), so the reconcile that follows doesn't report it as an
-	* external merge-target change.
+	* external merge-target or metadata change — the branch op's own ref change already evicts the branches.
 	*/
 	recordGkConfigSectionWrite(repoPath, ref, renamedTo) {
 		const commonPath = this.getCommonPath(repoPath);
-		const snapshot = this._gkConfigMergeSnapshots.get(commonPath);
+		const snapshot = this._gkConfigSnapshots.get(commonPath);
 		if (snapshot == null) return;
 		const prefixLength = `branch.${ref}.`.length;
 		const next = /* @__PURE__ */ new Map();
-		for (const [key, value] of snapshot) if (branchOverviewGkConfigKeysRegex.exec(key)?.[1] !== ref) next.set(key, value);
+		for (const [key, value] of snapshot) if (getReconciledGkConfigRef(key) !== ref) next.set(key, value);
 		else if (renamedTo != null) next.set(`branch.${renamedTo}.${key.substring(prefixLength)}`, value);
-		this._gkConfigMergeSnapshots.set(commonPath, next);
+		this._gkConfigSnapshots.set(commonPath, next);
 	}
 	/**
 	* Registers the reconciler invoked by {@link handleGkConfigChanged} on a watcher-observed
@@ -841,35 +882,63 @@ var Cache = class Cache {
 		this._gkConfigReconciler = reconciler;
 	}
 	/**
-	* Diffs a freshly-read gk config map's merge-relevant subset against `priorSnapshot` (captured by
-	* `handleGkConfigChanged` before the reconcile started, so it reflects the pre-change state even
-	* though this call's own re-read already raced ahead and refreshed the live snapshot), cascading
+	* Diffs a freshly-read gk config map's tracked subset against `priorSnapshot` (captured by
+	* `handleGkConfigChanged` before the reconcile started, so it reflects the pre-change state), cascading
 	* `baseBranchName`/`branchOverviews` for every ref whose merge-relevant key actually changed, then firing
-	* {@link onDidChangeMergeTargets} naming those refs.
+	* {@link onDidChangeMergeTargets} naming those refs. Changed branch metadata keys (another process's
+	* activity stamps or disposition) are patched into the cached branches in one call, and never fire the event.
+	* A key core itself wrote since `priorSnapshot` was captured (recorded in the live snapshot) is neither diffed nor
+	* overwritten by this read, which may predate the write: its writer already cascaded and announced it.
 	* `priorSnapshot` of `undefined` (never observed before this reconcile) is treated as "everything
 	* may have changed" — a full coarse clear, same as the pre-existing watcher behavior. Returns
 	* whether anything changed (i.e. whether a follow-up repository-changed event is warranted).
 	*/
 	reconcileGkConfigMap(repoPath, priorSnapshot, freshMap) {
 		const commonPath = this.getCommonPath(repoPath);
-		const newSubset = this.extractMergeRelevantGkConfig(freshMap);
-		this._gkConfigMergeSnapshots.set(commonPath, newSubset);
+		const newSubset = this.extractReconciledGkConfig(freshMap);
 		if (priorSnapshot == null) {
+			this._gkConfigSnapshots.set(commonPath, newSubset);
 			this.evictShared("baseBranchName", repoPath);
 			this.evictShared("branchOverviews", repoPath);
+			this.deleteBranchMetadata(repoPath);
 			this._onDidChangeMergeTargets.fire({
 				repoPath: commonPath,
 				refs: void 0
 			});
 			return true;
 		}
+		const ownWrites = /* @__PURE__ */ new Set();
+		const live = this._gkConfigSnapshots.get(commonPath);
+		if (live != null && live !== priorSnapshot) for (const key of /* @__PURE__ */ new Set([...priorSnapshot.keys(), ...live.keys()])) {
+			const value = live.get(key);
+			if (priorSnapshot.get(key) === value) continue;
+			ownWrites.add(key);
+			if (value == null) newSubset.delete(key);
+			else newSubset.set(key, value);
+		}
+		this._gkConfigSnapshots.set(commonPath, newSubset);
 		let refs;
-		for (const key of /* @__PURE__ */ new Set([...priorSnapshot.keys(), ...newSubset.keys()])) if (priorSnapshot.get(key) !== newSubset.get(key)) {
-			this.cascadeGkConfigKeyChange(commonPath, key);
+		const metadataChanges = [];
+		for (const key of /* @__PURE__ */ new Set([...priorSnapshot.keys(), ...newSubset.keys()])) {
+			if (ownWrites.has(key)) continue;
+			const value = newSubset.get(key);
+			if (priorSnapshot.get(key) === value) continue;
 			const ref = branchOverviewGkConfigKeysRegex.exec(key)?.[1];
-			if (ref != null) (refs ??= /* @__PURE__ */ new Set()).add(ref);
+			if (ref != null) {
+				this.cascadeGkConfigKeyChange(commonPath, key);
+				(refs ??= /* @__PURE__ */ new Set()).add(ref);
+				continue;
+			}
+			const metadataKey = parseBranchMetadataGkConfigKey(key);
+			if (metadataKey != null) metadataChanges.push({
+				branch: metadataKey.branch,
+				key: metadataKey.key,
+				value
+			});
 		}
-		if (refs == null) return false;
+		const metadataChanged = metadataChanges.length > 0;
+		if (metadataChanged) this.patchBranchMetadata(repoPath, metadataChanges);
+		if (refs == null) return metadataChanged;
 		this._onDidChangeMergeTargets.fire({
 			repoPath: commonPath,
 			refs
@@ -931,6 +1000,71 @@ var Cache = class Cache {
 	deleteBaseBranchName(repoPath, ref) {
 		this._caches.baseBranchName?.delete(this.getCommonPath(repoPath), ref);
 	}
+	/**
+	* Applies changed branch metadata keys (written here or reconciled from another process) to the cached branches
+	* without re-reading them, by updating {@link BranchMetadata} objects in place — the one exception to cached values
+	* never changing, since rebuilding every branch list, current branch and worktree list on every activity stamp
+	* costs far more. Patches every object a cached branch of the repository's worktrees holds for a changed branch:
+	* the cached map's, and any older map's that a cached branch list, current branch or worktree list still holds.
+	*
+	* Falls back to {@link deleteBranchMetadata} when one of them is still being read (it may have read the file
+	* before the change), or the cached map or a cached branch of a changed name has no object to patch.
+	*/
+	patchBranchMetadata(repoPath, changes) {
+		const targets = /* @__PURE__ */ new Map();
+		for (const change of changes) targets.set(change.branch, /* @__PURE__ */ new Set());
+		if (!this.collectBranchMetadata(this.getCommonPath(repoPath), targets)) {
+			this.deleteBranchMetadata(repoPath);
+			return;
+		}
+		for (const change of changes) for (const metadata of targets.get(change.branch)) setBranchMetadataValue(metadata, change.key, change.value);
+	}
+	/**
+	* Adds to `targets` every metadata object a cached holder has for each named branch (see
+	* {@link patchBranchMetadata}); `false` when the holders must be evicted instead.
+	*/
+	collectBranchMetadata(commonPath, targets) {
+		const metadataMap = getSettledOrPending(this._caches.branchMetadataMap, commonPath);
+		if (metadataMap === "pending") return false;
+		if (metadataMap != null) for (const [name, objects] of targets) {
+			const metadata = metadataMap.value.get(name);
+			if (metadata == null) return false;
+			objects.add(metadata);
+		}
+		const add = (branch) => {
+			if (branch == null || branch.remote || branch.detached) return true;
+			const objects = targets.get(branch.name);
+			if (objects == null) return true;
+			if (branch.metadata == null) return false;
+			objects.add(branch.metadata);
+			return true;
+		};
+		for (const path of /* @__PURE__ */ new Set([commonPath, ...this.getWorktreePaths(commonPath)])) {
+			for (const cache of [this._caches.sharedBranches, this._caches.branches]) {
+				const branches = getSettledOrPending(cache, path);
+				if (branches === "pending" || branches != null && !branches.value.values.every(add)) return false;
+			}
+			const current = getSettledOrPending(this._caches.branch, path);
+			if (current === "pending" || current != null && !add(current.value)) return false;
+			const worktrees = getSettledOrPending(this._caches.worktrees, path);
+			if (worktrees === "pending" || worktrees != null && !worktrees.value.every((w) => add(w.branch))) return false;
+		}
+		return true;
+	}
+	/**
+	* Drops the cached branches and worktrees for `repoPath` and its sibling worktrees when their metadata changed in
+	* a way {@link patchBranchMetadata} can't apply in place. Hard-evicts, so a read that started before the change
+	* isn't joined.
+	*/
+	deleteBranchMetadata(repoPath) {
+		for (const key of [
+			"branchMetadataMap",
+			"sharedBranches",
+			"branches",
+			"branch",
+			"worktrees"
+		]) this.evictShared(key, repoPath, "evict");
+	}
 	getBranchMergedStatus(repoPath, cacheKey, factory, cancellation) {
 		return this.getSharedOrCreateWithKey(this.branchMergedStatus, repoPath, cacheKey, factory, (data, newRepoPath) => {
 			if (!data.merged) return data;