@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/dist/utils/promiseCache.d.ts

@@ -1,205 +1,206 @@
+//#region ../utils/src/promiseCache.d.ts
 export declare class CacheController {
-    #private;
-    get invalidated(): boolean;
-    invalidate(): void;
+  #private;
+  get invalidated(): boolean;
+  invalidate(): void;
 }
 interface PromiseCacheOptions {
+  /** TTL (time-to-live) in milliseconds since creation */
+  createTTL?: number;
+  /** TTL (time-to-live) in milliseconds since last access */
+  accessTTL?: number;
+  /** Whether to expire the entry if the promise fails (default: true) */
+  expireOnError?: boolean;
+  /**
+   * TTL (time-to-live) in milliseconds for caching errors. When the factory rejects and `errorTTL` is set,
+   * the cache entry is replaced with `Promise.resolve(undefined)` for subsequent callers, and the error
+   * is re-thrown to the first caller. After `errorTTL` expires, the next call retries.
+   * Only used when `onError` is not provided. Mutually exclusive with `expireOnError`.
+   */
+  errorTTL?: number;
+  /** Maximum number of entries in the cache (LRU eviction when exceeded) */
+  capacity?: number;
+}
+export declare class PromiseCache<K, V> {
+  private readonly cache;
+  private readonly aborts;
+  private readonly controllers;
+  private readonly options;
+  constructor(options?: PromiseCacheOptions);
+  /** Clears all entries. Like `delete`, does NOT dispose in-flight abort aggregates — that would detach a running
+   *  op's cancellation (a later caller-abort couldn't cancel it); each factory's settle handler disposes its own. */
+  clear(): void;
+  /**
+   * Removes a promise from the cache.
+   *  Does NOT dispose the abort aggregate: while a factory is in flight, disposing would detach
+   *  its callers' cancellation and orphan the underlying op (a later caller-abort could no longer cancel the
+   *  running `git status`). The factory's own settle handler disposes the aggregate (see `getOrCreate`). */
+  delete(key: K): void;
+  /**
+   * Marks a cached entry as invalidated.
+   * - If the entry has a `CacheController` (created via `getOrCreate`), it is soft-invalidated:
+   *   existing waiters complete normally, new callers joining during the remainder of the
+   *   in-flight operation share the same promise, and the entry self-evicts on settle.
+   * - If the entry was set via plain `.set()` (no controller), it is hard-deleted — there is
+   *   no in-flight factory to ride along with.
+   *
+   * No-op if the key is not cached.
+   */
+  invalidate(key: K): void;
+  keys(): IterableIterator<K>;
+  /**
+   * Returns the number of entries in the cache, including expired entries that haven't been evicted yet
+   * (they are only evicted on access), so this reflects what's actually retained in memory.
+   */
+  get size(): number;
+  /**
+   * Gets a promise from the cache without creating it and updates accessed time
+   * @param key - The cache key
+   * @returns The cached promise, or undefined if not cached or expired
+   */
+  get(key: K): Promise<V> | undefined;
+  /**
+   * Gets a promise from the cache or creates a new one using the factory function.
+   *
+   * When `cancellation` is provided:
+   * - The factory receives an aggregate `AbortSignal` that only fires when **all** callers cancel
+   * - The returned promise rejects with `CancellationError` if this caller's signal fires
+   * - Other callers sharing the same cached promise are unaffected
+   *
+   * @param key - The cache key
+   * @param factory - Factory function to create the value if not cached
+   * @param cancellation - Optional per-caller AbortSignal
+   * @param options - Optional TTL and error handling options that override the defaults
+   */
+  getOrCreate(key: K, factory: (cacheable: CacheController, cancellation?: AbortSignal) => Promise<V>, options?: {
+    /** Per-caller AbortSignal — the factory receives an aggregate signal that only fires when all callers cancel */
+    cancellation?: AbortSignal;
     /** TTL (time-to-live) in milliseconds since creation */
     createTTL?: number;
     /** TTL (time-to-live) in milliseconds since last access */
     accessTTL?: number;
-    /** Whether to expire the entry if the promise fails (default: true) */
+    /** Whether to expire the entry if the promise fails */
     expireOnError?: boolean;
+    /**
+     * Called after the factory resolves. If the predicate resolves to true, the entry is evicted while
+     * the current caller still receives the resolved value.
+     */
+    evictWhen?: (value: V) => boolean | Promise<boolean>;
     /**
      * TTL (time-to-live) in milliseconds for caching errors. When the factory rejects and `errorTTL` is set,
      * the cache entry is replaced with `Promise.resolve(undefined)` for subsequent callers, and the error
      * is re-thrown to the first caller. After `errorTTL` expires, the next call retries.
-     * Only used when `onError` is not provided. Mutually exclusive with `expireOnError`.
+     * Only used when `onError` is not provided.
      */
     errorTTL?: number;
-    /** Maximum number of entries in the cache (LRU eviction when exceeded) */
-    capacity?: number;
-}
-export declare class PromiseCache<K, V> {
-    private readonly cache;
-    private readonly aborts;
-    private readonly controllers;
-    private readonly options;
-    constructor(options?: PromiseCacheOptions);
-    /** Clears all entries. Like `delete`, does NOT dispose in-flight abort aggregates — that would detach a running
-     *  op's cancellation (a later caller-abort couldn't cancel it); each factory's settle handler disposes its own. */
-    clear(): void;
-    /**
-     * Removes a promise from the cache.
-     *  Does NOT dispose the abort aggregate: while a factory is in flight, disposing would detach
-     *  its callers' cancellation and orphan the underlying op (a later caller-abort could no longer cancel the
-     *  running `git status`). The factory's own settle handler disposes the aggregate (see `getOrCreate`). */
-    delete(key: K): void;
-    /**
-     * Marks a cached entry as invalidated.
-     * - If the entry has a `CacheController` (created via `getOrCreate`), it is soft-invalidated:
-     *   existing waiters complete normally, new callers joining during the remainder of the
-     *   in-flight operation share the same promise, and the entry self-evicts on settle.
-     * - If the entry was set via plain `.set()` (no controller), it is hard-deleted — there is
-     *   no in-flight factory to ride along with.
-     *
-     * No-op if the key is not cached.
-     */
-    invalidate(key: K): void;
-    keys(): IterableIterator<K>;
-    /**
-     * Returns the number of entries in the cache, including expired entries that haven't been evicted yet
-     * (they are only evicted on access), so this reflects what's actually retained in memory.
-     */
-    get size(): number;
-    /**
-     * Gets a promise from the cache without creating it and updates accessed time
-     * @param key - The cache key
-     * @returns The cached promise, or undefined if not cached or expired
-     */
-    get(key: K): Promise<V> | undefined;
-    /**
-     * Gets a promise from the cache or creates a new one using the factory function.
-     *
-     * When `cancellation` is provided:
-     * - The factory receives an aggregate `AbortSignal` that only fires when **all** callers cancel
-     * - The returned promise rejects with `CancellationError` if this caller's signal fires
-     * - Other callers sharing the same cached promise are unaffected
-     *
-     * @param key - The cache key
-     * @param factory - Factory function to create the value if not cached
-     * @param cancellation - Optional per-caller AbortSignal
-     * @param options - Optional TTL and error handling options that override the defaults
-     */
-    getOrCreate(key: K, factory: (cacheable: CacheController, cancellation?: AbortSignal) => Promise<V>, options?: {
-        /** Per-caller AbortSignal — the factory receives an aggregate signal that only fires when all callers cancel */
-        cancellation?: AbortSignal;
-        /** TTL (time-to-live) in milliseconds since creation */
-        createTTL?: number;
-        /** TTL (time-to-live) in milliseconds since last access */
-        accessTTL?: number;
-        /** Whether to expire the entry if the promise fails */
-        expireOnError?: boolean;
-        /**
-         * Called after the factory resolves. If the predicate resolves to true, the entry is evicted while
-         * the current caller still receives the resolved value.
-         */
-        evictWhen?: (value: V) => boolean | Promise<boolean>;
-        /**
-         * TTL (time-to-live) in milliseconds for caching errors. When the factory rejects and `errorTTL` is set,
-         * the cache entry is replaced with `Promise.resolve(undefined)` for subsequent callers, and the error
-         * is re-thrown to the first caller. After `errorTTL` expires, the next call retries.
-         * Only used when `onError` is not provided.
-         */
-        errorTTL?: number;
-        /**
-         * Called when the factory promise rejects. Return a fallback result to cache
-         * instead of expiring. The fallback value is cached with the specified `createTTL`
-         * (defaults to the cache's `createTTL`). By default, the error is re-thrown to the
-         * first caller after caching the fallback. Set `suppress: true` to return the fallback
-         * value to the first caller instead. Return `undefined` to expire normally and re-throw.
-         */
-        onError?: (error: unknown) => {
-            value: V;
-            createTTL?: number;
-            suppress?: boolean;
-        } | undefined;
-    }): Promise<V>;
-    private attachCallerLifecycle;
-    private cleanup;
-    private expired;
     /**
-     * Sets a promise in the cache.
-     * The promise will use the default options from the cache constructor, unless overridden.
-     *
-     * @param key - The cache key
-     * @param promise - The promise to cache
-     * @param options - Optional TTL options that override the defaults
-     */
-    set(key: K, promise: Promise<V>, options?: {
-        accessTTL?: number;
-        createTTL?: number;
-    }): void;
+     * Called when the factory promise rejects. Return a fallback result to cache
+     * instead of expiring. The fallback value is cached with the specified `createTTL`
+     * (defaults to the cache's `createTTL`). By default, the error is re-thrown to the
+     * first caller after caching the fallback. Set `suppress: true` to return the fallback
+     * value to the first caller instead. Return `undefined` to expire normally and re-throw.
+     */
+    onError?: (error: unknown) => {
+      value: V;
+      createTTL?: number;
+      suppress?: boolean;
+    } | undefined;
+  }): Promise<V>;
+  private attachCallerLifecycle;
+  private cleanup;
+  private expired;
+  /**
+   * Sets a promise in the cache.
+   * The promise will use the default options from the cache constructor, unless overridden.
+   *
+   * @param key - The cache key
+   * @param promise - The promise to cache
+   * @param options - Optional TTL options that override the defaults
+   */
+  set(key: K, promise: Promise<V>, options?: {
+    accessTTL?: number;
+    createTTL?: number;
+  }): void;
 }
 /**
  * A Map-like wrapper for promises that automatically removes failed promises from the cache.
  * This provides a drop-in replacement for Map<K, Promise<V>> with automatic error cleanup.
  */
 export declare class PromiseMap<K, V> {
-    private readonly cache;
-    private readonly aborts;
-    private readonly controllers;
-    get [Symbol.toStringTag](): string;
-    /**
-     * Gets a promise from the cache or creates a new one using the factory function.
-     * Failed promises are automatically removed from the cache.
-     *
-     * When `cancellation` is provided:
-     * - The factory receives an aggregate `AbortSignal` that only fires when **all** callers cancel
-     * - The returned promise rejects with `CancellationError` if this caller's signal fires
-     * - Other callers sharing the same cached promise are unaffected
-     *
-     * Callers without a `cancellation` signal count as "permanent" subscribers — the aggregate
-     * cannot fire while at least one is active. The slot is released when the caller's returned
-     * promise settles.
-     */
-    getOrCreate(key: K, factory: (cacheable: CacheController, cancellation?: AbortSignal) => Promise<V>, cancellation?: AbortSignal): Promise<V>;
-    private attachCallerLifecycle;
-    /**
-     * Marks a cached entry as invalidated.
-     * - If the entry has a `CacheController` (created via `getOrCreate`), it is soft-invalidated:
-     *   existing waiters complete normally, new callers joining during the remainder of the
-     *   in-flight operation share the same promise, and the entry self-evicts on settle.
-     * - If the entry was set via plain `.set()` (no controller), it is hard-deleted — there is
-     *   no in-flight factory to ride along with.
-     *
-     * No-op if the key is not cached.
-     */
-    invalidate(key: K): void;
-    /**
-     * Gets a promise from the cache, or undefined if not found.
-     */
-    get(key: K): Promise<V> | undefined;
-    /**
-     * Sets a promise in the cache. The promise will be automatically removed if it fails.
-     */
-    set(key: K, promise: Promise<V>): this;
-    /**
-     * Checks if a key exists in the cache.
-     */
-    has(key: K): boolean;
-    /**
-     * Removes a key from the cache.
-     *  Does NOT dispose the abort aggregate: while a factory is in flight, disposing would detach
-     *  its callers' cancellation and orphan the underlying op (a later caller-abort could no longer cancel the
-     *  running `git status`). The factory's own settle handler disposes the aggregate (see `getOrCreate`). */
-    delete(key: K): boolean;
-    /**
-     * Clears all entries. Like `delete`, does NOT dispose in-flight abort aggregates — that would detach a running
-     * op's cancellation (a later caller-abort couldn't cancel it); each factory's settle handler disposes its own.
-     */
-    clear(): void;
-    /**
-     * Returns the number of entries in the cache.
-     */
-    get size(): number;
-    /**
-     * Returns an iterator for the cache keys.
-     */
-    keys(): IterableIterator<K>;
-    /**
-     * Returns an iterator for the cache values.
-     */
-    values(): IterableIterator<Promise<V>>;
-    /**
-     * Returns an iterator for the cache entries.
-     */
-    entries(): IterableIterator<[K, Promise<V>]>;
-    /**
-     * Executes a provided function once for each cache entry.
-     */
-    forEach(callbackfn: (value: Promise<V>, key: K, map: Map<K, Promise<V>>) => void, thisArg?: any): void;
-    [Symbol.iterator](): IterableIterator<[K, Promise<V>]>;
+  private readonly cache;
+  private readonly aborts;
+  private readonly controllers;
+  get [Symbol.toStringTag](): string;
+  /**
+   * Gets a promise from the cache or creates a new one using the factory function.
+   * Failed promises are automatically removed from the cache.
+   *
+   * When `cancellation` is provided:
+   * - The factory receives an aggregate `AbortSignal` that only fires when **all** callers cancel
+   * - The returned promise rejects with `CancellationError` if this caller's signal fires
+   * - Other callers sharing the same cached promise are unaffected
+   *
+   * Callers without a `cancellation` signal count as "permanent" subscribers — the aggregate
+   * cannot fire while at least one is active. The slot is released when the caller's returned
+   * promise settles.
+   */
+  getOrCreate(key: K, factory: (cacheable: CacheController, cancellation?: AbortSignal) => Promise<V>, cancellation?: AbortSignal): Promise<V>;
+  private attachCallerLifecycle;
+  /**
+   * Marks a cached entry as invalidated.
+   * - If the entry has a `CacheController` (created via `getOrCreate`), it is soft-invalidated:
+   *   existing waiters complete normally, new callers joining during the remainder of the
+   *   in-flight operation share the same promise, and the entry self-evicts on settle.
+   * - If the entry was set via plain `.set()` (no controller), it is hard-deleted — there is
+   *   no in-flight factory to ride along with.
+   *
+   * No-op if the key is not cached.
+   */
+  invalidate(key: K): void;
+  /**
+   * Gets a promise from the cache, or undefined if not found.
+   */
+  get(key: K): Promise<V> | undefined;
+  /**
+   * Sets a promise in the cache. The promise will be automatically removed if it fails.
+   */
+  set(key: K, promise: Promise<V>): this;
+  /**
+   * Checks if a key exists in the cache.
+   */
+  has(key: K): boolean;
+  /**
+   * Removes a key from the cache.
+   *  Does NOT dispose the abort aggregate: while a factory is in flight, disposing would detach
+   *  its callers' cancellation and orphan the underlying op (a later caller-abort could no longer cancel the
+   *  running `git status`). The factory's own settle handler disposes the aggregate (see `getOrCreate`). */
+  delete(key: K): boolean;
+  /**
+   * Clears all entries. Like `delete`, does NOT dispose in-flight abort aggregates — that would detach a running
+   * op's cancellation (a later caller-abort couldn't cancel it); each factory's settle handler disposes its own.
+   */
+  clear(): void;
+  /**
+   * Returns the number of entries in the cache.
+   */
+  get size(): number;
+  /**
+   * Returns an iterator for the cache keys.
+   */
+  keys(): IterableIterator<K>;
+  /**
+   * Returns an iterator for the cache values.
+   */
+  values(): IterableIterator<Promise<V>>;
+  /**
+   * Returns an iterator for the cache entries.
+   */
+  entries(): IterableIterator<[K, Promise<V>]>;
+  /**
+   * Executes a provided function once for each cache entry.
+   */
+  forEach(callbackfn: (value: Promise<V>, key: K, map: Map<K, Promise<V>>) => void, thisArg?: any): void;
+  [Symbol.iterator](): IterableIterator<[K, Promise<V>]>;
 }
 /**
  * A two-level cache that organizes PromiseCaches by repository path.
@@ -209,117 +210,117 @@ export declare class PromiseMap<K, V> {
  * with TTL and capacity management provided by PromiseCache.
  */
 export declare class RepoPromiseCacheMap<K, V> {
-    private readonly cache;
-    private readonly options;
-    constructor(options?: PromiseCacheOptions);
-    get [Symbol.toStringTag](): string;
-    /**
-     * Gets a promise from the cache or creates a new one using the factory function.
-     * Automatically creates the inner PromiseCache for the repository if it doesn't exist.
-     *
-     * @param repoPath - The repository path (outer key)
-     * @param key - The cache key within the repository (inner key)
-     * @param factory - Factory function to create the value if not cached
-     * @param options - Optional TTL and error handling options that override the defaults
-     */
-    getOrCreate(repoPath: string, key: K, factory: (cacheable: CacheController, cancellation?: AbortSignal) => Promise<V>, options?: {
-        /** Per-caller AbortSignal — the factory receives an aggregate signal that only fires when all callers cancel */
-        cancellation?: AbortSignal;
-        /** TTL (time-to-live) in milliseconds since creation */
-        createTTL?: number;
-        /** TTL (time-to-live) in milliseconds since last access */
-        accessTTL?: number;
-        /** Whether to expire the entry if the promise fails */
-        expireOnError?: boolean;
-        /**
-         * Called after the factory resolves. If the predicate resolves to true, the entry is evicted while
-         * the current caller still receives the resolved value.
-         */
-        evictWhen?: (value: V) => boolean | Promise<boolean>;
-        /**
-         * TTL (time-to-live) in milliseconds for caching errors. When the factory rejects and `errorTTL` is set,
-         * the cache entry is replaced with `Promise.resolve(undefined)` for subsequent callers, and the error
-         * is re-thrown to the first caller. After `errorTTL` expires, the next call retries.
-         * Only used when `onError` is not provided.
-         */
-        errorTTL?: number;
-        /**
-         * Called when the factory promise rejects. Return a fallback result to cache
-         * instead of expiring. The fallback value is cached with the specified `createTTL`
-         * (defaults to the cache's `createTTL`). By default, the error is re-thrown to the
-         * first caller after caching the fallback. Set `suppress: true` to return the fallback
-         * value to the first caller instead. Return `undefined` to expire normally and re-throw.
-         */
-        onError?: (error: unknown) => {
-            value: V;
-            createTTL?: number;
-            suppress?: boolean;
-        } | undefined;
-    }): Promise<V>;
-    /**
-     * Gets a promise from the cache without creating it.
-     *
-     * @param repoPath - The repository path (outer key)
-     * @param key - The cache key within the repository (inner key)
-     * @returns The cached promise, or undefined if not cached
-     */
-    get(repoPath: string, key: K): Promise<V> | undefined;
-    /**
-     * Sets a promise in the cache.
-     *
-     * @param repoPath - The repository path (outer key)
-     * @param key - The cache key within the repository (inner key)
-     * @param promise - The promise to cache
-     * @param options - Optional TTL options that override the defaults
-     */
-    set(repoPath: string, key: K, promise: Promise<V>, options?: {
-        accessTTL?: number;
-        createTTL?: number;
-    }): void;
-    /**
-     * Deletes a specific key from a repository's cache, or all keys for a repository.
-     *
-     * @param repoPath - The repository path
-     * @param key - Optional specific key to delete. If omitted, deletes the entire repository cache.
-     * @returns true if something was deleted, false otherwise
-     */
-    delete(repoPath: string, key?: K): boolean;
-    /**
-     * Marks a cached entry as invalidated. See `PromiseCache.invalidate` for semantics.
-     *
-     * @param repoPath - The repository path
-     * @param key - Optional specific key to invalidate. If omitted, invalidates every entry for the repository.
-     */
-    invalidate(repoPath: string, key?: K): void;
-    /**
-     * Deletes all keys matching a prefix from a repository's cache.
-     * @param repoPath - The repository path
-     * @param prefix - Key prefix to match
-     * @returns true if something was deleted
-     */
-    deleteByKeyPrefix(this: RepoPromiseCacheMap<string, V>, repoPath: string, prefix: string): boolean;
-    /**
-     * Invalidates all keys matching a prefix from a repository's cache. See `PromiseCache.invalidate`
-     * for semantics — in-flight entries are marked invalidated and shared with new callers; settled
-     * entries are hard-deleted. Prefer over `deleteByKeyPrefix` when the eviction is a "data has
-     * changed" event and in-flight factories' results would still be valid for current waiters.
-     * @param repoPath - The repository path
-     * @param prefix - Key prefix to match
-     * @returns true if something was invalidated
-     */
-    invalidateByKeyPrefix(this: RepoPromiseCacheMap<string, V>, repoPath: string, prefix: string): boolean;
+  private readonly cache;
+  private readonly options;
+  constructor(options?: PromiseCacheOptions);
+  get [Symbol.toStringTag](): string;
+  /**
+   * Gets a promise from the cache or creates a new one using the factory function.
+   * Automatically creates the inner PromiseCache for the repository if it doesn't exist.
+   *
+   * @param repoPath - The repository path (outer key)
+   * @param key - The cache key within the repository (inner key)
+   * @param factory - Factory function to create the value if not cached
+   * @param options - Optional TTL and error handling options that override the defaults
+   */
+  getOrCreate(repoPath: string, key: K, factory: (cacheable: CacheController, cancellation?: AbortSignal) => Promise<V>, options?: {
+    /** Per-caller AbortSignal — the factory receives an aggregate signal that only fires when all callers cancel */
+    cancellation?: AbortSignal;
+    /** TTL (time-to-live) in milliseconds since creation */
+    createTTL?: number;
+    /** TTL (time-to-live) in milliseconds since last access */
+    accessTTL?: number;
+    /** Whether to expire the entry if the promise fails */
+    expireOnError?: boolean;
     /**
-     * Clears all caches for all repositories.
+     * Called after the factory resolves. If the predicate resolves to true, the entry is evicted while
+     * the current caller still receives the resolved value.
      */
-    clear(): void;
+    evictWhen?: (value: V) => boolean | Promise<boolean>;
     /**
-     * Returns the total number of entries across all repository caches.
+     * TTL (time-to-live) in milliseconds for caching errors. When the factory rejects and `errorTTL` is set,
+     * the cache entry is replaced with `Promise.resolve(undefined)` for subsequent callers, and the error
+     * is re-thrown to the first caller. After `errorTTL` expires, the next call retries.
+     * Only used when `onError` is not provided.
      */
-    get entryCount(): number;
+    errorTTL?: number;
     /**
-     * Returns the number of repositories in the cache.
-     */
-    get size(): number;
+     * Called when the factory promise rejects. Return a fallback result to cache
+     * instead of expiring. The fallback value is cached with the specified `createTTL`
+     * (defaults to the cache's `createTTL`). By default, the error is re-thrown to the
+     * first caller after caching the fallback. Set `suppress: true` to return the fallback
+     * value to the first caller instead. Return `undefined` to expire normally and re-throw.
+     */
+    onError?: (error: unknown) => {
+      value: V;
+      createTTL?: number;
+      suppress?: boolean;
+    } | undefined;
+  }): Promise<V>;
+  /**
+   * Gets a promise from the cache without creating it.
+   *
+   * @param repoPath - The repository path (outer key)
+   * @param key - The cache key within the repository (inner key)
+   * @returns The cached promise, or undefined if not cached
+   */
+  get(repoPath: string, key: K): Promise<V> | undefined;
+  /**
+   * Sets a promise in the cache.
+   *
+   * @param repoPath - The repository path (outer key)
+   * @param key - The cache key within the repository (inner key)
+   * @param promise - The promise to cache
+   * @param options - Optional TTL options that override the defaults
+   */
+  set(repoPath: string, key: K, promise: Promise<V>, options?: {
+    accessTTL?: number;
+    createTTL?: number;
+  }): void;
+  /**
+   * Deletes a specific key from a repository's cache, or all keys for a repository.
+   *
+   * @param repoPath - The repository path
+   * @param key - Optional specific key to delete. If omitted, deletes the entire repository cache.
+   * @returns true if something was deleted, false otherwise
+   */
+  delete(repoPath: string, key?: K): boolean;
+  /**
+   * Marks a cached entry as invalidated. See `PromiseCache.invalidate` for semantics.
+   *
+   * @param repoPath - The repository path
+   * @param key - Optional specific key to invalidate. If omitted, invalidates every entry for the repository.
+   */
+  invalidate(repoPath: string, key?: K): void;
+  /**
+   * Deletes all keys matching a prefix from a repository's cache.
+   * @param repoPath - The repository path
+   * @param prefix - Key prefix to match
+   * @returns true if something was deleted
+   */
+  deleteByKeyPrefix(this: RepoPromiseCacheMap<string, V>, repoPath: string, prefix: string): boolean;
+  /**
+   * Invalidates all keys matching a prefix from a repository's cache. See `PromiseCache.invalidate`
+   * for semantics — in-flight entries are marked invalidated and shared with new callers; settled
+   * entries are hard-deleted. Prefer over `deleteByKeyPrefix` when the eviction is a "data has
+   * changed" event and in-flight factories' results would still be valid for current waiters.
+   * @param repoPath - The repository path
+   * @param prefix - Key prefix to match
+   * @returns true if something was invalidated
+   */
+  invalidateByKeyPrefix(this: RepoPromiseCacheMap<string, V>, repoPath: string, prefix: string): boolean;
+  /**
+   * Clears all caches for all repositories.
+   */
+  clear(): void;
+  /**
+   * Returns the total number of entries across all repository caches.
+   */
+  get entryCount(): number;
+  /**
+   * Returns the number of repositories in the cache.
+   */
+  get size(): number;
 }
 /**
  * A two-level cache that organizes PromiseMaps by repository path.
@@ -329,48 +330,48 @@ export declare class RepoPromiseCacheMap<K, V> {
  * with simple promise deduplication and automatic error cleanup.
  */
 export declare class RepoPromiseMap<K, V> {
-    private readonly cache;
-    get [Symbol.toStringTag](): string;
-    /**
-     * Gets a promise from the cache or creates a new one using the factory function.
-     * Automatically creates the inner PromiseMap for the repository if it doesn't exist.
-     *
-     * @param repoPath - The repository path (outer key)
-     * @param key - The cache key within the repository (inner key)
-     * @param factory - Factory function to create the value if not cached
-     */
-    getOrCreate(repoPath: string, key: K, factory: (cacheable: CacheController, cancellation?: AbortSignal) => Promise<V>, cancellation?: AbortSignal): Promise<V>;
-    /**
-     * Gets a promise from the cache without creating it.
-     *
-     * @param repoPath - The repository path (outer key)
-     * @param key - The cache key within the repository (inner key)
-     * @returns The cached promise, or undefined if not found
-     */
-    get(repoPath: string, key: K): Promise<V> | undefined;
-    /**
-     * Deletes a specific key from a repository's cache, or all keys for a repository.
-     *
-     * @param repoPath - The repository path
-     * @param key - Optional specific key to delete. If omitted, deletes the entire repository cache.
-     * @returns true if something was deleted, false otherwise
-     */
-    delete(repoPath: string, key?: K): boolean;
-    /**
-     * Marks a cached entry as invalidated. See `PromiseMap.invalidate` for semantics.
-     *
-     * @param repoPath - The repository path
-     * @param key - Optional specific key to invalidate. If omitted, invalidates every entry for the repository.
-     */
-    invalidate(repoPath: string, key?: K): void;
-    /**
-     * Clears all caches for all repositories.
-     */
-    clear(): void;
-    /**
-     * Returns the number of repositories in the cache.
-     */
-    get size(): number;
+  private readonly cache;
+  get [Symbol.toStringTag](): string;
+  /**
+   * Gets a promise from the cache or creates a new one using the factory function.
+   * Automatically creates the inner PromiseMap for the repository if it doesn't exist.
+   *
+   * @param repoPath - The repository path (outer key)
+   * @param key - The cache key within the repository (inner key)
+   * @param factory - Factory function to create the value if not cached
+   */
+  getOrCreate(repoPath: string, key: K, factory: (cacheable: CacheController, cancellation?: AbortSignal) => Promise<V>, cancellation?: AbortSignal): Promise<V>;
+  /**
+   * Gets a promise from the cache without creating it.
+   *
+   * @param repoPath - The repository path (outer key)
+   * @param key - The cache key within the repository (inner key)
+   * @returns The cached promise, or undefined if not found
+   */
+  get(repoPath: string, key: K): Promise<V> | undefined;
+  /**
+   * Deletes a specific key from a repository's cache, or all keys for a repository.
+   *
+   * @param repoPath - The repository path
+   * @param key - Optional specific key to delete. If omitted, deletes the entire repository cache.
+   * @returns true if something was deleted, false otherwise
+   */
+  delete(repoPath: string, key?: K): boolean;
+  /**
+   * Marks a cached entry as invalidated. See `PromiseMap.invalidate` for semantics.
+   *
+   * @param repoPath - The repository path
+   * @param key - Optional specific key to invalidate. If omitted, invalidates every entry for the repository.
+   */
+  invalidate(repoPath: string, key?: K): void;
+  /**
+   * Clears all caches for all repositories.
+   */
+  clear(): void;
+  /**
+   * Returns the number of repositories in the cache.
+   */
+  get size(): number;
 }
-export {};
+//#endregion
 //# sourceMappingURL=promiseCache.d.ts.map