@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/dist/git/cache.d.ts

@@ -1,31 +1,31 @@
-import type { PagedResult } from '../utils/paging.js';
-import type { PromiseOrValue } from '../utils/promise.js';
-import type { CacheController } from '../utils/promiseCache.js';
-import { PromiseCache, PromiseMap, RepoPromiseCacheMap } from '../utils/promiseCache.js';
-import type { ResourceUsage } from '../utils/resourceUsage.js';
-import type { Uri } from '../utils/uri.js';
-import type { ProgressiveGitBlame } from './models/blame.js';
-import type { BranchMetadata, GitBranch } from './models/branch.js';
-import type { GitCommit } from './models/commit.js';
-import type { GitContributor, GitContributorsStats } from './models/contributor.js';
-import type { ParsedGitDiffHunks } from './models/diff.js';
-import type { GitLog } from './models/log.js';
-import type { ConflictDetectionResult } from './models/mergeConflicts.js';
-import type { GitPausedOperationStatus } from './models/pausedOperationStatus.js';
-import type { GitBranchReference, GitRefTip, RefRecord } from './models/reference.js';
-import type { GitRemote } from './models/remote.js';
-import type { RemoteProvider } from './models/remoteProvider.js';
-import type { GitDir, RepositoryChange } from './models/repository.js';
-import type { GitStash } from './models/stash.js';
-import type { GitTag } from './models/tag.js';
-import type { GitUser } from './models/user.js';
-import type { GitWorktree } from './models/worktree.js';
-import type { BranchContributionsOverview, GitBranchMergedStatus } from './providers/branches.js';
-import type { GitCommitReachability, LeftRightCommitCountResult } from './providers/commits.js';
-import type { GitContributorsResult } from './providers/contributors.js';
-import type { ResolvedRevision } from './providers/revision.js';
-import type { GitResult } from './run.types.js';
-import type { GitIgnoreFilter } from './watching/gitIgnoreFilter.js';
+import { PagedResult } from "../utils/paging.js";
+import { PromiseOrValue } from "../utils/promise.js";
+import { CacheController, PromiseCache, PromiseMap, RepoPromiseCacheMap } from "../utils/promiseCache.js";
+import { ResourceUsage } from "../utils/resourceUsage.js";
+import { Uri } from "../utils/uri.js";
+import { ParsedGitDiffHunks } from "./models/diff.js";
+import { GitBranchReference, GitRefTip, RefRecord } from "./models/reference.js";
+import { GitCommit } from "./models/commit.js";
+import { ProgressiveGitBlame } from "./models/blame.js";
+import { BranchMetadata, GitBranch } from "./models/branch.js";
+import { GitContributor, GitContributorsStats } from "./models/contributor.js";
+import { GitLog } from "./models/log.js";
+import { ConflictDetectionResult } from "./models/mergeConflicts.js";
+import { GitPausedOperationStatus } from "./models/pausedOperationStatus.js";
+import { GitIgnoreFilter } from "./watching/gitIgnoreFilter.js";
+import { GitDir, RepositoryChange } from "./models/repository.js";
+import { RemoteProvider } from "./models/remoteProvider.js";
+import { GitRemote } from "./models/remote.js";
+import { GitStash } from "./models/stash.js";
+import { GitTag } from "./models/tag.js";
+import { GitUser } from "./models/user.js";
+import { GitResult } from "./run.types.js";
+import { GitWorktree } from "./models/worktree.js";
+import { GitCommitReachability, LeftRightCommitCountResult } from "./providers/commits.js";
+import { BranchContributionsOverview, GitBranchMergedStatus } from "./providers/branches.js";
+import { GitContributorsResult } from "./providers/contributors.js";
+import { ResolvedRevision } from "./providers/revision.js";
+//#region ../git/src/cache.d.ts
 type RepoPath = string;
 /** Cache types that are keyed by file path within a repo — support per-file clearing */
 export type UriScopedCachedGitTypes = 'blame' | 'diff' | 'fileLog';
