@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/dist/git/cache.js

@@ -1,1288 +1,960 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { exhaustiveArray } from '../utils/array.js';
-import { raceWithSignal } from '../utils/cancellation.js';
-import { debug } from '../utils/decorators/log.js';
-import { invalidateMemoized } from '../utils/decorators/memoize.js';
-import { normalizePath } from '../utils/path.js';
-import { PromiseCache, PromiseMap, RepoPromiseCacheMap } from '../utils/promiseCache.js';
-import { getBranchId } from './utils/branch.utils.js';
-import { createReference } from './utils/reference.utils.js';
-import { getCommonRepositoryPath, getRepositoryOrWorktreePath } from './utils/repository.utils.js';
-const uriScopedCachedGitTypes = ['blame', 'diff', 'fileLog'];
-export function areUriScopedCachedGitTypes(types) {
-    return types.every(t => uriScopedCachedGitTypes.includes(t));
+import { exhaustiveArray } from "../utils/array.js";
+import { raceWithSignal } from "../utils/cancellation.js";
+import { debug } from "../utils/decorators/log.js";
+import { invalidateMemoized } from "../utils/decorators/memoize.js";
+import { getBranchId } from "../utils/gitRefs.js";
+import { normalizePath } from "../utils/path.js";
+import { PromiseCache, PromiseMap, RepoPromiseCacheMap } from "../utils/promiseCache.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";
+//#region ../git/src/cache.ts
+const uriScopedCachedGitTypes = [
+	"blame",
+	"diff",
+	"fileLog"
+];
+function areUriScopedCachedGitTypes(types) {
+	return types.every((t) => uriScopedCachedGitTypes.includes(t));
 }
 /**
- * Ceiling on how long a derived branch base is trusted. Long enough that repeated reads during normal use
- * are served from cache, short enough that a base that changed by a route with no eviction signal (an
- * external delete-and-recreate of a branch that is never checked out) self-heals without a reload.
- */
-const baseBranchNameTTL = 5 * 60 * 1000; // 5 minutes
+* Ceiling on how long a derived branch base is trusted. Long enough that repeated reads during normal use
+* are served from cache, short enough that a base that changed by a route with no eviction signal (an
+* external delete-and-recreate of a branch that is never checked out) self-heals without a reload.
+*/
+const baseBranchNameTTL = 3e5;
 /**
- * Completed blame graphs retain several objects and substrings per line. Keep normal files hot, but let large
- * documents be owned by their active tracked-document snapshot instead of retaining a second long-lived owner.
- */
-const maxCachedBlameLines = 5000;
-export async function shouldEvictBlameCacheEntry(progressive) {
-    if (progressive == null)
-        return false;
-    try {
-        const blame = await progressive.completed;
-        return blame.lines.length > maxCachedBlameLines;
-    }
-    catch {
-        // The provider factory resolves as soon as streaming starts, so a later stream failure must also be retried.
-        return true;
-    }
+* Completed blame graphs retain several objects and substrings per line. Keep normal files hot, but let large
+* documents be owned by their active tracked-document snapshot instead of retaining a second long-lived owner.
+*/
+const maxCachedBlameLines = 5e3;
+async function shouldEvictBlameCacheEntry(progressive) {
+	if (progressive == null) return false;
+	try {
+		return (await progressive.completed).lines.length > maxCachedBlameLines;
+	} catch {
+		return true;
+	}
 }
 /**
- * gkConfig keys that participate in the `branchOverviews` cache's mergeTarget/mergeBase lineage.
- * Capture group 1 is the ref name (which may itself contain `.`/`/`).
- */
+* gkConfig keys that participate in the `branchOverviews` cache's mergeTarget/mergeBase lineage.
+* Capture group 1 is the ref name (which may itself contain `.`/`/`).
+*/
 const branchOverviewGkConfigKeysRegex = /^branch\.(.+)\.(?:gk-merge-(?:base|target(?:-user)?)|gk-target-base)$/;
 /** Compile-time enforced: adding a key to SharedCaches without listing it here is a type error */
 const sharedCacheKeys = new Set(exhaustiveArray()([
-    'baseBranchName',
-    'branchMergedStatus',
-    'branchMetadataMap',
-    'branchOverviews',
-    'branches',
-    'configKeys',
-    'configPatterns',
-    'contributors',
-    'contributorsLite',
-    'contributorsStats',
-    'defaultBranchName',
-    'gitResults',
-    'gkConfigMap',
-    'initialCommitSha',
-    'lastFetched',
-    'logShas',
-    'refs',
-    'refTips',
-    'remotes',
-    'sharedBranches',
-    'stashes',
-    'tags',
-    'worktrees',
+	"baseBranchName",
+	"branchMergedStatus",
+	"branchMetadataMap",
+	"branchOverviews",
+	"branches",
+	"configKeys",
+	"configPatterns",
+	"contributors",
+	"contributorsLite",
+	"contributorsStats",
+	"defaultBranchName",
+	"gitResults",
+	"gkConfigMap",
+	"initialCommitSha",
+	"lastFetched",
+	"logShas",
+	"refs",
+	"refTips",
+	"remotes",
+	"sharedBranches",
+	"stashes",
+	"tags",
+	"worktrees"
 ]));
 function createEmptyCaches() {
-    return {
-        baseBranchName: undefined,
-        bestRemotes: undefined,
-        blame: undefined,
-        branch: undefined,
-        branchMergedStatus: undefined,
-        branchMetadataMap: undefined,
-        branchOverviews: undefined,
-        branches: undefined,
-        commit: undefined,
-        commitCount: undefined,
-        fileExistence: undefined,
-        ignoreRevsFile: undefined,
-        leftRightCommitCount: undefined,
-        mergeBase: undefined,
-        configKeys: undefined,
-        configPatterns: undefined,
-        conflictDetection: undefined,
-        diff: undefined,
-        fileLog: undefined,
-        contributors: undefined,
-        contributorsLite: undefined,
-        contributorsStats: undefined,
-        currentBranchReference: undefined,
-        currentUser: undefined,
-        defaultBranchName: undefined,
-        gitDir: undefined,
-        gitIgnore: undefined,
-        gitResults: undefined,
-        gkConfigMap: undefined,
-        initialCommitSha: undefined,
-        lastFetched: undefined,
-        logShas: undefined,
-        pausedOperationStatus: undefined,
-        resolvedRevisions: undefined,
-        reachability: undefined,
-        refs: undefined,
-        refTips: undefined,
-        remotes: undefined,
-        sharedBranches: undefined,
-        stashes: undefined,
-        tags: undefined,
-        trackedPaths: undefined,
-        worktrees: undefined,
-    };
-}
-export class Cache {
-    _caches = createEmptyCaches();
-    _commonPathRegistry = new Map();
-    /** Reverse index: commonPath → set of worktree repoPaths that share it */
-    _worktreesByCommonPath = new Map();
-    /** Monotonic per-worktree "status clock" — see {@link getStatusGeneration}. */
-    _statusGenerations = new Map();
-    /** Monotonic per-path "close clock" — see {@link getCloseGeneration}. */
-    _closeGenerations = 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".
-     */
-    _gkConfigMergeSnapshots = new Map();
-    /**
-     * Reconciler registered by the CLI config sub-provider (see {@link setGkConfigReconciler}),
-     * invoked on a watcher-observed `'gkConfig'` change instead of the coarse `clearCaches(repoPath,
-     * 'gkConfig')` cascade. `undefined` (e.g. the GitHub provider, which has no `.git/gk/config`)
-     * falls back to the coarse clear.
-     */
-    _gkConfigReconciler;
-    [Symbol.dispose]() {
-        this.dispose();
-    }
-    dispose() {
-        this.reset();
-    }
-    /** Resource usage retained by instantiated sub-caches and their bookkeeping maps. */
-    getResourceUsage() {
-        const usage = {};
-        for (const [name, cache] of Object.entries(this._caches)) {
-            if (cache != null) {
-                usage[`cache.${name}.entries.count`] =
-                    cache instanceof RepoPromiseCacheMap ? cache.entryCount : cache.size;
-            }
-        }
-        usage['cache.commonPathRegistry.entries.count'] = this._commonPathRegistry.size;
-        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;
-        return usage;
-    }
-    get bestRemotes() {
-        return (this._caches.bestRemotes ??= new PromiseMap());
-    }
-    get blame() {
-        return (this._caches.blame ??= new RepoPromiseCacheMap({
-            createTTL: 1000 * 60 * 10, // 10 minutes
-            capacity: 50,
-        }));
-    }
-    get diff() {
-        return (this._caches.diff ??= new RepoPromiseCacheMap({
-            createTTL: 1000 * 60 * 10, // 10 minutes
-            capacity: 50,
-        }));
-    }
-    get fileLog() {
-        return (this._caches.fileLog ??= new RepoPromiseCacheMap({
-            createTTL: 1000 * 60 * 10, // 10 minutes
-            capacity: 50,
-        }));
-    }
-    get baseBranchName() {
-        return (this._caches.baseBranchName ??= new RepoPromiseCacheMap());
-    }
-    get branch() {
-        return (this._caches.branch ??= new PromiseMap());
-    }
-    get branchMergedStatus() {
-        return (this._caches.branchMergedStatus ??= new RepoPromiseCacheMap({
-            createTTL: 1000 * 60 * 30, // 30 minutes — content-keyed on tip shas, so this is just a backstop
-            accessTTL: 1000 * 60 * 60, // 60 minutes
-            capacity: 100, // Limit to 100 branch-pairs per repo
-        }));
-    }
-    get branchMetadataMap() {
-        return (this._caches.branchMetadataMap ??= new PromiseMap());
-    }
-    get branchOverviews() {
-        return (this._caches.branchOverviews ??= new RepoPromiseCacheMap({ accessTTL: 1000 * 60 * 60 }));
-    }
-    get branches() {
-        return (this._caches.branches ??= new PromiseMap());
-    }
-    /**
-     * Internal cache for raw shared branch data (keyed by commonPath)
-     * Separate from branches cache because branches need to be mapped for each worktree
-     */
-    get sharedBranches() {
-        return (this._caches.sharedBranches ??= new PromiseMap());
-    }
-    get configKeys() {
-        return (this._caches.configKeys ??= new RepoPromiseCacheMap({
-            createTTL: 1000 * 30, // 30 seconds - ensures global config changes are picked up
-        }));
-    }
-    get configPatterns() {
-        return (this._caches.configPatterns ??= new RepoPromiseCacheMap({
-            createTTL: 1000 * 30, // 30 seconds - ensures global config changes are picked up
-        }));
-    }
-    get gkConfigMap() {
-        return (this._caches.gkConfigMap ??= new PromiseMap());
-    }
-    get currentBranchReference() {
-        return (this._caches.currentBranchReference ??= new PromiseCache());
-    }
-    setCurrentBranchReferenceIfAbsent(worktreePath, reference) {
-        if (this.currentBranchReference.get(worktreePath) == null) {
-            this.currentBranchReference.set(worktreePath, Promise.resolve(reference));
-        }
-    }
-    get conflictDetection() {
-        return (this._caches.conflictDetection ??= new RepoPromiseCacheMap({
-            createTTL: 1000 * 30, // 30 seconds
-        }));
-    }
-    get contributors() {
-        return (this._caches.contributors ??= new RepoPromiseCacheMap({
-            accessTTL: 1000 * 60 * 60, // 60 minutes
-        }));
-    }
-    get contributorsLite() {
-        return (this._caches.contributorsLite ??= new RepoPromiseCacheMap({
-            accessTTL: 1000 * 60 * 60, // 60 minutes
-        }));
-    }
-    get contributorsStats() {
-        return (this._caches.contributorsStats ??= new RepoPromiseCacheMap({
-            accessTTL: 1000 * 60 * 60, // 60 minutes
-        }));
-    }
-    get currentUser() {
-        return (this._caches.currentUser ??= new Map());
-    }
-    get defaultBranchName() {
-        return (this._caches.defaultBranchName ??= new RepoPromiseCacheMap());
-    }
-    get gitDir() {
-        return (this._caches.gitDir ??= new Map());
-    }
-    get gitIgnore() {
-        return (this._caches.gitIgnore ??= new Map());
-    }
-    get gitResults() {
-        return (this._caches.gitResults ??= new RepoPromiseCacheMap({ capacity: 200 }));
-    }
-    get initialCommitSha() {
-        return (this._caches.initialCommitSha ??= new PromiseMap());
-    }
-    get lastFetched() {
-        return (this._caches.lastFetched ??= new PromiseCache({
-            createTTL: 1000 * 30, // 30 seconds
-        }));
-    }
-    get leftRightCommitCount() {
-        return (this._caches.leftRightCommitCount ??= new RepoPromiseCacheMap({
-            createTTL: 1000 * 60 * 5, // 5 minutes max age — invalidated sooner on branch/remote changes
-            capacity: 50, // Limit to 50 ref-pairs per repo
-        }));
-    }
-    get commit() {
-        return (this._caches.commit ??= new RepoPromiseCacheMap({
-            accessTTL: 1000 * 60 * 60, // 60 minutes
-            capacity: 100, // Limit to 100 commits per repo
-        }));
-    }
-    get commitCount() {
-        return (this._caches.commitCount ??= new RepoPromiseCacheMap({
-            accessTTL: 1000 * 60 * 60, // 60 minutes
-            capacity: 50,
-        }));
-    }
-    get mergeBase() {
-        return (this._caches.mergeBase ??= new RepoPromiseCacheMap({
-            accessTTL: 1000 * 60 * 60, // 60 minutes
-            capacity: 50,
-        }));
-    }
-    get logShas() {
-        return (this._caches.logShas ??= new RepoPromiseCacheMap({
-            createTTL: 1000 * 60 * 5, // 5 minutes max age
-            accessTTL: 1000 * 30, // 30 seconds if not accessed
-            capacity: 5, // Limit to 5 different ranges per repo
-        }));
-    }
-    get pausedOperationStatus() {
-        return (this._caches.pausedOperationStatus ??= new PromiseMap());
-    }
-    get resolvedRevisions() {
-        return (this._caches.resolvedRevisions ??= new RepoPromiseCacheMap({
-            capacity: 100,
-        }));
-    }
-    get refs() {
-        return (this._caches.refs ??= new PromiseMap());
-    }
-    get refTips() {
-        return (this._caches.refTips ??= new PromiseMap());
-    }
-    get reachability() {
-        return (this._caches.reachability ??= new RepoPromiseCacheMap({
-            accessTTL: 1000 * 60 * 60, // 60 minutes
-            capacity: 25, // Limit to 25 commits per repo
-        }));
-    }
-    get remotes() {
-        return (this._caches.remotes ??= new PromiseMap());
-    }
-    get stashes() {
-        return (this._caches.stashes ??= new RepoPromiseCacheMap({
-            accessTTL: 1000 * 60 * 60, // 60 minutes
-        }));
-    }
-    get tags() {
-        return (this._caches.tags ??= new PromiseMap());
-    }
-    get fileExistence() {
-        return (this._caches.fileExistence ??= new RepoPromiseCacheMap({
-            createTTL: 1000 * 10, // 10 seconds
-            capacity: 100,
-            expireOnError: true,
-        }));
-    }
-    // Key: repoPath (not the ignoreRevsFile path) so that per-repo cache resets (clearCaches with repoPath)
-    // correctly evict the entry. The actual file path is used inside the factory closure in blame.ts.
-    get ignoreRevsFile() {
-        return (this._caches.ignoreRevsFile ??= new PromiseCache({
-            accessTTL: 1000 * 60 * 60 * 2, // 2 hours
-            expireOnError: true,
-        }));
-    }
-    get trackedPaths() {
-        return (this._caches.trackedPaths ??= new RepoPromiseCacheMap({
-            createTTL: 1000 * 60, // 60 seconds
-            accessTTL: 1000 * 30, // 30 seconds idle
-            capacity: 200,
-        }));
-    }
-    get worktrees() {
-        return (this._caches.worktrees ??= new PromiseMap());
-    }
-    clearCaches(repoPath, ...types) {
-        const keysToClear = new Set();
-        if (!types.length) {
-            // Clear all caches
-            for (const key of Object.keys(this._caches)) {
-                keysToClear.add(key);
-            }
-            invalidateMemoized('providers');
-            this.incrementStatusGenerations(repoPath);
-        }
-        else {
-            // Clear specific cache types
-            if (types.includes('blame')) {
-                keysToClear.add('blame');
-            }
-            if (types.includes('diff')) {
-                keysToClear.add('diff');
-            }
-            if (types.includes('fileLog')) {
-                keysToClear.add('fileLog');
-            }
-            // Branch caches affected by HEAD/heads changes. `branchMergedStatus` is deliberately NOT
-            // cleared here — it's content-keyed on the involved tip shas, so tip movement already
-            // self-invalidates (a new key); evicting it here would only discard still-valid answers.
-            if (types.includes('branch') || types.includes('branches')) {
-                keysToClear.add('branch');
-                keysToClear.add('branchOverviews');
-                // `commit`/`commitCount` are keyed by symbolic ref or SHA — symbolic-ref entries
-                // can drift when branches move; cascade-clear conservatively.
-                keysToClear.add('commit');
-                keysToClear.add('commitCount');
-                keysToClear.add('conflictDetection');
-                keysToClear.add('currentBranchReference');
-                keysToClear.add('leftRightCommitCount');
-                // `mergeBase` keyed by ref-pairs — symbolic refs can move; cascade-clear.
-                keysToClear.add('mergeBase');
-                keysToClear.add('reachability');
-                keysToClear.add('resolvedRevisions');
-            }
-            // Shared branch caches (branch list, metadata). `baseBranchName` is deliberately NOT cleared
-            // here — a branch's base is set at creation and only changes when its stored key changes
-            // (`gkConfig`/`config` below) or the branch itself is created/renamed/deleted. Every op that
-            // does one of those calls `deleteBaseBranchName` and moves or drops the branch's persisted
-            // `branch.<ref>.gk-*` keys: `createBranch`/`deleteLocalBranch`/`renameBranch`, plus the two
-            // paths that create a branch as a side effect (`checkout -b`, `worktree add -b`). Tip movement
-            // can't change a base, so clearing on every commit only forced a `git reflog` re-derivation.
-            if (types.includes('branch')) {
-                // `'branch'` comes from a HEAD change — a checkout — which appends `checkout: moving from X
-                // to Y` to the reflog, exactly the entry `getBaseBranchName` greps for when nothing is
-                // stored. A base derived as "none" BEFORE that entry existed is cached with no TTL, so
-                // without this it stays "none" for the session even though the answer now exists.
-                //
-                // Deliberately not under `'branches'`: a tip move can't change a branch's base, so re-deriving
-                // on every commit would be pure cost. Checkouts are user-driven and rare by comparison.
-                keysToClear.add('baseBranchName');
-            }
-            if (types.includes('branches')) {
-                keysToClear.add('branchMetadataMap');
-                keysToClear.add('branches');
-                keysToClear.add('sharedBranches');
-                keysToClear.add('defaultBranchName');
-                keysToClear.add('initialCommitSha');
-                keysToClear.add('logShas');
-                keysToClear.add('refs');
-                keysToClear.add('refTips');
-            }
-            if (types.includes('config')) {
-                // `getBaseBranchName` falls back to `branch.<ref>.vscode-merge-base` (written by VS Code's
-                // built-in Git), which lives in `.git/config` — so a config change is the only signal that
-                // source changed. Cheap: config events are rare.
-                keysToClear.add('baseBranchName');
-                keysToClear.add('configKeys');
-                keysToClear.add('configPatterns');
-                keysToClear.add('currentBranchReference');
-                keysToClear.add('currentUser');
-                // `gitDir` is immutable repo topology (toplevel/git-dir/common-dir/superproject) — a
-                // `.git/config` content change never relocates it, and it's owned by the repo lifecycle
-                // (registerRepoPath/unregisterRepoPath). Clearing it here forced a redundant `git rev-parse`
-                // re-spawn (gitDir is read by getGkConfigPath→getGitDir on every gk op), so leave it warm.
-            }
-            if (types.includes('contributors')) {
-                keysToClear.add('branchOverviews');
-                keysToClear.add('contributors');
-                keysToClear.add('contributorsLite');
-                keysToClear.add('contributorsStats');
-            }
-            if (types.includes('gitignore')) {
-                keysToClear.add('gitIgnore');
-            }
-            if (types.includes('gkConfig')) {
-                keysToClear.add('gkConfigMap');
-                // Derived from `branch.<ref>.gk-merge-base`/`vscode-merge-base`; clear so external
-                // gkConfig mutations don't leave stale base-branch resolutions cached.
-                keysToClear.add('baseBranchName');
-                // Cached overviews are keyed by `${ref}|${mergeTarget}`; bulk gkConfig changes can
-                // affect any of the merge-target sources (stored, base, default), so clear all.
-                keysToClear.add('branchOverviews');
-            }
-            if (types.includes('lastFetched')) {
-                keysToClear.add('lastFetched');
-            }
-            if (types.includes('providers')) {
-                keysToClear.add('remotes');
-                keysToClear.add('bestRemotes');
-                invalidateMemoized('providers');
-            }
-            if (types.includes('remotes')) {
-                keysToClear.add('remotes');
-                keysToClear.add('bestRemotes');
-                keysToClear.add('defaultBranchName');
-            }
-            if (types.includes('stashes')) {
-                keysToClear.add('stashes');
-            }
-            if (types.includes('status')) {
-                keysToClear.add('pausedOperationStatus');
-                // A caller asserting "status changed" (the post-op hooks in `operations.ts`, a user-initiated
-                // refresh) has to advance the clock too — otherwise a `git status` still in flight from before
-                // the operation can satisfy the read that follows it.
-                this.incrementStatusGenerations(repoPath);
-            }
-            if (types.includes('tags')) {
-                keysToClear.add('tags');
-                keysToClear.add('refs');
-                keysToClear.add('refTips');
-                // `commit`/`commitCount` can be keyed by a tag name (e.g. the tag node's load-more count),
-                // which re-points on a force-moved or deleted-and-recreated tag — same drift the
-                // `branch`/`branches` cascade above clears for.
-                keysToClear.add('commit');
-                keysToClear.add('commitCount');
-            }
-            if (types.includes('tracking')) {
-                keysToClear.add('fileExistence');
-                keysToClear.add('trackedPaths');
-            }
-            if (types.includes('worktrees')) {
-                keysToClear.add('worktrees');
-            }
-            // Git results: cleared for any meaningful type change
-            if (types.some(t => t !== 'gitignore' && t !== 'gkConfig' && t !== 'providers')) {
-                keysToClear.add('gitResults');
-            }
-        }
-        for (const key of keysToClear) {
-            const cache = this._caches[key];
-            if (cache == null)
-                continue;
-            if (repoPath == null) {
-                cache.clear();
-            }
-            else if (sharedCacheKeys.has(key)) {
-                this.evictShared(key, repoPath);
-            }
-            else {
-                cache.delete(repoPath);
-            }
-        }
-    }
-    /**
-     * Evicts a single shared (commonPath-keyed) cache entry for `repoPath` and its sibling worktrees.
-     * Prefers `invalidate` where supported so in-flight work is shared across new callers and
-     * self-evicts on settle rather than spawning a duplicate factory. `invalidate` does the right
-     * thing per-entry: entries with a `CacheController` (created via `getOrCreate`) are marked
-     * invalidated; entries without one (created via plain `.set()`, e.g. per-worktree mapper results)
-     * are hard-deleted. Caches that don't support `invalidate` fall back to `delete`.
-     */
-    evictShared(key, repoPath) {
-        const cache = this._caches[key];
-        if (cache == null)
-            return;
-        const commonPath = this.getCommonPath(repoPath);
-        const invalidate = cache.invalidate;
-        if (typeof invalidate === 'function') {
-            invalidate.call(cache, commonPath);
-            for (const worktreePath of this.getWorktreePaths(commonPath)) {
-                if (worktreePath === commonPath)
-                    continue;
-                invalidate.call(cache, worktreePath);
-            }
-        }
-        else {
-            cache.delete(commonPath);
-            for (const worktreePath of this.getWorktreePaths(commonPath)) {
-                if (worktreePath === commonPath)
-                    continue;
-                cache.delete(worktreePath);
-            }
-        }
-    }
-    /**
-     * Monotonic per-worktree counter, advanced whenever anything that can change `git status` output is
-     * observed. `git status` and its siblings are point-in-time reads of mutable state, so deduplicating them
-     * on repoPath alone is unsound — a run that started before a commit would satisfy a caller that arrived
-     * after it. Callers stamp their in-flight run with the generation it started in and refuse older joins.
-     * Kept per exact worktree path (never spread to the common path) and advanced on `unregisterRepoPath` so a
-     * read in flight from a prior registration can't be joined after a reopen.
-     *
-     * Note: a run that never settles wedges only its own generation's callers (a newer generation gets a fresh
-     * key). `git.run` recovers via its per-command timeout (default 60s); a hung `git.stream` is caught by the
-     * status provider's `raceWithTimeout` backstop (scaled to `advanced.git.timeout`; see
-     * `dedupeByStatusGeneration`), which rejects a wedged read so waiters unblock and a later caller retries.
-     */
-    getStatusGeneration(repoPath) {
-        return this._statusGenerations.get(repoPath) ?? 0;
-    }
-    /** Advances the status clock — see {@link getStatusGeneration}. */
-    incrementStatusGeneration(repoPath) {
-        this._statusGenerations.set(repoPath, this.getStatusGeneration(repoPath) + 1);
-    }
-    /**
-     * Working-tree changes ride their own channel (`Repository.onDidChangeWorkingTree`), not
-     * `onRepositoryChanged` — an external `git restore <file>` may touch no `.git` path we classify — so
-     * they have to advance the status clock separately or a discard would never invalidate an in-flight read.
-     */
-    onWorkingTreeChanged(repoPath) {
-        this.incrementStatusGeneration(repoPath);
-    }
-    /** Advances the status clock for one worktree, or for every known worktree when `repoPath` is undefined. */
-    incrementStatusGenerations(repoPath) {
-        if (repoPath != null) {
-            this.incrementStatusGeneration(repoPath);
-            return;
-        }
-        // Union of registered repos and any path that already carries a generation — a secondary-worktree
-        // path incremented via its own watcher may never have been registered, but still has in-flight reads to fence.
-        const paths = new Set([...this._commonPathRegistry.keys(), ...this._statusGenerations.keys()]);
-        for (const path of paths) {
-            this.incrementStatusGeneration(path);
-        }
-    }
-    getCommonPath(repoPath) {
-        return this._commonPathRegistry.get(repoPath) ?? repoPath;
-    }
-    getWorktreePaths(commonPath) {
-        const worktrees = this._worktreesByCommonPath.get(commonPath);
-        return worktrees != null ? [...worktrees] : [];
-    }
-    isWorktree(repoPath) {
-        const commonPath = this._commonPathRegistry.get(repoPath);
-        return commonPath != null && commonPath !== repoPath;
-    }
-    /** Whether `repoPath` is currently registered (via {@link registerRepoPath}, not yet unregistered). */
-    isRegistered(repoPath) {
-        return this._commonPathRegistry.has(repoPath);
-    }
-    /**
-     * Monotonic per-path counter advanced whenever `repoPath` is unregistered (repo closed, worktree
-     * removed). Lets an async post-read step — e.g. the gk-config reconcile — detect that its target was
-     * closed (and possibly reopened) mid-flight and bail. Unlike an `isRegistered` check it doesn't
-     * require the caller to have registered in the first place, so it stays correct for consumers of
-     * this package that don't wire up the host's repo lifecycle.
-     */
-    getCloseGeneration(repoPath) {
-        return this._closeGenerations.get(repoPath) ?? 0;
-    }
-    /** Clears file-scoped caches (blame, diff, fileLog) for a specific path within a repo */
-    clearForPath(repoPath, path, ...types) {
-        const prefix = `${normalizePath(path)}:`;
-        if (!types.length || types.includes('blame')) {
-            this._caches.blame?.deleteByKeyPrefix(repoPath, prefix);
-        }
-        if (!types.length || types.includes('diff')) {
-            this._caches.diff?.deleteByKeyPrefix(repoPath, prefix);
-        }
-        if (!types.length || types.includes('fileLog')) {
-            this._caches.fileLog?.deleteByKeyPrefix(repoPath, prefix);
-        }
-    }
-    registerRepoPath(repoPath, gitDir) {
-        const normalizedPath = getRepositoryOrWorktreePath(repoPath);
-        const commonPath = gitDir.commonUri != null ? getCommonRepositoryPath(gitDir.commonUri) : normalizedPath;
-        this._commonPathRegistry.set(normalizedPath, commonPath);
-        let worktrees = this._worktreesByCommonPath.get(commonPath);
-        if (worktrees == null) {
-            worktrees = new Set();
-            this._worktreesByCommonPath.set(commonPath, worktrees);
-        }
-        worktrees.add(normalizedPath);
-    }
-    /**
-     * Symmetric companion to `registerRepoPath`. Clears cache entries specific to `repoPath`
-     * and removes the path from the registry.
-     *
-     * Call this when a worktree is deleted or a repo is closed so stale registry entries
-     * and derived cache entries don't persist.
-     *
-     * Targeted — does NOT cascade to sibling worktrees sharing the same commonPath. The
-     * shared commonPath entry in each shared cache is only evicted when unregistering the
-     * last remaining worktree for that commonPath (otherwise siblings still depend on it).
-     *
-     * Uses soft-invalidate where supported so any in-flight factory/mapper keeps its abort
-     * wiring intact — a caller whose signal aborts after unregister can still propagate
-     * cancellation into the underlying work rather than leaving it orphaned. Controller-backed
-     * entries self-evict on settle; plain `.set()`-based entries hard-delete immediately.
-     *
-     * Cache eviction is a no-op if `repoPath` is not registered, but the status clock is advanced
-     * unconditionally (a fresh registration must not let a post-reopen read join a pre-close one).
-     */
-    unregisterRepoPath(repoPath) {
-        // Advance the status clock on close so a status read still in flight from this registration can't be
-        // joined by a read issued after the path is reopened (which would otherwise reuse the same generation).
-        this.incrementStatusGeneration(repoPath);
-        // Advance the close clock so an async step that captured it before its read (see `getCloseGeneration`)
-        // can tell its target went away mid-flight.
-        this._closeGenerations.set(repoPath, this.getCloseGeneration(repoPath) + 1);
-        const commonPath = this._commonPathRegistry.get(repoPath) ?? repoPath;
-        const worktrees = this._worktreesByCommonPath.get(commonPath);
-        // After removing repoPath, would the commonPath have any worktrees left?
-        const isLastWorktree = worktrees == null || worktrees.size <= 1;
-        // Targeted per-repoPath cleanup: for per-worktree caches, clear this repoPath's
-        // entries. For shared caches, clear this repoPath's mapper entry (if it's a worktree
-        // distinct from commonPath); only evict the shared commonPath entry when this was the
-        // last worktree — otherwise siblings still rely on the shared data.
-        for (const key of Object.keys(this._caches)) {
-            const cache = this._caches[key];
-            if (cache == null)
-                continue;
-            // Prefer `invalidate` so in-flight abort wiring survives until the factory settles;
-            // fall back to `delete` for plain `Map`-typed caches that don't track promises.
-            const invalidate = cache.invalidate;
-            const evict = typeof invalidate === 'function'
-                ? (k) => invalidate.call(cache, k)
-                : (k) => cache.delete(k);
-            if (sharedCacheKeys.has(key)) {
-                if (repoPath !== commonPath) {
-                    evict(repoPath);
-                }
-                if (isLastWorktree) {
-                    evict(commonPath);
-                }
-            }
-            else {
-                evict(repoPath);
-            }
-        }
-        // Shared, commonPath-keyed like `gkConfigMap` — only evict once no worktree still depends on it.
-        if (isLastWorktree) {
-            this._gkConfigMergeSnapshots.delete(commonPath);
-        }
-        this._commonPathRegistry.delete(repoPath);
-        if (worktrees != null) {
-            worktrees.delete(repoPath);
-            if (worktrees.size === 0) {
-                this._worktreesByCommonPath.delete(commonPath);
-            }
-        }
-    }
-    reset() {
-        // Advance the close clock BEFORE dropping the registry it reads from. Advancing rather than
-        // clearing is the point: an async step that captured a generation must see a mismatch and bail,
-        // where a cleared map would hand it a fresh `0` that matches and let it repopulate what was just
-        // torn down. Union of registered paths and any already carrying a generation, mirroring
-        // `incrementStatusGenerations`.
-        for (const path of new Set([...this._commonPathRegistry.keys(), ...this._closeGenerations.keys()])) {
-            this._closeGenerations.set(path, this.getCloseGeneration(path) + 1);
-        }
-        this._commonPathRegistry.clear();
-        this._worktreesByCommonPath.clear();
-        this._statusGenerations.clear();
-        this._gkConfigMergeSnapshots.clear();
-        this._gkConfigReconciler = undefined;
-        this._caches = createEmptyCaches();
-    }
-    onRepositoryChanged(repoPath, changes) {
-        const changesSet = new Set(changes);
-        const hasAny = (...c) => c.some(ch => changesSet.has(ch));
-        if (hasAny('unknown', 'closed')) {
-            this.unregisterRepoPath(repoPath);
-            return;
-        }
-        // Advance the status clock (see {@link getStatusGeneration}) for changes that alter `git status` output but
-        // aren't mapped to the `'status'` cache type below: files (index/head/heads), untracked set (ignores/config),
-        // ahead/behind (remotes). Paused-op changes advance it too, but via `clearCaches('status')` (see below) —
-        // listing them here as well would double-increment the clock for a single change.
-        if (hasAny('index', 'head', 'heads', 'remotes', 'ignores', 'config')) {
-            this.incrementStatusGeneration(repoPath);
-        }
-        const types = new Set();
-        if (hasAny('head')) {
-            types.add('branch');
-        }
-        if (hasAny('index', 'heads', 'pausedOp')) {
-            types.add('blame');
-            types.add('diff');
-            types.add('fileLog');
-        }
-        if (hasAny('index')) {
-            types.add('tracking');
-        }
-        if (hasAny('config')) {
-            types.add('config');
-        }
-        if (hasAny('heads')) {
-            types.add('branches');
-            types.add('contributors');
-            types.add('worktrees');
-        }
-        if (hasAny('remotes')) {
-            types.add('branches');
-            types.add('contributors');
-            types.add('remotes');
-            types.add('worktrees');
-        }
-        if (hasAny('ignores')) {
-            types.add('gitignore');
-        }
-        if (hasAny('gkConfig')) {
-            // Handled separately (not folded into `types`/`clearCaches` below) — a gk write is usually a
-            // bookkeeping timestamp that can't affect `baseBranchName`/`branchOverviews`, so this reconciles
-            // down to only the keys that actually changed instead of coarsely clearing both on every write.
-            this.handleGkConfigChanged(repoPath);
-        }
-        if (hasAny('lastFetched')) {
-            types.add('lastFetched');
-        }
-        if (hasAny('remoteProviders')) {
-            types.add('providers');
-        }
-        if (hasAny('cherryPick', 'merge', 'rebase', 'revert', 'pausedOp')) {
-            types.add('branch');
-            types.add('status');
-        }
-        if (hasAny('stash')) {
-            types.add('stashes');
-        }
-        if (hasAny('tags')) {
-            types.add('tags');
-        }
-        if (hasAny('worktrees')) {
-            types.add('worktrees');
-        }
-        if (types.size) {
-            this.clearCaches(repoPath, ...types);
-        }
-    }
-    /**
-     * Handles a watcher-observed `'gkConfig'` change. Always evicts the cached bulk map (forcing the
-     * next read to hit disk). If a reconciler is registered (see {@link setGkConfigReconciler}),
-     * defers to it instead of coarsely clearing `baseBranchName`/`branchOverviews` — it re-reads the
-     * map and diffs it against the snapshot captured here (i.e. as it stood right before this change),
-     * cascading only the refs whose merge-relevant keys actually changed. Falls back to the coarse
-     * clear when no reconciler is registered (e.g. the GitHub provider) so nothing can go stale.
-     */
-    handleGkConfigChanged(repoPath) {
-        const commonPath = this.getCommonPath(repoPath);
-        // Hard-delete rather than `evictShared`'s soft-invalidate: the reconcile below needs a
-        // point-in-time read of the post-change file, and a soft-invalidated entry stays joinable — the
-        // re-read would ride a bulk read that started before this change and diff it as unchanged.
-        // Same reasoning as `refs.ts`'s `force: true` path and `deleteGkConfig`'s own hard delete.
-        this._caches.gkConfigMap?.delete(commonPath);
-        if (this._gkConfigReconciler == null) {
-            this.clearCaches(repoPath, 'gkConfig');
-            return;
-        }
-        const priorSnapshot = this._gkConfigMergeSnapshots.get(commonPath);
-        // Fire-and-forget, but the outcome still decides whether the coarse clear is owed: a reconcile that
-        // FAILED leaves every derived cache holding pre-change values with nothing else to correct them, so
-        // it falls back to the blunt behavior that registering a reconciler replaced. Kept here rather than
-        // in the reconciler so a bail path added later can't silently skip it — the return type makes each
-        // one say what it did.
-        void Promise.resolve(this._gkConfigReconciler(repoPath, priorSnapshot)).then(outcome => {
-            if (outcome === 'failed') {
-                this.clearCaches(repoPath, 'gkConfig');
-            }
-        }, 
-        // An exception escaping the reconciler is a failure by definition — and one its own `catch`
-        // never saw, so nothing else will have cascaded.
-        () => this.clearCaches(repoPath, 'gkConfig'));
-    }
-    /** Hard-evicts the cached bulk `.git/gk/config` map so the next read hits disk. */
-    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));
-    }
-    getBranches(repoPath, factory, mapper, cancellation) {
-        const commonPath = this.getCommonPath(repoPath);
-        // Register this caller with the shared factory's aggregate so that invariant 3
-        // (factory aborts iff every waiter has aborted) holds for same-`repoPath` cache hits too.
-        // The returned wrapped promise is deliberately discarded — we use the raw cached inner
-        // below to build the mapped entry. Swallow any rejection on this dangling reference so
-        // it doesn't surface as an unhandled rejection; the real caller-facing promise (via
-        // `branches.getOrCreate` below) is where caller cancellation flows to.
-        const registration = this.sharedBranches.getOrCreate(commonPath, (cacheable, signal) => {
-            const p = Promise.resolve(factory(commonPath, cacheable, signal));
-            // On factory invalidation, propagate to the derived per-worktree mapper entries
-            // via soft-invalidate — existing waiters on the mapper complete, and the entry
-            // self-evicts on mapper settle so the next callers build fresh derived entries.
-            void p
-                .finally(() => {
-                if (cacheable.invalidated) {
-                    this.branches.invalidate(commonPath);
-                    for (const worktreePath of this.getWorktreePaths(commonPath)) {
-                        this.branches.invalidate(worktreePath);
-                    }
-                }
-            })
-                // Swallow the cleanup chain's rejection so a rejected factory (e.g. cancellation)
-                // doesn't surface as an unhandled rejection; the caller-facing promise handles it.
-                .catch(() => { });
-            return p;
-        }, cancellation);
-        void registration.catch(() => { });
-        // Build the per-`repoPath` mapped entry through `getOrCreate` so mapper internal git
-        // work (e.g. `getCurrentBranchReferenceCore`) runs under a mapper-level aggregate signal
-        // separate from the factory's. Subsequent same-`repoPath` cache hits register with this
-        // aggregate too — invariant 2/3 hold at the mapper level.
-        return this.branches.getOrCreate(repoPath, (_cacheable, mapperSignal) => {
-            // After `getOrCreate` above, `sharedBranches[commonPath]` holds the raw inner
-            // factory promise. Fall back to `registration` in the paranoid case where a
-            // synchronously-rejected factory got auto-evicted before we retrieve it.
-            const rawShared = this.sharedBranches.get(commonPath) ?? registration;
-            return Promise.resolve(rawShared).then(shared => mapper(shared, repoPath, commonPath, mapperSignal));
-        }, cancellation);
-    }
-    static globalConfigKey = '';
-    getConfig(repoPath, key, factory) {
-        const cacheKey = repoPath != null ? this.getCommonPath(repoPath) : Cache.globalConfigKey;
-        const result = this.configKeys.get(cacheKey, key);
-        if (result != null)
-            return result;
-        const factoryPromise = Promise.resolve(factory());
-        this.configKeys.set(cacheKey, key, factoryPromise);
-        return factoryPromise;
-    }
-    getConfigRegex(repoPath, pattern, factory) {
-        const cacheKey = repoPath != null ? this.getCommonPath(repoPath) : Cache.globalConfigKey;
-        const result = this.configPatterns.get(cacheKey, pattern);
-        if (result != null)
-            return result;
-        const factoryPromise = Promise.resolve(factory());
-        this.configPatterns.set(cacheKey, pattern, factoryPromise);
-        return factoryPromise;
-    }
-    deleteConfig(repoPath, key) {
-        const cacheKey = repoPath != null ? this.getCommonPath(repoPath) : Cache.globalConfigKey;
-        this._caches.configKeys?.delete(cacheKey, key);
-        this._caches.configPatterns?.delete(cacheKey);
-    }
-    /**
-     * The whole `.git/gk/config` is read once and cached as a single map per commonPath; per-key and
-     * 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
-     * `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);
-            // Seed the reconcile baseline on first observation only. Refreshes belong to
-            // `reconcileGkConfigMap` (after it has cascaded) and `recordGkConfigWrite` (our own writes):
-            // an incidental read that happens to land between an external write and the watcher event
-            // would otherwise advance the baseline to the post-change value, so the reconcile would diff
-            // that value against itself and silently drop the change.
-            if (!this._gkConfigMergeSnapshots.has(commonPath)) {
-                this._gkConfigMergeSnapshots.set(commonPath, this.extractMergeRelevantGkConfig(map));
-            }
-            return map;
-        });
-    }
-    /** Extracts the subset of a gk config map whose keys participate in the `branchOverviews`/`baseBranchName` lineage. */
-    extractMergeRelevantGkConfig(map) {
-        const subset = new Map();
-        for (const [key, value] of map) {
-            if (branchOverviewGkConfigKeysRegex.test(key)) {
-                subset.set(key, value);
-            }
-        }
-        return subset;
-    }
-    /**
-     * Clears the cached `.git/gk/config` map and invalidates the derived caches
-     * (`baseBranchName`/`branchOverviews`) for the written key's ref.
-     *
-     * @param options.skipInvalidation Downstream caches the caller wants preserved despite this
-     * write. Use when the value being written is exactly what was just resolved — e.g. the Tier 2
-     * `storeMergeTargetBranchName` self-write inside `getBranchContributionsOverview` (skip
-     * `'branchOverviews'`) or the Tier 3 `storeBaseBranchName` self-write inside `getBaseBranchName`
-     * (skip both `'baseBranchName'` and `'branchOverviews'`). The bulk `gkConfigMap` map always
-     * invalidates so subsequent reads see the new value.
-     */
-    deleteGkConfig(repoPath, key, options) {
-        const commonPath = this.getCommonPath(repoPath);
-        this._caches.gkConfigMap?.delete(commonPath);
-        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.
-     */
-    recordGkConfigWrite(repoPath, key, value) {
-        if (!branchOverviewGkConfigKeysRegex.test(key))
-            return;
-        const commonPath = this.getCommonPath(repoPath);
-        const snapshot = this._gkConfigMergeSnapshots.get(commonPath);
-        if (snapshot == null)
-            return;
-        // Copy-on-write: a reconcile in flight is holding this map as its `priorSnapshot` baseline, so
-        // mutating it in place would silently move that baseline mid-diff.
-        const next = new Map(snapshot);
-        if (value == null) {
-            next.delete(key);
-        }
-        else {
-            next.set(key, value);
-        }
-        this._gkConfigMergeSnapshots.set(commonPath, next);
-    }
-    /**
-     * Registers the reconciler invoked by {@link handleGkConfigChanged} on a watcher-observed
-     * `'gkConfig'` change. Only one reconciler is kept — later registrations replace earlier ones,
-     * which is harmless since every CLI config sub-provider sharing this `Cache` reconciles the same
-     * underlying `.git/gk/config` file identically.
-     */
-    setGkConfigReconciler(reconciler) {
-        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
-     * `baseBranchName`/`branchOverviews` for every ref whose merge-relevant key actually changed.
-     * `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);
-        if (priorSnapshot == null) {
-            this.evictShared('baseBranchName', repoPath);
-            this.evictShared('branchOverviews', repoPath);
-            return true;
-        }
-        let changed = false;
-        for (const key of new Set([...priorSnapshot.keys(), ...newSubset.keys()])) {
-            if (priorSnapshot.get(key) !== newSubset.get(key)) {
-                changed = true;
-                this.cascadeGkConfigKeyChange(commonPath, key);
-            }
-        }
-        return changed;
-    }
-    /**
-     * Shared per-ref cascade for a changed `branch.<ref>.gk-...` key: invalidates `baseBranchName` (for
-     * `gk-merge-base`) and `branchOverviews` (for any merge-relevant key), honoring `skipInvalidation`.
-     * Used by both a direct write (`deleteGkConfig`) and a reconciled external change
-     * (`reconcileGkConfigMap`). No-ops for keys outside the merge-relevant subset.
-     */
-    cascadeGkConfigKeyChange(commonPath, key, skip) {
-        const refMatch = key.match(branchOverviewGkConfigKeysRegex);
-        if (refMatch == null)
-            return;
-        const ref = refMatch[1];
-        // `getBaseBranchName` reads `branch.<ref>.gk-merge-base` and caches the resolved value
-        // per-ref. A change to that key must invalidate the cached base or Tier 3 of
-        // `getBranchContributionsOverview` will resolve `mergeTarget` against the pre-change value.
-        if (key.endsWith('.gk-merge-base') && !skip?.includes('baseBranchName')) {
-            this._caches.baseBranchName?.delete(commonPath, ref);
-        }
-        if (skip?.includes('branchOverviews'))
-            return;
-        // When the change affects a branch's merge-target/base lineage, invalidate that branch's
-        // cached overviews so subsequent reads pick up the new stored value rather than stale data.
-        // `getBranchContributionsOverview` keys `branchOverviews` by `${ref}|${mergeTarget}`, so
-        // invalidate every entry for the affected ref regardless of which target it resolved to.
-        // Uses `invalidateByKeyPrefix` (not `deleteByKeyPrefix`) so an in-flight factory is still
-        // shared with new callers instead of triggering a duplicate fetch.
-        //
-        // Sibling worktrees get their own bucket, not just the shared one: `getSharedOrCreateWithKey`
-        // stores a per-worktree *mapped* entry under that worktree's own path, and prefix-invalidation
-        // only reaches one bucket. The in-flight case self-propagates on settle, but an already-settled
-        // overview would otherwise survive here — which the coarse `evictShared` path this replaced did
-        // clear, since it iterated the worktrees.
-        this._caches.branchOverviews?.invalidateByKeyPrefix(commonPath, `${ref}|`);
-        for (const worktreePath of this.getWorktreePaths(commonPath)) {
-            if (worktreePath === commonPath)
-                continue;
-            this._caches.branchOverviews?.invalidateByKeyPrefix(worktreePath, `${ref}|`);
-        }
-    }
-    async getBranchOverview(repoPath, cacheKey, factory, options) {
-        return this.getSharedOrCreateWithKey(this.branchOverviews, repoPath, cacheKey, factory, (data, newRepoPath) => data == null
-            ? data
-            : {
-                ...data,
-                repoPath: newRepoPath,
-                contributors: data.contributors.map(c => c.withRepoPath(newRepoPath)),
-            }, options);
-    }
-    async getContributors(repoPath, cacheKey, factory, options) {
-        return this.getSharedOrCreateWithKey(this.contributors, repoPath, cacheKey, factory, (data, newRepoPath) => ({
-            ...data,
-            contributors: data.contributors.map(c => c.withRepoPath(newRepoPath)),
-        }), options);
-    }
-    async getContributorsLite(repoPath, cacheKey, factory, options) {
-        return this.getSharedOrCreateWithKey(this.contributorsLite, repoPath, cacheKey, factory, (data, newRepoPath) => data.map(c => c.withRepoPath(newRepoPath)), options);
-    }
-    getContributorsStats(repoPath, cacheKey, factory, options) {
-        return this.getSharedSimpleWithKey(this.contributorsStats, repoPath, cacheKey, factory, options);
-    }
-    getBaseBranchName(repoPath, ref, factory, cancellation) {
-        return this.getSharedSimpleWithKey(this.baseBranchName, repoPath, ref, factory, {
-            // A bounded ceiling, because the eviction signals can't cover every way a base changes. The
-            // `'branches'` cascade deliberately doesn't clear this — a tip move can't change a base, and
-            // re-deriving per commit is the cost this exists to avoid — but that leaves a hole: a branch
-            // deleted and recreated OUTSIDE GitLens, and never checked out, emits only `heads`. A base
-            // derived as "none" before that would otherwise stay "none" for the session.
-            //
-            // `createTTL`, NOT `accessTTL`: the sliding variant resets on every read, so a branch card
-            // polling this entry would hold it alive forever and never re-derive — the exact case the
-            // ceiling exists for. Absolute from creation bounds staleness regardless of read frequency.
-            createTTL: baseBranchNameTTL,
-            cancellation: cancellation,
-        });
-    }
-    /**
-     * Clears the cached base branch for `ref`. Call from ops that create/rename/delete a branch — the
-     * `'branches'` cascade no longer clears these, since tip movement can't change a branch's base.
-     *
-     * Only clears the cache. A branch's base is *persisted* as `branch.<ref>.gk-merge-base` and read back
-     * before the reflog fallback, so an op that ends a branch's identity under a name must drop or move
-     * that key too (`removeGkConfigBranchSection`/`renameGkConfigBranchSection`) — otherwise the
-     * re-derivation this triggers just reads the stale value straight back.
-     */
-    deleteBaseBranchName(repoPath, ref) {
-        this._caches.baseBranchName?.delete(this.getCommonPath(repoPath), ref);
-    }
-    getBranchMergedStatus(repoPath, cacheKey, factory, cancellation) {
-        return this.getSharedOrCreateWithKey(this.branchMergedStatus, repoPath, cacheKey, factory, (data, newRepoPath) => {
-            if (!data.merged)
-                return data;
-            if (data.localBranchOnly == null)
-                return data;
-            const lbo = data.localBranchOnly;
-            return {
-                ...data,
-                localBranchOnly: createReference(lbo.ref, newRepoPath, {
-                    id: getBranchId(newRepoPath, lbo.remote, lbo.name),
-                    refType: 'branch',
-                    name: lbo.name,
-                    remote: lbo.remote,
-                    upstream: lbo.upstream,
-                    sha: lbo.sha,
-                }),
-            };
-        }, { cancellation: cancellation });
-    }
-    getBranchMetadataMap(repoPath, factory) {
-        return this.getSharedSimple(this.branchMetadataMap, repoPath, factory);
-    }
-    getDefaultBranchName(repoPath, remote, factory, cancellation) {
-        return this.getSharedSimpleWithKey(this.defaultBranchName, repoPath, remote, factory, {
-            cancellation: cancellation,
-        });
-    }
-    /** Clears the cached default branch for one `remote` key (the networked lookup or its `:local` variant). */
-    deleteDefaultBranchName(repoPath, remote) {
-        this._caches.defaultBranchName?.delete(this.getCommonPath(repoPath), remote);
-    }
-    getInitialCommitSha(repoPath, factory) {
-        return this.getSharedSimple(this.initialCommitSha, repoPath, factory);
-    }
-    getLastFetchedTimestamp(repoPath, factory) {
-        return this.getSharedSimple(this.lastFetched, repoPath, factory);
-    }
-    getRefs(repoPath, factory, cancellation) {
-        // Raw ref records are repoPath-agnostic (no per-worktree binding to remap), so we key only
-        // by commonPath and skip the per-worktree mapper that `getBranches`/`getTags` need.
-        const commonPath = this.getCommonPath(repoPath);
-        return this.refs.getOrCreate(commonPath, (cacheable, signal) => Promise.resolve(factory(commonPath, cacheable, signal)), cancellation);
-    }
-    getRefTips(repoPath, factory, cancellation) {
-        const commonPath = this.getCommonPath(repoPath);
-        return this.refTips.getOrCreate(commonPath, (cacheable, signal) => Promise.resolve(factory(commonPath, cacheable, signal)), cancellation);
-    }
-    async getRemotes(repoPath, factory, cancellation) {
-        return this.getSharedOrCreate(this.remotes, repoPath, factory, (data, newRepoPath) => data.map(r => r.withRepoPath(newRepoPath)), cancellation);
-    }
-    async getStash(repoPath, cacheKey, factory, options) {
-        return this.getSharedOrCreateWithKey(this.stashes, repoPath, cacheKey, factory, (data, newRepoPath) => ({
-            repoPath: newRepoPath,
-            stashes: new Map(Array.from(data.stashes.entries(), ([sha, s]) => [
-                sha,
-                s.withRepoPath(newRepoPath),
-            ])),
-        }), options);
-    }
-    async getTags(repoPath, factory, cancellation) {
-        return this.getSharedOrCreate(this.tags, repoPath, factory, (data, newRepoPath) => ({ ...data, values: data.values.map(t => t.withRepoPath(newRepoPath)) }), cancellation);
-    }
-    async getWorktrees(repoPath, factory, cancellation) {
-        return this.getSharedOrCreate(this.worktrees, repoPath, factory, (data, newRepoPath) => data.map(w => w.withRepoPath(newRepoPath)), cancellation);
-    }
-    async getSharedOrCreate(cache, repoPath, factory, mapper, cancellation) {
-        const commonPath = this.getCommonPath(repoPath);
-        // Always register this caller with the shared factory's aggregate so same-`repoPath` and
-        // worktree-distinct concurrent callers both contribute — invariant 3 (factory aborts iff
-        // every waiter aborts) holds uniformly. The wrapped return is our caller-facing promise
-        // for the commonPath-keyed branch; the per-worktree branch uses `raceWithSignal` below.
-        const sharedPromise = cache.getOrCreate(commonPath, (cacheable, signal) => {
-            const p = Promise.resolve(factory(commonPath, cacheable, signal));
-            // On factory invalidation (without rejection), propagate to the derived per-worktree
-            // mapper entries so they don't persist past the shared factory's settle. Mapper
-            // entries cached via `cache.set()` have no controller, so `invalidate` hard-deletes.
-            void p
-                .finally(() => {
-                if (cacheable.invalidated) {
-                    for (const worktreePath of this.getWorktreePaths(commonPath)) {
-                        if (worktreePath === commonPath)
-                            continue;
-                        cache.invalidate(worktreePath);
-                    }
-                }
-            })
-                // Swallow the cleanup chain's rejection so a rejected factory (e.g. cancellation)
-                // doesn't surface as an unhandled rejection; the caller-facing promise handles it.
-                .catch(() => { });
-            return p;
-        }, cancellation);
-        // Swallow any rejection on the registration wrapper so it isn't surfaced as an unhandled
-        // rejection when we discard it below (existing-mapper path). The real caller-facing
-        // promise is the returned value.
-        void sharedPromise.catch(() => { });
-        if (commonPath !== repoPath) {
-            // Reuse the cached mapped entry for this worktree if present; otherwise derive it off
-            // the raw inner shared promise so subsequent cache hits don't inherit the first
-            // caller's signal wrap.
-            const existing = cache.get(repoPath);
-            if (existing != null) {
-                return cancellation != null ? raceWithSignal(existing, cancellation) : existing;
-            }
-            const rawShared = cache.get(commonPath) ?? sharedPromise;
-            const mappedPromise = Promise.resolve(rawShared).then(data => mapper(data, repoPath));
-            cache.set(repoPath, mappedPromise);
-            return cancellation != null ? raceWithSignal(mappedPromise, cancellation) : mappedPromise;
-        }
-        return sharedPromise;
-    }
-    async getSharedOrCreateWithKey(cache, repoPath, cacheKey, factory, mapper, options) {
-        const commonPath = this.getCommonPath(repoPath);
-        const cancellation = options?.cancellation;
-        // Always register with the shared factory's aggregate (see `getSharedOrCreate` comment).
-        const sharedPromise = cache.getOrCreate(commonPath, cacheKey, (cacheable, signal) => {
-            const p = Promise.resolve(factory(commonPath, cacheable, signal));
-            // On factory invalidation (without rejection), propagate to the derived per-worktree
-            // mapper entries for this `cacheKey` so they don't persist past the shared factory's
-            // settle. Mapper entries cached via `cache.set()` have no controller, so `invalidate`
-            // hard-deletes.
-            void p
-                .finally(() => {
-                if (cacheable.invalidated) {
-                    for (const worktreePath of this.getWorktreePaths(commonPath)) {
-                        if (worktreePath === commonPath)
-                            continue;
-                        cache.invalidate(worktreePath, cacheKey);
-                    }
-                }
-            })
-                // Swallow the cleanup chain's rejection so a rejected factory (e.g. cancellation)
-                // doesn't surface as an unhandled rejection; the caller-facing promise handles it.
-                .catch(() => { });
-            return p;
-        }, options);
-        // Swallow any rejection on the registration wrapper so it isn't surfaced as an unhandled
-        // rejection when we discard it below (existing-mapper path).
-        void sharedPromise.catch(() => { });
-        if (commonPath !== repoPath) {
-            const existing = cache.get(repoPath, cacheKey);
-            if (existing != null) {
-                return cancellation != null ? raceWithSignal(existing, cancellation) : existing;
-            }
-            const rawShared = cache.get(commonPath, cacheKey) ?? sharedPromise;
-            const mappedPromise = Promise.resolve(rawShared).then(data => mapper(data, repoPath));
-            cache.set(repoPath, cacheKey, mappedPromise, options);
-            return cancellation != null ? raceWithSignal(mappedPromise, cancellation) : mappedPromise;
-        }
-        return sharedPromise;
-    }
-    async getSharedSimple(cache, repoPath, 
-    // `cacheable` is forwarded so a factory can refuse the entry when the read FAILED rather than
-    // genuinely produced nothing — see `getSharedSimpleWithKey` for why that distinction matters.
-    factory) {
-        const commonPath = this.getCommonPath(repoPath);
-        // `PromiseMap.getOrCreate(key, factory, cancellation?)` and
-        // `PromiseCache.getOrCreate(key, factory, options?)` have different 3rd-argument shapes,
-        // so we dispatch on cache type. Both register a `CacheController` so `invalidate` works.
-        if (cache instanceof PromiseCache) {
-            return cache.getOrCreate(commonPath, cacheable => Promise.resolve(factory(commonPath, cacheable)));
-        }
-        return cache.getOrCreate(commonPath, cacheable => Promise.resolve(factory(commonPath, cacheable)));
-    }
-    async getSharedSimpleWithKey(cache, repoPath, cacheKey, 
-    // `cacheable` is forwarded so a factory can distinguish "the answer is genuinely nothing" from "the
-    // read failed": callers here set no TTL by default, so a failure resolved as `undefined` would
-    // otherwise be served as a real answer until something explicitly evicts it.
-    factory, options) {
-        const commonPath = this.getCommonPath(repoPath);
-        return cache.getOrCreate(commonPath, cacheKey, (cacheable, signal) => Promise.resolve(factory(commonPath, cacheable, signal)), options);
-    }
+	return {
+		baseBranchName: void 0,
+		bestRemotes: void 0,
+		blame: void 0,
+		branch: void 0,
+		branchMergedStatus: void 0,
+		branchMetadataMap: void 0,
+		branchOverviews: void 0,
+		branches: void 0,
+		commit: void 0,
+		commitCount: void 0,
+		fileExistence: void 0,
+		ignoreRevsFile: void 0,
+		leftRightCommitCount: void 0,
+		mergeBase: void 0,
+		configKeys: void 0,
+		configPatterns: void 0,
+		conflictDetection: void 0,
+		diff: void 0,
+		fileLog: void 0,
+		contributors: void 0,
+		contributorsLite: void 0,
+		contributorsStats: void 0,
+		currentBranchReference: void 0,
+		currentUser: void 0,
+		defaultBranchName: void 0,
+		gitDir: void 0,
+		gitIgnore: void 0,
+		gitResults: void 0,
+		gkConfigMap: void 0,
+		initialCommitSha: void 0,
+		lastFetched: void 0,
+		logShas: void 0,
+		pausedOperationStatus: void 0,
+		resolvedRevisions: void 0,
+		reachability: void 0,
+		refs: void 0,
+		refTips: void 0,
+		remotes: void 0,
+		sharedBranches: void 0,
+		stashes: void 0,
+		tags: void 0,
+		trackedPaths: void 0,
+		worktrees: void 0
+	};
 }
-__decorate([
-    debug({ onlyExit: true })
-], Cache.prototype, "clearCaches", null);
-__decorate([
-    debug({ onlyExit: true })
-], Cache.prototype, "unregisterRepoPath", null);
-__decorate([
-    debug({ onlyExit: true })
-], Cache.prototype, "reset", null);
-__decorate([
-    debug({ onlyExit: true })
-], Cache.prototype, "onRepositoryChanged", null);
+var Cache = class Cache {
+	_caches = createEmptyCaches();
+	_commonPathRegistry = /* @__PURE__ */ new Map();
+	/** Reverse index: commonPath → set of worktree repoPaths that share it */
+	_worktreesByCommonPath = /* @__PURE__ */ new Map();
+	/** Monotonic per-worktree "status clock" — see {@link getStatusGeneration}. */
+	_statusGenerations = /* @__PURE__ */ new Map();
+	/** 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".
+	*/
+	_gkConfigMergeSnapshots = /* @__PURE__ */ new Map();
+	/**
+	* Reconciler registered by the CLI config sub-provider (see {@link setGkConfigReconciler}),
+	* invoked on a watcher-observed `'gkConfig'` change instead of the coarse `clearCaches(repoPath,
+	* 'gkConfig')` cascade. `undefined` (e.g. the GitHub provider, which has no `.git/gk/config`)
+	* falls back to the coarse clear.
+	*/
+	_gkConfigReconciler;
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	dispose() {
+		this.reset();
+	}
+	/** Resource usage retained by instantiated sub-caches and their bookkeeping maps. */
+	getResourceUsage() {
+		const usage = {};
+		for (const [name, cache] of Object.entries(this._caches)) if (cache != null) usage[`cache.${name}.entries.count`] = cache instanceof RepoPromiseCacheMap ? cache.entryCount : cache.size;
+		usage["cache.commonPathRegistry.entries.count"] = this._commonPathRegistry.size;
+		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;
+		return usage;
+	}
+	get bestRemotes() {
+		return this._caches.bestRemotes ??= new PromiseMap();
+	}
+	get blame() {
+		return this._caches.blame ??= new RepoPromiseCacheMap({
+			createTTL: 6e5,
+			capacity: 50
+		});
+	}
+	get diff() {
+		return this._caches.diff ??= new RepoPromiseCacheMap({
+			createTTL: 6e5,
+			capacity: 50
+		});
+	}
+	get fileLog() {
+		return this._caches.fileLog ??= new RepoPromiseCacheMap({
+			createTTL: 6e5,
+			capacity: 50
+		});
+	}
+	get baseBranchName() {
+		return this._caches.baseBranchName ??= new RepoPromiseCacheMap();
+	}
+	get branch() {
+		return this._caches.branch ??= new PromiseMap();
+	}
+	get branchMergedStatus() {
+		return this._caches.branchMergedStatus ??= new RepoPromiseCacheMap({
+			createTTL: 18e5,
+			accessTTL: 36e5,
+			capacity: 100
+		});
+	}
+	get branchMetadataMap() {
+		return this._caches.branchMetadataMap ??= new PromiseMap();
+	}
+	get branchOverviews() {
+		return this._caches.branchOverviews ??= new RepoPromiseCacheMap({ accessTTL: 36e5 });
+	}
+	get branches() {
+		return this._caches.branches ??= new PromiseMap();
+	}
+	/**
+	* Internal cache for raw shared branch data (keyed by commonPath)
+	* Separate from branches cache because branches need to be mapped for each worktree
+	*/
+	get sharedBranches() {
+		return this._caches.sharedBranches ??= new PromiseMap();
+	}
+	get configKeys() {
+		return this._caches.configKeys ??= new RepoPromiseCacheMap({ createTTL: 3e4 });
+	}
+	get configPatterns() {
+		return this._caches.configPatterns ??= new RepoPromiseCacheMap({ createTTL: 3e4 });
+	}
+	get gkConfigMap() {
+		return this._caches.gkConfigMap ??= new PromiseMap();
+	}
+	get currentBranchReference() {
+		return this._caches.currentBranchReference ??= new PromiseCache();
+	}
+	setCurrentBranchReferenceIfAbsent(worktreePath, reference) {
+		if (this.currentBranchReference.get(worktreePath) == null) this.currentBranchReference.set(worktreePath, Promise.resolve(reference));
+	}
+	get conflictDetection() {
+		return this._caches.conflictDetection ??= new RepoPromiseCacheMap({ createTTL: 3e4 });
+	}
+	get contributors() {
+		return this._caches.contributors ??= new RepoPromiseCacheMap({ accessTTL: 36e5 });
+	}
+	get contributorsLite() {
+		return this._caches.contributorsLite ??= new RepoPromiseCacheMap({ accessTTL: 36e5 });
+	}
+	get contributorsStats() {
+		return this._caches.contributorsStats ??= new RepoPromiseCacheMap({ accessTTL: 36e5 });
+	}
+	get currentUser() {
+		return this._caches.currentUser ??= /* @__PURE__ */ new Map();
+	}
+	get defaultBranchName() {
+		return this._caches.defaultBranchName ??= new RepoPromiseCacheMap();
+	}
+	get gitDir() {
+		return this._caches.gitDir ??= /* @__PURE__ */ new Map();
+	}
+	get gitIgnore() {
+		return this._caches.gitIgnore ??= /* @__PURE__ */ new Map();
+	}
+	get gitResults() {
+		return this._caches.gitResults ??= new RepoPromiseCacheMap({ capacity: 200 });
+	}
+	get initialCommitSha() {
+		return this._caches.initialCommitSha ??= new PromiseMap();
+	}
+	get lastFetched() {
+		return this._caches.lastFetched ??= new PromiseCache({ createTTL: 3e4 });
+	}
+	get leftRightCommitCount() {
+		return this._caches.leftRightCommitCount ??= new RepoPromiseCacheMap({
+			createTTL: 3e5,
+			capacity: 50
+		});
+	}
+	get commit() {
+		return this._caches.commit ??= new RepoPromiseCacheMap({
+			accessTTL: 36e5,
+			capacity: 100
+		});
+	}
+	get commitCount() {
+		return this._caches.commitCount ??= new RepoPromiseCacheMap({
+			accessTTL: 36e5,
+			capacity: 50
+		});
+	}
+	get mergeBase() {
+		return this._caches.mergeBase ??= new RepoPromiseCacheMap({
+			accessTTL: 36e5,
+			capacity: 50
+		});
+	}
+	get logShas() {
+		return this._caches.logShas ??= new RepoPromiseCacheMap({
+			createTTL: 3e5,
+			accessTTL: 3e4,
+			capacity: 5
+		});
+	}
+	get pausedOperationStatus() {
+		return this._caches.pausedOperationStatus ??= new PromiseMap();
+	}
+	get resolvedRevisions() {
+		return this._caches.resolvedRevisions ??= new RepoPromiseCacheMap({ capacity: 100 });
+	}
+	get refs() {
+		return this._caches.refs ??= new PromiseMap();
+	}
+	get refTips() {
+		return this._caches.refTips ??= new PromiseMap();
+	}
+	get reachability() {
+		return this._caches.reachability ??= new RepoPromiseCacheMap({
+			accessTTL: 36e5,
+			capacity: 25
+		});
+	}
+	get remotes() {
+		return this._caches.remotes ??= new PromiseMap();
+	}
+	get stashes() {
+		return this._caches.stashes ??= new RepoPromiseCacheMap({ accessTTL: 36e5 });
+	}
+	get tags() {
+		return this._caches.tags ??= new PromiseMap();
+	}
+	get fileExistence() {
+		return this._caches.fileExistence ??= new RepoPromiseCacheMap({
+			createTTL: 1e4,
+			capacity: 100,
+			expireOnError: true
+		});
+	}
+	get ignoreRevsFile() {
+		return this._caches.ignoreRevsFile ??= new PromiseCache({
+			accessTTL: 72e5,
+			expireOnError: true
+		});
+	}
+	get trackedPaths() {
+		return this._caches.trackedPaths ??= new RepoPromiseCacheMap({
+			createTTL: 6e4,
+			accessTTL: 3e4,
+			capacity: 200
+		});
+	}
+	get worktrees() {
+		return this._caches.worktrees ??= new PromiseMap();
+	}
+	clearCaches(repoPath, ...types) {
+		const keysToClear = /* @__PURE__ */ new Set();
+		if (!types.length) {
+			for (const key of Object.keys(this._caches)) keysToClear.add(key);
+			invalidateMemoized("providers");
+			this.incrementStatusGenerations(repoPath);
+		} else {
+			if (types.includes("blame")) keysToClear.add("blame");
+			if (types.includes("diff")) keysToClear.add("diff");
+			if (types.includes("fileLog")) keysToClear.add("fileLog");
+			if (types.includes("branch") || types.includes("branches")) {
+				keysToClear.add("branch");
+				keysToClear.add("branchOverviews");
+				keysToClear.add("commit");
+				keysToClear.add("commitCount");
+				keysToClear.add("conflictDetection");
+				keysToClear.add("currentBranchReference");
+				keysToClear.add("leftRightCommitCount");
+				keysToClear.add("mergeBase");
+				keysToClear.add("reachability");
+				keysToClear.add("resolvedRevisions");
+			}
+			if (types.includes("branch")) keysToClear.add("baseBranchName");
+			if (types.includes("branches")) {
+				keysToClear.add("branchMetadataMap");
+				keysToClear.add("branches");
+				keysToClear.add("sharedBranches");
+				keysToClear.add("defaultBranchName");
+				keysToClear.add("initialCommitSha");
+				keysToClear.add("logShas");
+				keysToClear.add("refs");
+				keysToClear.add("refTips");
+			}
+			if (types.includes("config")) {
+				keysToClear.add("baseBranchName");
+				keysToClear.add("configKeys");
+				keysToClear.add("configPatterns");
+				keysToClear.add("currentBranchReference");
+				keysToClear.add("currentUser");
+			}
+			if (types.includes("contributors")) {
+				keysToClear.add("branchOverviews");
+				keysToClear.add("contributors");
+				keysToClear.add("contributorsLite");
+				keysToClear.add("contributorsStats");
+			}
+			if (types.includes("gitignore")) keysToClear.add("gitIgnore");
+			if (types.includes("gkConfig")) {
+				keysToClear.add("gkConfigMap");
+				keysToClear.add("baseBranchName");
+				keysToClear.add("branchOverviews");
+			}
+			if (types.includes("lastFetched")) keysToClear.add("lastFetched");
+			if (types.includes("providers")) {
+				keysToClear.add("remotes");
+				keysToClear.add("bestRemotes");
+				invalidateMemoized("providers");
+			}
+			if (types.includes("remotes")) {
+				keysToClear.add("remotes");
+				keysToClear.add("bestRemotes");
+				keysToClear.add("defaultBranchName");
+			}
+			if (types.includes("stashes")) keysToClear.add("stashes");
+			if (types.includes("status")) {
+				keysToClear.add("pausedOperationStatus");
+				this.incrementStatusGenerations(repoPath);
+			}
+			if (types.includes("tags")) {
+				keysToClear.add("tags");
+				keysToClear.add("refs");
+				keysToClear.add("refTips");
+				keysToClear.add("commit");
+				keysToClear.add("commitCount");
+			}
+			if (types.includes("tracking")) {
+				keysToClear.add("fileExistence");
+				keysToClear.add("trackedPaths");
+			}
+			if (types.includes("worktrees")) keysToClear.add("worktrees");
+			if (types.some((t) => t !== "gitignore" && t !== "gkConfig" && t !== "providers")) keysToClear.add("gitResults");
+		}
+		for (const key of keysToClear) {
+			const cache = this._caches[key];
+			if (cache == null) continue;
+			if (repoPath == null) cache.clear();
+			else if (sharedCacheKeys.has(key)) this.evictShared(key, repoPath);
+			else cache.delete(repoPath);
+		}
+	}
+	/**
+	* Evicts a single shared (commonPath-keyed) cache entry for `repoPath` and its sibling worktrees.
+	* Prefers `invalidate` where supported so in-flight work is shared across new callers and
+	* self-evicts on settle rather than spawning a duplicate factory. `invalidate` does the right
+	* thing per-entry: entries with a `CacheController` (created via `getOrCreate`) are marked
+	* invalidated; entries without one (created via plain `.set()`, e.g. per-worktree mapper results)
+	* are hard-deleted. Caches that don't support `invalidate` fall back to `delete`.
+	*/
+	evictShared(key, repoPath) {
+		const cache = this._caches[key];
+		if (cache == null) return;
+		const commonPath = this.getCommonPath(repoPath);
+		const invalidate = cache.invalidate;
+		if (typeof invalidate === "function") {
+			invalidate.call(cache, commonPath);
+			for (const worktreePath of this.getWorktreePaths(commonPath)) {
+				if (worktreePath === commonPath) continue;
+				invalidate.call(cache, worktreePath);
+			}
+		} else {
+			cache.delete(commonPath);
+			for (const worktreePath of this.getWorktreePaths(commonPath)) {
+				if (worktreePath === commonPath) continue;
+				cache.delete(worktreePath);
+			}
+		}
+	}
+	/**
+	* Monotonic per-worktree counter, advanced whenever anything that can change `git status` output is
+	* observed. `git status` and its siblings are point-in-time reads of mutable state, so deduplicating them
+	* on repoPath alone is unsound — a run that started before a commit would satisfy a caller that arrived
+	* after it. Callers stamp their in-flight run with the generation it started in and refuse older joins.
+	* Kept per exact worktree path (never spread to the common path) and advanced on `unregisterRepoPath` so a
+	* read in flight from a prior registration can't be joined after a reopen.
+	*
+	* Note: a run that never settles wedges only its own generation's callers (a newer generation gets a fresh
+	* key). `git.run` recovers via its per-command timeout (default 60s); a hung `git.stream` is caught by the
+	* status provider's `raceWithTimeout` backstop (scaled to `advanced.git.timeout`; see
+	* `dedupeByStatusGeneration`), which rejects a wedged read so waiters unblock and a later caller retries.
+	*/
+	getStatusGeneration(repoPath) {
+		return this._statusGenerations.get(repoPath) ?? 0;
+	}
+	/** Advances the status clock — see {@link getStatusGeneration}. */
+	incrementStatusGeneration(repoPath) {
+		this._statusGenerations.set(repoPath, this.getStatusGeneration(repoPath) + 1);
+	}
+	/**
+	* Working-tree changes ride their own channel (`Repository.onDidChangeWorkingTree`), not
+	* `onRepositoryChanged` — an external `git restore <file>` may touch no `.git` path we classify — so
+	* they have to advance the status clock separately or a discard would never invalidate an in-flight read.
+	*/
+	onWorkingTreeChanged(repoPath) {
+		this.incrementStatusGeneration(repoPath);
+	}
+	/** Advances the status clock for one worktree, or for every known worktree when `repoPath` is undefined. */
+	incrementStatusGenerations(repoPath) {
+		if (repoPath != null) {
+			this.incrementStatusGeneration(repoPath);
+			return;
+		}
+		const paths = /* @__PURE__ */ new Set([...this._commonPathRegistry.keys(), ...this._statusGenerations.keys()]);
+		for (const path of paths) this.incrementStatusGeneration(path);
+	}
+	getCommonPath(repoPath) {
+		return this._commonPathRegistry.get(repoPath) ?? repoPath;
+	}
+	getWorktreePaths(commonPath) {
+		const worktrees = this._worktreesByCommonPath.get(commonPath);
+		return worktrees != null ? [...worktrees] : [];
+	}
+	isWorktree(repoPath) {
+		const commonPath = this._commonPathRegistry.get(repoPath);
+		return commonPath != null && commonPath !== repoPath;
+	}
+	/** Whether `repoPath` is currently registered (via {@link registerRepoPath}, not yet unregistered). */
+	isRegistered(repoPath) {
+		return this._commonPathRegistry.has(repoPath);
+	}
+	/**
+	* Monotonic per-path counter advanced whenever `repoPath` is unregistered (repo closed, worktree
+	* removed). Lets an async post-read step — e.g. the gk-config reconcile — detect that its target was
+	* closed (and possibly reopened) mid-flight and bail. Unlike an `isRegistered` check it doesn't
+	* require the caller to have registered in the first place, so it stays correct for consumers of
+	* this package that don't wire up the host's repo lifecycle.
+	*/
+	getCloseGeneration(repoPath) {
+		return this._closeGenerations.get(repoPath) ?? 0;
+	}
+	/** Clears file-scoped caches (blame, diff, fileLog) for a specific path within a repo */
+	clearForPath(repoPath, path, ...types) {
+		const prefix = `${normalizePath(path)}:`;
+		if (!types.length || types.includes("blame")) this._caches.blame?.deleteByKeyPrefix(repoPath, prefix);
+		if (!types.length || types.includes("diff")) this._caches.diff?.deleteByKeyPrefix(repoPath, prefix);
+		if (!types.length || types.includes("fileLog")) this._caches.fileLog?.deleteByKeyPrefix(repoPath, prefix);
+	}
+	registerRepoPath(repoPath, gitDir) {
+		const normalizedPath = getRepositoryOrWorktreePath(repoPath);
+		const commonPath = gitDir.commonUri != null ? getCommonRepositoryPath(gitDir.commonUri) : normalizedPath;
+		this._commonPathRegistry.set(normalizedPath, commonPath);
+		let worktrees = this._worktreesByCommonPath.get(commonPath);
+		if (worktrees == null) {
+			worktrees = /* @__PURE__ */ new Set();
+			this._worktreesByCommonPath.set(commonPath, worktrees);
+		}
+		worktrees.add(normalizedPath);
+	}
+	/**
+	* Symmetric companion to `registerRepoPath`. Clears cache entries specific to `repoPath`
+	* and removes the path from the registry.
+	*
+	* Call this when a worktree is deleted or a repo is closed so stale registry entries
+	* and derived cache entries don't persist.
+	*
+	* Targeted — does NOT cascade to sibling worktrees sharing the same commonPath. The
+	* shared commonPath entry in each shared cache is only evicted when unregistering the
+	* last remaining worktree for that commonPath (otherwise siblings still depend on it).
+	*
+	* Uses soft-invalidate where supported so any in-flight factory/mapper keeps its abort
+	* wiring intact — a caller whose signal aborts after unregister can still propagate
+	* cancellation into the underlying work rather than leaving it orphaned. Controller-backed
+	* entries self-evict on settle; plain `.set()`-based entries hard-delete immediately.
+	*
+	* Cache eviction is a no-op if `repoPath` is not registered, but the status clock is advanced
+	* unconditionally (a fresh registration must not let a post-reopen read join a pre-close one).
+	*/
+	unregisterRepoPath(repoPath) {
+		this.incrementStatusGeneration(repoPath);
+		this._closeGenerations.set(repoPath, this.getCloseGeneration(repoPath) + 1);
+		const commonPath = this._commonPathRegistry.get(repoPath) ?? repoPath;
+		const worktrees = this._worktreesByCommonPath.get(commonPath);
+		const isLastWorktree = worktrees == null || worktrees.size <= 1;
+		for (const key of Object.keys(this._caches)) {
+			const cache = this._caches[key];
+			if (cache == null) continue;
+			const invalidate = cache.invalidate;
+			const evict = typeof invalidate === "function" ? (k) => invalidate.call(cache, k) : (k) => cache.delete(k);
+			if (sharedCacheKeys.has(key)) {
+				if (repoPath !== commonPath) evict(repoPath);
+				if (isLastWorktree) evict(commonPath);
+			} else evict(repoPath);
+		}
+		if (isLastWorktree) this._gkConfigMergeSnapshots.delete(commonPath);
+		this._commonPathRegistry.delete(repoPath);
+		if (worktrees != null) {
+			worktrees.delete(repoPath);
+			if (worktrees.size === 0) this._worktreesByCommonPath.delete(commonPath);
+		}
+	}
+	reset() {
+		for (const path of /* @__PURE__ */ new Set([...this._commonPathRegistry.keys(), ...this._closeGenerations.keys()])) this._closeGenerations.set(path, this.getCloseGeneration(path) + 1);
+		this._commonPathRegistry.clear();
+		this._worktreesByCommonPath.clear();
+		this._statusGenerations.clear();
+		this._gkConfigMergeSnapshots.clear();
+		this._gkConfigReconciler = void 0;
+		this._caches = createEmptyCaches();
+	}
+	onRepositoryChanged(repoPath, changes) {
+		const changesSet = new Set(changes);
+		const hasAny = (...c) => c.some((ch) => changesSet.has(ch));
+		if (hasAny("unknown", "closed")) {
+			this.unregisterRepoPath(repoPath);
+			return;
+		}
+		if (hasAny("index", "head", "heads", "remotes", "ignores", "config")) this.incrementStatusGeneration(repoPath);
+		const types = /* @__PURE__ */ new Set();
+		if (hasAny("head")) types.add("branch");
+		if (hasAny("index", "heads", "pausedOp")) {
+			types.add("blame");
+			types.add("diff");
+			types.add("fileLog");
+		}
+		if (hasAny("index")) types.add("tracking");
+		if (hasAny("config")) types.add("config");
+		if (hasAny("heads")) {
+			types.add("branches");
+			types.add("contributors");
+			types.add("worktrees");
+		}
+		if (hasAny("remotes")) {
+			types.add("branches");
+			types.add("contributors");
+			types.add("remotes");
+			types.add("worktrees");
+		}
+		if (hasAny("ignores")) types.add("gitignore");
+		if (hasAny("gkConfig")) this.handleGkConfigChanged(repoPath);
+		if (hasAny("lastFetched")) types.add("lastFetched");
+		if (hasAny("remoteProviders")) types.add("providers");
+		if (hasAny("cherryPick", "merge", "rebase", "revert", "pausedOp")) {
+			types.add("branch");
+			types.add("status");
+		}
+		if (hasAny("stash")) types.add("stashes");
+		if (hasAny("tags")) types.add("tags");
+		if (hasAny("worktrees")) types.add("worktrees");
+		if (types.size) this.clearCaches(repoPath, ...types);
+	}
+	/**
+	* Handles a watcher-observed `'gkConfig'` change. Always evicts the cached bulk map (forcing the
+	* next read to hit disk). If a reconciler is registered (see {@link setGkConfigReconciler}),
+	* defers to it instead of coarsely clearing `baseBranchName`/`branchOverviews` — it re-reads the
+	* map and diffs it against the snapshot captured here (i.e. as it stood right before this change),
+	* cascading only the refs whose merge-relevant keys actually changed. Falls back to the coarse
+	* clear when no reconciler is registered (e.g. the GitHub provider) so nothing can go stale.
+	*/
+	handleGkConfigChanged(repoPath) {
+		const commonPath = this.getCommonPath(repoPath);
+		this._caches.gkConfigMap?.delete(commonPath);
+		if (this._gkConfigReconciler == null) {
+			this.clearCaches(repoPath, "gkConfig");
+			return;
+		}
+		const priorSnapshot = this._gkConfigMergeSnapshots.get(commonPath);
+		Promise.resolve(this._gkConfigReconciler(repoPath, priorSnapshot)).then((outcome) => {
+			if (outcome === "failed") this.clearCaches(repoPath, "gkConfig");
+		}, () => this.clearCaches(repoPath, "gkConfig"));
+	}
+	/** Hard-evicts the cached bulk `.git/gk/config` map so the next read hits disk. */
+	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));
+	}
+	getBranches(repoPath, factory, mapper, cancellation) {
+		const commonPath = this.getCommonPath(repoPath);
+		const registration = this.sharedBranches.getOrCreate(commonPath, (cacheable, signal) => {
+			const p = Promise.resolve(factory(commonPath, cacheable, signal));
+			p.finally(() => {
+				if (cacheable.invalidated) {
+					this.branches.invalidate(commonPath);
+					for (const worktreePath of this.getWorktreePaths(commonPath)) this.branches.invalidate(worktreePath);
+				}
+			}).catch(() => {});
+			return p;
+		}, cancellation);
+		registration.catch(() => {});
+		return this.branches.getOrCreate(repoPath, (_cacheable, mapperSignal) => {
+			const rawShared = this.sharedBranches.get(commonPath) ?? registration;
+			return Promise.resolve(rawShared).then((shared) => mapper(shared, repoPath, commonPath, mapperSignal));
+		}, cancellation);
+	}
+	static globalConfigKey = "";
+	getConfig(repoPath, key, factory) {
+		const cacheKey = repoPath != null ? this.getCommonPath(repoPath) : Cache.globalConfigKey;
+		const result = this.configKeys.get(cacheKey, key);
+		if (result != null) return result;
+		const factoryPromise = Promise.resolve(factory());
+		this.configKeys.set(cacheKey, key, factoryPromise);
+		return factoryPromise;
+	}
+	getConfigRegex(repoPath, pattern, factory) {
+		const cacheKey = repoPath != null ? this.getCommonPath(repoPath) : Cache.globalConfigKey;
+		const result = this.configPatterns.get(cacheKey, pattern);
+		if (result != null) return result;
+		const factoryPromise = Promise.resolve(factory());
+		this.configPatterns.set(cacheKey, pattern, factoryPromise);
+		return factoryPromise;
+	}
+	deleteConfig(repoPath, key) {
+		const cacheKey = repoPath != null ? this.getCommonPath(repoPath) : Cache.globalConfigKey;
+		this._caches.configKeys?.delete(cacheKey, key);
+		this._caches.configPatterns?.delete(cacheKey);
+	}
+	/**
+	* The whole `.git/gk/config` is read once and cached as a single map per commonPath; per-key and
+	* 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
+	* `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));
+			return map;
+		});
+	}
+	/** Extracts the subset of a gk config map whose keys participate in the `branchOverviews`/`baseBranchName` lineage. */
+	extractMergeRelevantGkConfig(map) {
+		const subset = /* @__PURE__ */ new Map();
+		for (const [key, value] of map) if (branchOverviewGkConfigKeysRegex.test(key)) subset.set(key, value);
+		return subset;
+	}
+	/**
+	* Clears the cached `.git/gk/config` map and invalidates the derived caches
+	* (`baseBranchName`/`branchOverviews`) for the written key's ref.
+	*
+	* @param options.skipInvalidation Downstream caches the caller wants preserved despite this
+	* write. Use when the value being written is exactly what was just resolved — e.g. the Tier 2
+	* `storeMergeTargetBranchName` self-write inside `getBranchContributionsOverview` (skip
+	* `'branchOverviews'`) or the Tier 3 `storeBaseBranchName` self-write inside `getBaseBranchName`
+	* (skip both `'baseBranchName'` and `'branchOverviews'`). The bulk `gkConfigMap` map always
+	* invalidates so subsequent reads see the new value.
+	*/
+	deleteGkConfig(repoPath, key, options) {
+		const commonPath = this.getCommonPath(repoPath);
+		this._caches.gkConfigMap?.delete(commonPath);
+		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.
+	*/
+	recordGkConfigWrite(repoPath, key, value) {
+		if (!branchOverviewGkConfigKeysRegex.test(key)) return;
+		const commonPath = this.getCommonPath(repoPath);
+		const snapshot = this._gkConfigMergeSnapshots.get(commonPath);
+		if (snapshot == null) return;
+		const next = new Map(snapshot);
+		if (value == null) next.delete(key);
+		else next.set(key, value);
+		this._gkConfigMergeSnapshots.set(commonPath, next);
+	}
+	/**
+	* Registers the reconciler invoked by {@link handleGkConfigChanged} on a watcher-observed
+	* `'gkConfig'` change. Only one reconciler is kept — later registrations replace earlier ones,
+	* which is harmless since every CLI config sub-provider sharing this `Cache` reconciles the same
+	* underlying `.git/gk/config` file identically.
+	*/
+	setGkConfigReconciler(reconciler) {
+		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
+	* `baseBranchName`/`branchOverviews` for every ref whose merge-relevant key actually changed.
+	* `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);
+		if (priorSnapshot == null) {
+			this.evictShared("baseBranchName", repoPath);
+			this.evictShared("branchOverviews", repoPath);
+			return true;
+		}
+		let changed = false;
+		for (const key of /* @__PURE__ */ new Set([...priorSnapshot.keys(), ...newSubset.keys()])) if (priorSnapshot.get(key) !== newSubset.get(key)) {
+			changed = true;
+			this.cascadeGkConfigKeyChange(commonPath, key);
+		}
+		return changed;
+	}
+	/**
+	* Shared per-ref cascade for a changed `branch.<ref>.gk-...` key: invalidates `baseBranchName` (for
+	* `gk-merge-base`) and `branchOverviews` (for any merge-relevant key), honoring `skipInvalidation`.
+	* Used by both a direct write (`deleteGkConfig`) and a reconciled external change
+	* (`reconcileGkConfigMap`). No-ops for keys outside the merge-relevant subset.
+	*/
+	cascadeGkConfigKeyChange(commonPath, key, skip) {
+		const refMatch = key.match(branchOverviewGkConfigKeysRegex);
+		if (refMatch == null) return;
+		const ref = refMatch[1];
+		if (key.endsWith(".gk-merge-base") && !skip?.includes("baseBranchName")) this._caches.baseBranchName?.delete(commonPath, ref);
+		if (skip?.includes("branchOverviews")) return;
+		this._caches.branchOverviews?.invalidateByKeyPrefix(commonPath, `${ref}|`);
+		for (const worktreePath of this.getWorktreePaths(commonPath)) {
+			if (worktreePath === commonPath) continue;
+			this._caches.branchOverviews?.invalidateByKeyPrefix(worktreePath, `${ref}|`);
+		}
+	}
+	async getBranchOverview(repoPath, cacheKey, factory, options) {
+		return this.getSharedOrCreateWithKey(this.branchOverviews, repoPath, cacheKey, factory, (data, newRepoPath) => data == null ? data : {
+			...data,
+			repoPath: newRepoPath,
+			contributors: data.contributors.map((c) => c.withRepoPath(newRepoPath))
+		}, options);
+	}
+	async getContributors(repoPath, cacheKey, factory, options) {
+		return this.getSharedOrCreateWithKey(this.contributors, repoPath, cacheKey, factory, (data, newRepoPath) => ({
+			...data,
+			contributors: data.contributors.map((c) => c.withRepoPath(newRepoPath))
+		}), options);
+	}
+	async getContributorsLite(repoPath, cacheKey, factory, options) {
+		return this.getSharedOrCreateWithKey(this.contributorsLite, repoPath, cacheKey, factory, (data, newRepoPath) => data.map((c) => c.withRepoPath(newRepoPath)), options);
+	}
+	getContributorsStats(repoPath, cacheKey, factory, options) {
+		return this.getSharedSimpleWithKey(this.contributorsStats, repoPath, cacheKey, factory, options);
+	}
+	getBaseBranchName(repoPath, ref, factory, cancellation) {
+		return this.getSharedSimpleWithKey(this.baseBranchName, repoPath, ref, factory, {
+			createTTL: baseBranchNameTTL,
+			cancellation
+		});
+	}
+	/**
+	* Clears the cached base branch for `ref`. Call from ops that create/rename/delete a branch — the
+	* `'branches'` cascade no longer clears these, since tip movement can't change a branch's base.
+	*
+	* Only clears the cache. A branch's base is *persisted* as `branch.<ref>.gk-merge-base` and read back
+	* before the reflog fallback, so an op that ends a branch's identity under a name must drop or move
+	* that key too (`removeGkConfigBranchSection`/`renameGkConfigBranchSection`) — otherwise the
+	* re-derivation this triggers just reads the stale value straight back.
+	*/
+	deleteBaseBranchName(repoPath, ref) {
+		this._caches.baseBranchName?.delete(this.getCommonPath(repoPath), ref);
+	}
+	getBranchMergedStatus(repoPath, cacheKey, factory, cancellation) {
+		return this.getSharedOrCreateWithKey(this.branchMergedStatus, repoPath, cacheKey, factory, (data, newRepoPath) => {
+			if (!data.merged) return data;
+			if (data.localBranchOnly == null) return data;
+			const lbo = data.localBranchOnly;
+			return {
+				...data,
+				localBranchOnly: createReference(lbo.ref, newRepoPath, {
+					id: getBranchId(newRepoPath, lbo.remote, lbo.name),
+					refType: "branch",
+					name: lbo.name,
+					remote: lbo.remote,
+					upstream: lbo.upstream,
+					sha: lbo.sha
+				})
+			};
+		}, { cancellation });
+	}
+	getBranchMetadataMap(repoPath, factory) {
+		return this.getSharedSimple(this.branchMetadataMap, repoPath, factory);
+	}
+	getDefaultBranchName(repoPath, remote, factory, cancellation) {
+		return this.getSharedSimpleWithKey(this.defaultBranchName, repoPath, remote, factory, { cancellation });
+	}
+	/** Clears the cached default branch for one `remote` key (the networked lookup or its `:local` variant). */
+	deleteDefaultBranchName(repoPath, remote) {
+		this._caches.defaultBranchName?.delete(this.getCommonPath(repoPath), remote);
+	}
+	getInitialCommitSha(repoPath, factory) {
+		return this.getSharedSimple(this.initialCommitSha, repoPath, factory);
+	}
+	getLastFetchedTimestamp(repoPath, factory) {
+		return this.getSharedSimple(this.lastFetched, repoPath, factory);
+	}
+	getRefs(repoPath, factory, cancellation) {
+		const commonPath = this.getCommonPath(repoPath);
+		return this.refs.getOrCreate(commonPath, (cacheable, signal) => Promise.resolve(factory(commonPath, cacheable, signal)), cancellation);
+	}
+	getRefTips(repoPath, factory, cancellation) {
+		const commonPath = this.getCommonPath(repoPath);
+		return this.refTips.getOrCreate(commonPath, (cacheable, signal) => Promise.resolve(factory(commonPath, cacheable, signal)), cancellation);
+	}
+	async getRemotes(repoPath, factory, cancellation) {
+		return this.getSharedOrCreate(this.remotes, repoPath, factory, (data, newRepoPath) => data.map((r) => r.withRepoPath(newRepoPath)), cancellation);
+	}
+	async getStash(repoPath, cacheKey, factory, options) {
+		return this.getSharedOrCreateWithKey(this.stashes, repoPath, cacheKey, factory, (data, newRepoPath) => ({
+			repoPath: newRepoPath,
+			stashes: new Map(Array.from(data.stashes.entries(), ([sha, s]) => [sha, s.withRepoPath(newRepoPath)]))
+		}), options);
+	}
+	async getTags(repoPath, factory, cancellation) {
+		return this.getSharedOrCreate(this.tags, repoPath, factory, (data, newRepoPath) => ({
+			...data,
+			values: data.values.map((t) => t.withRepoPath(newRepoPath))
+		}), cancellation);
+	}
+	async getWorktrees(repoPath, factory, cancellation) {
+		return this.getSharedOrCreate(this.worktrees, repoPath, factory, (data, newRepoPath) => data.map((w) => w.withRepoPath(newRepoPath)), cancellation);
+	}
+	async getSharedOrCreate(cache, repoPath, factory, mapper, cancellation) {
+		const commonPath = this.getCommonPath(repoPath);
+		const sharedPromise = cache.getOrCreate(commonPath, (cacheable, signal) => {
+			const p = Promise.resolve(factory(commonPath, cacheable, signal));
+			p.finally(() => {
+				if (cacheable.invalidated) for (const worktreePath of this.getWorktreePaths(commonPath)) {
+					if (worktreePath === commonPath) continue;
+					cache.invalidate(worktreePath);
+				}
+			}).catch(() => {});
+			return p;
+		}, cancellation);
+		sharedPromise.catch(() => {});
+		if (commonPath !== repoPath) {
+			const existing = cache.get(repoPath);
+			if (existing != null) return cancellation != null ? raceWithSignal(existing, cancellation) : existing;
+			const rawShared = cache.get(commonPath) ?? sharedPromise;
+			const mappedPromise = Promise.resolve(rawShared).then((data) => mapper(data, repoPath));
+			cache.set(repoPath, mappedPromise);
+			return cancellation != null ? raceWithSignal(mappedPromise, cancellation) : mappedPromise;
+		}
+		return sharedPromise;
+	}
+	async getSharedOrCreateWithKey(cache, repoPath, cacheKey, factory, mapper, options) {
+		const commonPath = this.getCommonPath(repoPath);
+		const cancellation = options?.cancellation;
+		const sharedPromise = cache.getOrCreate(commonPath, cacheKey, (cacheable, signal) => {
+			const p = Promise.resolve(factory(commonPath, cacheable, signal));
+			p.finally(() => {
+				if (cacheable.invalidated) for (const worktreePath of this.getWorktreePaths(commonPath)) {
+					if (worktreePath === commonPath) continue;
+					cache.invalidate(worktreePath, cacheKey);
+				}
+			}).catch(() => {});
+			return p;
+		}, options);
+		sharedPromise.catch(() => {});
+		if (commonPath !== repoPath) {
+			const existing = cache.get(repoPath, cacheKey);
+			if (existing != null) return cancellation != null ? raceWithSignal(existing, cancellation) : existing;
+			const rawShared = cache.get(commonPath, cacheKey) ?? sharedPromise;
+			const mappedPromise = Promise.resolve(rawShared).then((data) => mapper(data, repoPath));
+			cache.set(repoPath, cacheKey, mappedPromise, options);
+			return cancellation != null ? raceWithSignal(mappedPromise, cancellation) : mappedPromise;
+		}
+		return sharedPromise;
+	}
+	async getSharedSimple(cache, repoPath, factory) {
+		const commonPath = this.getCommonPath(repoPath);
+		if (cache instanceof PromiseCache) return cache.getOrCreate(commonPath, (cacheable) => Promise.resolve(factory(commonPath, cacheable)));
+		return cache.getOrCreate(commonPath, (cacheable) => Promise.resolve(factory(commonPath, cacheable)));
+	}
+	async getSharedSimpleWithKey(cache, repoPath, cacheKey, factory, options) {
+		const commonPath = this.getCommonPath(repoPath);
+		return cache.getOrCreate(commonPath, cacheKey, (cacheable, signal) => Promise.resolve(factory(commonPath, cacheable, signal)), options);
+	}
+};
+__decorate([debug({ onlyExit: true })], Cache.prototype, "clearCaches", null);
+__decorate([debug({ onlyExit: true })], Cache.prototype, "unregisterRepoPath", null);
+__decorate([debug({ onlyExit: true })], Cache.prototype, "reset", null);
+__decorate([debug({ onlyExit: true })], Cache.prototype, "onRepositoryChanged", null);
+//#endregion
+export { Cache, areUriScopedCachedGitTypes, shouldEvictBlameCacheEntry };
+
 //# sourceMappingURL=cache.js.map