@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/utils/promiseCache.js

@@ -1,724 +1,609 @@
-import { AbortAggregate, CancellationError, raceWithSignal } from './cancellation.js';
+import { AbortAggregate, CancellationError, raceWithSignal } from "./cancellation.js";
+//#region ../utils/src/promiseCache.ts
 /** Deletes `key` from `map` only if it still maps to `owner`. A `delete(key)` + fresh `getOrCreate` can install
- *  a successor under the same key while our factory is in flight; our late settle must not evict the successor. */
+*  a successor under the same key while our factory is in flight; our late settle must not evict the successor. */
 function deleteIfOwned(map, key, owner) {
-    if (map.get(key) === owner) {
-        map.delete(key);
-    }
-}
-export class CacheController {
-    #invalidated = false;
-    get invalidated() {
-        return this.#invalidated;
-    }
-    invalidate() {
-        this.#invalidated = true;
-    }
-}
-export class PromiseCache {
-    cache = new Map();
-    aborts = new Map();
-    controllers = new Map();
-    options;
-    constructor(options) {
-        this.options = { expireOnError: true, ...options };
-    }
-    /** 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() {
-        this.aborts.clear();
-        this.controllers.clear();
-        this.cache.clear();
-    }
-    /**
-     * 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) {
-        this.aborts.delete(key);
-        this.controllers.delete(key);
-        this.cache.delete(key);
-    }
-    /**
-     * 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) {
-        if (this.controllers.has(key)) {
-            this.controllers.get(key).invalidate();
-        }
-        else {
-            this.delete(key);
-        }
-    }
-    keys() {
-        return this.cache.keys();
-    }
-    /**
-     * 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() {
-        return this.cache.size;
-    }
-    /**
-     * 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) {
-        const now = Date.now();
-        const entry = this.cache.get(key);
-        if (entry == null || this.expired(entry, now)) {
-            return undefined;
-        }
-        // Update accessed time
-        entry.accessed = now;
-        return entry.promise;
-    }
-    /**
-     * 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
-     */
-    async getOrCreate(key, factory, options) {
-        const cancellation = options?.cancellation;
-        if (cancellation?.aborted)
-            return Promise.reject(new CancellationError());
-        const now = Date.now();
-        options = { ...this.options, ...options };
-        let entry = this.cache.get(key);
-        if (entry != null && !this.expired(entry, now)) {
-            // Cache hit — but don't join an entry whose aggregate has already permanently aborted (all prior
-            // callers cancelled, so the shared run is failing): that would hand this caller a doomed promise.
-            // Fall through to create a fresh entry; the doomed entry's late settle is `deleteIfOwned`-guarded.
-            const existingAborts = this.aborts.get(key);
-            if (existingAborts == null || !existingAborts.signal.aborted) {
-                entry.accessed = now;
-                const cleanup = existingAborts != null ? existingAborts.add(cancellation) : undefined;
-                return this.attachCallerLifecycle(entry.promise, cancellation, cleanup);
-            }
-        }
-        const cacheable = new CacheController();
-        // Always create the aggregate so subsequent callers (with or without signals) can contribute,
-        // and so delete/invalidate has a controller to interact with
-        const abortAgg = new AbortAggregate();
-        const cleanup = abortAgg.add(cancellation);
-        this.aborts.set(key, abortAgg);
-        this.controllers.set(key, cacheable);
-        const promise = factory(cacheable, abortAgg.signal);
-        void promise
-            .finally(() => {
-            // All three deletes are ownership-guarded — a hard `delete(key)` + fresh `getOrCreate` while our
-            // factory is in flight installs a successor under `key`; our late settle must not evict it.
-            if (cacheable.invalidated) {
-                deleteIfOwned(this.cache, key, entry);
-            }
-            abortAgg.dispose();
-            deleteIfOwned(this.aborts, key, abortAgg);
-            deleteIfOwned(this.controllers, key, cacheable);
-        })
-            // Swallow the cleanup chain's rejection so it doesn't surface as an unhandled rejection
-            // separate from the caller-facing promise's own handling (e.g. on cancellation).
-            .catch(() => { });
-        if (options?.onError != null) {
-            // Wrap the promise to handle errors with the onError callback
-            const errorHandled = promise.catch((ex) => {
-                const result = options.onError(ex);
-                // A hard `delete(key)` + fresh `getOrCreate` while we were in flight installs a successor;
-                // don't clobber it. But an EMPTY key (our entry already evicted, e.g. by the invalidated-finally)
-                // still takes the fallback — preserving base behavior of caching the error fallback.
-                const occupant = this.cache.get(key);
-                const clobbersSuccessor = occupant != null && occupant !== entry;
-                if (result != null) {
-                    // Replace the entry with a resolved fallback value for subsequent callers
-                    if (!clobbersSuccessor) {
-                        const errorNow = Date.now();
-                        this.cache.set(key, {
-                            promise: Promise.resolve(result.value),
-                            created: errorNow,
-                            accessed: errorNow,
-                            createTTL: result.createTTL ?? options.createTTL,
-                            accessTTL: options.accessTTL,
-                        });
-                    }
-                    // suppress: return fallback to first caller; otherwise re-throw
-                    if (result.suppress)
-                        return result.value;
-                }
-                else {
-                    deleteIfOwned(this.cache, key, entry);
-                }
-                throw ex;
-            });
-            entry = {
-                promise: errorHandled,
-                created: now,
-                accessed: now,
-                createTTL: options.createTTL,
-                accessTTL: options.accessTTL,
-            };
-            this.cache.set(key, entry);
-        }
-        else if (options?.errorTTL != null) {
-            // Cache resolved undefined for subsequent callers, re-throw to first caller
-            const errorTTL = options.errorTTL;
-            const errorHandled = promise.catch((ex) => {
-                // Overwrite unless a successor now owns the key (empty key still takes it — see onError above).
-                const occupant = this.cache.get(key);
-                if (occupant == null || occupant === entry) {
-                    const errorNow = Date.now();
-                    this.cache.set(key, {
-                        promise: Promise.resolve(undefined),
-                        created: errorNow,
-                        accessed: errorNow,
-                        createTTL: errorTTL,
-                        accessTTL: options.accessTTL,
-                    });
-                }
-                throw ex;
-            });
-            entry = {
-                promise: errorHandled,
-                created: now,
-                accessed: now,
-                createTTL: options.createTTL,
-                accessTTL: options.accessTTL,
-            };
-            this.cache.set(key, entry);
-        }
-        else {
-            entry = {
-                promise: promise,
-                created: now,
-                accessed: now,
-                createTTL: options.createTTL,
-                accessTTL: options.accessTTL,
-            };
-            this.cache.set(key, entry);
-            if (options?.expireOnError ?? true) {
-                // Ownership-guarded: a hard `delete(key)` + fresh `getOrCreate` replacing us while in flight must
-                // not have its entry evicted by our rejection.
-                const ourEntry = entry;
-                promise.catch(() => deleteIfOwned(this.cache, key, ourEntry));
-            }
-        }
-        const evictWhen = options?.evictWhen;
-        if (evictWhen != null) {
-            const candidate = entry;
-            void candidate.promise
-                .then(value => evictWhen(value))
-                .then(evict => {
-                if (evict) {
-                    deleteIfOwned(this.cache, key, candidate);
-                }
-            })
-                // A retention policy must not surface a rejection independently of the caller-facing operation.
-                .catch(() => { });
-        }
-        // Clean up expired entries and enforce capacity limit in one pass
-        if (this.cache.size > 1) {
-            queueMicrotask(() => this.cleanup());
-        }
-        return this.attachCallerLifecycle(entry.promise, cancellation, cleanup);
-    }
-    attachCallerLifecycle(promise, cancellation, cleanup) {
-        const returned = cancellation != null ? raceWithSignal(promise, cancellation) : promise;
-        if (cleanup != null) {
-            // Release this caller's aggregate slot when their wait ends.
-            // Attach .catch to swallow any rejection in the cleanup chain so it doesn't surface
-            // as an unhandled rejection separate from the caller's own handling of `returned`.
-            void returned.finally(cleanup).catch(() => { });
-        }
-        return returned;
-    }
-    cleanup() {
-        const now = Date.now();
-        const capacity = this.options.capacity;
-        // If no capacity limit, just remove expired entries
-        if (capacity == null) {
-            for (const [key, entry] of this.cache.entries()) {
-                if (this.expired(entry, now)) {
-                    this.cache.delete(key);
-                }
-            }
-            return;
-        }
-        // Single pass: collect non-expired entries and find LRU candidates
-        const entries = [];
-        for (const [key, entry] of this.cache.entries()) {
-            if (!this.expired(entry, now)) {
-                entries.push([key, entry]);
-            }
-            else {
-                this.cache.delete(key);
-            }
-        }
-        // If still over capacity, remove LRU entries
-        const excess = entries.length - capacity;
-        if (excess > 0) {
-            // Sort by accessed time (oldest first) and remove the excess
-            // Note: O(N log N) sort — acceptable at current cache sizes; replace with a linked-list LRU if capacity grows
-            entries.sort((a, b) => a[1].accessed - b[1].accessed);
-            for (let i = 0; i < excess; i++) {
-                this.cache.delete(entries[i][0]);
-            }
-        }
-    }
-    expired(entry, now) {
-        return ((entry.createTTL != null && now - entry.created >= entry.createTTL) ||
-            (entry.accessTTL != null && now - entry.accessed >= entry.accessTTL));
-    }
-    /**
-     * 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, promise, options) {
-        const now = Date.now();
-        const entry = {
-            promise: promise,
-            created: now,
-            accessed: now,
-            createTTL: options?.createTTL ?? this.options.createTTL,
-            accessTTL: options?.accessTTL ?? this.options.accessTTL,
-        };
-        this.cache.set(key, entry);
-        if (this.options.expireOnError ?? true) {
-            promise.catch(() => deleteIfOwned(this.cache, key, entry));
-        }
-    }
+	if (map.get(key) === owner) map.delete(key);
 }
+var CacheController = class {
+	#invalidated = false;
+	get invalidated() {
+		return this.#invalidated;
+	}
+	invalidate() {
+		this.#invalidated = true;
+	}
+};
+var PromiseCache = class {
+	cache = /* @__PURE__ */ new Map();
+	aborts = /* @__PURE__ */ new Map();
+	controllers = /* @__PURE__ */ new Map();
+	options;
+	constructor(options) {
+		this.options = {
+			expireOnError: true,
+			...options
+		};
+	}
+	/** 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() {
+		this.aborts.clear();
+		this.controllers.clear();
+		this.cache.clear();
+	}
+	/**
+	* 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) {
+		this.aborts.delete(key);
+		this.controllers.delete(key);
+		this.cache.delete(key);
+	}
+	/**
+	* 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) {
+		if (this.controllers.has(key)) this.controllers.get(key).invalidate();
+		else this.delete(key);
+	}
+	keys() {
+		return this.cache.keys();
+	}
+	/**
+	* 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() {
+		return this.cache.size;
+	}
+	/**
+	* 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) {
+		const now = Date.now();
+		const entry = this.cache.get(key);
+		if (entry == null || this.expired(entry, now)) return;
+		entry.accessed = now;
+		return entry.promise;
+	}
+	/**
+	* 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
+	*/
+	async getOrCreate(key, factory, options) {
+		const cancellation = options?.cancellation;
+		if (cancellation?.aborted) return Promise.reject(new CancellationError());
+		const now = Date.now();
+		options = {
+			...this.options,
+			...options
+		};
+		let entry = this.cache.get(key);
+		if (entry != null && !this.expired(entry, now)) {
+			const existingAborts = this.aborts.get(key);
+			if (existingAborts == null || !existingAborts.signal.aborted) {
+				entry.accessed = now;
+				const cleanup = existingAborts != null ? existingAborts.add(cancellation) : void 0;
+				return this.attachCallerLifecycle(entry.promise, cancellation, cleanup);
+			}
+		}
+		const cacheable = new CacheController();
+		const abortAgg = new AbortAggregate();
+		const cleanup = abortAgg.add(cancellation);
+		this.aborts.set(key, abortAgg);
+		this.controllers.set(key, cacheable);
+		const promise = factory(cacheable, abortAgg.signal);
+		promise.finally(() => {
+			if (cacheable.invalidated) deleteIfOwned(this.cache, key, entry);
+			abortAgg.dispose();
+			deleteIfOwned(this.aborts, key, abortAgg);
+			deleteIfOwned(this.controllers, key, cacheable);
+		}).catch(() => {});
+		if (options?.onError != null) {
+			entry = {
+				promise: promise.catch((ex) => {
+					const result = options.onError(ex);
+					const occupant = this.cache.get(key);
+					const clobbersSuccessor = occupant != null && occupant !== entry;
+					if (result != null) {
+						if (!clobbersSuccessor) {
+							const errorNow = Date.now();
+							this.cache.set(key, {
+								promise: Promise.resolve(result.value),
+								created: errorNow,
+								accessed: errorNow,
+								createTTL: result.createTTL ?? options.createTTL,
+								accessTTL: options.accessTTL
+							});
+						}
+						if (result.suppress) return result.value;
+					} else deleteIfOwned(this.cache, key, entry);
+					throw ex;
+				}),
+				created: now,
+				accessed: now,
+				createTTL: options.createTTL,
+				accessTTL: options.accessTTL
+			};
+			this.cache.set(key, entry);
+		} else if (options?.errorTTL != null) {
+			const errorTTL = options.errorTTL;
+			entry = {
+				promise: promise.catch((ex) => {
+					const occupant = this.cache.get(key);
+					if (occupant == null || occupant === entry) {
+						const errorNow = Date.now();
+						this.cache.set(key, {
+							promise: Promise.resolve(void 0),
+							created: errorNow,
+							accessed: errorNow,
+							createTTL: errorTTL,
+							accessTTL: options.accessTTL
+						});
+					}
+					throw ex;
+				}),
+				created: now,
+				accessed: now,
+				createTTL: options.createTTL,
+				accessTTL: options.accessTTL
+			};
+			this.cache.set(key, entry);
+		} else {
+			entry = {
+				promise,
+				created: now,
+				accessed: now,
+				createTTL: options.createTTL,
+				accessTTL: options.accessTTL
+			};
+			this.cache.set(key, entry);
+			if (options?.expireOnError ?? true) {
+				const ourEntry = entry;
+				promise.catch(() => deleteIfOwned(this.cache, key, ourEntry));
+			}
+		}
+		const evictWhen = options?.evictWhen;
+		if (evictWhen != null) {
+			const candidate = entry;
+			candidate.promise.then((value) => evictWhen(value)).then((evict) => {
+				if (evict) deleteIfOwned(this.cache, key, candidate);
+			}).catch(() => {});
+		}
+		if (this.cache.size > 1) queueMicrotask(() => this.cleanup());
+		return this.attachCallerLifecycle(entry.promise, cancellation, cleanup);
+	}
+	attachCallerLifecycle(promise, cancellation, cleanup) {
+		const returned = cancellation != null ? raceWithSignal(promise, cancellation) : promise;
+		if (cleanup != null) returned.finally(cleanup).catch(() => {});
+		return returned;
+	}
+	cleanup() {
+		const now = Date.now();
+		const capacity = this.options.capacity;
+		if (capacity == null) {
+			for (const [key, entry] of this.cache.entries()) if (this.expired(entry, now)) this.cache.delete(key);
+			return;
+		}
+		const entries = [];
+		for (const [key, entry] of this.cache.entries()) if (!this.expired(entry, now)) entries.push([key, entry]);
+		else this.cache.delete(key);
+		const excess = entries.length - capacity;
+		if (excess > 0) {
+			entries.sort((a, b) => a[1].accessed - b[1].accessed);
+			for (let i = 0; i < excess; i++) this.cache.delete(entries[i][0]);
+		}
+	}
+	expired(entry, now) {
+		return entry.createTTL != null && now - entry.created >= entry.createTTL || entry.accessTTL != null && now - entry.accessed >= entry.accessTTL;
+	}
+	/**
+	* 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, promise, options) {
+		const now = Date.now();
+		const entry = {
+			promise,
+			created: now,
+			accessed: now,
+			createTTL: options?.createTTL ?? this.options.createTTL,
+			accessTTL: options?.accessTTL ?? this.options.accessTTL
+		};
+		this.cache.set(key, entry);
+		if (this.options.expireOnError ?? true) promise.catch(() => deleteIfOwned(this.cache, key, entry));
+	}
+};
 /**
- * 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 class PromiseMap {
-    cache = new Map();
-    aborts = new Map();
-    controllers = new Map();
-    get [Symbol.toStringTag]() {
-        return 'PromiseMap';
-    }
-    /**
-     * 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, factory, cancellation) {
-        if (cancellation?.aborted)
-            return Promise.reject(new CancellationError());
-        const cached = this.cache.get(key);
-        if (cached != null) {
-            // Cache hit — but don't join an entry whose aggregate has already permanently aborted (all prior
-            // callers cancelled, so the shared run is failing): joining hands this caller a doomed promise.
-            // Fall through to a fresh entry; the doomed entry's late settle is `deleteIfOwned`-guarded.
-            const existingAborts = this.aborts.get(key);
-            if (existingAborts == null || !existingAborts.signal.aborted) {
-                const cleanup = existingAborts != null ? existingAborts.add(cancellation) : undefined;
-                return this.attachCallerLifecycle(cached, cancellation, cleanup);
-            }
-        }
-        // Cache miss — always create the aggregate so subsequent callers (with or without signals)
-        // can contribute, and so delete/invalidate has a controller to interact with
-        const cacheable = new CacheController();
-        const aborts = new AbortAggregate();
-        const cleanup = aborts.add(cancellation);
-        this.aborts.set(key, aborts);
-        this.controllers.set(key, cacheable);
-        const promise = factory(cacheable, aborts.signal);
-        // Automatically remove failed promises from the cache (ownership-guarded — see `deleteIfOwned`).
-        promise.catch(() => deleteIfOwned(this.cache, key, promise));
-        void promise
-            .finally(() => {
-            if (cacheable.invalidated) {
-                deleteIfOwned(this.cache, key, promise);
-            }
-            aborts.dispose();
-            deleteIfOwned(this.aborts, key, aborts);
-            deleteIfOwned(this.controllers, key, cacheable);
-        })
-            // Swallow the cleanup chain's rejection so it doesn't surface as an unhandled rejection
-            // separate from the caller-facing promise's own handling (e.g. on cancellation).
-            .catch(() => { });
-        this.cache.set(key, promise);
-        return this.attachCallerLifecycle(promise, cancellation, cleanup);
-    }
-    attachCallerLifecycle(promise, cancellation, cleanup) {
-        const returned = cancellation != null ? raceWithSignal(promise, cancellation) : promise;
-        if (cleanup != null) {
-            // Release this caller's aggregate slot when their wait ends.
-            // Attach .catch to swallow any rejection in the cleanup chain so it doesn't surface
-            // as an unhandled rejection separate from the caller's own handling of `returned`.
-            void returned.finally(cleanup).catch(() => { });
-        }
-        return returned;
-    }
-    /**
-     * 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) {
-        if (this.controllers.has(key)) {
-            this.controllers.get(key).invalidate();
-        }
-        else {
-            this.delete(key);
-        }
-    }
-    /**
-     * Gets a promise from the cache, or undefined if not found.
-     */
-    get(key) {
-        return this.cache.get(key);
-    }
-    /**
-     * Sets a promise in the cache. The promise will be automatically removed if it fails.
-     */
-    set(key, promise) {
-        this.cache.set(key, promise);
-        // Automatically remove failed promises from the cache (ownership-guarded — see `deleteIfOwned`).
-        promise.catch(() => deleteIfOwned(this.cache, key, promise));
-        return this;
-    }
-    /**
-     * Checks if a key exists in the cache.
-     */
-    has(key) {
-        return this.cache.has(key);
-    }
-    /**
-     * 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) {
-        this.aborts.delete(key);
-        this.controllers.delete(key);
-        return this.cache.delete(key);
-    }
-    /**
-     * 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() {
-        this.aborts.clear();
-        this.controllers.clear();
-        this.cache.clear();
-    }
-    /**
-     * Returns the number of entries in the cache.
-     */
-    get size() {
-        return this.cache.size;
-    }
-    /**
-     * Returns an iterator for the cache keys.
-     */
-    keys() {
-        return this.cache.keys();
-    }
-    /**
-     * Returns an iterator for the cache values.
-     */
-    values() {
-        return this.cache.values();
-    }
-    /**
-     * Returns an iterator for the cache entries.
-     */
-    entries() {
-        return this.cache.entries();
-    }
-    /**
-     * Executes a provided function once for each cache entry.
-     */
-    forEach(callbackfn, thisArg) {
-        this.cache.forEach(callbackfn, thisArg);
-    }
-    [Symbol.iterator]() {
-        return this.cache[Symbol.iterator]();
-    }
-}
+* 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.
+*/
+var PromiseMap = class {
+	cache = /* @__PURE__ */ new Map();
+	aborts = /* @__PURE__ */ new Map();
+	controllers = /* @__PURE__ */ new Map();
+	get [Symbol.toStringTag]() {
+		return "PromiseMap";
+	}
+	/**
+	* 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, factory, cancellation) {
+		if (cancellation?.aborted) return Promise.reject(new CancellationError());
+		const cached = this.cache.get(key);
+		if (cached != null) {
+			const existingAborts = this.aborts.get(key);
+			if (existingAborts == null || !existingAborts.signal.aborted) {
+				const cleanup = existingAborts != null ? existingAborts.add(cancellation) : void 0;
+				return this.attachCallerLifecycle(cached, cancellation, cleanup);
+			}
+		}
+		const cacheable = new CacheController();
+		const aborts = new AbortAggregate();
+		const cleanup = aborts.add(cancellation);
+		this.aborts.set(key, aborts);
+		this.controllers.set(key, cacheable);
+		const promise = factory(cacheable, aborts.signal);
+		promise.catch(() => deleteIfOwned(this.cache, key, promise));
+		promise.finally(() => {
+			if (cacheable.invalidated) deleteIfOwned(this.cache, key, promise);
+			aborts.dispose();
+			deleteIfOwned(this.aborts, key, aborts);
+			deleteIfOwned(this.controllers, key, cacheable);
+		}).catch(() => {});
+		this.cache.set(key, promise);
+		return this.attachCallerLifecycle(promise, cancellation, cleanup);
+	}
+	attachCallerLifecycle(promise, cancellation, cleanup) {
+		const returned = cancellation != null ? raceWithSignal(promise, cancellation) : promise;
+		if (cleanup != null) returned.finally(cleanup).catch(() => {});
+		return returned;
+	}
+	/**
+	* 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) {
+		if (this.controllers.has(key)) this.controllers.get(key).invalidate();
+		else this.delete(key);
+	}
+	/**
+	* Gets a promise from the cache, or undefined if not found.
+	*/
+	get(key) {
+		return this.cache.get(key);
+	}
+	/**
+	* Sets a promise in the cache. The promise will be automatically removed if it fails.
+	*/
+	set(key, promise) {
+		this.cache.set(key, promise);
+		promise.catch(() => deleteIfOwned(this.cache, key, promise));
+		return this;
+	}
+	/**
+	* Checks if a key exists in the cache.
+	*/
+	has(key) {
+		return this.cache.has(key);
+	}
+	/**
+	* 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) {
+		this.aborts.delete(key);
+		this.controllers.delete(key);
+		return this.cache.delete(key);
+	}
+	/**
+	* 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() {
+		this.aborts.clear();
+		this.controllers.clear();
+		this.cache.clear();
+	}
+	/**
+	* Returns the number of entries in the cache.
+	*/
+	get size() {
+		return this.cache.size;
+	}
+	/**
+	* Returns an iterator for the cache keys.
+	*/
+	keys() {
+		return this.cache.keys();
+	}
+	/**
+	* Returns an iterator for the cache values.
+	*/
+	values() {
+		return this.cache.values();
+	}
+	/**
+	* Returns an iterator for the cache entries.
+	*/
+	entries() {
+		return this.cache.entries();
+	}
+	/**
+	* Executes a provided function once for each cache entry.
+	*/
+	forEach(callbackfn, thisArg) {
+		this.cache.forEach(callbackfn, thisArg);
+	}
+	[Symbol.iterator]() {
+		return this.cache[Symbol.iterator]();
+	}
+};
 /**
- * A two-level cache that organizes PromiseCaches by repository path.
- * Automatically creates and manages inner PromiseCaches per repository.
- *
- * This is useful for caching data that varies by both repository and some other key,
- * with TTL and capacity management provided by PromiseCache.
- */
-export class RepoPromiseCacheMap {
-    cache = new Map();
-    options;
-    constructor(options) {
-        this.options = { expireOnError: true, ...options };
-    }
-    get [Symbol.toStringTag]() {
-        return 'RepoPromiseCacheMap';
-    }
-    /**
-     * 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, key, factory, options) {
-        let repoCache = this.cache.get(repoPath);
-        if (repoCache == null) {
-            repoCache = new PromiseCache(this.options);
-            this.cache.set(repoPath, repoCache);
-        }
-        return repoCache.getOrCreate(key, factory, options);
-    }
-    /**
-     * 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, key) {
-        const repoCache = this.cache.get(repoPath);
-        if (repoCache == null)
-            return undefined;
-        return repoCache.get(key);
-    }
-    /**
-     * 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, key, promise, options) {
-        let repoCache = this.cache.get(repoPath);
-        if (repoCache == null) {
-            repoCache = new PromiseCache(this.options);
-            this.cache.set(repoPath, repoCache);
-        }
-        repoCache.set(key, promise, options);
-    }
-    /**
-     * 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, key) {
-        if (key === undefined) {
-            return this.cache.delete(repoPath);
-        }
-        const repoCache = this.cache.get(repoPath);
-        if (repoCache == null)
-            return false;
-        repoCache.delete(key);
-        return true;
-    }
-    /**
-     * 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, key) {
-        const repoCache = this.cache.get(repoPath);
-        if (repoCache == null)
-            return;
-        if (key === undefined) {
-            for (const k of repoCache.keys()) {
-                repoCache.invalidate(k);
-            }
-        }
-        else {
-            repoCache.invalidate(key);
-        }
-    }
-    /**
-     * 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(repoPath, prefix) {
-        const repoCache = this.cache.get(repoPath);
-        if (repoCache == null)
-            return false;
-        let deleted = false;
-        for (const key of repoCache.keys()) {
-            if (key.startsWith(prefix)) {
-                repoCache.delete(key);
-                deleted = true;
-            }
-        }
-        return deleted;
-    }
-    /**
-     * 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(repoPath, prefix) {
-        const repoCache = this.cache.get(repoPath);
-        if (repoCache == null)
-            return false;
-        let invalidated = false;
-        for (const key of repoCache.keys()) {
-            if (key.startsWith(prefix)) {
-                repoCache.invalidate(key);
-                invalidated = true;
-            }
-        }
-        return invalidated;
-    }
-    /**
-     * Clears all caches for all repositories.
-     */
-    clear() {
-        this.cache.clear();
-    }
-    /**
-     * Returns the total number of entries across all repository caches.
-     */
-    get entryCount() {
-        let count = 0;
-        for (const repoCache of this.cache.values()) {
-            count += repoCache.size;
-        }
-        return count;
-    }
-    /**
-     * Returns the number of repositories in the cache.
-     */
-    get size() {
-        return this.cache.size;
-    }
-}
+* A two-level cache that organizes PromiseCaches by repository path.
+* Automatically creates and manages inner PromiseCaches per repository.
+*
+* This is useful for caching data that varies by both repository and some other key,
+* with TTL and capacity management provided by PromiseCache.
+*/
+var RepoPromiseCacheMap = class {
+	cache = /* @__PURE__ */ new Map();
+	options;
+	constructor(options) {
+		this.options = {
+			expireOnError: true,
+			...options
+		};
+	}
+	get [Symbol.toStringTag]() {
+		return "RepoPromiseCacheMap";
+	}
+	/**
+	* 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, key, factory, options) {
+		let repoCache = this.cache.get(repoPath);
+		if (repoCache == null) {
+			repoCache = new PromiseCache(this.options);
+			this.cache.set(repoPath, repoCache);
+		}
+		return repoCache.getOrCreate(key, factory, options);
+	}
+	/**
+	* 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, key) {
+		const repoCache = this.cache.get(repoPath);
+		if (repoCache == null) return void 0;
+		return repoCache.get(key);
+	}
+	/**
+	* 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, key, promise, options) {
+		let repoCache = this.cache.get(repoPath);
+		if (repoCache == null) {
+			repoCache = new PromiseCache(this.options);
+			this.cache.set(repoPath, repoCache);
+		}
+		repoCache.set(key, promise, options);
+	}
+	/**
+	* 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, key) {
+		if (key === void 0) return this.cache.delete(repoPath);
+		const repoCache = this.cache.get(repoPath);
+		if (repoCache == null) return false;
+		repoCache.delete(key);
+		return true;
+	}
+	/**
+	* 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, key) {
+		const repoCache = this.cache.get(repoPath);
+		if (repoCache == null) return;
+		if (key === void 0) for (const k of repoCache.keys()) repoCache.invalidate(k);
+		else repoCache.invalidate(key);
+	}
+	/**
+	* 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(repoPath, prefix) {
+		const repoCache = this.cache.get(repoPath);
+		if (repoCache == null) return false;
+		let deleted = false;
+		for (const key of repoCache.keys()) if (key.startsWith(prefix)) {
+			repoCache.delete(key);
+			deleted = true;
+		}
+		return deleted;
+	}
+	/**
+	* 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(repoPath, prefix) {
+		const repoCache = this.cache.get(repoPath);
+		if (repoCache == null) return false;
+		let invalidated = false;
+		for (const key of repoCache.keys()) if (key.startsWith(prefix)) {
+			repoCache.invalidate(key);
+			invalidated = true;
+		}
+		return invalidated;
+	}
+	/**
+	* Clears all caches for all repositories.
+	*/
+	clear() {
+		this.cache.clear();
+	}
+	/**
+	* Returns the total number of entries across all repository caches.
+	*/
+	get entryCount() {
+		let count = 0;
+		for (const repoCache of this.cache.values()) count += repoCache.size;
+		return count;
+	}
+	/**
+	* Returns the number of repositories in the cache.
+	*/
+	get size() {
+		return this.cache.size;
+	}
+};
 /**
- * A two-level cache that organizes PromiseMaps by repository path.
- * Automatically creates and manages inner PromiseMaps per repository.
- *
- * This is useful for caching data that varies by both repository and some other key,
- * with simple promise deduplication and automatic error cleanup.
- */
-export class RepoPromiseMap {
-    cache = new Map();
-    get [Symbol.toStringTag]() {
-        return 'RepoPromiseMap';
-    }
-    /**
-     * 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, key, factory, cancellation) {
-        let repoCache = this.cache.get(repoPath);
-        if (repoCache == null) {
-            repoCache = new PromiseMap();
-            this.cache.set(repoPath, repoCache);
-        }
-        return repoCache.getOrCreate(key, factory, cancellation);
-    }
-    /**
-     * 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, key) {
-        const repoCache = this.cache.get(repoPath);
-        return repoCache?.get(key);
-    }
-    /**
-     * 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, key) {
-        if (key === undefined) {
-            return this.cache.delete(repoPath);
-        }
-        const repoCache = this.cache.get(repoPath);
-        if (repoCache == null)
-            return false;
-        return repoCache.delete(key);
-    }
-    /**
-     * 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, key) {
-        const repoCache = this.cache.get(repoPath);
-        if (repoCache == null)
-            return;
-        if (key === undefined) {
-            for (const k of repoCache.keys()) {
-                repoCache.invalidate(k);
-            }
-        }
-        else {
-            repoCache.invalidate(key);
-        }
-    }
-    /**
-     * Clears all caches for all repositories.
-     */
-    clear() {
-        this.cache.clear();
-    }
-    /**
-     * Returns the number of repositories in the cache.
-     */
-    get size() {
-        return this.cache.size;
-    }
-}
+* A two-level cache that organizes PromiseMaps by repository path.
+* Automatically creates and manages inner PromiseMaps per repository.
+*
+* This is useful for caching data that varies by both repository and some other key,
+* with simple promise deduplication and automatic error cleanup.
+*/
+var RepoPromiseMap = class {
+	cache = /* @__PURE__ */ new Map();
+	get [Symbol.toStringTag]() {
+		return "RepoPromiseMap";
+	}
+	/**
+	* 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, key, factory, cancellation) {
+		let repoCache = this.cache.get(repoPath);
+		if (repoCache == null) {
+			repoCache = new PromiseMap();
+			this.cache.set(repoPath, repoCache);
+		}
+		return repoCache.getOrCreate(key, factory, cancellation);
+	}
+	/**
+	* 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, key) {
+		return this.cache.get(repoPath)?.get(key);
+	}
+	/**
+	* 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, key) {
+		if (key === void 0) return this.cache.delete(repoPath);
+		const repoCache = this.cache.get(repoPath);
+		if (repoCache == null) return false;
+		return repoCache.delete(key);
+	}
+	/**
+	* 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, key) {
+		const repoCache = this.cache.get(repoPath);
+		if (repoCache == null) return;
+		if (key === void 0) for (const k of repoCache.keys()) repoCache.invalidate(k);
+		else repoCache.invalidate(key);
+	}
+	/**
+	* Clears all caches for all repositories.
+	*/
+	clear() {
+		this.cache.clear();
+	}
+	/**
+	* Returns the number of repositories in the cache.
+	*/
+	get size() {
+		return this.cache.size;
+	}
+};
+//#endregion
+export { CacheController, PromiseCache, PromiseMap, RepoPromiseCacheMap, RepoPromiseMap };
+
 //# sourceMappingURL=promiseCache.js.map