@gitkraken/core-gitlens 0.6.0 → 0.7.0

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

@@ -1,1433 +1,1094 @@
-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;
-};
-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 { GitCommit, GitCommitIdentity } from '../../git/models/commit.js';
-import { GitFileChange } from '../../git/models/fileChange.js';
-import { createUncommittedChangesCommit } from '../../git/utils/commit.utils.js';
-import { isRevisionRange, isSha, isUncommitted, isUncommittedStaged } from '../../git/utils/revision.utils.js';
-import { parseSearchQueryGitCommand } from '../../git/utils/search.utils.js';
-import { compareReachableRefs } from '../../git/utils/sorting.js';
-import { isUserMatch } from '../../git/utils/user.utils.js';
-import { chunk as chunkArray } from '../../utils/array.js';
-import { CancellationError, isCancellationError } from '../../utils/cancellation.js';
-import { debug, trace } from '../../utils/decorators/log.js';
-import { createDisposable } from '../../utils/disposable.js';
-import { filterMap, findLast, first, join, last, some } from '../../utils/iterable.js';
-import { getScopedLogger } from '../../utils/logger.scoped.js';
-import { isFolderGlob, normalizePath, splitPath, stripFolderGlob } from '../../utils/path.js';
-import { maybeStopWatch } from '../../utils/stopwatch.js';
-import { escapeRegex, iterateByDelimiter } from '../../utils/string.js';
-import { fileUri, joinUriPath, toFsPath } from '../../utils/uri.js';
-import { gitConfigsLog, gitConfigsLogWithFiles, GitErrors } from '../exec/git.js';
-import { getCommitsLogParser, getShaAndDatesLogParser, getShaAndFilesAndStatsLogParser, getShaLogParser, } from '../parsers/logParser.js';
-import { getReflogParser, parseGitRefLog } from '../parsers/reflogParser.js';
-import { parseSignatureOutput, signatureFormat } from '../parsers/signatureParser.js';
-import { extractCommitterFromCommitObject, extractSshPublicKeyFromCommitObject, } from '../parsers/sshSignatureParser.js';
-import { createCommitFileset } from './commitFilesetUtils.js';
-import { convertStashesToStdin } from './stash.js';
-const emptyPromise = Promise.resolve(undefined);
-const reflogCommands = ['merge', 'pull'];
+import { filterMap, findLast, first, join, last, some } from "../../utils/iterable.js";
+import { chunk } from "../../utils/array.js";
+import { CancellationError, isCancellationError } from "../../utils/cancellation.js";
+import { escapeRegex, iterateByDelimiter } from "../../utils/string.js";
+import { getScopedLogger } from "../../utils/logger.scoped.js";
+import { debug, trace } from "../../utils/decorators/log.js";
+import { fileUri, joinUriPath, toFsPath } from "../../utils/uri.js";
+import { isFolderGlob, normalizePath, splitPath, stripFolderGlob } from "../../utils/path.js";
+import { isRevisionRange, isSha, isUncommitted, isUncommittedStaged } from "../../git/utils/revision.utils.js";
+import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
+import { createDisposable } from "../../utils/disposable.js";
+import { GitErrors, gitConfigsLog, gitConfigsLogWithFiles } from "../exec/git.js";
+import { GitFileChange } from "../../git/models/fileChange.js";
+import { createUncommittedChangesCommit } from "../../git/utils/commit.utils.js";
+import { GitCommit, GitCommitIdentity } from "../../git/models/commit.js";
+import { isUserMatch } from "../../git/utils/user.utils.js";
+import { maybeStopWatch } from "../../utils/stopwatch.js";
+import _usingCtx from "../../_virtual/@oxc-project+runtime/helpers/esm/usingCtx.js";
+import { compareReachableRefs } from "../../git/utils/sorting.js";
+import { parseSearchQueryGitCommand } from "../../git/utils/search.utils.js";
+import { getCommitsLogParser, getShaAndDatesLogParser, getShaAndFilesAndStatsLogParser, getShaLogParser } from "../parsers/logParser.js";
+import { getReflogParser, parseGitRefLog } from "../parsers/reflogParser.js";
+import { parseSignatureOutput, signatureFormat } from "../parsers/signatureParser.js";
+import { extractCommitterFromCommitObject, extractSshPublicKeyFromCommitObject } from "../parsers/sshSignatureParser.js";
+import { createCommitFileset } from "./commitFilesetUtils.js";
+import { convertStashesToStdin } from "./stash.js";
+//#region ../git-cli/src/providers/commits.ts
+const emptyPromise = Promise.resolve(void 0);
+const reflogCommands = ["merge", "pull"];
 /** Keeps `filterUnpublishedShas` well inside Windows' ~32K command-line cap (40 hex chars + separator each). */
 const maxShasPerRevListSpawn = 500;
