@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/git-cli/providers/refs.js

@@ -1,481 +1,337 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+import { CancellationError, isCancellationError } from "../../utils/cancellation.js";
+import { iterateAsyncByDelimiter } from "../../utils/string.js";
+import { getScopedLogger } from "../../utils/logger.scoped.js";
+import { debug, trace } from "../../utils/decorators/log.js";
+import { toFsPath } from "../../utils/uri.js";
+import "../../git/models/revision.js";
+import { isSha, isShaWithOptionalRevisionSuffix, isUncommitted } from "../../git/utils/revision.utils.js";
+import { createReference } from "../../git/utils/reference.utils.js";
+import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
+import { createDisposable } from "../../utils/disposable.js";
+import { gitConfigsBranch } from "../exec/git.js";
+import { maybeStopWatch } from "../../utils/stopwatch.js";
+import _usingCtx from "../../_virtual/@oxc-project+runtime/helpers/esm/usingCtx.js";
+import { isRemoteHEAD } from "../../git/utils/branch.utils.js";
+import { compareRefTips } from "../../git/utils/sorting.js";
+import { getRefParser } from "../parsers/refParser.js";
+//#region ../git-cli/src/providers/refs.ts
+var RefsGitSubProvider = class {
+	context;
+	git;
+	cache;
+	provider;
+	constructor(context, git, cache, provider) {
+		this.context = context;
+		this.git = git;
+		this.cache = cache;
+		this.provider = provider;
+	}
+	async checkIfCouldBeValidBranchOrTagName(repoPath, ref) {
+		try {
+			const result = await this.git.run({
+				cwd: repoPath,
+				errors: "throw"
+			}, "check-ref-format", "--branch", ref);
+			return Boolean(result.stdout.trim());
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Raw `git for-each-ref` records covering branches, remotes, tags, and replace-refs in a single
+	* pass. CLI-internal — siblings call via `this.provider.refs.getRefs(...)`. The `RefRecord` shape
+	* is `for-each-ref`-specific and intentionally absent from the public `GitRefsSubProvider`
+	* interface.
+	*/
+	async getRefs(repoPath, cancellation, options) {
+		if (!repoPath) return [];
+		const scope = getScopedLogger();
+		if (options?.force) {
+			const commonPath = this.cache.getCommonPath(repoPath);
+			this.cache.refs.delete(commonPath);
+			this.cache.refTips.delete(commonPath);
+		}
+		return this.cache.getRefs(repoPath, async (commonPath, cacheable, signal) => {
+			try {
+				try {
+					var _usingCtx$1 = _usingCtx();
+					const supported = await this.git.supported("git:for-each-ref");
+					const parser = getRefParser(supported);
+					const result = await this.git.run({
+						cwd: commonPath,
+						cancellation: signal,
+						configs: gitConfigsBranch,
+						errors: "ignore"
+					}, "for-each-ref", ...parser.arguments, "refs/heads/", "refs/remotes/", "refs/tags/", "refs/replace/");
+					if (result.completion.status !== "exited" || result.exitCode !== 0 || signal?.aborted) {
+						cacheable?.invalidate();
+						return [];
+					}
+					if (!result?.stdout) return [];
+					const sw = _usingCtx$1.u(maybeStopWatch(scope, { log: {
+						onlyExit: true,
+						level: "debug"
+					} }));
+					const records = [...parser.parse(result.stdout)];
+					sw?.stop({ suffix: ` parsed ${records.length} ref records` });
+					return records;
+				} catch (_) {
+					_usingCtx$1.e = _;
+				} finally {
+					_usingCtx$1.d();
+				}
+			} catch (ex) {
+				cacheable?.invalidate();
+				if (isCancellationError(ex)) throw ex;
+				scope?.error(ex);
+				return [];
+			}
+		}, cancellation);
+	}
+	async getRefTips(repoPath, options, cancellation) {
+		if (!repoPath) return [];
+		const scope = getScopedLogger();
+		const all = await this.cache.getRefTips(repoPath, async (_commonPath, _cacheable, signal) => {
+			try {
+				var _usingCtx3 = _usingCtx();
+				const records = await this.getRefs(repoPath, signal);
+				const sw = _usingCtx3.u(maybeStopWatch(scope, { log: {
+					onlyExit: true,
+					level: "debug"
+				} }));
+				const tips = [];
+				for (const record of records) {
+					const fullName = record.name;
+					if (!fullName) continue;
+					if (isRemoteHEAD(fullName)) continue;
+					let type;
+					let name;
+					if (fullName.startsWith("refs/heads/")) {
+						type = "branch";
+						name = fullName.substring(11);
+					} else if (fullName.startsWith("refs/remotes/")) {
+						type = "remote";
+						name = fullName.substring(13);
+					} else if (fullName.startsWith("refs/tags/")) {
+						type = "tag";
+						name = fullName.substring(10);
+					} else continue;
+					const sha = record.peeledObjectname || record.objectname;
+					tips.push({
+						type,
+						name,
+						fullName,
+						sha
+					});
+				}
+				sw?.stop({ suffix: ` projected ${tips.length} ref tips` });
+				return tips;
+			} catch (_) {
+				_usingCtx3.e = _;
+			} finally {
+				_usingCtx3.d();
+			}
+		}, cancellation);
+		const include = options?.include;
+		if (include == null || include.includes("heads") && include.includes("remotes") && include.includes("tags")) return all;
+		return all.filter((r) => {
+			switch (r.type) {
+				case "branch": return include.includes("heads");
+				case "remote": return include.includes("remotes");
+				case "tag": return include.includes("tags");
+			}
+		});
+	}
+	async getRefsContainingShas(repoPath, shas, oldestSha, options, cancellation) {
+		try {
+			var _usingCtx4 = _usingCtx();
+			const targetShas = shas instanceof Set ? shas : new Set(shas);
+			if (!targetShas.size || !oldestSha) return /* @__PURE__ */ new Map();
+			const scope = getScopedLogger();
+			const tips = await this.getRefTips(repoPath, options, cancellation);
+			if (cancellation?.aborted) throw new CancellationError();
+			if (!tips.length) return /* @__PURE__ */ new Map();
+			const tipsByName = /* @__PURE__ */ new Map();
+			const propMap = /* @__PURE__ */ new Map();
+			for (const tip of tips) {
+				tipsByName.set(tip.fullName, tip);
+				let names = propMap.get(tip.sha);
+				if (names == null) {
+					names = /* @__PURE__ */ new Set();
+					propMap.set(tip.sha, names);
+				}
+				names.add(tip.fullName);
+			}
+			const sw = _usingCtx4.u(maybeStopWatch(scope, { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			const stream = this.git.stream({
+				cwd: repoPath,
+				cancellation,
+				configs: gitConfigsBranch
+			}, "rev-list", "--topo-order", "--parents", "--all", `^${oldestSha}^@`);
+			_usingCtx4.u(createDisposable(() => void stream.return?.(void 0)));
+			try {
+				for await (const line of iterateAsyncByDelimiter(stream, "\n")) {
+					if (cancellation?.aborted) throw new CancellationError();
+					if (!line) continue;
+					const firstSpace = line.indexOf(" ");
+					const sha = firstSpace === -1 ? line : line.substring(0, firstSpace);
+					if (!sha) continue;
+					const refs = propMap.get(sha);
+					if (!refs?.size) continue;
+					if (firstSpace === -1) continue;
+					let start = firstSpace + 1;
+					while (start < line.length) {
+						const next = line.indexOf(" ", start);
+						const parentSha = next === -1 ? line.substring(start) : line.substring(start, next);
+						if (parentSha) {
+							let parentRefs = propMap.get(parentSha);
+							if (parentRefs == null) {
+								parentRefs = new Set(refs);
+								propMap.set(parentSha, parentRefs);
+							} else for (const name of refs) parentRefs.add(name);
+						}
+						if (next === -1) break;
+						start = next + 1;
+					}
+				}
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				scope?.error(ex);
+				return /* @__PURE__ */ new Map();
+			}
+			const result = /* @__PURE__ */ new Map();
+			for (const sha of targetShas) {
+				const names = propMap.get(sha);
+				if (!names?.size) continue;
+				const refs = [];
+				for (const name of names) {
+					const tip = tipsByName.get(name);
+					if (tip != null) refs.push(tip);
+				}
+				refs.sort(compareRefTips);
+				result.set(sha, refs);
+			}
+			sw?.stop({ suffix: ` resolved ${result.size}/${targetShas.size} target shas` });
+			return result;
+		} catch (_) {
+			_usingCtx4.e = _;
+		} finally {
+			_usingCtx4.d();
+		}
+	}
+	async getMergeBase(repoPath, ref1, ref2, options, cancellation) {
+		const scope = getScopedLogger();
+		try {
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				caching: {
+					cache: this.cache.gitResults,
+					options: { accessTTL: 3e5 }
+				},
+				...options?.priority != null ? { priority: options.priority } : void 0
+			}, "merge-base", options?.forkPoint ? "--fork-point" : void 0, ref1, ref2);
+			if (!result.stdout) return void 0;
+			return result.stdout.split("\n")[0].trim() || void 0;
+		} catch (ex) {
+			scope?.error(ex);
+			if (isCancellationError(ex)) throw ex;
+			return;
+		}
+	}
+	async getReference(repoPath, ref, cancellation) {
+		if (!ref || ref === "0000000000000000000000000000000000000000-") return void 0;
+		if (!await this.isValidReference(repoPath, ref, void 0, cancellation)) return void 0;
+		if (ref !== "HEAD" && !isShaWithOptionalRevisionSuffix(ref)) {
+			const branch = await this.provider.branches.getBranch(repoPath, ref, cancellation);
+			if (branch != null) return createReference(branch.ref, repoPath, {
+				id: branch.id,
+				refType: "branch",
+				name: branch.name,
+				remote: branch.remote,
+				upstream: branch.upstream
+			});
+			const tag = await this.provider.tags.getTag(repoPath, ref, cancellation);
+			if (tag != null) return createReference(tag.ref, repoPath, {
+				id: tag.id,
+				refType: "tag",
+				name: tag.name
+			});
+		}
+		return createReference(ref, repoPath, { refType: "revision" });
+	}
+	async getSymbolicReferenceName(repoPath, ref, options, cancellation) {
+		const supportsEndOfOptions = await this.git.supports("git:rev-parse:end-of-options");
+		return (await this.git.run({
+			cwd: repoPath,
+			cancellation,
+			errors: "ignore",
+			caching: {
+				cache: this.cache.gitResults,
+				options: { accessTTL: 6e4 }
+			},
+			...options?.priority != null ? { priority: options.priority } : void 0
+		}, "rev-parse", "--verify", "--quiet", "--symbolic-full-name", "--abbrev-ref", supportsEndOfOptions ? "--end-of-options" : void 0, ref)).stdout.trim() || void 0;
+	}
+	async hasBranchOrTag(repoPath, options, cancellation) {
+		if (repoPath == null) return false;
+		const [{ values: branches }, { values: tags }] = await Promise.all([this.provider.branches.getBranches(repoPath, {
+			filter: options?.filter?.branches,
+			sort: false
+		}, cancellation), this.provider.tags.getTags(repoPath, {
+			filter: options?.filter?.tags,
+			sort: false
+		}, cancellation)]);
+		return branches.length !== 0 || tags.length !== 0;
+	}
+	async isValidReference(repoPath, ref, pathOrUri, cancellation) {
+		const path = pathOrUri != null ? toFsPath(pathOrUri) : void 0;
+		const relativePath = path ? this.provider.getRelativePath(path, repoPath) : void 0;
+		return Boolean((await this.validateReference(repoPath, ref, relativePath, cancellation))?.length);
+	}
+	async validateReference(repoPath, ref, relativePath, cancellation) {
+		if (!ref) return void 0;
+		if (ref === "0000000000000000000000000000000000000000-" || isUncommitted(ref)) return ref;
+		const supportsEndOfOptions = await this.git.supports("git:rev-parse:end-of-options");
+		const stable = relativePath == null && isSha(ref);
+		return (await this.git.run({
+			cwd: repoPath,
+			cancellation,
+			errors: "ignore",
+			caching: {
+				cache: this.cache.gitResults,
+				options: { accessTTL: stable ? 3e5 : 6e4 }
+			}
+		}, "rev-parse", "--verify", supportsEndOfOptions ? "--end-of-options" : void 0, relativePath ? `${ref}:./${relativePath}` : `${ref}^{commit}`)).stdout.trim() || void 0;
+	}
+	async updateReference(repoPath, ref, newRef, cancellation) {
+		const scope = getScopedLogger();
+		try {
+			await this.git.run({
+				cwd: repoPath,
+				cancellation
+			}, "update-ref", ref, newRef);
+		} catch (ex) {
+			scope?.error(ex);
+			if (isCancellationError(ex)) throw ex;
+		}
+	}
 };
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { deletedOrMissing } from '../../git/models/revision.js';
-import { isRemoteHEAD } from '../../git/utils/branch.utils.js';
-import { createReference } from '../../git/utils/reference.utils.js';
-import { isSha, isShaWithOptionalRevisionSuffix, isUncommitted } from '../../git/utils/revision.utils.js';
-import { compareRefTips } from '../../git/utils/sorting.js';
-import { CancellationError, isCancellationError } from '../../utils/cancellation.js';
-import { debug, trace } from '../../utils/decorators/log.js';
-import { createDisposable } from '../../utils/disposable.js';
-import { getScopedLogger } from '../../utils/logger.scoped.js';
-import { maybeStopWatch } from '../../utils/stopwatch.js';
-import { iterateAsyncByDelimiter } from '../../utils/string.js';
-import { toFsPath } from '../../utils/uri.js';
-import { gitConfigsBranch } from '../exec/git.js';
-import { getRefParser } from '../parsers/refParser.js';
-export class RefsGitSubProvider {
-    context;
-    git;
-    cache;
-    provider;
-    constructor(context, git, cache, provider) {
-        this.context = context;
-        this.git = git;
-        this.cache = cache;
-        this.provider = provider;
-    }
-    async checkIfCouldBeValidBranchOrTagName(repoPath, ref) {
-        try {
-            const result = await this.git.run({ cwd: repoPath, errors: 'throw' }, 'check-ref-format', '--branch', ref);
-            return Boolean(result.stdout.trim());
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Raw `git for-each-ref` records covering branches, remotes, tags, and replace-refs in a single
-     * pass. CLI-internal — siblings call via `this.provider.refs.getRefs(...)`. The `RefRecord` shape
-     * is `for-each-ref`-specific and intentionally absent from the public `GitRefsSubProvider`
-     * interface.
-     */
-    async getRefs(repoPath, cancellation, options) {
-        if (!repoPath)
-            return [];
-        const scope = getScopedLogger();
-        // Forces a fresh enumeration: evicts the shared cache entry (and the derived `refTips` projection,
-        // which would otherwise still answer from the old records) so the factory below re-runs and
-        // repopulates both from one spawn. Deliberately `delete`, not `invalidate` — soft-invalidation
-        // leaves an in-flight entry rideable, so a caller needing a point-in-time read (the graph's tip
-        // gate) could join an enumeration that started before the change it's trying to detect. Evicting
-        // is safe mid-flight: the in-flight factory's settle is ownership-guarded and won't evict the
-        // successor installed here.
-        if (options?.force) {
-            const commonPath = this.cache.getCommonPath(repoPath);
-            this.cache.refs.delete(commonPath);
-            this.cache.refTips.delete(commonPath);
-        }
-        return this.cache.getRefs(repoPath, async (commonPath, cacheable, signal) => {
-            try {
-                const env_1 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const supported = await this.git.supported('git:for-each-ref');
-                    const parser = getRefParser(supported);
-                    const result = await this.git.run({ cwd: commonPath, cancellation: signal, configs: gitConfigsBranch, errors: 'ignore' }, 'for-each-ref', ...parser.arguments, 'refs/heads/', 'refs/remotes/', 'refs/tags/', 
-                    // `git replace`/grafts — not surfaced to branch/tag/refTip consumers (filtered by
-                    // refname prefix), but needed by the graph's replace-ref change gate (graph.ts).
-                    'refs/replace/');
-                    // Under `errors: 'ignore'` a cancelled run RESOLVES empty rather than throwing, so the
-                    // catch below never sees it and an empty enumeration would be cached as a real answer —
-                    // permanently, since this map has no TTL. Same guard `git.run`'s own caching path uses.
-                    // The graph's tip gate calls this with `force: true` and supersedes itself freely, so it
-                    // is routinely the sole registrant on the aggregate whose abort kills the spawn.
-                    // Covers a FAILED enumeration too, not just a cancelled one: a transient `for-each-ref`
-                    // failure (a lingering `index.lock`, EMFILE, the git dir briefly unavailable) also
-                    // resolves empty, and caching that `[]` would blank every branch, tag and ref-tip
-                    // consumer for the rest of the session. A genuinely ref-less repo still exits cleanly
-                    // with empty stdout, so it caches as before.
-                    if (result.completion.status !== 'exited' || result.exitCode !== 0 || signal?.aborted) {
-                        cacheable?.invalidate();
-                        return [];
-                    }
-                    if (!result?.stdout)
-                        return [];
-                    const sw = __addDisposableResource(env_1, maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } }), false);
-                    const records = [...parser.parse(result.stdout)];
-                    sw?.stop({ suffix: ` parsed ${records.length} ref records` });
-                    return records;
-                }
-                catch (e_1) {
-                    env_1.error = e_1;
-                    env_1.hasError = true;
-                }
-                finally {
-                    __disposeResources(env_1);
-                }
-            }
-            catch (ex) {
-                cacheable?.invalidate();
-                if (isCancellationError(ex))
-                    throw ex;
-                scope?.error(ex);
-                return [];
-            }
-        }, cancellation);
-    }
-    async getRefTips(repoPath, options, cancellation) {
-        if (!repoPath)
-            return [];
-        const scope = getScopedLogger();
-        // Cache always holds the full set; subset filtering is applied on read so callers asking
-        // for different subsets share one cache entry.
-        const all = await this.cache.getRefTips(repoPath, async (_commonPath, _cacheable, signal) => {
-            const env_2 = { stack: [], error: void 0, hasError: false };
-            try {
-                const records = await this.getRefs(repoPath, signal);
-                const sw = __addDisposableResource(env_2, maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } }), false);
-                const tips = [];
-                for (const record of records) {
-                    const fullName = record.name;
-                    if (!fullName)
-                        continue;
-                    // Skip refs/remotes/<remote>/HEAD — symbolic, not a real tip.
-                    if (isRemoteHEAD(fullName))
-                        continue;
-                    let type;
-                    let name;
-                    if (fullName.startsWith('refs/heads/')) {
-                        type = 'branch';
-                        name = fullName.substring(11);
-                    }
-                    else if (fullName.startsWith('refs/remotes/')) {
-                        type = 'remote';
-                        name = fullName.substring(13);
-                    }
-                    else if (fullName.startsWith('refs/tags/')) {
-                        type = 'tag';
-                        name = fullName.substring(10);
-                    }
-                    else {
-                        continue;
-                    }
-                    // Annotated tags: peeledObjectname is the commit SHA; objectname is the tag-object SHA.
-                    // Lightweight tags / branches: peeledObjectname is empty; objectname is already the commit SHA.
-                    const sha = record.peeledObjectname || record.objectname;
-                    tips.push({ type: type, name: name, fullName: fullName, sha: sha });
-                }
-                sw?.stop({ suffix: ` projected ${tips.length} ref tips` });
-                return tips;
-            }
-            catch (e_2) {
-                env_2.error = e_2;
-                env_2.hasError = true;
-            }
-            finally {
-                __disposeResources(env_2);
-            }
-        }, cancellation);
-        const include = options?.include;
-        if (include == null || (include.includes('heads') && include.includes('remotes') && include.includes('tags'))) {
-            return all;
-        }
-        return all.filter(r => {
-            switch (r.type) {
-                case 'branch':
-                    return include.includes('heads');
-                case 'remote':
-                    return include.includes('remotes');
-                case 'tag':
-                    return include.includes('tags');
-            }
-        });
-    }
-    async getRefsContainingShas(repoPath, shas, oldestSha, options, cancellation) {
-        const env_3 = { stack: [], error: void 0, hasError: false };
-        try {
-            const targetShas = shas instanceof Set ? shas : new Set(shas);
-            if (!targetShas.size || !oldestSha)
-                return new Map();
-            const scope = getScopedLogger();
-            const tips = await this.getRefTips(repoPath, options, cancellation);
-            if (cancellation?.aborted)
-                throw new CancellationError();
-            if (!tips.length)
-                return new Map();
-            // Index tips by full ref name (for projection back to GitRefTip later) and seed the
-            // propagation map by tip SHA. Multiple refs sharing a tip (e.g. local + remote-tracking)
-            // collapse into one Set entry whose union covers all of them.
-            const tipsByName = new Map();
-            const propMap = new Map();
-            for (const tip of tips) {
-                tipsByName.set(tip.fullName, tip);
-                let names = propMap.get(tip.sha);
-                if (names == null) {
-                    names = new Set();
-                    propMap.set(tip.sha, names);
-                }
-                names.add(tip.fullName);
-            }
-            const sw = __addDisposableResource(env_3, maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } }), false);
-            // `^<oldestSha>^@` excludes the parents of <oldestSha> and everything older. When <oldestSha>
-            // is a root commit, `^@` resolves to nothing and the walk is naturally unbounded — git
-            // doesn't error in that case (no negative refs to apply).
-            const stream = this.git.stream({ cwd: repoPath, cancellation: cancellation, configs: gitConfigsBranch }, 'rev-list', '--topo-order', '--parents', '--all', `^${oldestSha}^@`);
-            const _streamDisposer = __addDisposableResource(env_3, createDisposable(() => void stream.return?.(undefined)), false);
-            // Topological propagation: `--topo-order` emits all children of X before X's own line, so
-            // by the time we process "X P1 P2..." every child has already merged its set into X. We
-            // then forward X's accumulated set to each parent — one-pass and correct.
-            try {
-                for await (const line of iterateAsyncByDelimiter(stream, '\n')) {
-                    if (cancellation?.aborted)
-                        throw new CancellationError();
-                    if (!line)
-                        continue;
-                    const firstSpace = line.indexOf(' ');
-                    const sha = firstSpace === -1 ? line : line.substring(0, firstSpace);
-                    if (!sha)
-                        continue;
-                    const refs = propMap.get(sha);
-                    if (!refs?.size)
-                        continue;
-                    if (firstSpace === -1)
-                        continue; // No parents — nothing to propagate to
-                    // Walk parent SHAs by index without splitting the whole line.
-                    let start = firstSpace + 1;
-                    while (start < line.length) {
-                        const next = line.indexOf(' ', start);
-                        const parentSha = next === -1 ? line.substring(start) : line.substring(start, next);
-                        if (parentSha) {
-                            let parentRefs = propMap.get(parentSha);
-                            if (parentRefs == null) {
-                                parentRefs = new Set(refs);
-                                propMap.set(parentSha, parentRefs);
-                            }
-                            else {
-                                for (const name of refs) {
-                                    parentRefs.add(name);
-                                }
-                            }
-                        }
-                        if (next === -1)
-                            break;
-                        start = next + 1;
-                    }
-                }
-            }
-            catch (ex) {
-                if (isCancellationError(ex))
-                    throw ex;
-                scope?.error(ex);
-                return new Map();
-            }
-            // Project to targets, materialize GitRefTip[], sort.
-            const result = new Map();
-            for (const sha of targetShas) {
-                const names = propMap.get(sha);
-                if (!names?.size)
-                    continue;
-                const refs = [];
-                for (const name of names) {
-                    const tip = tipsByName.get(name);
-                    if (tip != null) {
-                        refs.push(tip);
-                    }
-                }
-                refs.sort(compareRefTips);
-                result.set(sha, refs);
-            }
-            sw?.stop({ suffix: ` resolved ${result.size}/${targetShas.size} target shas` });
-            return result;
-        }
-        catch (e_3) {
-            env_3.error = e_3;
-            env_3.hasError = true;
-        }
-        finally {
-            __disposeResources(env_3);
-        }
-    }
-    async getMergeBase(repoPath, ref1, ref2, options, cancellation) {
-        const scope = getScopedLogger();
-        try {
-            const result = await this.git.run({
-                cwd: repoPath,
-                cancellation: cancellation,
-                // Why: ref1/ref2 are usually branch names; correctness relies on the gitResults cache being
-                // cleared on 'heads'/'remotes' events when refs move. Web (no fs watcher) sees up to
-                // `accessTTL` of staleness — acceptable trade-off for the perf win on graph/branch reads.
-                caching: { cache: this.cache.gitResults, options: { accessTTL: 5 * 60 * 1000 } },
-                ...(options?.priority != null ? { priority: options.priority } : undefined),
-            }, 'merge-base', options?.forkPoint ? '--fork-point' : undefined, ref1, ref2);
-            if (!result.stdout)
-                return undefined;
-            return result.stdout.split('\n')[0].trim() || undefined;
-        }
-        catch (ex) {
-            scope?.error(ex);
-            if (isCancellationError(ex))
-                throw ex;
-            return undefined;
-        }
-    }
-    async getReference(repoPath, ref, cancellation) {
-        if (!ref || ref === deletedOrMissing)
-            return undefined;
-        if (!(await this.isValidReference(repoPath, ref, undefined, cancellation)))
-            return undefined;
-        if (ref !== 'HEAD' && !isShaWithOptionalRevisionSuffix(ref)) {
-            const branch = await this.provider.branches.getBranch(repoPath, ref, cancellation);
-            if (branch != null) {
-                return createReference(branch.ref, repoPath, {
-                    id: branch.id,
-                    refType: 'branch',
-                    name: branch.name,
-                    remote: branch.remote,
-                    upstream: branch.upstream,
-                });
-            }
-            const tag = await this.provider.tags.getTag(repoPath, ref, cancellation);
-            if (tag != null) {
-                return createReference(tag.ref, repoPath, {
-                    id: tag.id,
-                    refType: 'tag',
-                    name: tag.name,
-                });
-            }
-        }
-        return createReference(ref, repoPath, { refType: 'revision' });
-    }
-    async getSymbolicReferenceName(repoPath, ref, options, cancellation) {
-        const supportsEndOfOptions = await this.git.supports('git:rev-parse:end-of-options');
-        const result = await this.git.run({
-            cwd: repoPath,
-            cancellation: cancellation,
-            errors: 'ignore',
-            // Why: a fixed ref name's symbolic name is itself stable; only HEAD is mutable, and the
-            // gitResults cache is cleared on 'head' events. 60s TTL is the failsafe for watcher
-            // latency / web — matches the other "resolve symbolic state" calls in commits.ts.
-            caching: { cache: this.cache.gitResults, options: { accessTTL: 60 * 1000 } },
-            ...(options?.priority != null ? { priority: options.priority } : undefined),
-        }, 'rev-parse', '--verify', '--quiet', '--symbolic-full-name', '--abbrev-ref', supportsEndOfOptions ? '--end-of-options' : undefined, ref);
-        return result.stdout.trim() || undefined;
-    }
-    async hasBranchOrTag(repoPath, options, cancellation) {
-        if (repoPath == null)
-            return false;
-        const [{ values: branches }, { values: tags }] = await Promise.all([
-            this.provider.branches.getBranches(repoPath, { filter: options?.filter?.branches, sort: false }, cancellation),
-            this.provider.tags.getTags(repoPath, { filter: options?.filter?.tags, sort: false }, cancellation),
-        ]);
-        return branches.length !== 0 || tags.length !== 0;
-    }
-    async isValidReference(repoPath, ref, pathOrUri, cancellation) {
-        const path = pathOrUri != null ? toFsPath(pathOrUri) : undefined;
-        const relativePath = path ? this.provider.getRelativePath(path, repoPath) : undefined;
-        return Boolean((await this.validateReference(repoPath, ref, relativePath, cancellation))?.length);
-    }
-    async validateReference(repoPath, ref, relativePath, cancellation) {
-        if (!ref)
-            return undefined;
-        if (ref === deletedOrMissing || isUncommitted(ref))
-            return ref;
-        const supportsEndOfOptions = await this.git.supports('git:rev-parse:end-of-options');
-        // Why: a SHA-only validation (no path suffix) is effectively immutable — 5-min TTL is safe.
-        // Otherwise the resolved SHA can shift on ref move (or working-tree change for path-scoped
-        // validation); rely on gitResults being cleared on 'head'/'heads'/'remotes' events, with 60s
-        // TTL as the failsafe for watcher latency / web.
-        const stable = relativePath == null && isSha(ref);
-        const result = await this.git.run({
-            cwd: repoPath,
-            cancellation: cancellation,
-            errors: 'ignore',
-            caching: {
-                cache: this.cache.gitResults,
-                options: { accessTTL: stable ? 5 * 60 * 1000 : 60 * 1000 },
-            },
-        }, 'rev-parse', '--verify', supportsEndOfOptions ? '--end-of-options' : undefined, relativePath ? `${ref}:./${relativePath}` : `${ref}^{commit}`);
-        return result.stdout.trim() || undefined;
-    }
-    async updateReference(repoPath, ref, newRef, cancellation) {
-        const scope = getScopedLogger();
-        try {
-            await this.git.run({ cwd: repoPath, cancellation: cancellation }, 'update-ref', ref, newRef);
-        }
-        catch (ex) {
-            scope?.error(ex);
-            if (isCancellationError(ex))
-                throw ex;
-        }
-    }
-}
-__decorate([
-    debug()
-], RefsGitSubProvider.prototype, "checkIfCouldBeValidBranchOrTagName", null);
-__decorate([
-    debug()
-], RefsGitSubProvider.prototype, "getRefs", null);
-__decorate([
-    debug()
-], RefsGitSubProvider.prototype, "getRefTips", null);
-__decorate([
-    debug()
-], RefsGitSubProvider.prototype, "getRefsContainingShas", null);
-__decorate([
-    debug()
-], RefsGitSubProvider.prototype, "getMergeBase", null);
-__decorate([
-    debug()
-], RefsGitSubProvider.prototype, "getReference", null);
-__decorate([
-    debug()
-], RefsGitSubProvider.prototype, "getSymbolicReferenceName", null);
-__decorate([
-    debug({ args: repoPath => ({ repoPath: repoPath }) })
-], RefsGitSubProvider.prototype, "hasBranchOrTag", null);
-__decorate([
-    debug()
-], RefsGitSubProvider.prototype, "isValidReference", null);
-__decorate([
-    trace()
-], RefsGitSubProvider.prototype, "validateReference", null);
-__decorate([
-    debug()
-], RefsGitSubProvider.prototype, "updateReference", null);
+__decorate([debug()], RefsGitSubProvider.prototype, "checkIfCouldBeValidBranchOrTagName", null);
+__decorate([debug()], RefsGitSubProvider.prototype, "getRefs", null);
+__decorate([debug()], RefsGitSubProvider.prototype, "getRefTips", null);
+__decorate([debug()], RefsGitSubProvider.prototype, "getRefsContainingShas", null);
+__decorate([debug()], RefsGitSubProvider.prototype, "getMergeBase", null);
+__decorate([debug()], RefsGitSubProvider.prototype, "getReference", null);
+__decorate([debug()], RefsGitSubProvider.prototype, "getSymbolicReferenceName", null);
+__decorate([debug({ args: (repoPath) => ({ repoPath }) })], RefsGitSubProvider.prototype, "hasBranchOrTag", null);
+__decorate([debug()], RefsGitSubProvider.prototype, "isValidReference", null);
+__decorate([trace()], RefsGitSubProvider.prototype, "validateReference", null);
+__decorate([debug()], RefsGitSubProvider.prototype, "updateReference", null);
+//#endregion
+export { RefsGitSubProvider };
+
 //# sourceMappingURL=refs.js.map