@@ -49,274 +49,274 @@ export declare function shouldEvictBlameCacheEntry(progressive: ProgressiveGitBl
  */
 export type GkConfigInvalidationTarget = 'branchOverviews' | 'baseBranchName';
 export declare class Cache implements Disposable {
-    private _caches;
-    private _commonPathRegistry;
-    /** Reverse index: commonPath → set of worktree repoPaths that share it */
-    private _worktreesByCommonPath;
-    /** Monotonic per-worktree "status clock" — see {@link getStatusGeneration}. */
-    private _statusGenerations;
-    /** Monotonic per-path "close clock" — see {@link getCloseGeneration}. */
-    private _closeGenerations;
-    /**
-     * 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".
-     */
-    private _gkConfigMergeSnapshots;
-    /**
-     * 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.
-     */
-    private _gkConfigReconciler;
-    [Symbol.dispose](): void;
-    dispose(): void;
-    /** Resource usage retained by instantiated sub-caches and their bookkeeping maps. */
-    getResourceUsage(): ResourceUsage;
-    get bestRemotes(): PromiseMap<RepoPath, GitRemote<RemoteProvider>[]>;
-    get blame(): RepoPromiseCacheMap<string, ProgressiveGitBlame | undefined>;
-    get diff(): RepoPromiseCacheMap<string, ParsedGitDiffHunks | undefined>;
-    get fileLog(): RepoPromiseCacheMap<string, GitLog | undefined>;
-    private get baseBranchName();
-    get branch(): PromiseMap<RepoPath, GitBranch | undefined>;
-    get branchMergedStatus(): RepoPromiseCacheMap<string, GitBranchMergedStatus>;
-    private get branchMetadataMap();
-    private get branchOverviews();
-    get branches(): PromiseMap<RepoPath, PagedResult<GitBranch>>;
-    /**
-     * Internal cache for raw shared branch data (keyed by commonPath)
-     * Separate from branches cache because branches need to be mapped for each worktree
-     */
-    private get sharedBranches();
-    private get configKeys();
-    private get configPatterns();
-    private get gkConfigMap();
-    get currentBranchReference(): PromiseCache<RepoPath, GitBranchReference | undefined>;
-    setCurrentBranchReferenceIfAbsent(worktreePath: string, reference: GitBranchReference | undefined): void;
-    get conflictDetection(): RepoPromiseCacheMap<ConflictDetectionCacheKey, ConflictDetectionResult>;
-    get contributors(): RepoPromiseCacheMap<string, GitContributorsResult>;
-    get contributorsLite(): RepoPromiseCacheMap<string, GitContributor[]>;
-    get contributorsStats(): RepoPromiseCacheMap<string, GitContributorsStats | undefined>;
-    get currentUser(): Map<RepoPath, GitUser | null>;
-    get defaultBranchName(): RepoPromiseCacheMap<string, string | undefined>;
-    get gitDir(): Map<RepoPath, GitDir>;
-    get gitIgnore(): Map<RepoPath, GitIgnoreFilter>;
-    get gitResults(): RepoPromiseCacheMap<RepoPath, GitResult>;
-    get initialCommitSha(): PromiseMap<RepoPath, string | undefined>;
-    get lastFetched(): PromiseCache<RepoPath, number | undefined>;
-    get leftRightCommitCount(): RepoPromiseCacheMap<string, LeftRightCommitCountResult | undefined>;
-    get commit(): RepoPromiseCacheMap<string, GitCommit | undefined>;
-    get commitCount(): RepoPromiseCacheMap<string, number | undefined>;
-    get mergeBase(): RepoPromiseCacheMap<string, string | undefined>;
-    get logShas(): RepoPromiseCacheMap<string, string[]>;
-    get pausedOperationStatus(): PromiseMap<RepoPath, GitPausedOperationStatus | undefined>;
-    get resolvedRevisions(): RepoPromiseCacheMap<string, ResolvedRevision>;
-    get refs(): PromiseMap<RepoPath, RefRecord[]>;
-    get refTips(): PromiseMap<RepoPath, GitRefTip[]>;
-    get reachability(): RepoPromiseCacheMap<string, GitCommitReachability | undefined>;
-    get remotes(): PromiseMap<RepoPath, GitRemote[]>;
-    get stashes(): RepoPromiseCacheMap<string, GitStash>;
-    get tags(): PromiseMap<RepoPath, PagedResult<GitTag>>;
-    get fileExistence(): RepoPromiseCacheMap<string, boolean>;
-    get ignoreRevsFile(): PromiseCache<string, boolean>;
-    get trackedPaths(): RepoPromiseCacheMap<string, [string, string] | false>;
-    get worktrees(): PromiseMap<RepoPath, GitWorktree[]>;
-    clearCaches(repoPath: string | undefined, ...types: CachedGitTypes[]): void;
-    /**
-     * 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`.
-     */
-    private evictShared;
-    /**
-     * 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: string): number;
-    /** Advances the status clock — see {@link getStatusGeneration}. */
-    incrementStatusGeneration(repoPath: string): void;
-    /**
-     * 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: string): void;
-    /** Advances the status clock for one worktree, or for every known worktree when `repoPath` is undefined. */
-    private incrementStatusGenerations;
-    getCommonPath(repoPath: string): string;
-    getWorktreePaths(commonPath: string): string[];
-    isWorktree(repoPath: string): boolean;
-    /** Whether `repoPath` is currently registered (via {@link registerRepoPath}, not yet unregistered). */
-    isRegistered(repoPath: string): boolean;
-    /**
-     * 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: string): number;
-    /** Clears file-scoped caches (blame, diff, fileLog) for a specific path within a repo */
-    clearForPath(repoPath: string, path: string, ...types: UriScopedCachedGitTypes[]): void;
-    registerRepoPath(repoPath: Uri, gitDir: GitDir): void;
-    /**
-     * 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: string): void;
-    reset(): void;
-    onRepositoryChanged(repoPath: string, changes: Iterable<RepositoryChange>): void;
-    /**
-     * 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.
-     */
-    private handleGkConfigChanged;
-    /** Hard-evicts the cached bulk `.git/gk/config` map so the next read hits disk. */
-    deleteGkConfigMap(repoPath: string): void;
-    /** The merge-relevant gk config snapshot currently serving as the reconcile baseline. */
-    getGkConfigMergeSnapshot(repoPath: string): ReadonlyMap<string, string> | undefined;
-    getBranches(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<PagedResult<GitBranch>>, mapper: (branches: PagedResult<GitBranch>, targetRepoPath: string, commonPath: string, cancellation?: AbortSignal) => PromiseOrValue<PagedResult<GitBranch>>, cancellation?: AbortSignal): Promise<PagedResult<GitBranch>>;
-    private static readonly globalConfigKey;
-    getConfig(repoPath: string | undefined, key: string, factory: () => PromiseOrValue<string | undefined>): Promise<string | undefined>;
-    getConfigRegex(repoPath: string | undefined, pattern: string, factory: () => PromiseOrValue<Map<string, string>>): Promise<Map<string, string>>;
-    deleteConfig(repoPath: string | undefined, key: string): void;
-    /**
-     * 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: string, factory: (cacheable: CacheController) => PromiseOrValue<Map<string, string>>): Promise<Map<string, string>>;
-    /** Extracts the subset of a gk config map whose keys participate in the `branchOverviews`/`baseBranchName` lineage. */
-    private extractMergeRelevantGkConfig;
-    /**
-     * 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: string, key: string, options?: {
-        skipInvalidation?: readonly GkConfigInvalidationTarget[];
-    }): void;
-    /**
-     * 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: string, key: string, value: string | undefined): void;
-    /**
-     * 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: (repoPath: string, priorSnapshot: ReadonlyMap<string, string> | undefined) => PromiseOrValue<GkReconcileOutcome>): void;
-    /**
-     * 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: string, priorSnapshot: ReadonlyMap<string, string> | undefined, freshMap: ReadonlyMap<string, string>): boolean;
-    /**
-     * 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.
-     */
-    private cascadeGkConfigKeyChange;
-    getBranchOverview(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<BranchContributionsOverview | undefined>, options?: {
-        accessTTL?: number;
-        cancellation?: AbortSignal;
-    }): Promise<BranchContributionsOverview | undefined>;
-    getContributors(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitContributorsResult>, options?: {
-        accessTTL?: number;
-        cancellation?: AbortSignal;
-    }): Promise<GitContributorsResult>;
-    getContributorsLite(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitContributor[]>, options?: {
-        accessTTL?: number;
-        cancellation?: AbortSignal;
-    }): Promise<GitContributor[]>;
-    getContributorsStats(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitContributorsStats | undefined>, options?: {
-        accessTTL?: number;
-        cancellation?: AbortSignal;
-    }): Promise<GitContributorsStats | undefined>;
-    getBaseBranchName(repoPath: string, ref: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<string | undefined>, cancellation?: AbortSignal): Promise<string | undefined>;
-    /**
-     * 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: string, ref: string): void;
-    getBranchMergedStatus(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitBranchMergedStatus>, cancellation?: AbortSignal): Promise<GitBranchMergedStatus>;
-    getBranchMetadataMap(repoPath: string, factory: (commonPath: string) => PromiseOrValue<Map<string, BranchMetadata>>): Promise<Map<string, BranchMetadata>>;
-    getDefaultBranchName(repoPath: string, remote: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<string | undefined>, cancellation?: AbortSignal): Promise<string | undefined>;
-    /** Clears the cached default branch for one `remote` key (the networked lookup or its `:local` variant). */
-    deleteDefaultBranchName(repoPath: string, remote: string): void;
-    getInitialCommitSha(repoPath: string, factory: (commonPath: string) => PromiseOrValue<string | undefined>): Promise<string | undefined>;
-    getLastFetchedTimestamp(repoPath: string, factory: (commonPath: string) => PromiseOrValue<number | undefined>): Promise<number | undefined>;
-    getRefs(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<RefRecord[]>, cancellation?: AbortSignal): Promise<RefRecord[]>;
-    getRefTips(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitRefTip[]>, cancellation?: AbortSignal): Promise<GitRefTip[]>;
-    getRemotes(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitRemote[]>, cancellation?: AbortSignal): Promise<GitRemote[]>;
-    getStash(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitStash>, options?: {
-        accessTTL?: number;
-        cancellation?: AbortSignal;
-    }): Promise<GitStash>;
-    getTags(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<PagedResult<GitTag>>, cancellation?: AbortSignal): Promise<PagedResult<GitTag>>;
-    getWorktrees(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitWorktree[]>, cancellation?: AbortSignal): Promise<GitWorktree[]>;
-    private getSharedOrCreate;
-    private getSharedOrCreateWithKey;
-    private getSharedSimple;
-    private getSharedSimpleWithKey;
+  private _caches;
+  private _commonPathRegistry;
+  /** Reverse index: commonPath → set of worktree repoPaths that share it */
+  private _worktreesByCommonPath;
+  /** Monotonic per-worktree "status clock" — see {@link getStatusGeneration}. */
+  private _statusGenerations;
+  /** Monotonic per-path "close clock" — see {@link getCloseGeneration}. */
+  private _closeGenerations;
+  /**
+   * 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".
+   */
+  private _gkConfigMergeSnapshots;
+  /**
+   * 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.
+   */
+  private _gkConfigReconciler;
+  [Symbol.dispose](): void;
+  dispose(): void;
+  /** Resource usage retained by instantiated sub-caches and their bookkeeping maps. */
+  getResourceUsage(): ResourceUsage;
+  get bestRemotes(): PromiseMap<RepoPath, GitRemote<RemoteProvider>[]>;
+  get blame(): RepoPromiseCacheMap<string, ProgressiveGitBlame | undefined>;
+  get diff(): RepoPromiseCacheMap<string, ParsedGitDiffHunks | undefined>;
+  get fileLog(): RepoPromiseCacheMap<string, GitLog | undefined>;
+  private get baseBranchName();
+  get branch(): PromiseMap<RepoPath, GitBranch | undefined>;
+  get branchMergedStatus(): RepoPromiseCacheMap<string, GitBranchMergedStatus>;
+  private get branchMetadataMap();
+  private get branchOverviews();
+  get branches(): PromiseMap<RepoPath, PagedResult<GitBranch>>;
+  /**
+   * Internal cache for raw shared branch data (keyed by commonPath)
+   * Separate from branches cache because branches need to be mapped for each worktree
+   */
+  private get sharedBranches();
+  private get configKeys();
+  private get configPatterns();
+  private get gkConfigMap();
+  get currentBranchReference(): PromiseCache<RepoPath, GitBranchReference | undefined>;
+  setCurrentBranchReferenceIfAbsent(worktreePath: string, reference: GitBranchReference | undefined): void;
+  get conflictDetection(): RepoPromiseCacheMap<ConflictDetectionCacheKey, ConflictDetectionResult>;
+  get contributors(): RepoPromiseCacheMap<string, GitContributorsResult>;
+  get contributorsLite(): RepoPromiseCacheMap<string, GitContributor[]>;
+  get contributorsStats(): RepoPromiseCacheMap<string, GitContributorsStats | undefined>;
+  get currentUser(): Map<RepoPath, GitUser | null>;
+  get defaultBranchName(): RepoPromiseCacheMap<string, string | undefined>;
+  get gitDir(): Map<RepoPath, GitDir>;
+  get gitIgnore(): Map<RepoPath, GitIgnoreFilter>;
+  get gitResults(): RepoPromiseCacheMap<RepoPath, GitResult>;
+  get initialCommitSha(): PromiseMap<RepoPath, string | undefined>;
+  get lastFetched(): PromiseCache<RepoPath, number | undefined>;
+  get leftRightCommitCount(): RepoPromiseCacheMap<string, LeftRightCommitCountResult | undefined>;
+  get commit(): RepoPromiseCacheMap<string, GitCommit | undefined>;
+  get commitCount(): RepoPromiseCacheMap<string, number | undefined>;
+  get mergeBase(): RepoPromiseCacheMap<string, string | undefined>;
+  get logShas(): RepoPromiseCacheMap<string, string[]>;
+  get pausedOperationStatus(): PromiseMap<RepoPath, GitPausedOperationStatus | undefined>;
+  get resolvedRevisions(): RepoPromiseCacheMap<string, ResolvedRevision>;
+  get refs(): PromiseMap<RepoPath, RefRecord[]>;
+  get refTips(): PromiseMap<RepoPath, GitRefTip[]>;
+  get reachability(): RepoPromiseCacheMap<string, GitCommitReachability | undefined>;
+  get remotes(): PromiseMap<RepoPath, GitRemote[]>;
+  get stashes(): RepoPromiseCacheMap<string, GitStash>;
+  get tags(): PromiseMap<RepoPath, PagedResult<GitTag>>;
+  get fileExistence(): RepoPromiseCacheMap<string, boolean>;
+  get ignoreRevsFile(): PromiseCache<string, boolean>;
+  get trackedPaths(): RepoPromiseCacheMap<string, [string, string] | false>;
+  get worktrees(): PromiseMap<RepoPath, GitWorktree[]>;
+  clearCaches(repoPath: string | undefined, ...types: CachedGitTypes[]): void;
+  /**
+   * 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`.
+   */
+  private evictShared;
+  /**
+   * 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: string): number;
+  /** Advances the status clock — see {@link getStatusGeneration}. */
+  incrementStatusGeneration(repoPath: string): void;
+  /**
+   * 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: string): void;
+  /** Advances the status clock for one worktree, or for every known worktree when `repoPath` is undefined. */
+  private incrementStatusGenerations;
+  getCommonPath(repoPath: string): string;
+  getWorktreePaths(commonPath: string): string[];
+  isWorktree(repoPath: string): boolean;
+  /** Whether `repoPath` is currently registered (via {@link registerRepoPath}, not yet unregistered). */
+  isRegistered(repoPath: string): boolean;
+  /**
+   * 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: string): number;
+  /** Clears file-scoped caches (blame, diff, fileLog) for a specific path within a repo */
+  clearForPath(repoPath: string, path: string, ...types: UriScopedCachedGitTypes[]): void;
+  registerRepoPath(repoPath: Uri, gitDir: GitDir): void;
+  /**
+   * 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: string): void;
+  reset(): void;
+  onRepositoryChanged(repoPath: string, changes: Iterable<RepositoryChange>): void;
+  /**
+   * 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.
+   */
+  private handleGkConfigChanged;
+  /** Hard-evicts the cached bulk `.git/gk/config` map so the next read hits disk. */
+  deleteGkConfigMap(repoPath: string): void;
+  /** The merge-relevant gk config snapshot currently serving as the reconcile baseline. */
+  getGkConfigMergeSnapshot(repoPath: string): ReadonlyMap<string, string> | undefined;
+  getBranches(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<PagedResult<GitBranch>>, mapper: (branches: PagedResult<GitBranch>, targetRepoPath: string, commonPath: string, cancellation?: AbortSignal) => PromiseOrValue<PagedResult<GitBranch>>, cancellation?: AbortSignal): Promise<PagedResult<GitBranch>>;
+  private static readonly globalConfigKey;
+  getConfig(repoPath: string | undefined, key: string, factory: () => PromiseOrValue<string | undefined>): Promise<string | undefined>;
+  getConfigRegex(repoPath: string | undefined, pattern: string, factory: () => PromiseOrValue<Map<string, string>>): Promise<Map<string, string>>;
+  deleteConfig(repoPath: string | undefined, key: string): void;
+  /**
+   * 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: string, factory: (cacheable: CacheController) => PromiseOrValue<Map<string, string>>): Promise<Map<string, string>>;
+  /** Extracts the subset of a gk config map whose keys participate in the `branchOverviews`/`baseBranchName` lineage. */
+  private extractMergeRelevantGkConfig;
+  /**
+   * 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: string, key: string, options?: {
+    skipInvalidation?: readonly GkConfigInvalidationTarget[];
+  }): void;
+  /**
+   * 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: string, key: string, value: string | undefined): void;
+  /**
+   * 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: (repoPath: string, priorSnapshot: ReadonlyMap<string, string> | undefined) => PromiseOrValue<GkReconcileOutcome>): void;
+  /**
+   * 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: string, priorSnapshot: ReadonlyMap<string, string> | undefined, freshMap: ReadonlyMap<string, string>): boolean;
+  /**
+   * 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.
+   */
+  private cascadeGkConfigKeyChange;
+  getBranchOverview(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<BranchContributionsOverview | undefined>, options?: {
+    accessTTL?: number;
+    cancellation?: AbortSignal;
+  }): Promise<BranchContributionsOverview | undefined>;
+  getContributors(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitContributorsResult>, options?: {
+    accessTTL?: number;
+    cancellation?: AbortSignal;
+  }): Promise<GitContributorsResult>;
+  getContributorsLite(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitContributor[]>, options?: {
+    accessTTL?: number;
+    cancellation?: AbortSignal;
+  }): Promise<GitContributor[]>;
+  getContributorsStats(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitContributorsStats | undefined>, options?: {
+    accessTTL?: number;
+    cancellation?: AbortSignal;
+  }): Promise<GitContributorsStats | undefined>;
+  getBaseBranchName(repoPath: string, ref: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<string | undefined>, cancellation?: AbortSignal): Promise<string | undefined>;
+  /**
+   * 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: string, ref: string): void;
+  getBranchMergedStatus(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitBranchMergedStatus>, cancellation?: AbortSignal): Promise<GitBranchMergedStatus>;
+  getBranchMetadataMap(repoPath: string, factory: (commonPath: string) => PromiseOrValue<Map<string, BranchMetadata>>): Promise<Map<string, BranchMetadata>>;
+  getDefaultBranchName(repoPath: string, remote: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<string | undefined>, cancellation?: AbortSignal): Promise<string | undefined>;
+  /** Clears the cached default branch for one `remote` key (the networked lookup or its `:local` variant). */
+  deleteDefaultBranchName(repoPath: string, remote: string): void;
+  getInitialCommitSha(repoPath: string, factory: (commonPath: string) => PromiseOrValue<string | undefined>): Promise<string | undefined>;
+  getLastFetchedTimestamp(repoPath: string, factory: (commonPath: string) => PromiseOrValue<number | undefined>): Promise<number | undefined>;
+  getRefs(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<RefRecord[]>, cancellation?: AbortSignal): Promise<RefRecord[]>;
+  getRefTips(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitRefTip[]>, cancellation?: AbortSignal): Promise<GitRefTip[]>;
+  getRemotes(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitRemote[]>, cancellation?: AbortSignal): Promise<GitRemote[]>;
+  getStash(repoPath: string, cacheKey: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitStash>, options?: {
+    accessTTL?: number;
+    cancellation?: AbortSignal;
+  }): Promise<GitStash>;
+  getTags(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<PagedResult<GitTag>>, cancellation?: AbortSignal): Promise<PagedResult<GitTag>>;
+  getWorktrees(repoPath: string, factory: (commonPath: string, cacheable: CacheController, cancellation?: AbortSignal) => PromiseOrValue<GitWorktree[]>, cancellation?: AbortSignal): Promise<GitWorktree[]>;
+  private getSharedOrCreate;
+  private getSharedOrCreateWithKey;
+  private getSharedSimple;
+  private getSharedSimpleWithKey;
 }
-export {};
+//#endregion
 //# sourceMappingURL=cache.d.ts.map