@gitkraken/core-gitlens 0.1.0

package/dist/git/cache.js

@@ -0,0 +1,765 @@
+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 { getCommonRepositoryPath, getRepositoryOrWorktreePath } from './utils/repository.utils.js';
+const uriScopedCachedGitTypes = ['blame', 'diff', 'fileLog'];
+export function areUriScopedCachedGitTypes(types) {
+    return types.every(t => uriScopedCachedGitTypes.includes(t));
+}
+/** Compile-time enforced: adding a key to SharedCaches without listing it here is a type error */
+const sharedCacheKeys = new Set(exhaustiveArray()([
+    'branches',
+    'configKeys',
+    'configPatterns',
+    'contributors',
+    'contributorsLite',
+    'contributorsStats',
+    'defaultBranchName',
+    'gitResults',
+    'gkConfigKeys',
+    'gkConfigPatterns',
+    'initialCommitSha',
+    'logShas',
+    'remotes',
+    'sharedBranches',
+    'stashes',
+    'tags',
+    'worktrees',
+]));
+function createEmptyCaches() {
+    return {
+        bestRemotes: undefined,
+        blame: undefined,
+        branch: undefined,
+        branches: undefined,
+        fileExistence: undefined,
+        ignoreRevsFile: undefined,
+        leftRightCommitCount: 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,
+        gkConfigKeys: undefined,
+        gkConfigPatterns: undefined,
+        initialCommitSha: undefined,
+        lastFetched: undefined,
+        logShas: undefined,
+        pausedOperationStatus: undefined,
+        resolvedRevisions: undefined,
+        reachability: 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();
+    [Symbol.dispose]() {
+        this.dispose();
+    }
+    dispose() {
+        this.reset();
+    }
+    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 branch() {
+        return (this._caches.branch ??= new PromiseMap());
+    }
+    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 gkConfigKeys() {
+        return (this._caches.gkConfigKeys ??= new RepoPromiseCacheMap());
+    }
+    get gkConfigPatterns() {
+        return (this._caches.gkConfigPatterns ??= new RepoPromiseCacheMap());
+    }
+    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
+        }));
+    }
+    getLeftRightCommitCount(repoPath, key, factory) {
+        const cached = this.leftRightCommitCount.get(repoPath, key);
+        if (cached != null)
+            return cached;
+        const factoryPromise = Promise.resolve(factory());
+        this.leftRightCommitCount.set(repoPath, key, factoryPromise);
+        return factoryPromise;
+    }
+    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 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 PromiseMap());
+    }
+    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');
+        }
+        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');
+            }
+            // Per-worktree branch caches (current branch / HEAD sensitive)
+            if (types.includes('branch') || types.includes('branches')) {
+                keysToClear.add('branch');
+                keysToClear.add('conflictDetection');
+                keysToClear.add('currentBranchReference');
+                keysToClear.add('leftRightCommitCount');
+                keysToClear.add('reachability');
+                keysToClear.add('resolvedRevisions');
+            }
+            // Shared branch caches (branch list, metadata)
+            if (types.includes('branches')) {
+                keysToClear.add('branches');
+                keysToClear.add('sharedBranches');
+                keysToClear.add('defaultBranchName');
+                keysToClear.add('initialCommitSha');
+                keysToClear.add('logShas');
+            }
+            if (types.includes('config')) {
+                keysToClear.add('configKeys');
+                keysToClear.add('configPatterns');
+                keysToClear.add('currentBranchReference');
+                keysToClear.add('currentUser');
+                keysToClear.add('gitDir');
+            }
+            if (types.includes('contributors')) {
+                keysToClear.add('contributors');
+                keysToClear.add('contributorsLite');
+                keysToClear.add('contributorsStats');
+            }
+            if (types.includes('gitignore')) {
+                keysToClear.add('gitIgnore');
+            }
+            if (types.includes('gkConfig')) {
+                keysToClear.add('gkConfigKeys');
+                keysToClear.add('gkConfigPatterns');
+            }
+            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');
+            }
+            if (types.includes('tags')) {
+                keysToClear.add('tags');
+            }
+            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)) {
+                const commonPath = this.getCommonPath(repoPath);
+                // For shared caches, prefer `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`.
+                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);
+                    }
+                }
+            }
+            else {
+                cache.delete(repoPath);
+            }
+        }
+    }
+    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;
+    }
+    /** 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.
+     *
+     * No-op if `repoPath` is not registered.
+     */
+    unregisterRepoPath(repoPath) {
+        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);
+            }
+        }
+        this._commonPathRegistry.delete(repoPath);
+        if (worktrees != null) {
+            worktrees.delete(repoPath);
+            if (worktrees.size === 0) {
+                this._worktreesByCommonPath.delete(commonPath);
+            }
+        }
+    }
+    reset() {
+        this._commonPathRegistry.clear();
+        this._worktreesByCommonPath.clear();
+        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;
+        }
+        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')) {
+            types.add('gkConfig');
+        }
+        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);
+        }
+    }
+    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);
+                    }
+                }
+            });
+            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);
+    }
+    getGkConfig(repoPath, key, factory) {
+        const cacheKey = this.getCommonPath(repoPath);
+        const result = this.gkConfigKeys.get(cacheKey, key);
+        if (result != null)
+            return result;
+        const factoryPromise = Promise.resolve(factory());
+        this.gkConfigKeys.set(cacheKey, key, factoryPromise);
+        return factoryPromise;
+    }
+    getGkConfigRegex(repoPath, pattern, factory) {
+        const cacheKey = this.getCommonPath(repoPath);
+        const result = this.gkConfigPatterns.get(cacheKey, pattern);
+        if (result != null)
+            return result;
+        const factoryPromise = Promise.resolve(factory());
+        this.gkConfigPatterns.set(cacheKey, pattern, factoryPromise);
+        return factoryPromise;
+    }
+    deleteGkConfig(repoPath, key) {
+        const cacheKey = this.getCommonPath(repoPath);
+        this._caches.gkConfigKeys?.delete(cacheKey, key);
+        this._caches.gkConfigPatterns?.delete(cacheKey);
+    }
+    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);
+    }
+    getDefaultBranchName(repoPath, remote, factory) {
+        return this.getSharedSimpleWithKey(this.defaultBranchName, repoPath, remote, factory);
+    }
+    getInitialCommitSha(repoPath, factory) {
+        return this.getSharedSimple(this.initialCommitSha, repoPath, factory);
+    }
+    getLastFetchedTimestamp(repoPath, factory) {
+        return this.getSharedSimple(this.lastFetched, repoPath, factory);
+    }
+    async getRemotes(repoPath, factory, cancellation) {
+        return this.getSharedOrCreate(this.remotes, repoPath, factory, (data, newRepoPath) => data.map(r => r.withRepoPath(newRepoPath)), cancellation);
+    }
+    async getStash(repoPath, factory, cancellation) {
+        return this.getSharedOrCreate(this.stashes, repoPath, factory, (data, newRepoPath) => ({
+            repoPath: newRepoPath,
+            stashes: new Map(Array.from(data.stashes.entries(), ([sha, s]) => [
+                sha,
+                s.withRepoPath(newRepoPath),
+            ])),
+        }), cancellation);
+    }
+    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);
+                    }
+                }
+            });
+            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);
+                    }
+                }
+            });
+            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, 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, () => Promise.resolve(factory(commonPath)));
+        }
+        return cache.getOrCreate(commonPath, () => Promise.resolve(factory(commonPath)));
+    }
+    async getSharedSimpleWithKey(cache, repoPath, cacheKey, factory, options) {
+        const commonPath = this.getCommonPath(repoPath);
+        return cache.getOrCreate(commonPath, cacheKey, () => Promise.resolve(factory(commonPath)), 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);
+//# sourceMappingURL=cache.js.map