-export class CommitsGitSubProvider {
-    context;
-    git;
-    cache;
-    provider;
-    constructor(context, git, cache, provider) {
-        this.context = context;
-        this.git = git;
-        this.cache = cache;
-        this.provider = provider;
-    }
-    async createUnreachableCommitFromTree(repoPath, tree, parent, message, cancellation) {
-        const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'commit-tree', tree, '-p', parent, '-m', message);
-        return result.stdout.trim();
-    }
-    async getCommit(repoPath, rev, cancellation) {
-        if (isUncommitted(rev, true)) {
-            return createUncommittedChangesCommit(repoPath, rev, new Date(), await this.provider.config.getCurrentUser(repoPath));
-        }
-        const log = await this.getLogCore(repoPath, rev, { limit: 1 }, cancellation);
-        if (log == null)
-            return undefined;
-        return log.commits.get(rev) ?? first(log.commits.values());
-    }
-    getCommitCount(repoPath, rev, cancellation) {
-        return this.cache.commitCount.getOrCreate(repoPath, rev, async (cacheable, signal) => {
-            // Bind the shared spawn to the aggregate `signal` (fires only when ALL current callers
-            // abort), not this-caller's `cancellation` — otherwise a superseded caller's abort would
-            // kill the shared command and reject concurrent riders that never cancelled.
-            const result = await this.git.run({ cwd: repoPath, cancellation: signal ?? cancellation, errors: 'ignore' }, 'rev-list', '--count', rev, '--');
-            if (result.completion.status === 'cancelled' || signal?.aborted) {
-                throw new CancellationError();
-            }
-            // `errors: 'ignore'` turns a failed run (unknown rev, a transient `index.lock`) into an
-            // empty stdout rather than a throw. That's indistinguishable from a real answer here, so
-            // don't let it become a cached one — this entry has a sliding hour-long TTL, and repeated
-            // access would keep a transient failure alive indefinitely. The pre-cache implementation
-            // simply retried on the next call; invalidating restores that.
-            //
-            // BOTH conditions, not either alone. `exitCode !== 0` catches "git ran and said no" (a bad
-            // rev exits 128); `status !== 'exited'` catches "git never answered" — a queue rejection or
-            // spawn failure (no exit code at all), or a swallowed `GitWarnings` match, which carries git's
-            // real code and so can slip past the exit-code test on its own.
-            if (result.completion.status !== 'exited' || result.exitCode !== 0) {
-                cacheable.invalidate();
-                return undefined;
-            }
-            const data = result.stdout.trim();
-            if (!data)
-                return undefined;
-            const count = parseInt(data, 10);
-            return isNaN(count) ? undefined : count;
-        }, { cancellation: cancellation });
-    }
-    async hasUnpublishedCommits(repoPath, rev, cancellation) {
-        // `<rev> --not --remotes` = commits reachable from `rev` but not from any remote-tracking ref.
-        // `--max-count=1` early-exits at the first such commit, so this is a presence probe, not a count.
-        const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'ignore' }, 'rev-list', '--max-count=1', rev, '--not', '--remotes', '--');
-        if (result.completion.status === 'cancelled' || cancellation?.aborted) {
-            throw new CancellationError();
-        }
-        return result.stdout.trim().length > 0;
-    }
-    async filterUnpublishedShas(repoPath, shas, options, cancellation) {
-        const unpublished = new Set();
-        if (!shas.length)
-            return unpublished;
-        // One walk answers every sha: `<shas…> --not --remotes` yields the commits reachable from any of them
-        // but not from any remote-tracking ref, so a sha is unpublished exactly when it appears in the output.
-        // Callers pass tips from sibling worktrees — safe from a single `cwd` because the object store and
-        // `refs/remotes` are shared across a repo's worktrees (unlike the index/working tree, which are not).
-        //
-        // NOT `--no-walk`: it "has no effect if a range is specified", and `--not --remotes` makes this a range,
-        // so it would silently walk anyway and return the whole unpublished history instead of just these tips.
-        // The walk is bounded by divergence from the remotes, not by repo size; callers skip this entirely when
-        // the repo has no remotes (where every local commit would qualify).
-        // Chunked so a repo with a very large number of worktrees can't overflow the platform's argument
-        // limit (Windows' `CreateProcess` caps the whole command line at ~32K characters).
-        // Deliberately NOT `errors: 'ignore'`: this answers for EVERY sha at once, so a swallowed failure
-        // would return an empty set the caller can't distinguish from "nothing is unpublished", publishing a
-        // confident `hasUnpushed: false` across every worktree in the batch. Letting it throw degrades the
-        // caller to "unknown", which omits the field and leaves the client's last-known value in place.
-        for (const chunk of chunkArray([...shas], maxShasPerRevListSpawn)) {
-            const result = await this.git.run({
-                cwd: repoPath,
-                cancellation: cancellation,
-                ...(options?.priority != null ? { priority: options.priority } : undefined),
-            }, 'rev-list', ...chunk, '--not', '--remotes', '--');
-            // Anything but a clean exit leaves empty stdout, which this function would otherwise read as
-            // "every sha is published" — publishing a definite, wrong `hasUnpushed: false` for the whole
-            // batch. Dropping `errors: 'ignore'` was not enough on its own: a stderr matching `GitWarnings`
-            // (a repo path that briefly vanished, an unknown rev) is swallowed by the default handler and
-            // resolves rather than throwing. Rethrow so the caller degrades to "unknown".
-            if (result.completion.status !== 'exited')
-                throw result.completion.error;
-            if (cancellation?.aborted)
-                throw new CancellationError();
-            const candidates = new Set(chunk);
-            for (const line of iterateByDelimiter(result.stdout, '\n')) {
-                const sha = line.trim();
-                // The walk emits ancestors too; keep only the tips we were asked about.
-                if (sha.length && candidates.has(sha)) {
-                    unpublished.add(sha);
-                }
-            }
-        }
-        return unpublished;
-    }
-    async getCommitDates(repoPath, rev, cancellation) {
-        const parser = getShaAndDatesLogParser();
-        const result = await this.git.run({
-            cwd: repoPath,
-            cancellation: cancellation,
-            errors: 'ignore',
-            // Why: full SHAs identify immutable commits (5-min TTL is safe). Non-SHA refs rely on
-            // gitResults being cleared on 'head'/'heads'/'remotes' events; the 60s TTL is the
-            // failsafe for watcher latency / web (no fs watcher).
-            caching: {
-                cache: this.cache.gitResults,
-                options: { accessTTL: isSha(rev) ? 5 * 60 * 1000 : 60 * 1000 },
-            },
-        }, 'log', '-1', ...parser.arguments, rev);
-        if (result.completion.status === 'cancelled' || cancellation?.aborted)
-            return undefined;
-        for (const entry of parser.parse(result.stdout)) {
-            const authorSeconds = Number(entry.authorDate);
-            const committerSeconds = Number(entry.committerDate);
-            if (!Number.isFinite(authorSeconds) || !Number.isFinite(committerSeconds))
-                return undefined;
-            return {
-                authorDate: new Date(authorSeconds * 1000),
-                committerDate: new Date(committerSeconds * 1000),
-            };
-        }
-        return undefined;
-    }
-    async getCommitFiles(repoPath, rev, cancellation) {
-        const parser = getShaAndFilesAndStatsLogParser();
-        const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog }, 'log', ...parser.arguments, '-n1', rev && !isUncommittedStaged(rev) ? rev : undefined, '--');
-        const repoUri = fileUri(normalizePath(repoPath));
-        const files = first(parser.parse(result.stdout))?.files.map(f => new GitFileChange(repoPath, f.path, f.status, joinUriPath(repoUri, normalizePath(f.path)), f.originalPath, f.originalPath != null ? joinUriPath(repoUri, normalizePath(f.originalPath)) : undefined, undefined, { additions: f.additions, deletions: f.deletions, changes: 0 }, undefined, undefined, f.mode, f.oid ? { oid: f.oid, previousOid: f.previousOid } : undefined));
-        return files ?? [];
-    }
-    async getCommitForFile(repoPath, pathOrUri, rev, options, cancellation) {
-        const scope = getScopedLogger();
-        const [relativePath, root] = splitPath(toFsPath(pathOrUri), repoPath);
-        try {
-            const log = await this.getLogForPath(root, relativePath, rev, { limit: 1 }, cancellation);
-            if (log == null)
-                return undefined;
-            let commit;
-            if (rev) {
-                commit = log.commits.get(rev);
-                if (commit == null && !options?.firstIfNotFound) {
-                    // If the ref isn't a valid sha we will never find it, so let it fall through so we return the first
-                    if (isSha(rev) || isUncommitted(rev))
-                        return undefined;
-                }
-            }
-            return commit ?? first(log.commits.values());
-        }
-        catch (ex) {
-            scope?.error(ex);
-            if (isCancellationError(ex))
-                throw ex;
-            return undefined;
-        }
-    }
-    getCommitReachability(repoPath, rev, cancellation) {
-        if (repoPath == null || isUncommitted(rev))
-            return Promise.resolve(undefined);
-        const scope = getScopedLogger();
-        const getCore = async (cacheable) => {
-            try {
-                // Use for-each-ref with %(HEAD) to mark current branch with *
-                const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'ignore' }, 'for-each-ref', '--contains', rev, '--format=%(HEAD)%(refname)', '--sort=-version:refname', '--sort=-committerdate', '--sort=-HEAD', 'refs/heads/', 'refs/remotes/', 'refs/tags/');
-                if (cancellation?.aborted)
-                    throw new CancellationError();
-                const refs = [];
-                // Parse branches from refs/heads/ and refs/remotes/
-                if (result?.stdout) {
-                    const lines = result.stdout.split('\n');
-                    for (let line of lines) {
-                        line = line.trim();
-                        if (!line)
-                            continue;
-                        // %(HEAD) outputs '*' for current branch, ' ' for others
-                        const isCurrent = line.startsWith('*');
-                        const refname = isCurrent ? line.substring(1) : line; // Skip the HEAD marker
-                        // Skip HEADs
-                        if (refname.endsWith('/HEAD'))
-                            continue;
-                        if (refname.startsWith('refs/heads/')) {
-                            // Remove 'refs/heads/'
-                            const name = refname.substring(11);
-                            refs.push({
-                                refType: 'branch',
-                                name: name,
-                                remote: false,
-                                current: isCurrent,
-                            });
-                        }
-                        else if (refname.startsWith('refs/remotes/')) {
-                            // Remove 'refs/remotes/'
-                            refs.push({ refType: 'branch', name: refname.substring(13), remote: true });
-                        }
-                        else if (refname.startsWith('refs/tags/')) {
-                            // Remove 'refs/tags/'
-                            refs.push({ refType: 'tag', name: refname.substring(10) });
-                        }
-                    }
-                }
-                // git already returns sorted by -HEAD, -committerdate, -version:refname;
-                // compareReachableRefs refines by current-first / local-before-remote / tag-version.
-                refs.sort(compareReachableRefs);
-                return { refs: refs };
-            }
-            catch (ex) {
-                cacheable?.invalidate();
-                if (isCancellationError(ex))
-                    throw ex;
-                debugger;
-                scope?.error(ex);
-                return undefined;
-            }
-        };
-        return this.cache.reachability.getOrCreate(repoPath, rev, getCore);
-    }
-    async getIncomingActivity(repoPath, options, cancellation) {
-        const scope = getScopedLogger();
-        const cfg = this.context.config;
-        const parser = getReflogParser();
-        const args = ['--walk-reflogs', ...parser.arguments, '--date=iso8601'];
-        const ordering = options?.ordering ?? cfg?.commits.ordering;
-        if (ordering) {
-            args.push(`--${ordering}-order`);
-        }
-        if (options?.all) {
-            args.push('--all');
-        }
-        // Pass a much larger limit to reflog, because we aggregate the data and we won't know how many lines we'll need
-        const limit = (options?.limit ?? cfg?.commits.maxItems ?? 0) * 100;
-        if (limit) {
-            args.push(`-n${limit}`);
-        }
-        if (options?.skip) {
-            args.push(`--skip=${options.skip}`);
-        }
-        try {
-            const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog, priority: 'background' }, 'log', ...args);
-            const reflog = parseGitRefLog(parser, result.stdout, repoPath, reflogCommands, limit, limit * 100);
-            if (reflog?.hasMore) {
-                reflog.more = this.getReflogMoreFn(reflog, options);
-            }
-            return reflog;
-        }
-        catch (ex) {
-            scope?.error(ex);
-            if (isCancellationError(ex))
-                throw ex;
-            return undefined;
-        }
-    }
-    getReflogMoreFn(reflog, options) {
-        return async (limit) => {
-            limit = limit ?? 0;
-            const moreLog = await this.getIncomingActivity(reflog.repoPath, {
-                ...options,
-                limit: limit,
-                skip: reflog.total,
-            });
-            if (moreLog == null) {
-                // If we can't find any more, assume we have everything
-                return { ...reflog, hasMore: false, more: undefined };
-            }
-            const mergedLog = {
-                repoPath: reflog.repoPath,
-                records: [...reflog.records, ...moreLog.records],
-                count: reflog.count + moreLog.count,
-                total: reflog.total + moreLog.total,
-                limit: (reflog.limit ?? 0) + limit,
-                hasMore: moreLog.hasMore,
-            };
-            if (mergedLog.hasMore) {
-                mergedLog.more = this.getReflogMoreFn(mergedLog, options);
-            }
-            return mergedLog;
-        };
-    }
-    getInitialCommitSha(repoPath, cancellation) {
-        // Initial commit SHA is shared across all worktrees
-        return this.cache.getInitialCommitSha(repoPath, async (commonPath) => {
-            try {
-                const result = await this.git.run({ cwd: commonPath, cancellation: cancellation, errors: 'ignore' }, 'rev-list', `--max-parents=0`, 'HEAD', '--');
-                if (result.completion.status === 'cancelled' || cancellation?.aborted) {
-                    throw new CancellationError();
-                }
-                return result.stdout.trim().split('\n')?.[0];
-            }
-            catch (ex) {
-                if (isCancellationError(ex))
-                    throw ex;
-                return undefined;
-            }
-        });
-    }
-    async getLeftRightCommitCount(repoPath, range, options, cancellation) {
-        const authors = options?.authors?.length
-            ? options.authors.map(a => `--author=^${escapeRegex(a.name ?? '')} <${escapeRegex(a.email ?? '')}>$`)
-            : [];
-        const run = async () => {
-            const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'ignore' }, 'rev-list', '--left-right', '--count', ...authors, options?.excludeMerges ? '--no-merges' : undefined, range, '--');
-            if (result.completion.status === 'cancelled' || cancellation?.aborted) {
-                throw new CancellationError();
-            }
-            if (!result.stdout)
-                return undefined;
-            const parts = result.stdout.split('\t');
-            if (parts.length !== 2)
-                return undefined;
-            const [left, right] = parts;
-            const counts = {
-                left: parseInt(left, 10),
-                right: parseInt(right, 10),
-            };
-            if (isNaN(counts.left) || isNaN(counts.right))
-                return undefined;
-            return counts;
-        };
-        // Author-filtered calls are one-off (e.g. "who made these commits") with low re-hit
-        // rate; skip the cache to protect its capacity for the hot no-author merge-target path.
-        if (authors.length > 0)
-            return run();
-        // Cache key: range + excludeMerges. RepositoryChange events affecting branches/remotes
-        // invalidate this cache via clearCaches('branches').
-        const cacheKey = `${range}\x1f${options?.excludeMerges ? 'no-merges' : ''}`;
-        return this.cache.leftRightCommitCount.getOrCreate(repoPath, cacheKey, run);
-    }
-    async getLog(repoPath, rev, options, cancellation) {
-        return this.getLogCore(repoPath, rev, options, cancellation);
-    }
-    async getLogCore(repoPath, rev, options, cancellation, additionalArgs) {
-        const scope = getScopedLogger();
-        try {
-            const currentUserPromise = this.provider.config.getCurrentUser(repoPath);
-            const cfg = this.context.config;
-            const limit = options?.limit ?? cfg?.commits.maxItems ?? 0;
-            const isSingleCommit = limit === 1;
-            const cfgIncludeFiles = options?.includeFiles ?? cfg?.commits.includeFileDetails ?? true;
-            const includeFiles = cfgIncludeFiles || isSingleCommit || Boolean(options?.path?.pathspec);
-            const parser = getCommitsLogParser(includeFiles, Boolean(options?.path?.pathspec && options?.path?.range));
-            const args = ['log', ...parser.arguments];
-            const similarityThreshold = options?.similarityThreshold ?? cfg?.commits.similarityThreshold;
-            args.push(`-M${similarityThreshold == null ? '' : `${similarityThreshold}%`}`, '--use-mailmap');
-            if (options?.all) {
-                args.push('--all');
-                if (options?.path?.pathspec) {
-                    args.push('--single-worktree');
-                }
-            }
-            const merges = options?.merges ?? true;
-            if (merges) {
-                // If we are are asking for a specific ref, ensure we return the merge commit files
-                if (isSingleCommit) {
-                    args.push('-m');
-                }
-                args.push(merges === 'first-parent' ? '--first-parent' : '--no-min-parents');
-            }
-            else {
-                args.push('--no-merges');
-            }
-            const ordering = options?.ordering ?? cfg?.commits.ordering;
-            if (ordering) {
-                args.push(`--${ordering}-order`);
-            }
-            if (options?.authors?.length) {
-                args.push(...options.authors.map(a => `--author=^${escapeRegex(a.name ?? '')} <${escapeRegex(a.email ?? '')}>$`));
-            }
-            let overrideHasMore;
-            if (options?.since) {
-                overrideHasMore = true;
-                args.push(`--since="${options.since}"`);
-            }
-            if (options?.until) {
-                overrideHasMore = true;
-                args.push(`--until="${options.until}"`);
-            }
-            if (additionalArgs?.length) {
-                args.push(...additionalArgs);
-            }
-            if (limit > 0) {
-                overrideHasMore = isSingleCommit ? false : undefined;
-                // Add 1 to the limit so we can check if there are more commits
-                args.push(`-n${isSingleCommit ? 1 : limit + 1}`);
-            }
-            let stashes;
-            if (!isSingleCommit && options?.stashes) {
-                stashes =
-                    typeof options.stashes === 'boolean'
-                        ? (await this.provider.stash?.getStash(repoPath, { reachableFrom: rev }, cancellation))?.stashes
-                        : options.stashes;
-                if (stashes?.size) {
-                    rev ??= 'HEAD';
-                }
-            }
-            if (rev && !isUncommittedStaged(rev)) {
-                args.push(rev);
-            }
-            let pathspec;
-            let pathspecRange;
-            if (options?.path?.pathspec) {
-                pathspec = options.path.pathspec;
-                const { filters, range, renames } = options.path;
-                if (filters?.length) {
-                    args.push(`--diff-filter=${filters.join('')}`);
-                }
-                if (range != null) {
-                    // Git doesn't allow rename detection (`--follow`) if a range is used
-                    const [start, end] = getGitStartEnd(range);
-                    pathspecRange = `${start},${end}`;
-                    args.push(`-L ${pathspecRange}:${pathspec}`, '--');
-                }
-                else {
-                    if (renames !== false) {
-                        args.push('--follow');
-                    }
-                    args.push('--', pathspec);
-                }
-            }
-            else {
-                args.push('--');
-            }
-            const currentUser = await currentUserPromise.catch(() => undefined);
-            if (cancellation?.aborted)
-                throw new CancellationError();
-            const cmdOpts = {
-                cwd: repoPath,
-                cancellation: cancellation,
-                configs: gitConfigsLogWithFiles,
-                // Single-commit log serves user-initiated reads (commit details, hover, etc.).
-                // Mirrors getCommitDates: full SHAs are immutable so a 5-min TTL is safe; non-SHA refs
-                // rely on gitResults being cleared on head/heads/remotes events (60s is the failsafe
-                // for watcher latency / web with no fs watcher).
-                ...(isSingleCommit && rev
-                    ? {
-                        caching: {
-                            cache: this.cache.gitResults,
-                            options: { accessTTL: isSha(rev) ? 5 * 60 * 1000 : 60 * 1000 },
-                        },
-                    }
-                    : undefined),
-            };
-            let { commits, count } = await parseCommits(parser, isSingleCommit ? this.git.run(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args), repoPath, pathspec, limit, undefined, currentUser);
-            // If we didn't find any history from the working tree, check to see if the file was renamed
-            if (rev == null && pathspec && !commits.size) {
-                const status = await this.provider.status?.getStatusForFile?.(repoPath, pathspec, undefined, cancellation);
-                if (status?.originalPath != null) {
-                    pathspec = status.originalPath;
-                    if (pathspecRange) {
-                        const index = args.findIndex(a => a.startsWith('-L '));
-                        args.splice(index, 1, `-L ${pathspecRange}:${pathspec}`);
-                    }
-                    else {
-                        args.splice(args.length - 1, 1, pathspec);
-                    }
-                    ({ commits, count } = await parseCommits(parser, isSingleCommit ? this.git.run(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args), repoPath, pathspec, limit, undefined, currentUser));
-                }
-            }
-            // Merge stashes in-memory rather than via `git log --stdin <stash>` — git would
-            // walk each stash's parent chains and pull in pre-rebase ancestors that aren't
-            // reachable from <rev>. Slot each stash directly above its first parent; stashes
-            // whose parent isn't in the result (rebased away, or below the current limit) are
-            // dropped — the Stashes view still surfaces them, and they reappear here if the
-            // parent loads via "Load more".
-            if (stashes?.size) {
-                // `stashes` arrives in `git stash list` order (newest @{0} first), so per-parent
-                // groups naturally land newest-first without an explicit sort
-                const stashesByParent = new Map();
-                for (const stash of stashes.values()) {
-                    const parentSha = stash.parents[0];
-                    if (parentSha == null || !commits.has(parentSha))
-                        continue;
-                    const group = stashesByParent.get(parentSha);
-                    if (group != null) {
-                        group.push(stash);
-                    }
-                    else {
-                        stashesByParent.set(parentSha, [stash]);
-                    }
-                }
-                if (stashesByParent.size) {
-                    const cap = limit > 0 ? limit + 1 : Number.POSITIVE_INFINITY;
-                    const merged = new Map();
-                    outer: for (const c of commits.values()) {
-                        const group = stashesByParent.get(c.sha);
-                        if (group != null) {
-                            for (const s of group) {
-                                if (merged.size >= cap)
-                                    break outer;
-                                merged.set(s.sha, s);
-                            }
-                        }
-                        if (merged.size >= cap)
-                            break;
-                        merged.set(c.sha, c);
-                    }
-                    commits = merged;
-                }
-            }
-            const log = {
-                repoPath: repoPath,
-                commits: commits,
-                sha: isRevisionRange(rev) ? undefined : rev,
-                count: commits.size,
-                limit: limit,
-                hasMore: overrideHasMore ?? (limit > 0 && count > limit),
-            };
-            if (!isSingleCommit) {
-                log.query = (limit) => this.getLogCore(repoPath, rev, { ...options, limit: limit }, undefined, additionalArgs);
-                if (log.hasMore) {
-                    log.more = this.getLogCoreMoreFn(log, rev, options);
-                }
-            }
-            return log;
-        }
-        catch (ex) {
-            if (isCancellationError(ex))
-                throw ex;
-            // Check if this is a "bad object" error due to a submodule's internal SHA
-            const pathspec = options?.path?.pathspec;
-            if (rev && pathspec && ex instanceof Error && GitErrors.badObject.test(ex.message)) {
-                const tree = await this.provider.revision.getTreeEntryForRevision(repoPath, pathspec, 'HEAD');
-                if (tree?.type === 'commit') {
-                    // It's a submodule - retry without the rev and without rename tracking
-                    return this.getLogCore(repoPath, undefined, { ...options, path: { ...options.path, pathspec: pathspec, renames: false } }, cancellation, additionalArgs);
-                }
-            }
-            scope?.error(ex);
-            debugger;
-            return undefined;
-        }
-    }
-    getLogCoreMoreFn(log, rev, options) {
-        return async (limit) => {
-            const moreUntil = limit != null && typeof limit === 'object' ? limit.until : undefined;
-            let moreLimit = typeof limit === 'number' ? limit : undefined;
-            if (moreUntil && some(log.commits.values(), c => c.ref === moreUntil)) {
-                return log;
-            }
-            moreLimit = moreLimit ?? 0;
-            // If the log is for a range, then just get everything prior + more
-            if (isRevisionRange(log.sha)) {
-                const moreLog = await this.getLogCore(log.repoPath, rev, {
-                    ...options,
-                    limit: moreLimit === 0 ? 0 : (options?.limit ?? 0) + moreLimit,
-                });
-                // If we can't find any more, assume we have everything
-                if (moreLog == null)
-                    return { ...log, hasMore: false, more: undefined };
-                return moreLog;
-            }
-            // Stashes are not part of the normal commit history, so we need to find the last non-stash commit for the cursor
-            const lastCommit = findLast(log.commits.values(), c => !GitCommit.isStash(c)) ?? last(log.commits.values());
-            const sha = lastCommit?.ref;
-            // Check to make sure the filename hasn't changed and if it has use the previous
-            const lastCommitFile = lastCommit?.anyFiles?.[0];
-            if (options?.path?.pathspec && lastCommitFile != null) {
-                const path = lastCommitFile.originalPath ?? lastCommitFile.path;
-                if (path !== options.path.pathspec) {
-                    options = { ...options, path: { ...options.path, pathspec: path } };
-                }
-            }
-            // If we were asked for all refs, use the last commit timestamp (plus a second) as a cursor
-            let timestamp;
-            if (options?.all) {
-                const date = lastCommit?.committer.date;
-                // Git only allows 1-second precision, so round up to the nearest second
-                timestamp = date != null ? Math.ceil(date.getTime() / 1000) + 1 : undefined;
-            }
-            let moreLogCount;
-            let queryLimit = moreUntil == null ? moreLimit : 0;
-            do {
-                const moreLog = await this.getLogCore(log.repoPath, timestamp ? rev : moreUntil == null ? `${sha}^` : `${moreUntil}^..${sha}^`, {
-                    ...options,
-                    limit: queryLimit,
-                    ...(timestamp ? { until: timestamp } : undefined),
-                }, undefined, timestamp ? ['--boundary'] : undefined);
-                // If we can't find any more, assume we have everything
-                if (moreLog == null)
-                    return { ...log, hasMore: false, more: undefined };
-                const currentCount = log.commits.size;
-                const commits = new Map([...log.commits, ...moreLog.commits]);
-                if (currentCount === commits.size && queryLimit !== 0) {
-                    // If we didn't find any new commits, we must have them all so return that we have everything
-                    if (moreLogCount === moreLog.commits.size) {
-                        return { ...log, hasMore: false, more: undefined };
-                    }
-                    moreLogCount = moreLog.commits.size;
-                    queryLimit = queryLimit * 2;
-                    continue;
-                }
-                if (timestamp != null && sha != null && !moreLog.commits.has(sha)) {
-                    debugger;
-                }
-                const mergedLog = {
-                    repoPath: log.repoPath,
-                    commits: commits,
-                    sha: log.sha,
-                    count: commits.size,
-                    limit: moreUntil == null ? (log.limit ?? 0) + moreLimit : undefined,
-                    hasMore: moreUntil == null ? moreLog.hasMore : true,
-                    // The oldest commit SHA of the previous page — the graph webview compares this
-                    // against its last displayed row to determine the merge point for appending new rows
-                    startingCursor: sha,
-                    endingCursor: moreLog.endingCursor,
-                    pagedCommits: () => {
-                        // Remove any duplicates
-                        for (const sha of log.commits.keys()) {
-                            moreLog.commits.delete(sha);
-                        }
-                        return moreLog.commits;
-                    },
-                    // oxlint-disable-next-line no-loop-func
-                    query: (limit) => this.getLogCore(log.repoPath, rev, { ...options, limit: limit }),
-                };
-                if (mergedLog.hasMore) {
-                    mergedLog.more = this.getLogCoreMoreFn(mergedLog, rev, options);
-                }
-                return mergedLog;
-            } while (true);
-        };
-    }
-    async getLogForPath(repoPath, pathOrUri, rev, options, cancellation) {
-        if (repoPath == null)
-            return undefined;
-        const scope = getScopedLogger();
-        let relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
-        if (repoPath != null && repoPath === relativePath) {
-            throw new Error(`Path cannot match the repository path; path=${relativePath}`);
-        }
-        const cfg = this.context.config;
-        options = {
-            ...options,
-            all: options?.all ?? cfg?.fileHistory?.showAllBranches,
-            limit: options?.limit ?? cfg?.commits.maxItems ?? 0,
-            merges: options?.merges ?? cfg?.fileHistory?.showMergeCommits,
-            ordering: options?.ordering ?? cfg?.commits.ordering ?? undefined,
-            renames: options?.renames ?? cfg?.fileHistory?.followRenames,
-            similarityThreshold: options?.similarityThreshold ?? cfg?.commits.similarityThreshold,
-        };
-        if (isFolderGlob(relativePath)) {
-            relativePath = stripFolderGlob(relativePath);
-            options.isFolder = true;
-        }
-        else if (options.isFolder == null) {
-            const tree = await this.provider.revision.getTreeEntryForRevision(repoPath, relativePath, rev || 'HEAD');
-            if (cancellation?.aborted)
-                throw new CancellationError();
-            if (tree?.type === 'commit') {
-                // It's a submodule — line ranges and rename tracking don't apply, and the rev may reference
-                // the submodule's internal SHA which isn't valid in the parent repo
-                options.range = undefined;
-                options.renames = false;
-                // rev = undefined;
-            }
-            else {
-                options.isFolder = tree?.type === 'tree';
-            }
-        }
-        // Build cache key — only for non-folder, non-filtered queries
-        let cacheKey;
-        if (!options.isFolder &&
-            options.authors == null &&
-            options.cursor == null &&
-            options.filters == null &&
-            options.range == null &&
-            options.since == null &&
-            options.until == null) {
-            let suffix = 'log';
-            if (rev != null) {
-                suffix += `:${rev}`;
-            }
-            if (options.all) {
-                suffix += ':all';
-            }
-            if (options.limit) {
-                suffix += `:n${options.limit}`;
-            }
-            if (options.merges) {
-                suffix += `:merges=${options.merges}`;
-            }
-            if (options.ordering) {
-                suffix += `:ordering=${options.ordering}`;
-            }
-            if (options.renames) {
-                suffix += ':follow';
-            }
-            cacheKey = `${normalizePath(relativePath)}:${suffix}`;
-        }
-        if (cacheKey != null) {
-            // Check for exact cache hit
-            const cached = this.cache.fileLog.get(repoPath, cacheKey);
-            if (cached != null) {
-                scope?.trace(`Cache hit: '${cacheKey}'`);
-                return cached;
-            }
-            // Subset optimization: if requesting partial log, check if whole-file log is cached
-            if (rev != null || (options.limit != null && options.limit !== 0)) {
-                const baseKey = `${normalizePath(relativePath)}:log${options.renames ? ':follow' : ''}`;
-                const baseLog = this.cache.fileLog.get(repoPath, baseKey);
-                if (baseLog != null) {
-                    if (rev == null) {
-                        scope?.trace(`Cache hit: ~'${cacheKey}'`);
-                        return baseLog;
-                    }
-                    scope?.trace(`Cache ?: '${cacheKey}'`);
-                    const log = await baseLog;
-                    if (log != null && !log.hasMore && log.commits.has(rev)) {
-                        scope?.trace(`Cache hit: '${cacheKey}'`);
-                        // Create a copy of the log starting at the requested commit
-                        let skip = true;
-                        let i = 0;
-                        const limit = options.limit;
-                        const commits = new Map(filterMap(log.commits.entries(), ([sha, c]) => {
-                            if (skip) {
-                                if (sha !== rev)
-                                    return undefined;
-                                skip = false;
-                            }
-                            i++;
-                            if (limit != null && i > limit) {
-                                return undefined;
-                            }
-                            return [sha, c];
-                        }));
-                        const optsCopy = { ...options };
-                        return {
-                            ...log,
-                            limit: optsCopy.limit,
-                            count: commits.size,
-                            commits: commits,
-                            query: (limit) => this.getLogForPath(repoPath, pathOrUri, rev, {
-                                ...optsCopy,
-                                limit: limit,
-                            }),
-                        };
-                    }
-                }
-            }
-            scope?.trace(`Cache miss: '${cacheKey}'`);
-            return this.cache.fileLog.getOrCreate(repoPath, cacheKey, (_cacheable, signal) => this.getLogForPathCore(repoPath, relativePath, rev, options, signal), { cancellation: cancellation });
-        }
-        return this.getLogForPathCore(repoPath, relativePath, rev, options, cancellation);
-    }
-    async getLogForPathCore(repoPath, path, rev, options, cancellation) {
-        const scope = getScopedLogger();
-        const tracked = await this.provider.isTrackedWithDetails(path, repoPath, rev);
-        if (cancellation?.aborted)
-            throw new CancellationError();
-        if (tracked == null) {
-            scope?.debug(`Skipping log; '${path}' is not tracked`);
-            return emptyPromise;
-        }
-        const relativePath = tracked.path;
-        const root = repoPath;
-        const log = await this.getLogCore(root, rev, {
-            all: options.all,
-            authors: options.authors,
-            cursor: options.cursor,
-            limit: options.limit,
-            merges: options.merges,
-            ordering: options.ordering,
-            since: options.since,
-            until: options.until,
-            path: {
-                pathspec: relativePath,
-                filters: options.filters,
-                range: options.range,
-                renames: options.renames,
-            },
-        }, cancellation);
-        return log;
-    }
-    async getLogShas(repoPath, rev, options, cancellation) {
-        const scope = getScopedLogger();
-        const cfg = this.context.config;
-        options ??= {};
-        options.limit ??= cfg?.commits.maxItems ?? 0;
-        options.ordering ??= cfg?.commits.ordering ?? undefined;
-        options.similarityThreshold ??= cfg?.commits.similarityThreshold;
-        options.merges ??= true;
-        const getCore = async () => {
-            try {
-                const parser = getShaLogParser();
-                const args = [...parser.arguments];
-                if (options.all) {
-                    args.push(`--all`);
-                }
-                if (options.ordering) {
-                    args.push(`--${options.ordering}-order`);
-                }
-                if (options.limit) {
-                    args.push(`-n${options.limit}`);
-                }
-                if (options.since) {
-                    args.push(`--since="${options.since}"`);
-                }
-                if (options.merges) {
-                    args.push(options.merges === 'first-parent' ? '--first-parent' : '--no-min-parents');
-                }
-                else {
-                    args.push('--no-merges');
-                }
-                if (options.reverse) {
-                    args.push('--reverse');
-                }
-                if (options.authors?.length) {
-                    if (!args.includes('--use-mailmap')) {
-                        args.push('--use-mailmap');
-                    }
-                    args.push(...options.authors.map(a => `--author=^${escapeRegex(a.name ?? '')} <${escapeRegex(a.email ?? '')}>$`));
-                }
-                const pathspec = options.pathOrUri != null ? this.provider.getRelativePath(options.pathOrUri, repoPath) : undefined;
-                if (pathspec) {
-                    const similarityThreshold = options.similarityThreshold;
-                    args.push(`-M${similarityThreshold == null ? '' : `${similarityThreshold}%`}`);
-                }
-                if (rev && !isUncommittedStaged(rev)) {
-                    args.push(rev);
-                }
-                args.push('--');
-                if (pathspec) {
-                    args.push(pathspec);
-                }
-                const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog }, 'log', ...args);
-                return [...parser.parse(result.stdout)];
-            }
-            catch (ex) {
-                scope?.error(ex);
-                if (isCancellationError(ex))
-                    throw ex;
-                debugger;
-                return [];
-            }
-        };
-        // Cache simple queries (no pathspec, no authors) as these are on hot paths (e.g. getting unpublished commits)
-        const cacheable = !options.pathOrUri && !options.authors?.length && !options.reverse && !options.all;
-        if (cacheable) {
-            return this.cache.logShas.getOrCreate(repoPath, `${rev ?? ''}:${options.ordering ?? ''}:${options.limit}:${options.merges}:${options.since ?? ''}`, () => getCore());
-        }
-        return getCore();
-    }
-    async getOldestUnpushedShaForPath(repoPath, pathOrUri, cancellation) {
-        const scope = getScopedLogger();
-        try {
-            const relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
-            const parser = getShaLogParser();
-            const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, configs: gitConfigsLog }, 'log', ...parser.arguments, '--follow', '--reverse', '@{u}..', '--', relativePath);
-            return first(parser.parse(result.stdout));
-        }
-        catch (ex) {
-            scope?.error(ex);
-            if (isCancellationError(ex))
-                throw ex;
-            debugger;
-            return undefined;
-        }
-    }
-    async hasCommitBeenPushed(repoPath, rev, cancellation) {
-        if (repoPath == null)
-            return false;
-        return this.isAncestorOf(repoPath, rev, '@{u}', cancellation);
-    }
-    async isAncestorOf(repoPath, rev1, rev2, cancellation) {
-        if (repoPath == null)
-            return false;
-        const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'ignore' }, 'merge-base', '--is-ancestor', rev1, rev2);
-        // A cancelled check has no answer. `completion` now keeps that distinct from a real "is an ancestor"
-        // result — the missing `exitCode` alone already makes the check below `false` — but callers branch on
-        // `isCancellationError`, so this still has to throw rather than quietly answer "no".
-        if (cancellation?.aborted)
-            throw new CancellationError();
-        return result.exitCode === 0;
-    }
-    async searchCommits(repoPath, search, options, cancellation) {
-        const scope = getScopedLogger();
-        search = { matchAll: false, matchCase: false, matchRegex: true, matchWholeWord: false, ...search };
-        // Pre-process natural language search queries via the host-provided hook
-        if (search.naturalLanguage &&
-            (typeof search.naturalLanguage !== 'object' || !search.naturalLanguage.processedQuery)) {
-            search = (await this.context.searchQuery?.preprocessQuery?.(search, options?.source)) ?? search;
-        }
-        // The conversion failed — `search.query` is still the raw English sentence, not a query; running
-        // it as an ERE would produce a regex error about text the user never wrote.
-        if (typeof search.naturalLanguage === 'object' && search.naturalLanguage.error) {
-            return { search: search, log: undefined };
-        }
-        try {
-            const cfg = this.context.config;
-            const currentUser = await this.provider.config.getCurrentUser(repoPath);
-            if (cancellation?.aborted)
-                throw new CancellationError();
-            const parser = getCommitsLogParser(true);
-            const similarityThreshold = options?.similarityThreshold ?? cfg?.commits.similarityThreshold;
-            const args = [
-                'log',
-                ...parser.arguments,
-                `-M${similarityThreshold == null ? '' : `${similarityThreshold}%`}`,
-                '--use-mailmap',
-            ];
-            const { args: searchArgs, files, shas, filters } = parseSearchQueryGitCommand(search, currentUser);
-            // Stash commits have 2-3 parents, so `--merges` matches them; excluded in parseCommits.
-            // Derived from the args git actually runs rather than `filters.type`, since a multi-value
-            // `type:` query (e.g. `type:merge type:tip`) leaves `--merges` in the args while
-            // `filters.type` reflects only the last value parsed
-            const mergesOnly = searchArgs.includes('--merges');
-            let stashes;
-            let stdin;
-            let resolvedShas;
-            if (shas?.size) {
-                resolvedShas = await this.provider.revision.resolveShas(repoPath, shas, cancellation);
-                if (cancellation?.aborted)
-                    throw new CancellationError();
-                // Short SHA(s) matched no commit: return empty (empty stdin to `--no-walk --stdin`
-                // would return HEAD, so we must not fall through to git).
-                if (!resolvedShas.size) {
-                    return {
-                        search: search,
-                        log: {
-                            repoPath: repoPath,
-                            commits: new Map(),
-                            sha: undefined,
-                            searchFilters: filters,
-                            count: 0,
-                            limit: options?.limit ?? cfg?.search?.maxItems ?? 0,
-                            hasMore: false,
-                        },
-                    };
-                }
-            }
-            if (resolvedShas?.size) {
-                stdin = join(resolvedShas, '\n');
-                args.push('--no-walk');
-            }
-            else if (!filters.refs) {
-                // Don't include stashes when using ref: filter, as they would add unrelated commits
-                // There *HAS* to be a better way to get git log to return stashes, but this is the best we've found
-                const converted = convertStashesToStdin(await this.provider.stash?.getStash(repoPath, undefined, cancellation));
-                stashes = converted.stashes;
-                // `--all` already surfaces refs/stash's tip on its own, so when merges-only there's no need
-                // to walk the rest of the stash stack via stdin -- parseCommits still excludes any stash
-                // sha that slips through via refs/stash
-                stdin = mergesOnly ? undefined : converted.stdin;
-            }
-            else if (mergesOnly) {
-                // `ref:` skips walking stashes into the results (they're unrelated to the ref), but a
-                // stash's tip can still leak in via `--merges` if the ref reaches refs/stash -- fetch
-                // stashes here purely so parseCommits can exclude them, without widening the walk via
-                // stdin
-                stashes = convertStashesToStdin(await this.provider.stash?.getStash(repoPath, undefined, cancellation)).stashes;
-            }
-            if (stdin) {
-                args.push('--stdin');
-            }
-            const limit = options?.limit ?? cfg?.search?.maxItems ?? 0;
-            if (limit && !shas?.size) {
-                args.push(`-n${limit + 1}`);
-            }
-            const ordering = options?.ordering ?? cfg?.commits.ordering;
-            if (ordering) {
-                args.push(`--${ordering}-order`);
-            }
-            if (options?.skip) {
-                args.push(`--skip=${options.skip}`);
-            }
-            // Add the search args, but skip any shas (as they are already included in the stdin)
-            for (const arg of searchArgs) {
-                if (shas?.has(arg) || args.includes(arg))
-                    continue;
-                args.push(arg);
-            }
-            const pathspec = files?.join(' ');
-            const { commits, count, countStashChildCommits } = await parseCommits(parser, this.git.stream({
-                cwd: repoPath,
-                cancellation: cancellation,
-                configs: ['-C', repoPath, ...gitConfigsLog],
-                stdin: stdin,
-            }, ...args, '--', ...files), repoPath, pathspec, limit, stashes, currentUser, filters, mergesOnly);
-            const log = {
-                repoPath: repoPath,
-                commits: commits,
-                sha: undefined,
-                searchFilters: filters,
-                count: commits.size,
-                limit: limit,
-                hasMore: count - countStashChildCommits > commits.size,
-                query: (limit) => this.searchCommits(repoPath, search, { ...options, limit: limit }).then(r => r.log),
-            };
-            if (log.hasMore) {
-                const searchCommitsCore = (log) => {
-                    return async (limit) => {
-                        limit = limit ?? 0;
-                        const moreLog = (await this.searchCommits(log.repoPath, search, {
-                            ...options,
-                            limit: limit,
-                            skip: log.count,
-                        })).log;
-                        // If we can't find any more, assume we have everything
-                        if (moreLog == null)
-                            return { ...log, hasMore: false, more: undefined };
-                        const commits = new Map([...log.commits, ...moreLog.commits]);
-                        const mergedLog = {
-                            repoPath: log.repoPath,
-                            commits: commits,
-                            sha: log.sha,
-                            searchFilters: filters,
-                            count: commits.size,
-                            limit: (log.limit ?? 0) + limit,
-                            hasMore: moreLog.hasMore,
-                            query: (limit) => this.searchCommits(log.repoPath, search, { ...options, limit: limit }).then(r => r.log),
-                        };
-                        if (mergedLog.hasMore) {
-                            mergedLog.more = searchCommitsCore(mergedLog);
-                        }
-                        return mergedLog;
-                    };
-                };
-                log.more = searchCommitsCore(log);
-            }
-            return { search: search, log: log };
-        }
-        catch (ex) {
-            scope?.error(ex);
-            if (isCancellationError(ex))
-                throw ex;
-            return { search: search, log: undefined };
-        }
-    }
-    async getCommitSignature(repoPath, sha) {
-        const scope = getScopedLogger();
-        try {
-            const result = await this.git.run({
-                cwd: repoPath,
-                errors: 'ignore',
-                caching: {
-                    cache: this.cache.gitResults,
-                    options: { accessTTL: isSha(sha) ? 5 * 60 * 1000 : 60 * 1000 },
-                },
-                configs: gitConfigsLog,
-            }, 'log', `--format=${signatureFormat}`, '-1', sha);
-            if (!result.stdout)
-                return undefined;
-            return parseSignatureOutput(result.stdout);
-        }
-        catch (ex) {
-            scope?.error(ex);
-            return undefined;
-        }
-    }
-    async isCommitSigned(repoPath, sha) {
-        const scope = getScopedLogger();
-        try {
-            const result = await this.git.run({
-                cwd: repoPath,
-                errors: 'ignore',
-                caching: {
-                    cache: this.cache.gitResults,
-                    options: { accessTTL: isSha(sha) ? 5 * 60 * 1000 : 60 * 1000 },
-                },
-            }, 'cat-file', 'commit', sha);
-            return /^gpgsig(-sha256)? /m.test(result.stdout);
-        }
-        catch (ex) {
-            scope?.error(ex);
-            return false;
-        }
-    }
-    async getCommitsSshSigners(repoPath, shas) {
-        const scope = getScopedLogger();
-        const result = new Map();
-        if (shas.length === 0)
-            return result;
-        try {
-            // Read every commit object in a single `cat-file --batch` process (the SHAs are piped to stdin) rather than
-            // spawning one `git` per commit — the embedded SSH signature and committer identity are then parsed from
-            // each raw object, avoiding a separate (and far heavier) `git log` pass to enumerate identities.
-            const data = await this.git.run({ cwd: repoPath, errors: 'ignore', stdin: `${shas.join('\n')}\n`, encoding: 'buffer' }, 'cat-file', '--batch');
-            parseCatFileBatchForSshSigners(data.stdout, new Set(shas), result);
-        }
-        catch (ex) {
-            scope?.error(ex);
-        }
-        return result;
-    }
-}
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "createUnreachableCommitFromTree", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getCommit", null);
-__decorate([
-    debug({ exit: true })
-], CommitsGitSubProvider.prototype, "getCommitCount", null);
-__decorate([
-    debug({ exit: true })
-], CommitsGitSubProvider.prototype, "hasUnpublishedCommits", null);
-__decorate([
-    debug({
-        args: (repoPath, shas) => ({ repoPath: repoPath, shas: `${shas.length} value(s)` }),
-        exit: r => `${r.size} unpublished`,
-    })
-], CommitsGitSubProvider.prototype, "filterUnpublishedShas", null);
-__decorate([
-    debug({ exit: true })
-], CommitsGitSubProvider.prototype, "getCommitDates", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getCommitFiles", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getCommitForFile", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getCommitReachability", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getIncomingActivity", null);
-__decorate([
-    debug({ exit: true })
-], CommitsGitSubProvider.prototype, "getInitialCommitSha", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getLeftRightCommitCount", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getLog", null);
-__decorate([
-    trace({ args: (repoPath, rev) => ({ repoPath: repoPath, rev: rev }), exit: true })
-], CommitsGitSubProvider.prototype, "getLogCore", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getLogForPath", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getLogShas", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getOldestUnpushedShaForPath", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "hasCommitBeenPushed", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "isAncestorOf", null);
-__decorate([
-    debug({
-        args: (repoPath, s) => ({
-            repoPath: repoPath,
-            search: `[${s.matchAll ? 'A' : ''}${s.matchCase ? 'C' : ''}${s.matchRegex ? 'R' : ''}${s.matchWholeWord ? 'W' : ''}]: ${s.query.length > 500 ? `${s.query.substring(0, 500)}...` : s.query}`,
-        }),
-    })
-], CommitsGitSubProvider.prototype, "searchCommits", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getCommitSignature", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "isCommitSigned", null);
-__decorate([
-    debug()
-], CommitsGitSubProvider.prototype, "getCommitsSshSigners", null);
+var CommitsGitSubProvider = class {
+	context;
+	git;
+	cache;
+	provider;
+	constructor(context, git, cache, provider) {
+		this.context = context;
+		this.git = git;
+		this.cache = cache;
+		this.provider = provider;
+	}
+	async createUnreachableCommitFromTree(repoPath, tree, parent, message, cancellation) {
+		return (await this.git.run({
+			cwd: repoPath,
+			cancellation,
+			errors: "throw"
+		}, "commit-tree", tree, "-p", parent, "-m", message)).stdout.trim();
+	}
+	async getCommit(repoPath, rev, cancellation) {
+		if (isUncommitted(rev, true)) return createUncommittedChangesCommit(repoPath, rev, /* @__PURE__ */ new Date(), await this.provider.config.getCurrentUser(repoPath));
+		const log = await this.getLogCore(repoPath, rev, { limit: 1 }, cancellation);
+		if (log == null) return void 0;
+		return log.commits.get(rev) ?? first(log.commits.values());
+	}
+	getCommitCount(repoPath, rev, cancellation) {
+		return this.cache.commitCount.getOrCreate(repoPath, rev, async (cacheable, signal) => {
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation: signal ?? cancellation,
+				errors: "ignore"
+			}, "rev-list", "--count", rev, "--");
+			if (result.completion.status === "cancelled" || signal?.aborted) throw new CancellationError();
+			if (result.completion.status !== "exited" || result.exitCode !== 0) {
+				cacheable.invalidate();
+				return;
+			}
+			const data = result.stdout.trim();
+			if (!data) return void 0;
+			const count = parseInt(data, 10);
+			return isNaN(count) ? void 0 : count;
+		}, { cancellation });
+	}
+	async hasUnpublishedCommits(repoPath, rev, cancellation) {
+		const result = await this.git.run({
+			cwd: repoPath,
+			cancellation,
+			errors: "ignore"
+		}, "rev-list", "--max-count=1", rev, "--not", "--remotes", "--");
+		if (result.completion.status === "cancelled" || cancellation?.aborted) throw new CancellationError();
+		return result.stdout.trim().length > 0;
+	}
+	async filterUnpublishedShas(repoPath, shas, options, cancellation) {
+		const unpublished = /* @__PURE__ */ new Set();
+		if (!shas.length) return unpublished;
+		for (const chunk$1 of chunk([...shas], maxShasPerRevListSpawn)) {
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				...options?.priority != null ? { priority: options.priority } : void 0
+			}, "rev-list", ...chunk$1, "--not", "--remotes", "--");
+			if (result.completion.status !== "exited") throw result.completion.error;
+			if (cancellation?.aborted) throw new CancellationError();
+			const candidates = new Set(chunk$1);
+			for (const line of iterateByDelimiter(result.stdout, "\n")) {
+				const sha = line.trim();
+				if (sha.length && candidates.has(sha)) unpublished.add(sha);
+			}
+		}
+		return unpublished;
+	}
+	async getCommitDates(repoPath, rev, cancellation) {
+		const parser = getShaAndDatesLogParser();
+		const result = await this.git.run({
+			cwd: repoPath,
+			cancellation,
+			errors: "ignore",
+			caching: {
+				cache: this.cache.gitResults,
+				options: { accessTTL: isSha(rev) ? 3e5 : 6e4 }
+			}
+		}, "log", "-1", ...parser.arguments, rev);
+		if (result.completion.status === "cancelled" || cancellation?.aborted) return void 0;
+		for (const entry of parser.parse(result.stdout)) {
+			const authorSeconds = Number(entry.authorDate);
+			const committerSeconds = Number(entry.committerDate);
+			if (!Number.isFinite(authorSeconds) || !Number.isFinite(committerSeconds)) return void 0;
+			return {
+				authorDate: /* @__PURE__ */ new Date(authorSeconds * 1e3),
+				committerDate: /* @__PURE__ */ new Date(committerSeconds * 1e3)
+			};
+		}
+	}
+	async getCommitFiles(repoPath, rev, cancellation) {
+		const parser = getShaAndFilesAndStatsLogParser();
+		const result = await this.git.run({
+			cwd: repoPath,
+			cancellation,
+			configs: gitConfigsLog
+		}, "log", ...parser.arguments, "-n1", rev && !isUncommittedStaged(rev) ? rev : void 0, "--");
+		const repoUri = fileUri(normalizePath(repoPath));
+		return first(parser.parse(result.stdout))?.files.map((f) => new GitFileChange(repoPath, f.path, f.status, joinUriPath(repoUri, normalizePath(f.path)), f.originalPath, f.originalPath != null ? joinUriPath(repoUri, normalizePath(f.originalPath)) : void 0, void 0, {
+			additions: f.additions,
+			deletions: f.deletions,
+			changes: 0
+		}, void 0, void 0, f.mode, f.oid ? {
+			oid: f.oid,
+			previousOid: f.previousOid
+		} : void 0)) ?? [];
+	}
+	async getCommitForFile(repoPath, pathOrUri, rev, options, cancellation) {
+		const scope = getScopedLogger();
+		const [relativePath, root] = splitPath(toFsPath(pathOrUri), repoPath);
+		try {
+			const log = await this.getLogForPath(root, relativePath, rev, { limit: 1 }, cancellation);
+			if (log == null) return void 0;
+			let commit;
+			if (rev) {
+				commit = log.commits.get(rev);
+				if (commit == null && !options?.firstIfNotFound) {
+					if (isSha(rev) || isUncommitted(rev)) return void 0;
+				}
+			}
+			return commit ?? first(log.commits.values());
+		} catch (ex) {
+			scope?.error(ex);
+			if (isCancellationError(ex)) throw ex;
+			return;
+		}
+	}
+	getCommitReachability(repoPath, rev, cancellation) {
+		if (repoPath == null || isUncommitted(rev)) return Promise.resolve(void 0);
+		const scope = getScopedLogger();
+		const getCore = async (cacheable) => {
+			try {
+				const result = await this.git.run({
+					cwd: repoPath,
+					cancellation,
+					errors: "ignore"
+				}, "for-each-ref", "--contains", rev, "--format=%(HEAD)%(refname)", "--sort=-version:refname", "--sort=-committerdate", "--sort=-HEAD", "refs/heads/", "refs/remotes/", "refs/tags/");
+				if (cancellation?.aborted) throw new CancellationError();
+				const refs = [];
+				if (result?.stdout) {
+					const lines = result.stdout.split("\n");
+					for (let line of lines) {
+						line = line.trim();
+						if (!line) continue;
+						const isCurrent = line.startsWith("*");
+						const refname = isCurrent ? line.substring(1) : line;
+						if (refname.endsWith("/HEAD")) continue;
+						if (refname.startsWith("refs/heads/")) {
+							const name = refname.substring(11);
+							refs.push({
+								refType: "branch",
+								name,
+								remote: false,
+								current: isCurrent
+							});
+						} else if (refname.startsWith("refs/remotes/")) refs.push({
+							refType: "branch",
+							name: refname.substring(13),
+							remote: true
+						});
+						else if (refname.startsWith("refs/tags/")) refs.push({
+							refType: "tag",
+							name: refname.substring(10)
+						});
+					}
+				}
+				refs.sort(compareReachableRefs);
+				return { refs };
+			} catch (ex) {
+				cacheable?.invalidate();
+				if (isCancellationError(ex)) throw ex;
+				debugger;
+				scope?.error(ex);
+				return;
+			}
+		};
+		return this.cache.reachability.getOrCreate(repoPath, rev, getCore);
+	}
+	async getIncomingActivity(repoPath, options, cancellation) {
+		const scope = getScopedLogger();
+		const cfg = this.context.config;
+		const parser = getReflogParser();
+		const args = [
+			"--walk-reflogs",
+			...parser.arguments,
+			"--date=iso8601"
+		];
+		const ordering = options?.ordering ?? cfg?.commits.ordering;
+		if (ordering) args.push(`--${ordering}-order`);
+		if (options?.all) args.push("--all");
+		const limit = (options?.limit ?? cfg?.commits.maxItems ?? 0) * 100;
+		if (limit) args.push(`-n${limit}`);
+		if (options?.skip) args.push(`--skip=${options.skip}`);
+		try {
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				configs: gitConfigsLog,
+				priority: "background"
+			}, "log", ...args);
+			const reflog = parseGitRefLog(parser, result.stdout, repoPath, reflogCommands, limit, limit * 100);
+			if (reflog?.hasMore) reflog.more = this.getReflogMoreFn(reflog, options);
+			return reflog;
+		} catch (ex) {
+			scope?.error(ex);
+			if (isCancellationError(ex)) throw ex;
+			return;
+		}
+	}
+	getReflogMoreFn(reflog, options) {
+		return async (limit) => {
+			limit = limit ?? 0;
+			const moreLog = await this.getIncomingActivity(reflog.repoPath, {
+				...options,
+				limit,
+				skip: reflog.total
+			});
+			if (moreLog == null) return {
+				...reflog,
+				hasMore: false,
+				more: void 0
+			};
+			const mergedLog = {
+				repoPath: reflog.repoPath,
+				records: [...reflog.records, ...moreLog.records],
+				count: reflog.count + moreLog.count,
+				total: reflog.total + moreLog.total,
+				limit: (reflog.limit ?? 0) + limit,
+				hasMore: moreLog.hasMore
+			};
+			if (mergedLog.hasMore) mergedLog.more = this.getReflogMoreFn(mergedLog, options);
+			return mergedLog;
+		};
+	}
+	getInitialCommitSha(repoPath, cancellation) {
+		return this.cache.getInitialCommitSha(repoPath, async (commonPath) => {
+			try {
+				const result = await this.git.run({
+					cwd: commonPath,
+					cancellation,
+					errors: "ignore"
+				}, "rev-list", `--max-parents=0`, "HEAD", "--");
+				if (result.completion.status === "cancelled" || cancellation?.aborted) throw new CancellationError();
+				return result.stdout.trim().split("\n")?.[0];
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				return;
+			}
+		});
+	}
+	async getLeftRightCommitCount(repoPath, range, options, cancellation) {
+		const authors = options?.authors?.length ? options.authors.map((a) => `--author=^${escapeRegex(a.name ?? "")} <${escapeRegex(a.email ?? "")}>$`) : [];
+		const run = async () => {
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				errors: "ignore"
+			}, "rev-list", "--left-right", "--count", ...authors, options?.excludeMerges ? "--no-merges" : void 0, range, "--");
+			if (result.completion.status === "cancelled" || cancellation?.aborted) throw new CancellationError();
+			if (!result.stdout) return void 0;
+			const parts = result.stdout.split("	");
+			if (parts.length !== 2) return void 0;
+			const [left, right] = parts;
+			const counts = {
+				left: parseInt(left, 10),
+				right: parseInt(right, 10)
+			};
+			if (isNaN(counts.left) || isNaN(counts.right)) return void 0;
+			return counts;
+		};
+		if (authors.length > 0) return run();
+		const cacheKey = `${range}\x1f${options?.excludeMerges ? "no-merges" : ""}`;
+		return this.cache.leftRightCommitCount.getOrCreate(repoPath, cacheKey, run);
+	}
+	async getLog(repoPath, rev, options, cancellation) {
+		return this.getLogCore(repoPath, rev, options, cancellation);
+	}
+	async getLogCore(repoPath, rev, options, cancellation, additionalArgs) {
+		const scope = getScopedLogger();
+		try {
+			const currentUserPromise = this.provider.config.getCurrentUser(repoPath);
+			const cfg = this.context.config;
+			const limit = options?.limit ?? cfg?.commits.maxItems ?? 0;
+			const isSingleCommit = limit === 1;
+			const includeFiles = (options?.includeFiles ?? cfg?.commits.includeFileDetails?.(repoPath) ?? true) || isSingleCommit || Boolean(options?.path?.pathspec);
+			const parser = getCommitsLogParser(includeFiles, Boolean(options?.path?.pathspec && options?.path?.range));
+			const args = ["log", ...parser.arguments];
+			const similarityThreshold = options?.similarityThreshold ?? cfg?.commits.similarityThreshold;
+			args.push(`-M${similarityThreshold == null ? "" : `${similarityThreshold}%`}`, "--use-mailmap");
+			if (options?.all) {
+				args.push("--all");
+				if (options?.path?.pathspec) args.push("--single-worktree");
+			}
+			const merges = options?.merges ?? true;
+			if (merges) {
+				if (isSingleCommit) args.push("-m");
+				args.push(merges === "first-parent" ? "--first-parent" : "--no-min-parents");
+			} else args.push("--no-merges");
+			const ordering = options?.ordering ?? cfg?.commits.ordering;
+			if (ordering) args.push(`--${ordering}-order`);
+			if (options?.authors?.length) args.push(...options.authors.map((a) => `--author=^${escapeRegex(a.name ?? "")} <${escapeRegex(a.email ?? "")}>$`));
+			let overrideHasMore;
+			if (options?.since) {
+				overrideHasMore = true;
+				args.push(`--since="${options.since}"`);
+			}
+			if (options?.until) {
+				overrideHasMore = true;
+				args.push(`--until="${options.until}"`);
+			}
+			if (additionalArgs?.length) args.push(...additionalArgs);
+			if (limit > 0) {
+				overrideHasMore = isSingleCommit ? false : void 0;
+				args.push(`-n${isSingleCommit ? 1 : limit + 1}`);
+			}
+			let stashes;
+			if (!isSingleCommit && options?.stashes) {
+				stashes = typeof options.stashes === "boolean" ? (await this.provider.stash?.getStash(repoPath, { reachableFrom: rev }, cancellation))?.stashes : options.stashes;
+				if (stashes?.size) rev ??= "HEAD";
+			}
+			if (rev && !isUncommittedStaged(rev)) args.push(rev);
+			let pathspec;
+			let pathspecRange;
+			if (options?.path?.pathspec) {
+				pathspec = options.path.pathspec;
+				const { filters, range, renames } = options.path;
+				if (filters?.length) args.push(`--diff-filter=${filters.join("")}`);
+				if (range != null) {
+					const [start, end] = getGitStartEnd(range);
+					pathspecRange = `${start},${end}`;
+					args.push(`-L ${pathspecRange}:${pathspec}`, "--");
+				} else {
+					if (renames !== false) args.push("--follow");
+					args.push("--", pathspec);
+				}
+			} else args.push("--");
+			const currentUser = await currentUserPromise.catch(() => void 0);
+			if (cancellation?.aborted) throw new CancellationError();
+			const isEagerPagedFileLog = includeFiles && !isSingleCommit && !options?.path?.pathspec;
+			const cmdOpts = {
+				cwd: repoPath,
+				cancellation,
+				configs: gitConfigsLogWithFiles,
+				...isSingleCommit && rev ? { caching: {
+					cache: this.cache.gitResults,
+					options: { accessTTL: isSha(rev) ? 3e5 : 6e4 }
+				} } : void 0,
+				...isEagerPagedFileLog ? { slownessCategory: "commitFiles" } : void 0
+			};
+			let { commits, count } = await parseCommits(parser, isSingleCommit ? this.git.run(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args), repoPath, pathspec, limit, void 0, currentUser);
+			if (rev == null && pathspec && !commits.size) {
+				const status = await this.provider.status?.getStatusForFile?.(repoPath, pathspec, void 0, cancellation);
+				if (status?.originalPath != null) {
+					pathspec = status.originalPath;
+					if (pathspecRange) {
+						const index = args.findIndex((a) => a.startsWith("-L "));
+						args.splice(index, 1, `-L ${pathspecRange}:${pathspec}`);
+					} else args.splice(args.length - 1, 1, pathspec);
+					({commits, count} = await parseCommits(parser, isSingleCommit ? this.git.run(cmdOpts, ...args) : this.git.stream(cmdOpts, ...args), repoPath, pathspec, limit, void 0, currentUser));
+				}
+			}
+			if (stashes?.size) {
+				const stashesByParent = /* @__PURE__ */ new Map();
+				for (const stash of stashes.values()) {
+					const parentSha = stash.parents[0];
+					if (parentSha == null || !commits.has(parentSha)) continue;
+					const group = stashesByParent.get(parentSha);
+					if (group != null) group.push(stash);
+					else stashesByParent.set(parentSha, [stash]);
+				}
+				if (stashesByParent.size) {
+					const cap = limit > 0 ? limit + 1 : Number.POSITIVE_INFINITY;
+					const merged = /* @__PURE__ */ new Map();
+					outer: for (const c of commits.values()) {
+						const group = stashesByParent.get(c.sha);
+						if (group != null) for (const s of group) {
+							if (merged.size >= cap) break outer;
+							merged.set(s.sha, s);
+						}
+						if (merged.size >= cap) break;
+						merged.set(c.sha, c);
+					}
+					commits = merged;
+				}
+			}
+			const log = {
+				repoPath,
+				commits,
+				sha: isRevisionRange(rev) ? void 0 : rev,
+				count: commits.size,
+				limit,
+				hasMore: overrideHasMore ?? (limit > 0 && count > limit)
+			};
+			if (!isSingleCommit) {
+				log.query = (limit) => this.getLogCore(repoPath, rev, {
+					...options,
+					limit
+				}, void 0, additionalArgs);
+				if (log.hasMore) log.more = this.getLogCoreMoreFn(log, rev, options);
+			}
+			return log;
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			const pathspec = options?.path?.pathspec;
+			if (rev && pathspec && ex instanceof Error && GitErrors.badObject.test(ex.message)) {
+				if ((await this.provider.revision.getTreeEntryForRevision(repoPath, pathspec, "HEAD"))?.type === "commit") return this.getLogCore(repoPath, void 0, {
+					...options,
+					path: {
+						...options.path,
+						pathspec,
+						renames: false
+					}
+				}, cancellation, additionalArgs);
+			}
+			scope?.error(ex);
+			debugger;
+			return;
+		}
+	}
+	getLogCoreMoreFn(log, rev, options) {
+		return async (limit) => {
+			const moreUntil = limit != null && typeof limit === "object" ? limit.until : void 0;
+			let moreLimit = typeof limit === "number" ? limit : void 0;
+			if (moreUntil && some(log.commits.values(), (c) => c.ref === moreUntil)) return log;
+			moreLimit = moreLimit ?? 0;
+			if (isRevisionRange(log.sha)) {
+				const moreLog = await this.getLogCore(log.repoPath, rev, {
+					...options,
+					limit: moreLimit === 0 ? 0 : (options?.limit ?? 0) + moreLimit
+				});
+				if (moreLog == null) return {
+					...log,
+					hasMore: false,
+					more: void 0
+				};
+				return moreLog;
+			}
+			const lastCommit = findLast(log.commits.values(), (c) => !GitCommit.isStash(c)) ?? last(log.commits.values());
+			const sha = lastCommit?.ref;
+			const lastCommitFile = lastCommit?.anyFiles?.[0];
+			if (options?.path?.pathspec && lastCommitFile != null) {
+				const path = lastCommitFile.originalPath ?? lastCommitFile.path;
+				if (path !== options.path.pathspec) options = {
+					...options,
+					path: {
+						...options.path,
+						pathspec: path
+					}
+				};
+			}
+			let timestamp;
+			if (options?.all) {
+				const date = lastCommit?.committer.date;
+				timestamp = date != null ? Math.ceil(date.getTime() / 1e3) + 1 : void 0;
+			}
+			let moreLogCount;
+			let queryLimit = moreUntil == null ? moreLimit : 0;
+			do {
+				const moreLog = await this.getLogCore(log.repoPath, timestamp ? rev : moreUntil == null ? `${sha}^` : `${moreUntil}^..${sha}^`, {
+					...options,
+					limit: queryLimit,
+					...timestamp ? { until: timestamp } : void 0
+				}, void 0, timestamp ? ["--boundary"] : void 0);
+				if (moreLog == null) return {
+					...log,
+					hasMore: false,
+					more: void 0
+				};
+				const currentCount = log.commits.size;
+				const commits = new Map([...log.commits, ...moreLog.commits]);
+				if (currentCount === commits.size && queryLimit !== 0) {
+					if (moreLogCount === moreLog.commits.size) return {
+						...log,
+						hasMore: false,
+						more: void 0
+					};
+					moreLogCount = moreLog.commits.size;
+					queryLimit = queryLimit * 2;
+					continue;
+				}
+				if (timestamp != null && sha != null && !moreLog.commits.has(sha)) debugger;
+				const mergedLog = {
+					repoPath: log.repoPath,
+					commits,
+					sha: log.sha,
+					count: commits.size,
+					limit: moreUntil == null ? (log.limit ?? 0) + moreLimit : void 0,
+					hasMore: moreUntil == null ? moreLog.hasMore : true,
+					startingCursor: sha,
+					endingCursor: moreLog.endingCursor,
+					pagedCommits: () => {
+						for (const sha of log.commits.keys()) moreLog.commits.delete(sha);
+						return moreLog.commits;
+					},
+					query: (limit) => this.getLogCore(log.repoPath, rev, {
+						...options,
+						limit
+					})
+				};
+				if (mergedLog.hasMore) mergedLog.more = this.getLogCoreMoreFn(mergedLog, rev, options);
+				return mergedLog;
+			} while (true);
+		};
+	}
+	async getLogForPath(repoPath, pathOrUri, rev, options, cancellation) {
+		if (repoPath == null) return void 0;
+		const scope = getScopedLogger();
+		let relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
+		if (repoPath != null && repoPath === relativePath) throw new Error(`Path cannot match the repository path; path=${relativePath}`);
+		const cfg = this.context.config;
+		options = {
+			...options,
+			all: options?.all ?? cfg?.fileHistory?.showAllBranches,
+			limit: options?.limit ?? cfg?.commits.maxItems ?? 0,
+			merges: options?.merges ?? cfg?.fileHistory?.showMergeCommits,
+			ordering: options?.ordering ?? cfg?.commits.ordering ?? void 0,
+			renames: options?.renames ?? cfg?.fileHistory?.followRenames,
+			similarityThreshold: options?.similarityThreshold ?? cfg?.commits.similarityThreshold
+		};
+		if (isFolderGlob(relativePath)) {
+			relativePath = stripFolderGlob(relativePath);
+			options.isFolder = true;
+		} else if (options.isFolder == null) {
+			const tree = await this.provider.revision.getTreeEntryForRevision(repoPath, relativePath, rev || "HEAD");
+			if (cancellation?.aborted) throw new CancellationError();
+			if (tree?.type === "commit") {
+				options.range = void 0;
+				options.renames = false;
+			} else options.isFolder = tree?.type === "tree";
+		}
+		let cacheKey;
+		if (!options.isFolder && options.authors == null && options.cursor == null && options.filters == null && options.range == null && options.since == null && options.until == null) {
+			let suffix = "log";
+			if (rev != null) suffix += `:${rev}`;
+			if (options.all) suffix += ":all";
+			if (options.limit) suffix += `:n${options.limit}`;
+			if (options.merges) suffix += `:merges=${options.merges}`;
+			if (options.ordering) suffix += `:ordering=${options.ordering}`;
+			if (options.renames) suffix += ":follow";
+			cacheKey = `${normalizePath(relativePath)}:${suffix}`;
+		}
+		if (cacheKey != null) {
+			const cached = this.cache.fileLog.get(repoPath, cacheKey);
+			if (cached != null) {
+				scope?.trace(`Cache hit: '${cacheKey}'`);
+				return cached;
+			}
+			if (rev != null || options.limit != null && options.limit !== 0) {
+				const baseKey = `${normalizePath(relativePath)}:log${options.renames ? ":follow" : ""}`;
+				const baseLog = this.cache.fileLog.get(repoPath, baseKey);
+				if (baseLog != null) {
+					if (rev == null) {
+						scope?.trace(`Cache hit: ~'${cacheKey}'`);
+						return baseLog;
+					}
+					scope?.trace(`Cache ?: '${cacheKey}'`);
+					const log = await baseLog;
+					if (log != null && !log.hasMore && log.commits.has(rev)) {
+						scope?.trace(`Cache hit: '${cacheKey}'`);
+						let skip = true;
+						let i = 0;
+						const limit = options.limit;
+						const commits = new Map(filterMap(log.commits.entries(), ([sha, c]) => {
+							if (skip) {
+								if (sha !== rev) return void 0;
+								skip = false;
+							}
+							i++;
+							if (limit != null && i > limit) return;
+							return [sha, c];
+						}));
+						const optsCopy = { ...options };
+						return {
+							...log,
+							limit: optsCopy.limit,
+							count: commits.size,
+							commits,
+							query: (limit) => this.getLogForPath(repoPath, pathOrUri, rev, {
+								...optsCopy,
+								limit
+							})
+						};
+					}
+				}
+			}
+			scope?.trace(`Cache miss: '${cacheKey}'`);
+			return this.cache.fileLog.getOrCreate(repoPath, cacheKey, (_cacheable, signal) => this.getLogForPathCore(repoPath, relativePath, rev, options, signal), { cancellation });
+		}
+		return this.getLogForPathCore(repoPath, relativePath, rev, options, cancellation);
+	}
+	async getLogForPathCore(repoPath, path, rev, options, cancellation) {
+		const scope = getScopedLogger();
+		const tracked = await this.provider.isTrackedWithDetails(path, repoPath, rev);
+		if (cancellation?.aborted) throw new CancellationError();
+		if (tracked == null) {
+			scope?.debug(`Skipping log; '${path}' is not tracked`);
+			return emptyPromise;
+		}
+		const relativePath = tracked.path;
+		const root = repoPath;
+		return await this.getLogCore(root, rev, {
+			all: options.all,
+			authors: options.authors,
+			cursor: options.cursor,
+			limit: options.limit,
+			merges: options.merges,
+			ordering: options.ordering,
+			since: options.since,
+			until: options.until,
+			path: {
+				pathspec: relativePath,
+				filters: options.filters,
+				range: options.range,
+				renames: options.renames
+			}
+		}, cancellation);
+	}
+	async getLogShas(repoPath, rev, options, cancellation) {
+		const scope = getScopedLogger();
+		const cfg = this.context.config;
+		options ??= {};
+		options.limit ??= cfg?.commits.maxItems ?? 0;
+		options.ordering ??= cfg?.commits.ordering ?? void 0;
+		options.similarityThreshold ??= cfg?.commits.similarityThreshold;
+		options.merges ??= true;
+		const getCore = async () => {
+			try {
+				const parser = getShaLogParser();
+				const args = [...parser.arguments];
+				if (options.all) args.push(`--all`);
+				if (options.ordering) args.push(`--${options.ordering}-order`);
+				if (options.limit) args.push(`-n${options.limit}`);
+				if (options.since) args.push(`--since="${options.since}"`);
+				if (options.merges) args.push(options.merges === "first-parent" ? "--first-parent" : "--no-min-parents");
+				else args.push("--no-merges");
+				if (options.reverse) args.push("--reverse");
+				if (options.authors?.length) {
+					if (!args.includes("--use-mailmap")) args.push("--use-mailmap");
+					args.push(...options.authors.map((a) => `--author=^${escapeRegex(a.name ?? "")} <${escapeRegex(a.email ?? "")}>$`));
+				}
+				const pathspec = options.pathOrUri != null ? this.provider.getRelativePath(options.pathOrUri, repoPath) : void 0;
+				if (pathspec) {
+					const similarityThreshold = options.similarityThreshold;
+					args.push(`-M${similarityThreshold == null ? "" : `${similarityThreshold}%`}`);
+				}
+				if (rev && !isUncommittedStaged(rev)) args.push(rev);
+				args.push("--");
+				if (pathspec) args.push(pathspec);
+				const result = await this.git.run({
+					cwd: repoPath,
+					cancellation,
+					configs: gitConfigsLog
+				}, "log", ...args);
+				return [...parser.parse(result.stdout)];
+			} catch (ex) {
+				scope?.error(ex);
+				if (isCancellationError(ex)) throw ex;
+				debugger;
+				return [];
+			}
+		};
+		if (!options.pathOrUri && !options.authors?.length && !options.reverse && !options.all) return this.cache.logShas.getOrCreate(repoPath, `${rev ?? ""}:${options.ordering ?? ""}:${options.limit}:${options.merges}:${options.since ?? ""}`, () => getCore());
+		return getCore();
+	}
+	async getOldestUnpushedShaForPath(repoPath, pathOrUri, cancellation) {
+		const scope = getScopedLogger();
+		try {
+			const relativePath = this.provider.getRelativePath(pathOrUri, repoPath);
+			const parser = getShaLogParser();
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				configs: gitConfigsLog
+			}, "log", ...parser.arguments, "--follow", "--reverse", "@{u}..", "--", relativePath);
+			return first(parser.parse(result.stdout));
+		} catch (ex) {
+			scope?.error(ex);
+			if (isCancellationError(ex)) throw ex;
+			debugger;
+			return;
+		}
+	}
+	async hasCommitBeenPushed(repoPath, rev, cancellation) {
+		if (repoPath == null) return false;
+		return this.isAncestorOf(repoPath, rev, "@{u}", cancellation);
+	}
+	async isAncestorOf(repoPath, rev1, rev2, cancellation) {
+		if (repoPath == null) return false;
+		const result = await this.git.run({
+			cwd: repoPath,
+			cancellation,
+			errors: "ignore"
+		}, "merge-base", "--is-ancestor", rev1, rev2);
+		if (cancellation?.aborted) throw new CancellationError();
+		return result.exitCode === 0;
+	}
+	async searchCommits(repoPath, search, options, cancellation) {
+		const scope = getScopedLogger();
+		search = {
+			matchAll: false,
+			matchCase: false,
+			matchRegex: true,
+			matchWholeWord: false,
+			...search
+		};
+		if (search.naturalLanguage && (typeof search.naturalLanguage !== "object" || !search.naturalLanguage.processedQuery)) search = await this.context.searchQuery?.preprocessQuery?.(search, options?.source) ?? search;
+		if (typeof search.naturalLanguage === "object" && search.naturalLanguage.error) return {
+			search,
+			log: void 0
+		};
+		try {
+			const cfg = this.context.config;
+			const currentUser = await this.provider.config.getCurrentUser(repoPath);
+			if (cancellation?.aborted) throw new CancellationError();
+			const parser = getCommitsLogParser(true);
+			const similarityThreshold = options?.similarityThreshold ?? cfg?.commits.similarityThreshold;
+			const args = [
+				"log",
+				...parser.arguments,
+				`-M${similarityThreshold == null ? "" : `${similarityThreshold}%`}`,
+				"--use-mailmap"
+			];
+			const { args: searchArgs, files, shas, filters } = parseSearchQueryGitCommand(search, currentUser);
+			const mergesOnly = searchArgs.includes("--merges");
+			let stashes;
+			let stdin;
+			let resolvedShas;
+			if (shas?.size) {
+				resolvedShas = await this.provider.revision.resolveShas(repoPath, shas, cancellation);
+				if (cancellation?.aborted) throw new CancellationError();
+				if (!resolvedShas.size) return {
+					search,
+					log: {
+						repoPath,
+						commits: /* @__PURE__ */ new Map(),
+						sha: void 0,
+						searchFilters: filters,
+						count: 0,
+						limit: options?.limit ?? cfg?.search?.maxItems ?? 0,
+						hasMore: false
+					}
+				};
+			}
+			if (resolvedShas?.size) {
+				stdin = join(resolvedShas, "\n");
+				args.push("--no-walk");
+			} else if (!filters.refs) {
+				const converted = convertStashesToStdin(await this.provider.stash?.getStash(repoPath, void 0, cancellation));
+				stashes = converted.stashes;
+				stdin = mergesOnly ? void 0 : converted.stdin;
+			} else if (mergesOnly) stashes = convertStashesToStdin(await this.provider.stash?.getStash(repoPath, void 0, cancellation)).stashes;
+			if (stdin) args.push("--stdin");
+			const limit = options?.limit ?? cfg?.search?.maxItems ?? 0;
+			if (limit && !shas?.size) args.push(`-n${limit + 1}`);
+			const ordering = options?.ordering ?? cfg?.commits.ordering;
+			if (ordering) args.push(`--${ordering}-order`);
+			if (options?.skip) args.push(`--skip=${options.skip}`);
+			for (const arg of searchArgs) {
+				if (shas?.has(arg) || args.includes(arg)) continue;
+				args.push(arg);
+			}
+			const pathspec = files?.join(" ");
+			const { commits, count, countStashChildCommits } = await parseCommits(parser, this.git.stream({
+				cwd: repoPath,
+				cancellation,
+				configs: [
+					"-C",
+					repoPath,
+					...gitConfigsLog
+				],
+				stdin
+			}, ...args, "--", ...files), repoPath, pathspec, limit, stashes, currentUser, filters, mergesOnly);
+			const log = {
+				repoPath,
+				commits,
+				sha: void 0,
+				searchFilters: filters,
+				count: commits.size,
+				limit,
+				hasMore: count - countStashChildCommits > commits.size,
+				query: (limit) => this.searchCommits(repoPath, search, {
+					...options,
+					limit
+				}).then((r) => r.log)
+			};
+			if (log.hasMore) {
+				const searchCommitsCore = (log) => {
+					return async (limit) => {
+						limit = limit ?? 0;
+						const moreLog = (await this.searchCommits(log.repoPath, search, {
+							...options,
+							limit,
+							skip: log.count
+						})).log;
+						if (moreLog == null) return {
+							...log,
+							hasMore: false,
+							more: void 0
+						};
+						const commits = new Map([...log.commits, ...moreLog.commits]);
+						const mergedLog = {
+							repoPath: log.repoPath,
+							commits,
+							sha: log.sha,
+							searchFilters: filters,
+							count: commits.size,
+							limit: (log.limit ?? 0) + limit,
+							hasMore: moreLog.hasMore,
+							query: (limit) => this.searchCommits(log.repoPath, search, {
+								...options,
+								limit
+							}).then((r) => r.log)
+						};
+						if (mergedLog.hasMore) mergedLog.more = searchCommitsCore(mergedLog);
+						return mergedLog;
+					};
+				};
+				log.more = searchCommitsCore(log);
+			}
+			return {
+				search,
+				log
+			};
+		} catch (ex) {
+			scope?.error(ex);
+			if (isCancellationError(ex)) throw ex;
+			return {
+				search,
+				log: void 0
+			};
+		}
+	}
+	async getCommitSignature(repoPath, sha) {
+		const scope = getScopedLogger();
+		try {
+			const result = await this.git.run({
+				cwd: repoPath,
+				errors: "ignore",
+				caching: {
+					cache: this.cache.gitResults,
+					options: { accessTTL: isSha(sha) ? 3e5 : 6e4 }
+				},
+				configs: gitConfigsLog
+			}, "log", `--format=${signatureFormat}`, "-1", sha);
+			if (!result.stdout) return void 0;
+			return parseSignatureOutput(result.stdout);
+		} catch (ex) {
+			scope?.error(ex);
+			return;
+		}
+	}
+	async isCommitSigned(repoPath, sha) {
+		const scope = getScopedLogger();
+		try {
+			const result = await this.git.run({
+				cwd: repoPath,
+				errors: "ignore",
+				caching: {
+					cache: this.cache.gitResults,
+					options: { accessTTL: isSha(sha) ? 3e5 : 6e4 }
+				}
+			}, "cat-file", "commit", sha);
+			return /^gpgsig(-sha256)? /m.test(result.stdout);
+		} catch (ex) {
+			scope?.error(ex);
+			return false;
+		}
+	}
+	async getCommitsSshSigners(repoPath, shas) {
+		const scope = getScopedLogger();
+		const result = /* @__PURE__ */ new Map();
+		if (shas.length === 0) return result;
+		try {
+			parseCatFileBatchForSshSigners((await this.git.run({
+				cwd: repoPath,
+				errors: "ignore",
+				stdin: `${shas.join("\n")}\n`,
+				encoding: "buffer"
+			}, "cat-file", "--batch")).stdout, new Set(shas), result);
+		} catch (ex) {
+			scope?.error(ex);
+		}
+		return result;
+	}
+};
+__decorate([debug()], CommitsGitSubProvider.prototype, "createUnreachableCommitFromTree", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getCommit", null);
+__decorate([debug({ exit: true })], CommitsGitSubProvider.prototype, "getCommitCount", null);
+__decorate([debug({ exit: true })], CommitsGitSubProvider.prototype, "hasUnpublishedCommits", null);
+__decorate([debug({
+	args: (repoPath, shas) => ({
+		repoPath,
+		shas: `${shas.length} value(s)`
+	}),
+	exit: (r) => `${r.size} unpublished`
+})], CommitsGitSubProvider.prototype, "filterUnpublishedShas", null);
+__decorate([debug({ exit: true })], CommitsGitSubProvider.prototype, "getCommitDates", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getCommitFiles", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getCommitForFile", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getCommitReachability", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getIncomingActivity", null);
+__decorate([debug({ exit: true })], CommitsGitSubProvider.prototype, "getInitialCommitSha", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getLeftRightCommitCount", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getLog", null);
+__decorate([trace({
+	args: (repoPath, rev) => ({
+		repoPath,
+		rev
+	}),
+	exit: true
+})], CommitsGitSubProvider.prototype, "getLogCore", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getLogForPath", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getLogShas", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getOldestUnpushedShaForPath", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "hasCommitBeenPushed", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "isAncestorOf", null);
+__decorate([debug({ args: (repoPath, s) => ({
+	repoPath,
+	search: `[${s.matchAll ? "A" : ""}${s.matchCase ? "C" : ""}${s.matchRegex ? "R" : ""}${s.matchWholeWord ? "W" : ""}]: ${s.query.length > 500 ? `${s.query.substring(0, 500)}...` : s.query}`
+}) })], CommitsGitSubProvider.prototype, "searchCommits", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getCommitSignature", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "isCommitSigned", null);
+__decorate([debug()], CommitsGitSubProvider.prototype, "getCommitsSshSigners", null);
 /**
- * Parses `git cat-file --batch` output, extracting the embedded SSH public key (if any) from each requested commit
- * object. Each record is `<sha> <type> <size>` LF `<content>` LF (or `<sha> missing` LF), and the object's bytes are
- * consumed using the header's `<size>` rather than scanned line-by-line — so a commit/tag body line that happens to
- * look like an object header can never be misread as a boundary. Operates on the raw `Buffer` because `<size>` counts
- * bytes, not decoded characters.
- *
- * Exported for unit testing.
- */
-export function parseCatFileBatchForSshSigners(stdout, requestedShas, out) {
-    const headerRegex = /^([0-9a-f]{40,64}) (commit|tag|blob|missing)(?: (\d+))?$/;
-    let offset = 0;
-    while (offset < stdout.length) {
-        const newline = stdout.indexOf(0x0a, offset);
-        if (newline === -1)
-            break;
-        const match = headerRegex.exec(stdout.toString('utf8', offset, newline));
-        offset = newline + 1;
-        // A missing object (or an unrecognizable header) has no content body following its header line.
-        if (match == null || match[2] === 'missing')
-            continue;
-        const sha = match[1];
-        const object = stdout.toString('utf8', offset, offset + Number(match[3]));
-        offset += Number(match[3]) + 1; // consume the object's bytes and the trailing newline that separates records
-        if (!requestedShas.has(sha))
-            continue;
-        const key = extractSshPublicKeyFromCommitObject(object);
-        if (key == null)
-            continue;
-        const committer = extractCommitterFromCommitObject(object);
-        out.set(sha, { key: key, name: committer?.name, email: committer?.email });
-    }
+* Parses `git cat-file --batch` output, extracting the embedded SSH public key (if any) from each requested commit
+* object. Each record is `<sha> <type> <size>` LF `<content>` LF (or `<sha> missing` LF), and the object's bytes are
+* consumed using the header's `<size>` rather than scanned line-by-line — so a commit/tag body line that happens to
+* look like an object header can never be misread as a boundary. Operates on the raw `Buffer` because `<size>` counts
+* bytes, not decoded characters.
+*
+* Exported for unit testing.
+*/
+function parseCatFileBatchForSshSigners(stdout, requestedShas, out) {
+	const headerRegex = /^([0-9a-f]{40,64}) (commit|tag|blob|missing)(?: (\d+))?$/;
+	let offset = 0;
+	while (offset < stdout.length) {
+		const newline = stdout.indexOf(10, offset);
+		if (newline === -1) break;
+		const match = headerRegex.exec(stdout.toString("utf8", offset, newline));
+		offset = newline + 1;
+		if (match == null || match[2] === "missing") continue;
+		const sha = match[1];
+		const object = stdout.toString("utf8", offset, offset + Number(match[3]));
+		offset += Number(match[3]) + 1;
+		if (!requestedShas.has(sha)) continue;
+		const key = extractSshPublicKeyFromCommitObject(object);
+		if (key == null) continue;
+		const committer = extractCommitterFromCommitObject(object);
+		out.set(sha, {
+			key,
+			name: committer?.name,
+			email: committer?.email
+		});
+	}
 }
 function toCommit(c, repoPath, pathspec, currentUser) {
-    const message = c.message.trim();
-    const index = message.indexOf('\n');
-    const isCurrentAuthor = isUserMatch(currentUser, c.author, c.authorEmail) || undefined;
-    const isCurrentCommitter = isUserMatch(currentUser, c.committer, c.committerEmail) || undefined;
-    return new GitCommit(repoPath, c.sha, new GitCommitIdentity(c.author, c.authorEmail, new Date(Number(c.authorDate) * 1000), undefined, isCurrentAuthor), new GitCommitIdentity(c.committer, c.committerEmail, new Date(Number(c.committerDate) * 1000), undefined, isCurrentCommitter), index !== -1 ? message.substring(0, index) : message, c.parents?.split(' ') ?? [], message, createCommitFileset(c, repoPath, pathspec), c.stats, undefined, c.tips?.split(' '));
+	const message = c.message.trim();
+	const index = message.indexOf("\n");
+	const isCurrentAuthor = isUserMatch(currentUser, c.author, c.authorEmail) || void 0;
+	const isCurrentCommitter = isUserMatch(currentUser, c.committer, c.committerEmail) || void 0;
+	return new GitCommit(repoPath, c.sha, new GitCommitIdentity(c.author, c.authorEmail, /* @__PURE__ */ new Date(Number(c.authorDate) * 1e3), void 0, isCurrentAuthor), new GitCommitIdentity(c.committer, c.committerEmail, /* @__PURE__ */ new Date(Number(c.committerDate) * 1e3), void 0, isCurrentCommitter), index !== -1 ? message.substring(0, index) : message, c.parents?.split(" ") ?? [], message, createCommitFileset(c, repoPath, pathspec), c.stats, void 0, c.tips?.split(" "));
 }
 function getGitStartEnd(range) {
-    // Library DiffRange is always 1-based, startLine <= endLine
-    return [range.startLine, range.endLine];
+	return [range.startLine, range.endLine];
 }
-async function parseCommits(parser, resultOrStream, repoPath, pathspec, limit, stashes, currentUser, searchFilters, 
-// Stash commits have 2-3 parents, so `--merges` matches them; excluded below. Passed in by the
-// caller (derived from the args git actually runs) rather than re-derived from `searchFilters.type`
-// here, since a multi-value `type:` query (e.g. `type:merge type:tip`) leaves `--merges` in the
-// args while `searchFilters.type` reflects only the last value parsed
-mergesOnly = false) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        let count = 0;
-        let countStashChildCommits = 0;
-        const commits = new Map();
-        const tipsOnly = searchFilters?.type === 'tip';
-        if (resultOrStream instanceof Promise) {
-            const env_2 = { stack: [], error: void 0, hasError: false };
-            try {
-                const scope = getScopedLogger();
-                const result = await resultOrStream;
-                const sw = __addDisposableResource(env_2, maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } }), false);
-                if (stashes?.size) {
-                    const allowFilteredFiles = searchFilters?.files ?? false;
-                    const stashesOnly = searchFilters?.type === 'stash';
-                    for (const c of parser.parse(result.stdout)) {
-                        if (stashesOnly && !stashes?.has(c.sha))
-                            continue;
-                        if (mergesOnly && stashes?.has(c.sha))
-                            continue;
-                        if (tipsOnly && !c.tips)
-                            continue;
-                        count++;
-                        if (limit && count > limit)
-                            break;
-                        const stash = stashes?.get(c.sha);
-                        if (stash != null) {
-                            if (commits.has(stash.sha)) {
-                                countStashChildCommits++;
-                            }
-                            else if (allowFilteredFiles) {
-                                commits.set(stash.sha, stash.with({
-                                    fileset: {
-                                        ...createCommitFileset(c, repoPath, pathspec),
-                                        // Add the full stash files back into the fileset
-                                        files: stash.fileset?.files,
-                                    },
-                                }));
-                            }
-                            else {
-                                commits.set(stash.sha, stash);
-                            }
-                            continue;
-                        }
-                        commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
-                    }
-                }
-                else {
-                    for (const c of parser.parse(result.stdout)) {
-                        if (tipsOnly && !c.tips)
-                            continue;
-                        count++;
-                        if (limit && count > limit)
-                            break;
-                        commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
-                    }
-                }
-                sw?.stop({ suffix: ` created ${count} commits` });
-                return { commits: commits, count: count, countStashChildCommits: countStashChildCommits };
-            }
-            catch (e_1) {
-                env_2.error = e_1;
-                env_2.hasError = true;
-            }
-            finally {
-                __disposeResources(env_2);
-            }
-        }
-        const _streamDisposer = __addDisposableResource(env_1, createDisposable(() => void resultOrStream.return?.(undefined)), false);
-        if (stashes?.size) {
-            const allowFilteredFiles = searchFilters?.files ?? false;
-            const stashesOnly = searchFilters?.type === 'stash';
-            for await (const c of parser.parseAsync(resultOrStream)) {
-                if (stashesOnly && !stashes?.has(c.sha))
-                    continue;
-                if (mergesOnly && stashes?.has(c.sha))
-                    continue;
-                if (tipsOnly && !c.tips)
-                    continue;
-                count++;
-                if (limit && count > limit)
-                    break;
-                const stash = stashes?.get(c.sha);
-                if (stash != null) {
-                    if (commits.has(stash.sha)) {
-                        countStashChildCommits++;
-                    }
-                    else if (allowFilteredFiles) {
-                        commits.set(stash.sha, stash.with({
-                            fileset: {
-                                ...createCommitFileset(c, repoPath, pathspec),
-                                // Add the full stash files back into the fileset
-                                files: stash.fileset?.files,
-                            },
-                        }));
-                    }
-                    else {
-                        commits.set(stash.sha, stash);
-                    }
-                    continue;
-                }
-                commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
-            }
-        }
-        else {
-            for await (const c of parser.parseAsync(resultOrStream)) {
-                if (tipsOnly && !c.tips)
-                    continue;
-                count++;
-                if (limit && count > limit)
-                    break;
-                commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
-            }
-        }
-        return { commits: commits, count: count, countStashChildCommits: countStashChildCommits };
-    }
-    catch (e_2) {
-        env_1.error = e_2;
-        env_1.hasError = true;
-    }
-    finally {
-        __disposeResources(env_1);
-    }
+async function parseCommits(parser, resultOrStream, repoPath, pathspec, limit, stashes, currentUser, searchFilters, mergesOnly = false) {
+	try {
+		var _usingCtx$1 = _usingCtx();
+		let count = 0;
+		let countStashChildCommits = 0;
+		const commits = /* @__PURE__ */ new Map();
+		const tipsOnly = searchFilters?.type === "tip";
+		if (resultOrStream instanceof Promise) try {
+			var _usingCtx3 = _usingCtx();
+			const scope = getScopedLogger();
+			const result = await resultOrStream;
+			const sw = _usingCtx3.u(maybeStopWatch(scope, { log: {
+				onlyExit: true,
+				level: "debug"
+			} }));
+			if (stashes?.size) {
+				const allowFilteredFiles = searchFilters?.files ?? false;
+				const stashesOnly = searchFilters?.type === "stash";
+				for (const c of parser.parse(result.stdout)) {
+					if (stashesOnly && !stashes?.has(c.sha)) continue;
+					if (mergesOnly && stashes?.has(c.sha)) continue;
+					if (tipsOnly && !c.tips) continue;
+					count++;
+					if (limit && count > limit) break;
+					const stash = stashes?.get(c.sha);
+					if (stash != null) {
+						if (commits.has(stash.sha)) countStashChildCommits++;
+						else if (allowFilteredFiles) commits.set(stash.sha, stash.with({ fileset: {
+							...createCommitFileset(c, repoPath, pathspec),
+							files: stash.fileset?.files
+						} }));
+						else commits.set(stash.sha, stash);
+						continue;
+					}
+					commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
+				}
+			} else for (const c of parser.parse(result.stdout)) {
+				if (tipsOnly && !c.tips) continue;
+				count++;
+				if (limit && count > limit) break;
+				commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
+			}
+			sw?.stop({ suffix: ` created ${count} commits` });
+			return {
+				commits,
+				count,
+				countStashChildCommits
+			};
+		} catch (_) {
+			_usingCtx3.e = _;
+		} finally {
+			_usingCtx3.d();
+		}
+		_usingCtx$1.u(createDisposable(() => void resultOrStream.return?.(void 0)));
+		if (stashes?.size) {
+			const allowFilteredFiles = searchFilters?.files ?? false;
+			const stashesOnly = searchFilters?.type === "stash";
+			for await (const c of parser.parseAsync(resultOrStream)) {
+				if (stashesOnly && !stashes?.has(c.sha)) continue;
+				if (mergesOnly && stashes?.has(c.sha)) continue;
+				if (tipsOnly && !c.tips) continue;
+				count++;
+				if (limit && count > limit) break;
+				const stash = stashes?.get(c.sha);
+				if (stash != null) {
+					if (commits.has(stash.sha)) countStashChildCommits++;
+					else if (allowFilteredFiles) commits.set(stash.sha, stash.with({ fileset: {
+						...createCommitFileset(c, repoPath, pathspec),
+						files: stash.fileset?.files
+					} }));
+					else commits.set(stash.sha, stash);
+					continue;
+				}
+				commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
+			}
+		} else for await (const c of parser.parseAsync(resultOrStream)) {
+			if (tipsOnly && !c.tips) continue;
+			count++;
+			if (limit && count > limit) break;
+			commits.set(c.sha, toCommit(c, repoPath, pathspec, currentUser));
+		}
+		return {
+			commits,
+			count,
+			countStashChildCommits
+		};
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
 }
+//#endregion
+export { CommitsGitSubProvider, parseCatFileBatchForSshSigners };
+
 //# sourceMappingURL=commits.js.map